diff --git a/src/preprocessing/categorical_encoder.rs b/src/preprocessing/categorical_encoder.rs index 75cbf2b..18e569a 100644 --- a/src/preprocessing/categorical_encoder.rs +++ b/src/preprocessing/categorical_encoder.rs @@ -1,12 +1,12 @@ //! # One-hot Encoding For [RealNumber](../../math/num/trait.RealNumber.html) Matricies //! Transform a data [Matrix](../../linalg/trait.BaseMatrix.html) by replacing all categorical variables with their one-hot equivalents //! -//! Internally OneHotEncoder treats every categorical column as a series and transforms it using [SeriesOneHotEncoder](../series_encoder/struct.SeriesOneHotEncoder.html) +//! Internally OneHotEncoder treats every categorical column as a series and transforms it using [CategoryMapper](../series_encoder/struct.CategoryMapper.html) //! //! ### Usage Example //! ``` //! use smartcore::linalg::naive::dense_matrix::DenseMatrix; -//! use smartcore::preprocessing::categorical_encoder::{OneHotEnc, OneHotEncoderParams}; +//! use smartcore::preprocessing::categorical_encoder::{OneHotEncoder, OneHotEncoderParams}; //! let data = DenseMatrix::from_2d_array(&[ //! &[1.5, 1.0, 1.5, 3.0], //! &[1.5, 2.0, 1.5, 4.0], @@ -15,7 +15,7 @@ //! ]); //! let encoder_params = OneHotEncoderParams::from_cat_idx(&[1, 3]); //! // Infer number of categories from data and return a reusable encoder -//! let encoder = OneHotEnc::fit(&data, encoder_params).unwrap(); +//! let encoder = OneHotEncoder::fit(&data, encoder_params).unwrap(); //! // Transform categorical to one-hot encoded (can transform similar) //! let oh_data = encoder.transform(&data).unwrap(); //! // Produces the following: @@ -30,7 +30,7 @@ use crate::error::Failed; use crate::linalg::Matrix; use crate::preprocessing::data_traits::{CategoricalFloat, Categorizable}; -use crate::preprocessing::series_encoder::{SeriesOneHotEncoder, SeriesEncoder}; +use crate::preprocessing::series_encoder::CategoryMapper; /// OneHotEncoder Parameters #[derive(Debug, Clone)] @@ -97,17 +97,18 @@ fn validate_col_is_categorical(data: &[T]) -> bool { /// Encode Categorical variavbles of data matrix to one-hot #[derive(Debug, Clone)] -pub struct OneHotEncoder { - series_encoders: Vec, +pub struct OneHotEncoder { + category_mappers: Vec>, col_idx_categorical: Vec, } -impl> OneHotEncoder { +impl OneHotEncoder { /// Create an encoder instance with categories infered from data matrix - pub fn fit>( - data: &M, - params: OneHotEncoderParams, - ) -> Result, Failed> { + pub fn fit(data: &M, params: OneHotEncoderParams) -> Result + where + T: Categorizable, + M: Matrix, + { match (params.col_idx_categorical, params.infer_categorical) { (None, false) => Err(Failed::fit( "Must pass categorical series ids or infer flag", @@ -126,8 +127,7 @@ impl> OneHotEncoder { // col buffer to avoid allocations let mut col_buf: Vec = iter::repeat(T::zero()).take(nrows).collect(); - let mut res: Vec = - Vec::with_capacity(idxs.len()); + let mut res: Vec> = Vec::with_capacity(idxs.len()); for &idx in &idxs { data.copy_col_as_vec(idx, &mut col_buf); @@ -139,11 +139,11 @@ impl> OneHotEncoder { return Err(Failed::fit(&msg[..])); } let hashable_col = col_buf.iter().map(|v| v.to_category()); - res.push(E::fit_to_iter(hashable_col)); + res.push(CategoryMapper::fit_to_iter(hashable_col)); } Ok(Self { - series_encoders: res, //Self::build_series_encoders::(data, &idxs[..]), + category_mappers: res, col_idx_categorical: idxs, }) } @@ -155,10 +155,14 @@ impl> OneHotEncoder { } /// Transform categorical variables to one-hot encoded and return a new matrix - pub fn transform>(&self, x: &M) -> Result { + pub fn transform(&self, x: &M) -> Result + where + T: Categorizable, + M: Matrix, + { let (nrows, p) = x.shape(); let additional_params: Vec = self - .series_encoders + .category_mappers .iter() .map(|enc| enc.num_categories()) .collect(); @@ -172,10 +176,10 @@ impl> OneHotEncoder { for (pidx, &old_cidx) in self.col_idx_categorical.iter().enumerate() { let cidx = new_col_idx[old_cidx]; let col_iter = (0..nrows).map(|r| x.get(r, old_cidx).to_category()); - let sencoder = &self.series_encoders[pidx]; - let oh_series: Vec>> = sencoder.transform_iter(col_iter); + let sencoder = &self.category_mappers[pidx]; + let oh_series = col_iter.map(|c| sencoder.get_one_hot::>(&c)); - for (row, oh_vec) in oh_series.iter().enumerate() { + for (row, oh_vec) in oh_series.enumerate() { match oh_vec { None => { // Since we support T types, bad value in a series causes in to be invalid @@ -215,16 +219,11 @@ impl> OneHotEncoder { } } -/// Convinince type for common use -pub type OneHotEnc = OneHotEncoder>; - - #[cfg(test)] mod tests { use super::*; use crate::linalg::naive::dense_matrix::DenseMatrix; - use crate::preprocessing::series_encoder::SeriesOneHotEncoder; - + use crate::preprocessing::series_encoder::CategoryMapper; #[test] fn adjust_idxs() { @@ -275,8 +274,8 @@ mod tests { let series = vec![3.0, 1.0, 2.0, 1.0]; let hashable_series: Vec = series.iter().map(|v| v.to_category()).collect(); - let enc = SeriesOneHotEncoder::from_positional_category_vec(hashable_series); - let inv = enc.invert_one(vec![0.0, 0.0, 1.0]); + let enc = CategoryMapper::from_positional_category_vec(hashable_series); + let inv = enc.invert_one_hot(vec![0.0, 0.0, 1.0]); let orig_val: f64 = inv.unwrap().into(); assert_eq!(orig_val, 2.0); } @@ -284,11 +283,11 @@ mod tests { fn test_fit() { let (x, _) = build_fake_matrix(); let params = OneHotEncoderParams::from_cat_idx(&[1, 3]); - let oh_enc = OneHotEnc::fit(&x, params).unwrap(); - assert_eq!(oh_enc.series_encoders.len(), 2); + let oh_enc = OneHotEncoder::fit(&x, params).unwrap(); + assert_eq!(oh_enc.category_mappers.len(), 2); let num_cat: Vec = oh_enc - .series_encoders + .category_mappers .iter() .map(|a| a.num_categories()) .collect(); @@ -299,13 +298,13 @@ mod tests { fn matrix_transform_test() { let (x, expected_x) = build_fake_matrix(); let params = OneHotEncoderParams::from_cat_idx(&[1, 3]); - let oh_enc = OneHotEnc::fit(&x, params).unwrap(); + let oh_enc = OneHotEncoder::fit(&x, params).unwrap(); let nm = oh_enc.transform(&x).unwrap(); assert_eq!(nm, expected_x); let (x, expected_x) = build_cat_first_and_last(); let params = OneHotEncoderParams::from_cat_idx(&[0, 2]); - let oh_enc = OneHotEnc::fit(&x, params).unwrap(); + let oh_enc = OneHotEncoder::fit(&x, params).unwrap(); let nm = oh_enc.transform(&x).unwrap(); assert_eq!(nm, expected_x); } @@ -320,7 +319,7 @@ mod tests { ]); let params = OneHotEncoderParams::from_cat_idx(&[1]); - match OneHotEnc::fit(&m, params) { + match OneHotEncoder::fit(&m, params) { Err(_) => { assert!(true); }