qualia_core_db/solvers/statistics/regression/
selection.rs1use 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
22pub 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 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 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 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); 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}