Skip to main content

solow_preprocessing/
label_binarizer.rs

1//! `LabelBinarizer` and `MultiLabelBinarizer` — turn integer / string
2//! label vectors into a binary indicator matrix.
3
4use ndarray::{Array2, ArrayView2};
5use solow_core::{Error, Result};
6
7/// LabelBinarizer.
8#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
9#[derive(Clone, Debug, PartialEq)]
10pub struct LabelBinarizer {
11    /// Sorted unique labels seen at fit.
12    pub classes: Vec<i64>,
13    /// Whether the fit saw exactly 2 classes → returns a column vector.
14    pub is_binary: bool,
15}
16
17impl LabelBinarizer {
18    /// Fit.
19    pub fn fit(y: &[i64]) -> Result<Self> {
20        if y.is_empty() {
21            return Err(Error::Value("LabelBinarizer::fit: empty label vector".into()));
22        }
23        let mut classes: Vec<i64> = y.to_vec();
24        classes.sort();
25        classes.dedup();
26        let is_binary = classes.len() == 2;
27        Ok(Self { classes, is_binary })
28    }
29
30    /// Transform.
31    pub fn transform(&self, y: &[i64]) -> Result<Array2<f64>> {
32        let n = y.len();
33        if self.is_binary {
34            let mut out = Array2::<f64>::zeros((n, 1));
35            for i in 0..n {
36                if y[i] == self.classes[1] {
37                    out[[i, 0]] = 1.0;
38                }
39            }
40            Ok(out)
41        } else {
42            let k = self.classes.len();
43            let mut out = Array2::<f64>::zeros((n, k));
44            for i in 0..n {
45                if let Some(idx) = self.classes.iter().position(|&c| c == y[i]) {
46                    out[[i, idx]] = 1.0;
47                }
48            }
49            Ok(out)
50        }
51    }
52
53    /// Inverse-transform: argmax by column, mapped back to labels.
54    pub fn inverse_transform(&self, y: ArrayView2<'_, f64>) -> Result<Vec<i64>> {
55        let n = y.nrows();
56        if self.is_binary {
57            if y.ncols() != 1 {
58                return Err(Error::Shape("LabelBinarizer::inverse_transform: expected 1 column".into()));
59            }
60            Ok((0..n).map(|i| if y[[i, 0]] >= 0.5 { self.classes[1] } else { self.classes[0] }).collect())
61        } else {
62            if y.ncols() != self.classes.len() {
63                return Err(Error::Shape("LabelBinarizer::inverse_transform: column count mismatch".into()));
64            }
65            let k = self.classes.len();
66            Ok((0..n).map(|i| {
67                let mut best = 0;
68                let mut best_v = y[[i, 0]];
69                for c in 1..k {
70                    if y[[i, c]] > best_v {
71                        best_v = y[[i, c]];
72                        best = c;
73                    }
74                }
75                self.classes[best]
76            }).collect())
77        }
78    }
79}
80
81/// MultiLabelBinarizer — like LabelBinarizer but each sample can carry
82/// multiple labels (represented as a `Vec<i64>`).
83#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
84#[derive(Clone, Debug, PartialEq)]
85pub struct MultiLabelBinarizer {
86    /// Sorted unique labels seen at fit.
87    pub classes: Vec<i64>,
88}
89
90impl MultiLabelBinarizer {
91    /// Fit.
92    pub fn fit(y: &[Vec<i64>]) -> Result<Self> {
93        if y.is_empty() {
94            return Err(Error::Value("MultiLabelBinarizer::fit: empty input".into()));
95        }
96        let mut classes: Vec<i64> = y.iter().flatten().copied().collect();
97        classes.sort();
98        classes.dedup();
99        Ok(Self { classes })
100    }
101
102    /// Transform.
103    pub fn transform(&self, y: &[Vec<i64>]) -> Result<Array2<f64>> {
104        let n = y.len();
105        let k = self.classes.len();
106        let mut out = Array2::<f64>::zeros((n, k));
107        for i in 0..n {
108            for &lbl in &y[i] {
109                if let Some(idx) = self.classes.iter().position(|&c| c == lbl) {
110                    out[[i, idx]] = 1.0;
111                }
112            }
113        }
114        Ok(out)
115    }
116}
117
118#[cfg(test)]
119mod tests {
120    use super::*;
121
122    #[test]
123    fn label_binarizer_binary_returns_a_single_column() {
124        let y = vec![0_i64, 1, 0, 1];
125        let lb = LabelBinarizer::fit(&y).unwrap();
126        let z = lb.transform(&y).unwrap();
127        assert_eq!(z.shape(), &[4, 1]);
128    }
129
130    #[test]
131    fn label_binarizer_multiclass_returns_k_columns() {
132        let y = vec![0_i64, 1, 2, 0];
133        let lb = LabelBinarizer::fit(&y).unwrap();
134        let z = lb.transform(&y).unwrap();
135        assert_eq!(z.shape(), &[4, 3]);
136    }
137
138    #[test]
139    fn multilabel_binarizer_returns_a_correct_indicator_matrix() {
140        let y = vec![vec![0_i64, 1], vec![1], vec![2, 0]];
141        let mlb = MultiLabelBinarizer::fit(&y).unwrap();
142        let z = mlb.transform(&y).unwrap();
143        assert_eq!(z.shape(), &[3, 3]);
144        assert_eq!(z[[0, 0]], 1.0);
145        assert_eq!(z[[0, 1]], 1.0);
146        assert_eq!(z[[0, 2]], 0.0);
147    }
148}