qualia_core_db/solvers/learning/regression/
ridge.rs1use crate::solvers::learning::LearningError;
10use crate::solvers::linear_algebra::cholesky::{cholesky_factor, cholesky_solve};
11use crate::solvers::linear_algebra::gemm::{gemm, matvec, Transpose};
12use crate::solvers::statistics::descriptive::mean;
13
14#[derive(Debug, Clone)]
17pub struct RidgeModel {
18 pub coefficients: Vec<f64>,
19 pub intercept: f64,
20 pub lambda: f64,
21}
22
23impl RidgeModel {
24 pub fn predict_row(&self, x_row: &[f64]) -> f64 {
26 self.intercept
27 + self
28 .coefficients
29 .iter()
30 .zip(x_row)
31 .map(|(b, x)| b * x)
32 .sum::<f64>()
33 }
34 pub fn predict(&self, x: &[f64], n: usize, p: usize) -> Vec<f64> {
36 (0..n)
37 .map(|i| self.predict_row(&x[i * p..(i + 1) * p]))
38 .collect()
39 }
40}
41
42pub fn fit(
45 x: &[f64],
46 y: &[f64],
47 n: usize,
48 p: usize,
49 lambda: f64,
50) -> Result<RidgeModel, LearningError> {
51 if n == 0 || p == 0 || x.len() != n * p || y.len() != n {
52 return Err(LearningError::InvalidDimension);
53 }
54 if n < 2 || lambda < 0.0 {
55 return Err(LearningError::InsufficientData);
56 }
57
58 let mut xbar = vec![0.0; p];
60 let mut colbuf = vec![0.0; n];
61 for j in 0..p {
62 for i in 0..n {
63 colbuf[i] = x[i * p + j];
64 }
65 xbar[j] = mean(&colbuf).ok_or(LearningError::InsufficientData)?;
66 }
67 let ybar = mean(y).ok_or(LearningError::InsufficientData)?;
68 let mut xc = vec![0.0; n * p];
69 let mut yc = vec![0.0; n];
70 for i in 0..n {
71 for j in 0..p {
72 xc[i * p + j] = x[i * p + j] - xbar[j];
73 }
74 yc[i] = y[i] - ybar;
75 }
76
77 let mut a = vec![0.0; p * p];
79 gemm(
80 Transpose::Yes,
81 Transpose::No,
82 p,
83 p,
84 n,
85 1.0,
86 &xc,
87 &xc,
88 0.0,
89 &mut a,
90 )?;
91 for j in 0..p {
92 a[j * p + j] += lambda;
93 }
94 let mut b = vec![0.0; p];
95 matvec(Transpose::Yes, p, n, &xc, &yc, &mut b)?;
96
97 let mut l = vec![0.0; p * p];
98 cholesky_factor(p, &a, &mut l).map_err(|_| LearningError::Singular)?;
99 let mut coefficients = vec![0.0; p];
100 cholesky_solve(p, &l, &b, &mut coefficients)?;
101
102 let intercept = ybar
104 - coefficients
105 .iter()
106 .zip(xbar.iter())
107 .map(|(b, m)| b * m)
108 .sum::<f64>();
109
110 Ok(RidgeModel {
111 coefficients,
112 intercept,
113 lambda,
114 })
115}
116
117#[cfg(test)]
118mod tests {
119 use super::*;
120 use crate::solvers::learning::regression::linear;
121
122 #[test]
123 fn lambda_zero_matches_ols() {
124 let x = [1.0, 2.0, 2.0, 1.0, 3.0, 0.0, 4.0, 5.0, 5.0, 4.0];
125 let y = [3.0, 5.0, 4.0, 9.0, 13.0];
126 let ridge = fit(&x, &y, 5, 2, 0.0).unwrap();
127 let ols = linear::fit(&x, &y, 5, 2, true).unwrap();
128 assert!((ridge.intercept - ols.coefficients[0]).abs() < 1e-7);
129 assert!((ridge.coefficients[0] - ols.coefficients[1]).abs() < 1e-7);
130 assert!((ridge.coefficients[1] - ols.coefficients[2]).abs() < 1e-7);
131 }
132
133 #[test]
134 fn penalty_shrinks_coefficients() {
135 let x = [1.0, 2.0, 2.0, 1.0, 3.0, 0.0, 4.0, 5.0, 5.0, 4.0];
136 let y = [3.0, 5.0, 4.0, 9.0, 13.0];
137 let small = fit(&x, &y, 5, 2, 0.0).unwrap();
138 let big = fit(&x, &y, 5, 2, 50.0).unwrap();
139 let norm = |m: &RidgeModel| m.coefficients.iter().map(|c| c * c).sum::<f64>().sqrt();
140 assert!(
141 norm(&big) < norm(&small),
142 "ridge must shrink: {} !< {}",
143 norm(&big),
144 norm(&small)
145 );
146 }
147
148 #[test]
149 fn stable_on_collinear_where_ols_fails() {
150 let x = [1.0, 2.0, 2.0, 4.0, 3.0, 6.0, 4.0, 8.0, 5.0, 10.0];
152 let y = [1.0, 2.0, 3.0, 4.0, 5.0];
153 assert_eq!(
154 linear::fit(&x, &y, 5, 2, true).unwrap_err(),
155 LearningError::Singular
156 );
157 let ridge = fit(&x, &y, 5, 2, 1.0).unwrap();
158 assert!(ridge.coefficients.iter().all(|c| c.is_finite()));
159 }
160}