solow_preprocessing/
label_binarizer.rs1use ndarray::{Array2, ArrayView2};
5use solow_core::{Error, Result};
6
7#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
9#[derive(Clone, Debug, PartialEq)]
10pub struct LabelBinarizer {
11 pub classes: Vec<i64>,
13 pub is_binary: bool,
15}
16
17impl LabelBinarizer {
18 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 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 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#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
84#[derive(Clone, Debug, PartialEq)]
85pub struct MultiLabelBinarizer {
86 pub classes: Vec<i64>,
88}
89
90impl MultiLabelBinarizer {
91 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 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}