1use ndarray::{Array2, ArrayView2};
14use solow_core::{Error, Result};
15
16#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
18#[derive(Clone, Debug, PartialEq)]
19pub struct MultiTaskLasso {
20 pub coef: Array2<f64>,
22 pub x_mean: Vec<f64>,
24 pub y_mean: Vec<f64>,
26 pub alpha: f64,
28 pub n_iter: usize,
30 pub converged: bool,
32}
33
34impl MultiTaskLasso {
35 pub fn fit(x: ArrayView2<'_, f64>, y: ArrayView2<'_, f64>) -> Result<Self> {
37 Self::fit_with(x, y, 1.0, 1000, 1e-4)
38 }
39
40 pub fn fit_with(
42 x: ArrayView2<'_, f64>,
43 y: ArrayView2<'_, f64>,
44 alpha: f64,
45 max_iter: usize,
46 tol: f64,
47 ) -> Result<Self> {
48 MultiTaskElasticNet::fit_with(x, y, alpha, 1.0, max_iter, tol).map(|m| Self {
49 coef: m.coef,
50 x_mean: m.x_mean,
51 y_mean: m.y_mean,
52 alpha: m.alpha,
53 n_iter: m.n_iter,
54 converged: m.converged,
55 })
56 }
57
58 pub fn predict(&self, x: ArrayView2<'_, f64>) -> Result<Array2<f64>> {
60 let d = self.x_mean.len();
61 let q = self.y_mean.len();
62 if x.ncols() != d {
63 return Err(Error::Shape("MultiTaskLasso::predict: shape mismatch".into()));
64 }
65 let n = x.nrows();
66 let mut out = Array2::<f64>::zeros((n, q));
67 for i in 0..n {
68 for j in 0..q {
69 let mut s = self.y_mean[j];
70 for k in 0..d {
71 s += (x[[i, k]] - self.x_mean[k]) * self.coef[[k, j]];
72 }
73 out[[i, j]] = s;
74 }
75 }
76 Ok(out)
77 }
78}
79
80#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
82#[derive(Clone, Debug, PartialEq)]
83pub struct MultiTaskElasticNet {
84 pub coef: Array2<f64>,
86 pub x_mean: Vec<f64>,
88 pub y_mean: Vec<f64>,
90 pub alpha: f64,
92 pub l1_ratio: f64,
94 pub n_iter: usize,
96 pub converged: bool,
98}
99
100impl MultiTaskElasticNet {
101 pub fn fit(x: ArrayView2<'_, f64>, y: ArrayView2<'_, f64>) -> Result<Self> {
104 Self::fit_with(x, y, 1.0, 0.5, 1000, 1e-4)
105 }
106
107 pub fn fit_with(
109 x: ArrayView2<'_, f64>,
110 y: ArrayView2<'_, f64>,
111 alpha: f64,
112 l1_ratio: f64,
113 max_iter: usize,
114 tol: f64,
115 ) -> Result<Self> {
116 let n = x.nrows();
117 let d = x.ncols();
118 let q = y.ncols();
119 if y.nrows() != n {
120 return Err(Error::Shape("MultiTaskEN: y/x row mismatch".into()));
121 }
122 if !(0.0..=1.0).contains(&l1_ratio) {
123 return Err(Error::Value("MultiTaskEN: l1_ratio must be in [0, 1]".into()));
124 }
125 if alpha < 0.0 {
126 return Err(Error::Value("MultiTaskEN: alpha must be ≥ 0".into()));
127 }
128 let l1 = alpha * l1_ratio;
129 let l2 = alpha * (1.0 - l1_ratio);
130 let mut x_mean = vec![0.0_f64; d];
132 for j in 0..d {
133 let m: f64 = (0..n).map(|i| x[[i, j]]).sum::<f64>() / n as f64;
134 x_mean[j] = m;
135 }
136 let mut y_mean = vec![0.0_f64; q];
137 for j in 0..q {
138 let m: f64 = (0..n).map(|i| y[[i, j]]).sum::<f64>() / n as f64;
139 y_mean[j] = m;
140 }
141 let mut xc = Array2::<f64>::zeros((n, d));
142 for i in 0..n {
143 for j in 0..d {
144 xc[[i, j]] = x[[i, j]] - x_mean[j];
145 }
146 }
147 let mut yc = Array2::<f64>::zeros((n, q));
148 for i in 0..n {
149 for j in 0..q {
150 yc[[i, j]] = y[[i, j]] - y_mean[j];
151 }
152 }
153 let mut col_sq = vec![0.0_f64; d];
155 for j in 0..d {
156 let mut s = 0.0_f64;
157 for i in 0..n {
158 s += xc[[i, j]] * xc[[i, j]];
159 }
160 col_sq[j] = s / n as f64;
161 }
162 let mut beta = Array2::<f64>::zeros((d, q));
163 let mut r = yc;
164 let mut iters = 0_usize;
165 let mut converged = false;
166 for it in 0..max_iter {
167 iters = it + 1;
168 let mut max_delta = 0.0_f64;
169 for j in 0..d {
170 if col_sq[j] < 1e-30 {
171 continue;
172 }
173 let mut gj = vec![0.0_f64; q];
176 for k in 0..q {
177 let mut s = 0.0_f64;
178 for i in 0..n {
179 s += xc[[i, j]] * (r[[i, k]] + xc[[i, j]] * beta[[j, k]]);
180 }
181 gj[k] = s / n as f64;
182 }
183 let norm = {
184 let mut s = 0.0_f64;
185 for k in 0..q {
186 s += gj[k] * gj[k];
187 }
188 s.sqrt()
189 };
190 let mut new_row = vec![0.0_f64; q];
191 if norm > l1 {
192 let factor = 1.0 - l1 / norm;
193 for k in 0..q {
194 new_row[k] = factor * gj[k] / (col_sq[j] + l2);
195 }
196 }
197 for k in 0..q {
198 let d_val = (new_row[k] - beta[[j, k]]).abs();
199 if d_val > max_delta {
200 max_delta = d_val;
201 }
202 }
203 for k in 0..q {
205 let diff = beta[[j, k]] - new_row[k];
206 for i in 0..n {
207 r[[i, k]] += xc[[i, j]] * diff;
208 }
209 beta[[j, k]] = new_row[k];
210 }
211 }
212 if max_delta < tol {
213 converged = true;
214 break;
215 }
216 }
217 Ok(Self {
218 coef: beta,
219 x_mean,
220 y_mean,
221 alpha,
222 l1_ratio,
223 n_iter: iters,
224 converged,
225 })
226 }
227
228 pub fn predict(&self, x: ArrayView2<'_, f64>) -> Result<Array2<f64>> {
230 let d = self.x_mean.len();
231 let q = self.y_mean.len();
232 if x.ncols() != d {
233 return Err(Error::Shape("MultiTaskEN::predict: shape mismatch".into()));
234 }
235 let n = x.nrows();
236 let mut out = Array2::<f64>::zeros((n, q));
237 for i in 0..n {
238 for j in 0..q {
239 let mut s = self.y_mean[j];
240 for k in 0..d {
241 s += (x[[i, k]] - self.x_mean[k]) * self.coef[[k, j]];
242 }
243 out[[i, j]] = s;
244 }
245 }
246 Ok(out)
247 }
248}
249
250#[cfg(test)]
251mod tests {
252 use super::*;
253 use ndarray::array;
254
255 #[test]
256 fn multi_task_lasso_recovers_a_two_output_linear_signal() {
257 let x = array![
259 [1.0_f64, 0.0], [0.0, 1.0], [2.0, 1.0], [1.0, 2.0], [3.0, 2.0]
260 ];
261 let y = array![
262 [2.0_f64, -1.0], [3.0, 1.0], [7.0, -1.0], [8.0, 1.0], [12.0, -1.0]
263 ];
264 let m = MultiTaskLasso::fit_with(x.view(), y.view(), 0.001, 5000, 1e-8).unwrap();
265 let p = m.predict(x.view()).unwrap();
266 for i in 0..5 {
267 for j in 0..2 {
268 assert!((p[[i, j]] - y[[i, j]]).abs() < 0.2, "row {i} col {j}: pred={} y={}", p[[i, j]], y[[i, j]]);
269 }
270 }
271 }
272}