1use ndarray::{Array1, Array2, ArrayView1, ArrayView2, Axis};
15use solow_core::{Error, Result};
16use std::collections::BTreeMap;
17
18#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
30#[derive(Clone, Debug, PartialEq)]
31pub struct LabelEncoder {
32 pub classes: Vec<String>,
36}
37
38impl LabelEncoder {
39 pub fn fit<I, T>(labels: I) -> Self
41 where
42 I: IntoIterator<Item = T>,
43 T: ToString,
44 {
45 let mut set: BTreeMap<String, ()> = BTreeMap::new();
46 for l in labels {
47 set.insert(l.to_string(), ());
48 }
49 Self {
50 classes: set.into_keys().collect(),
51 }
52 }
53
54 pub fn n_classes(&self) -> usize {
56 self.classes.len()
57 }
58
59 pub fn transform<I, T>(&self, labels: I) -> Result<Array1<usize>>
61 where
62 I: IntoIterator<Item = T>,
63 T: ToString,
64 {
65 let ll: Vec<String> = labels.into_iter().map(|l| l.to_string()).collect();
66 let mut out = Array1::<usize>::zeros(ll.len());
67 for (i, l) in ll.iter().enumerate() {
68 let idx = self
69 .classes
70 .binary_search(l)
71 .map_err(|_| Error::Value(format!("LabelEncoder: unseen label {l:?}")))?;
72 out[i] = idx;
73 }
74 Ok(out)
75 }
76
77 pub fn inverse_transform(&self, encoded: ArrayView1<'_, usize>) -> Result<Vec<String>> {
79 let mut out = Vec::with_capacity(encoded.len());
80 for &c in encoded.iter() {
81 if c >= self.classes.len() {
82 return Err(Error::Value(format!(
83 "LabelEncoder::inverse_transform: class {c} is out of range for {}",
84 self.classes.len()
85 )));
86 }
87 out.push(self.classes[c].clone());
88 }
89 Ok(out)
90 }
91
92 pub fn fit_transform<I, T>(labels: I) -> (Self, Array1<usize>)
94 where
95 I: IntoIterator<Item = T>,
96 T: ToString,
97 T: Clone,
98 {
99 let materialized: Vec<T> = labels.into_iter().collect();
101 let enc = Self::fit(materialized.iter().cloned());
102 let arr = enc
103 .transform(materialized.into_iter())
104 .expect("fit vocabulary must cover every input label");
105 (enc, arr)
106 }
107}
108
109#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
120#[derive(Clone, Debug, PartialEq)]
121pub struct OrdinalEncoder {
122 pub encoders: Vec<LabelEncoder>,
124}
125
126impl OrdinalEncoder {
127 pub fn fit(x: ArrayView2<'_, f64>) -> Result<Self> {
129 if x.nrows() == 0 || x.ncols() == 0 {
130 return Err(Error::Value(
131 "OrdinalEncoder::fit: x must have at least one row and one column".into(),
132 ));
133 }
134 let mut encoders = Vec::with_capacity(x.ncols());
135 for j in 0..x.ncols() {
136 let col: Vec<String> = x.column(j).iter().map(|v| v.to_string()).collect();
137 encoders.push(LabelEncoder::fit(col.into_iter()));
138 }
139 Ok(Self { encoders })
140 }
141
142 pub fn transform(&self, x: ArrayView2<'_, f64>) -> Result<Array2<usize>> {
144 if x.ncols() != self.encoders.len() {
145 return Err(Error::Shape(format!(
146 "OrdinalEncoder::transform: expected {} columns, got {}",
147 self.encoders.len(),
148 x.ncols()
149 )));
150 }
151 let mut out = Array2::<usize>::zeros((x.nrows(), x.ncols()));
152 for j in 0..x.ncols() {
153 let col: Vec<String> = x.column(j).iter().map(|v| v.to_string()).collect();
154 let enc = self.encoders[j].transform(col.into_iter())?;
155 for i in 0..x.nrows() {
156 out[[i, j]] = enc[i];
157 }
158 }
159 Ok(out)
160 }
161
162 pub fn fit_transform(x: ArrayView2<'_, f64>) -> Result<(Self, Array2<usize>)> {
164 let e = Self::fit(x)?;
165 let t = e.transform(x)?;
166 Ok((e, t))
167 }
168}
169
170#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
181#[derive(Clone, Debug, PartialEq)]
182pub struct OneHotEncoder {
183 pub encoders: Vec<LabelEncoder>,
185 pub drop_first: bool,
189}
190
191impl OneHotEncoder {
192 pub fn fit(x: ArrayView2<'_, f64>) -> Result<Self> {
194 Self::fit_with(x, false)
195 }
196
197 pub fn fit_with(x: ArrayView2<'_, f64>, drop_first: bool) -> Result<Self> {
199 if x.nrows() == 0 || x.ncols() == 0 {
200 return Err(Error::Value(
201 "OneHotEncoder::fit: x must have at least one row and one column".into(),
202 ));
203 }
204 let ord = OrdinalEncoder::fit(x)?;
205 Ok(Self {
206 encoders: ord.encoders,
207 drop_first,
208 })
209 }
210
211 pub fn n_output_columns(&self) -> usize {
213 self.encoders
214 .iter()
215 .map(|e| {
216 let k = e.n_classes();
217 if self.drop_first {
218 k.saturating_sub(1)
219 } else {
220 k
221 }
222 })
223 .sum()
224 }
225
226 pub fn transform(&self, x: ArrayView2<'_, f64>) -> Result<Array2<f64>> {
228 if x.ncols() != self.encoders.len() {
229 return Err(Error::Shape(format!(
230 "OneHotEncoder::transform: expected {} columns, got {}",
231 self.encoders.len(),
232 x.ncols()
233 )));
234 }
235 let cols_out = self.n_output_columns();
236 let mut out = Array2::<f64>::zeros((x.nrows(), cols_out));
237 let mut base_col = 0usize;
239 for (j, enc) in self.encoders.iter().enumerate() {
240 let k = enc.n_classes();
241 let drop = if self.drop_first { 1 } else { 0 };
242 let block_width = k - drop;
243 let col: Vec<String> = x.column(j).iter().map(|v| v.to_string()).collect();
244 let codes = enc.transform(col.into_iter())?;
245 for i in 0..x.nrows() {
246 let c = codes[i];
247 if c < drop {
248 continue;
250 }
251 out[[i, base_col + (c - drop)]] = 1.0;
252 }
253 base_col += block_width;
254 }
255 Ok(out)
256 }
257
258 pub fn fit_transform(x: ArrayView2<'_, f64>) -> Result<(Self, Array2<f64>)> {
260 let e = Self::fit(x)?;
261 let t = e.transform(x)?;
262 Ok((e, t))
263 }
264}
265
266#[allow(dead_code)]
268fn _touch(_: Axis) {}
269
270#[cfg(test)]
271mod tests {
272 use super::*;
273 use ndarray::array;
274
275 #[test]
276 fn label_encoder_round_trip() {
277 let (enc, codes) = LabelEncoder::fit_transform(["b", "a", "c", "a", "b"]);
278 assert_eq!(
279 enc.classes,
280 vec!["a".to_string(), "b".to_string(), "c".to_string()]
281 );
282 assert_eq!(codes.to_vec(), vec![1, 0, 2, 0, 1]);
283 let back = enc.inverse_transform(codes.view()).unwrap();
284 assert_eq!(back, vec!["b", "a", "c", "a", "b"]);
285 }
286
287 #[test]
288 fn label_encoder_rejects_unseen() {
289 let enc = LabelEncoder::fit(["a", "b", "c"]);
290 assert!(enc.transform(["a", "d"].into_iter()).is_err());
291 }
292
293 #[test]
294 fn one_hot_no_drop_produces_full_block() {
295 let x = array![[0.0], [1.0], [2.0], [0.0]];
296 let (enc, oh) = OneHotEncoder::fit_transform(x.view()).unwrap();
297 assert_eq!(enc.n_output_columns(), 3);
298 assert_eq!(oh.dim(), (4, 3));
299 assert_eq!(oh.row(0).to_vec(), vec![1.0, 0.0, 0.0]);
301 assert_eq!(oh.row(1).to_vec(), vec![0.0, 1.0, 0.0]);
302 assert_eq!(oh.row(2).to_vec(), vec![0.0, 0.0, 1.0]);
303 }
304
305 #[test]
306 fn one_hot_drop_first_drops_baseline() {
307 let x = array![[0.0], [1.0], [2.0]];
308 let enc = OneHotEncoder::fit_with(x.view(), true).unwrap();
309 let oh = enc.transform(x.view()).unwrap();
310 assert_eq!(oh.dim(), (3, 2));
311 assert_eq!(oh.row(0).to_vec(), vec![0.0, 0.0]); assert_eq!(oh.row(1).to_vec(), vec![1.0, 0.0]);
313 assert_eq!(oh.row(2).to_vec(), vec![0.0, 1.0]);
314 }
315}