gam_models/fit_orchestration/
fit_config.rs

1use super::*;
2
3fn normalize_optional_column(value: Option<String>, field: &str) -> Result<Option<String>, String> {
4    value
5        .map(|value| {
6            let value = value.trim();
7            if value.is_empty() {
8                Err(format!("{field} must be a non-empty column name"))
9            } else {
10                Ok(value.to_string())
11            }
12        })
13        .transpose()
14}
15
16/// Validate the survival baseline fields shared by every front end.
17pub fn validate_survival_baseline_config(
18    likelihood_mode: SurvivalLikelihoodMode,
19    baseline_target: &str,
20    baseline_scale: Option<f64>,
21    baseline_shape: Option<f64>,
22    baseline_rate: Option<f64>,
23    baseline_makeham: Option<f64>,
24) -> Result<(), String> {
25    if likelihood_mode == SurvivalLikelihoodMode::Weibull {
26        if baseline_rate.is_some() || baseline_makeham.is_some() {
27            return Err(
28                "survival likelihood 'weibull' does not use baseline_rate or baseline_makeham"
29                    .to_string(),
30            );
31        }
32        if !matches!(baseline_target, "linear" | "weibull") {
33            return Err(
34                "survival likelihood 'weibull' supports only baseline_target 'linear' or 'weibull'"
35                    .to_string(),
36            );
37        }
38        return Ok(());
39    }
40
41    match baseline_target {
42        "linear" => {
43            if baseline_scale.is_some()
44                || baseline_shape.is_some()
45                || baseline_rate.is_some()
46                || baseline_makeham.is_some()
47            {
48                return Err("baseline_target 'linear' does not use baseline parameters".to_string());
49            }
50        }
51        "weibull" => {
52            if baseline_rate.is_some() || baseline_makeham.is_some() {
53                return Err(
54                    "baseline_target 'weibull' does not use baseline_rate or baseline_makeham"
55                        .to_string(),
56                );
57            }
58        }
59        "gompertz" => {
60            if baseline_scale.is_some() || baseline_makeham.is_some() {
61                return Err(
62                    "baseline_target 'gompertz' does not use baseline_scale or baseline_makeham"
63                        .to_string(),
64                );
65            }
66        }
67        "gompertz-makeham" => {
68            if baseline_scale.is_some() {
69                return Err(
70                    "baseline_target 'gompertz-makeham' does not use baseline_scale".to_string(),
71                );
72            }
73        }
74        other => {
75            return Err(format!(
76                "unsupported baseline_target '{other}'; use linear, weibull, gompertz, or gompertz-makeham"
77            ));
78        }
79    }
80    Ok(())
81}
82
83impl FitConfig {
84    /// Normalize and validate the canonical configuration contract.
85    ///
86    /// CLI and JSON layers translate syntax only. Model-family legality and
87    /// cross-field invariants live here so direct Rust callers cannot bypass
88    /// the same rules enforced by application front ends.
89    pub fn resolve(mut self) -> Result<Self, String> {
90        self.family = self.family.and_then(|value| {
91            let value = value.trim();
92            (!value.eq_ignore_ascii_case("auto")).then(|| value.to_string())
93        });
94        self.survival_likelihood = self.survival_likelihood.trim().to_ascii_lowercase();
95        self.baseline_target = self.baseline_target.trim().to_ascii_lowercase();
96        self.link = self.link.and_then(|value| {
97            let value = value.trim();
98            (!value.is_empty()).then(|| value.to_string())
99        });
100        self.offset_column = normalize_optional_column(self.offset_column, "offset_column")?;
101        self.noise_offset_column =
102            normalize_optional_column(self.noise_offset_column, "noise_offset_column")?;
103        self.weight_column = normalize_optional_column(self.weight_column, "weight_column")?;
104        self.z_column = normalize_optional_column(self.z_column, "z_column")?;
105
106        if !self.ridge_lambda.is_finite() || self.ridge_lambda < 0.0 {
107            return Err("ridge_lambda must be finite and >= 0".to_string());
108        }
109        if self.outer_max_iter == Some(0) {
110            return Err("outer_max_iter must be >= 1".to_string());
111        }
112        self.frailty.validate().map_err(|error| error.to_string())?;
113        self.spatial_optimization.validate()?;
114        let likelihood_mode = parse_survival_likelihood_mode(&self.survival_likelihood)?;
115        validate_survival_baseline_config(
116            likelihood_mode,
117            &self.baseline_target,
118            self.baseline_scale,
119            self.baseline_shape,
120            self.baseline_rate,
121            self.baseline_makeham,
122        )?;
123        Ok(self)
124    }
125}
126
127#[cfg(test)]
128mod tests {
129    use super::*;
130
131    #[test]
132    fn resolve_normalizes_front_end_spellings() {
133        let resolved = FitConfig {
134            family: Some(" AUTO ".to_string()),
135            survival_likelihood: " Transformation ".to_string(),
136            baseline_target: " Linear ".to_string(),
137            ..FitConfig::default()
138        }
139        .resolve()
140        .unwrap();
141        assert_eq!(resolved.family, None);
142        assert_eq!(resolved.survival_likelihood, "transformation");
143        assert_eq!(resolved.baseline_target, "linear");
144    }
145
146    #[test]
147    fn resolve_rejects_invalid_shared_fields() {
148        assert!(
149            FitConfig {
150                ridge_lambda: f64::NAN,
151                ..FitConfig::default()
152            }
153            .resolve()
154            .is_err()
155        );
156        assert!(
157            FitConfig {
158                outer_max_iter: Some(0),
159                ..FitConfig::default()
160            }
161            .resolve()
162            .is_err()
163        );
164        assert!(
165            FitConfig {
166                weight_column: Some("   ".to_string()),
167                ..FitConfig::default()
168            }
169            .resolve()
170            .is_err()
171        );
172    }
173}
gam_models/fit_orchestration/fit_config.rs

gam_models/fit_orchestration/
fit_config.rs
