Skip to main content

solow_regression/
multitask.rs

1//! MultiTaskLasso and MultiTaskElasticNet — joint sparsity across
2//! several regression tasks (Argyriou-Evgeniou-Pontil 2007).
3//!
4//! Given `X ∈ ℝ^{n × d}` and `Y ∈ ℝ^{n × q}`, solve
5//!
6//! ```text
7//!     β̂ = arg min_{β ∈ ℝ^{d × q}} (1/2n) ‖Y − Xβ‖_F² + α · Σⱼ ‖βⱼ,·‖₂
8//! ```
9//!
10//! for MultiTaskLasso, and add an `(1 − ρ)·L2` term for the elastic-net
11//! variant.
12
13use ndarray::{Array2, ArrayView2};
14use solow_core::{Error, Result};
15
16/// Fitted MultiTaskLasso.
17#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
18#[derive(Clone, Debug, PartialEq)]
19pub struct MultiTaskLasso {
20    /// Coefficient matrix `(d × q)`.
21    pub coef: Array2<f64>,
22    /// Column mean subtracted at fit (`d`).
23    pub x_mean: Vec<f64>,
24    /// Y mean subtracted at fit (`q`).
25    pub y_mean: Vec<f64>,
26    /// L1 penalty α used.
27    pub alpha: f64,
28    /// Convergence iterations run.
29    pub n_iter: usize,
30    /// Whether convergence was reached.
31    pub converged: bool,
32}
33
34impl MultiTaskLasso {
35    /// Fit with the reference defaults `alpha = 1.0`, `max_iter = 1000`, `tol = 1e-4`.
36    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    /// Full-configuration fit.
41    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    /// Predict.
59    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/// Fitted MultiTaskElasticNet.
81#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
82#[derive(Clone, Debug, PartialEq)]
83pub struct MultiTaskElasticNet {
84    /// Coefficient matrix `(d × q)`.
85    pub coef: Array2<f64>,
86    /// Column mean subtracted at fit (`d`).
87    pub x_mean: Vec<f64>,
88    /// Y mean subtracted at fit (`q`).
89    pub y_mean: Vec<f64>,
90    /// Combined penalty (α controls total strength, l1_ratio controls sparsity).
91    pub alpha: f64,
92    /// L1/L2 mix.
93    pub l1_ratio: f64,
94    /// Convergence iterations run.
95    pub n_iter: usize,
96    /// Whether convergence was reached.
97    pub converged: bool,
98}
99
100impl MultiTaskElasticNet {
101    /// Fit with the reference defaults `alpha = 1.0`, `l1_ratio = 0.5`,
102    /// `max_iter = 1000`, `tol = 1e-4`.
103    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    /// Full-configuration fit.
108    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        // Centre X and Y column-wise.
131        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        // Column-of-X L2 norms (for the coord-descent step size).
154        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                // Row j of β. Full residual gradient:
174                //   g = (1/n) X_jᵀ (R + X_j βⱼ)
175                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                // Update residual: R += X_j (β_old − β_new).
204                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    /// Predict.
229    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        // y_0 = 2·x_0 + 3·x_1, y_1 = -x_0 + x_1
258        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}