work/smartcore
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Renaming fit/transform for API compatibility. Also rename label to category.

Browse Source
This commit is contained in:
gaxler
2021-01-27 12:13:45 -08:00
parent 19088b682a
commit 6109fc5211
1 changed files with 70 additions and 102 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/preprocessing/target_encoders.rs
+69 -101
View File
@@ -2,96 +2,86 @@
//! # Encode categorical features as a one-hot or multi-class numeric array. //! # Encode categorical features as a one-hot or multi-class numeric array.
use crate::error::Failed; use crate::error::Failed;
use crate::linalg::BaseVector;
use crate::math::num::RealNumber; use crate::math::num::RealNumber;
use std::collections::HashMap; use std::collections::HashMap;
use std::hash::Hash; use std::hash::Hash;
/// Make a one-hot encoded vector from a categorical variable /// Make a one-hot encoded vector from a categorical variable
pub fn make_one_hot<T: RealNumber, V: BaseVector<T>>(label_idx: usize, num_labels: usize) -> V { pub fn make_one_hot<T: RealNumber, V: BaseVector<T>>(category_idx: usize, num_categories: usize) -> V {
let pos = T::from_f64(1f64).unwrap(); let pos = T::from_f64(1f64).unwrap();
let mut z = V::zeros(num_labels); let mut z = V::zeros(num_categories);
z.set(label_idx, pos); z.set(category_idx, pos);
z z
} }
/// Turn a collection of `CategoryType`s into a one-hot vectors.
/// This struct encodes single class per exmample /// This struct encodes single class per exmample
/// ///
/// You can fit a label enumeration by passing a collection of labels. /// You can fit_to_series a category enumeration by passing a collection of categories.
/// Label numbers will be assigned in the order they are encountered /// category numbers will be assigned in the order they are encountered
/// ///
/// Example: /// Example:
/// ``` /// ```
/// use std::collections::HashMap; /// use std::collections::HashMap;
/// use smartcore::preprocessing::target_encoders::OneHotEncoder; /// use smartcore::preprocessing::target_encoders::OneHotEncoder;
/// ///
/// let fake_labels: Vec<usize> = vec![1,2,3,4,5,3,5,3,1,2,4]; /// let fake_categories: Vec<usize> = vec![1,2,3,4,5,3,5,3,1,2,4];
/// let enc = OneHotEncoder::<usize>::fit(&fake_labels[..]); /// let enc = OneHotEncoder::<usize>::fit_to_series(&fake_categories[..]);
/// let oh_vec: Vec<f64> = enc.transform_one(&1).unwrap(); /// let oh_vec: Vec<f64> = enc.transform_one(&1).unwrap();
/// // notice that 1 is actually a zero-th positional label /// // notice that 1 is actually a zero-th positional category
/// assert_eq!(oh_vec, vec![1.0, 0.0, 0.0, 0.0, 0.0]); /// assert_eq!(oh_vec, vec![1.0, 0.0, 0.0, 0.0, 0.0]);
/// ``` /// ```
/// ///
/// You can also pass a predefined label enumeration such as a hashmap `HashMap<LabelType, usize>` or a vector `Vec<LabelType>` /// You can also pass a predefined category enumeration such as a hashmap `HashMap<CategoryType, usize>` or a vector `Vec<CategoryType>`
/// ///
/// ///
/// ``` /// ```
/// use std::collections::HashMap; /// use std::collections::HashMap;
/// use smartcore::preprocessing::target_encoders::OneHotEncoder; /// use smartcore::preprocessing::target_encoders::OneHotEncoder;
/// ///
/// let label_map: HashMap<&str, usize> = /// let category_map: HashMap<&str, usize> =
/// vec![("cat", 2), ("background",0), ("dog", 1)] /// vec![("cat", 2), ("background",0), ("dog", 1)]
/// .into_iter() /// .into_iter()
/// .collect(); /// .collect();
/// let label_vec = vec!["background", "dog", "cat"]; /// let category_vec = vec!["background", "dog", "cat"];
/// ///
/// let enc_lv = OneHotEncoder::<&str>::from_positional_label_vec(label_vec); /// let enc_lv = OneHotEncoder::<&str>::from_positional_category_vec(category_vec);
/// let enc_lm = OneHotEncoder::<&str>::from_label_map(label_map); /// let enc_lm = OneHotEncoder::<&str>::from_category_map(category_map);
/// ///
/// // ["background", "dog", "cat"] /// // ["background", "dog", "cat"]
/// println!("{:?}", enc_lv.get_labels()); /// println!("{:?}", enc_lv.get_categories());
/// assert_eq!(enc_lv.transform_one::<f64>(&"dog"), enc_lm.transform_one::<f64>(&"dog")) /// assert_eq!(enc_lv.transform_one::<f64>(&"dog"), enc_lm.transform_one::<f64>(&"dog"))
/// ``` /// ```
pub struct OneHotEncoder<LabelType> { pub struct OneHotEncoder<CategoryType> {
label_to_idx: HashMap<LabelType, usize>, category_map: HashMap<CategoryType, usize>,
labels: Vec<LabelType>, categories: Vec<CategoryType>,
num_classes: usize, num_categories: usize,
} }
enum LabelDefinition<T> { impl<CategoryType: Hash + Eq + Clone> OneHotEncoder<CategoryType> {
LabelToClsNumMap(HashMap<T, usize>),
PositionalLabel(Vec<T>),
}
/// Crearte a vector of size num_labels with zeros everywhere and 1 at label_idx (one-hot vector)
pub fn make_one_hot<T: RealNumber>(label_idx: usize, num_labels: usize) -> Vec<T> {
let (pos, neg) = (T::from_f64(1f64).unwrap(), T::from_f64(0f64).unwrap());
(0..num_labels)
.map(|idx| if idx == label_idx { pos } else { neg })
.collect()
}
impl<'a, LabelType: Hash + Eq + Clone> OneHotEncoder<LabelType> {
/// Fit an encoder to a lable list /// Fit an encoder to a lable list
pub fn fit(labels: &[LabelType]) -> Self { pub fn fit_to_series(categories: &[CategoryType]) -> Self {
let mut label_map: HashMap<LabelType, usize> = HashMap::new(); let mut category_map: HashMap<CategoryType, usize> = HashMap::new();
let mut class_num = 0usize; let mut category_num = 0usize;
let mut unique_lables: Vec<LabelType> = Vec::new(); let mut unique_lables: Vec<CategoryType> = Vec::new();
for l in labels { for l in categories {
if !label_map.contains_key(&l) { if !category_map.contains_key(&l) {
label_map.insert(l.clone(), class_num); category_map.insert(l.clone(), category_num);
unique_lables.push(l.clone()); unique_lables.push(l.clone());
class_num += 1; category_num += 1;
} }
} }
Self { Self {
label_to_idx: label_map, category_map: category_map,
num_classes: class_num, num_categories: category_num,
labels: unique_lables, categories: unique_lables,
} }
} }
/// Build an encoder from a predefined (label -> class number) map /// Build an encoder from a predefined (category -> class number) map
pub fn from_label_map(category_map: HashMap<CategoryType, usize>) -> Self { pub fn from_category_map(category_map: HashMap<CategoryType, usize>) -> Self {
let mut _unique_cat: Vec<(CategoryType, usize)> = let mut _unique_cat: Vec<(CategoryType, usize)> =
category_map.iter().map(|(k, v)| (k.clone(), *v)).collect(); category_map.iter().map(|(k, v)| (k.clone(), *v)).collect();
_unique_cat.sort_by(|a, b| a.1.cmp(&b.1)); _unique_cat.sort_by(|a, b| a.1.cmp(&b.1));
@@ -103,9 +93,8 @@ impl<'a, LabelType: Hash + Eq + Clone> OneHotEncoder<LabelType> {
} }
} }
/// Build an encoder from a predefined positional label-class num vector /// Build an encoder from a predefined positional category-class num vector
pub fn from_positional_label_vec(categories: Vec<CategoryType>) -> Self { pub fn from_positional_category_vec(categories: Vec<CategoryType>) -> Self {
// Self::from_label_def(LabelDefinition::PositionalLabel(categories))
let category_map: HashMap<CategoryType, usize> = categories let category_map: HashMap<CategoryType, usize> = categories
.iter() .iter()
.enumerate() .enumerate()
@@ -118,27 +107,30 @@ impl<'a, LabelType: Hash + Eq + Clone> OneHotEncoder<LabelType> {
} }
} }
/// Transform a slice of label types into one-hot vectors /// Transform a slice of category types into one-hot vectors
/// None is returned if unknown label is encountered /// None is returned if unknown category is encountered
pub fn transform<U: RealNumber>(&self, labels: &[LabelType]) -> Vec<Option<Vec<U>>> { pub fn transfrom_series<U: RealNumber>(
labels.iter().map(|l| self.transform_one(l)).collect() &self,
categories: &[CategoryType],
) -> Vec<Option<Vec<U>>> {
categories.iter().map(|l| self.transform_one(l)).collect()
} }
/// Transform a single label type into a one-hot vector /// Transform a single category type into a one-hot vector
pub fn transform_one<U: RealNumber>(&self, label: &LabelType) -> Option<Vec<U>> { pub fn transform_one<U: RealNumber>(&self, category: &CategoryType) -> Option<Vec<U>> {
match self.label_to_idx.get(label) { match self.category_map.get(category) {
None => None, None => None,
Some(&idx) => Some(make_one_hot(idx, self.num_classes)), Some(&idx) => Some(make_one_hot(idx, self.num_categories)),
} }
} }
/// Get labels ordered by encoder's label enumeration /// Get categories ordered by encoder's category enumeration
pub fn get_labels(&self) -> &Vec<LabelType> { pub fn get_categories(&self) -> &Vec<CategoryType> {
&self.labels &self.categories
} }
/// Invert one-hot vector, back to the label /// Invert one-hot vector, back to the category
pub fn invert_one<U: RealNumber>(&self, one_hot: Vec<U>) -> Result<LabelType, Failed> { pub fn invert_one<U: RealNumber>(&self, one_hot: Vec<U>) -> Result<CategoryType, Failed> {
let pos = U::from_f64(1f64).unwrap(); let pos = U::from_f64(1f64).unwrap();
let s: Vec<usize> = one_hot let s: Vec<usize> = one_hot
@@ -149,7 +141,7 @@ impl<'a, LabelType: Hash + Eq + Clone> OneHotEncoder<LabelType> {
if s.len() == 1 { if s.len() == 1 {
let idx = s[0]; let idx = s[0];
return Ok(self.labels[idx].clone()); return Ok(self.categories[idx].clone());
} }
let pos_entries = format!( let pos_entries = format!(
"Expected a single positive entry, {} entires found", "Expected a single positive entry, {} entires found",
@@ -157,31 +149,6 @@ impl<'a, LabelType: Hash + Eq + Clone> OneHotEncoder<LabelType> {
); );
Err(Failed::transform(&pos_entries[..])) Err(Failed::transform(&pos_entries[..]))
} }
fn from_label_def(labels: LabelDefinition<LabelType>) -> Self {
let (label_map, class_num, unique_lables) = match labels {
LabelDefinition::LabelToClsNumMap(h) => {
let mut _unique_lab: Vec<(LabelType, usize)> =
h.iter().map(|(k, v)| (k.clone(), *v)).collect();
_unique_lab.sort_by(|a, b| a.1.cmp(&b.1));
let unique_lab: Vec<LabelType> = _unique_lab.into_iter().map(|a| a.0).collect();
(h, unique_lab.len(), unique_lab)
}
LabelDefinition::PositionalLabel(unique_lab) => {
let h: HashMap<LabelType, usize> = unique_lab
.iter()
.enumerate()
.map(|(v, k)| (k.clone(), v))
.collect();
(h, unique_lab.len(), unique_lab)
}
};
Self {
label_to_idx: label_map,
num_classes: class_num,
labels: unique_lables,
}
}
} }
#[cfg(test)] #[cfg(test)]
@@ -189,11 +156,11 @@ mod tests {
use super::*; use super::*;
#[test] #[test]
fn from_labels() { fn from_categories() {
let fake_labels: Vec<usize> = vec![1, 2, 3, 4, 5, 3, 5, 3, 1, 2, 4]; let fake_categories: Vec<usize> = vec![1, 2, 3, 4, 5, 3, 5, 3, 1, 2, 4];
let enc = OneHotEncoder::<usize>::fit(&fake_labels[0..]); let enc = OneHotEncoder::<usize>::fit_to_series(&fake_categories[0..]);
let oh_vec: Vec<f64> = match enc.transform_one(&1) { let oh_vec: Vec<f64> = match enc.transform_one(&1) {
None => panic!("Wrong labels"), None => panic!("Wrong categories"),
Some(v) => v, Some(v) => v,
}; };
let res: Vec<f64> = vec![1f64, 0f64, 0f64, 0f64, 0f64]; let res: Vec<f64> = vec![1f64, 0f64, 0f64, 0f64, 0f64];
@@ -201,19 +168,19 @@ mod tests {
} }
fn build_fake_str_enc<'a>() -> OneHotEncoder<&'a str> { fn build_fake_str_enc<'a>() -> OneHotEncoder<&'a str> {
let fake_label_pos = vec!["background", "dog", "cat"]; let fake_category_pos = vec!["background", "dog", "cat"];
let enc = OneHotEncoder::<&str>::from_positional_label_vec(fake_label_pos); let enc = OneHotEncoder::<&str>::from_positional_category_vec(fake_category_pos);
enc enc
} }
#[test] #[test]
fn label_map_and_vec() { fn category_map_and_vec() {
let label_map: HashMap<&str, usize> = vec![("background", 0), ("dog", 1), ("cat", 2)] let category_map: HashMap<&str, usize> = vec![("background", 0), ("dog", 1), ("cat", 2)]
.into_iter() .into_iter()
.collect(); .collect();
let enc = OneHotEncoder::<&str>::from_label_map(label_map); let enc = OneHotEncoder::<&str>::from_category_map(category_map);
let oh_vec: Vec<f64> = match enc.transform_one(&"dog") { let oh_vec: Vec<f64> = match enc.transform_one(&"dog") {
None => panic!("Wrong labels"), None => panic!("Wrong categories"),
Some(v) => v, Some(v) => v,
}; };
let res: Vec<f64> = vec![0f64, 1f64, 0f64]; let res: Vec<f64> = vec![0f64, 1f64, 0f64];
@@ -221,10 +188,10 @@ mod tests {
} }
#[test] #[test]
fn positional_labels_vec() { fn positional_categories_vec() {
let enc = build_fake_str_enc(); let enc = build_fake_str_enc();
let oh_vec: Vec<f64> = match enc.transform_one(&"dog") { let oh_vec: Vec<f64> = match enc.transform_one(&"dog") {
None => panic!("Wrong labels"), None => panic!("Wrong categories"),
Some(v) => v, Some(v) => v,
}; };
let res: Vec<f64> = vec![0.0, 1.0, 0.0]; let res: Vec<f64> = vec![0.0, 1.0, 0.0];
@@ -244,9 +211,10 @@ mod tests {
} }
#[test] #[test]
fn test_many_labels() { fn test_many_categorys() {
let enc = build_fake_str_enc(); let enc = build_fake_str_enc();
let res: Vec<Option<Vec<f64>>> = enc.transform(&["dog", "cat", "fish", "background"]); let res: Vec<Option<Vec<f64>>> =
enc.transfrom_series(&["dog", "cat", "fish", "background"]);
let v = vec![ let v = vec![
Some(vec![0.0, 1.0, 0.0]), Some(vec![0.0, 1.0, 0.0]),
Some(vec![0.0, 0.0, 1.0]), Some(vec![0.0, 0.0, 1.0]),