Skip to main content

qualia_core_db/solvers/statistics/regression/
selection.rs

1//! General-to-specific / backward stepwise selection (exploratory — receipt must flag).
2
3use crate::solvers::statistics::regression::multiple_ols;
4
5use serde::Serialize;
6
7#[derive(Debug, Clone, PartialEq, Serialize)]
8pub struct StepwiseStep {
9    pub dropped_column: Option<usize>,
10    pub remaining: Vec<usize>,
11    pub adj_r_squared: f64,
12    pub f_p_value: Option<f64>,
13}
14
15#[derive(Debug, Clone, PartialEq, Serialize)]
16pub struct StepwiseResult {
17    pub selected_columns: Vec<usize>,
18    pub steps: Vec<StepwiseStep>,
19    pub exploratory: bool,
20}
21
22/// Backward elimination: drop the predictor with largest p-value while
23/// p > `exit_alpha`, bounded by `max_steps`. Always records `exploratory: true`.
24pub fn stepwise_backward(
25    x: &[f64],
26    y: &[f64],
27    n: usize,
28    p: usize,
29    exit_alpha: f64,
30    max_steps: usize,
31) -> Option<StepwiseResult> {
32    if p == 0 || x.len() != n * p || y.len() != n || max_steps == 0 {
33        return None;
34    }
35    let mut remaining: Vec<usize> = (0..p).collect();
36    let mut steps = Vec::new();
37    for _ in 0..max_steps {
38        if remaining.len() <= 1 {
39            break;
40        }
41        let k = remaining.len();
42        let mut xr = vec![0.0; n * k];
43        for i in 0..n {
44            for (c, &col) in remaining.iter().enumerate() {
45                xr[i * k + c] = x[i * p + col];
46            }
47        }
48        let m = multiple_ols(&xr, y, n, k, true)?;
49        // p_values[0] = intercept; slopes start at 1.
50        let mut worst_local = 0usize;
51        let mut worst_p = -1.0_f64;
52        for j in 0..k {
53            let pv = m.p_values[j + 1];
54            if pv > worst_p {
55                worst_p = pv;
56                worst_local = j;
57            }
58        }
59        steps.push(StepwiseStep {
60            dropped_column: None,
61            remaining: remaining.clone(),
62            adj_r_squared: m.adj_r_squared,
63            f_p_value: m.f_p_value,
64        });
65        if worst_p <= exit_alpha {
66            break;
67        }
68        let dropped = remaining.remove(worst_local);
69        if let Some(last) = steps.last_mut() {
70            last.dropped_column = Some(dropped);
71        }
72    }
73    // Final fit note.
74    let k = remaining.len();
75    if k >= 1 {
76        let mut xr = vec![0.0; n * k];
77        for i in 0..n {
78            for (c, &col) in remaining.iter().enumerate() {
79                xr[i * k + c] = x[i * p + col];
80            }
81        }
82        if let Some(m) = multiple_ols(&xr, y, n, k, true) {
83            steps.push(StepwiseStep {
84                dropped_column: None,
85                remaining: remaining.clone(),
86                adj_r_squared: m.adj_r_squared,
87                f_p_value: m.f_p_value,
88            });
89        }
90    }
91    Some(StepwiseResult {
92        selected_columns: remaining,
93        steps,
94        exploratory: true,
95    })
96}
97
98#[cfg(test)]
99mod tests {
100    use super::*;
101
102    #[test]
103    fn drops_noise_predictor() {
104        // y ~ x0; x1 is noise.
105        let n = 20;
106        let mut x = Vec::with_capacity(n * 2);
107        let mut y = Vec::with_capacity(n);
108        for i in 0..n {
109            let t = i as f64;
110            x.push(t);
111            x.push(((i * 17) % 7) as f64); // weak noise
112            y.push(1.0 + 2.0 * t + 0.01 * ((i % 3) as f64));
113        }
114        let r = stepwise_backward(&x, &y, n, 2, 0.05, 5).unwrap();
115        assert!(r.exploratory);
116        assert!(
117            r.selected_columns == vec![0] || r.selected_columns.contains(&0),
118            "sel={:?}",
119            r.selected_columns
120        );
121    }
122}