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

fmt fix

Browse Source
This commit is contained in:
gaxler
2021-01-25 23:55:43 -08:00
parent 991631876e
commit dbca6d43ce
3 changed files with 79 additions and 75 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/lib.rs
+2 -2
View File
@@ -91,9 +91,9 @@ pub mod naive_bayes;
/// Supervised neighbors-based learning methods /// Supervised neighbors-based learning methods
pub mod neighbors; pub mod neighbors;
pub(crate) mod optimization; pub(crate) mod optimization;
/// Preprocessing utilities
pub mod preprocessing;
/// Support Vector Machines /// Support Vector Machines
pub mod svm; pub mod svm;
/// Supervised tree-based learning methods /// Supervised tree-based learning methods
pub mod tree; pub mod tree;
/// Preprocessing utilities
pub mod preprocessing;
src/preprocessing/target_encoders.rs
+70 -66
View File
@@ -1,22 +1,18 @@
#![allow(clippy::ptr_arg)] #![allow(clippy::ptr_arg)]
//! # 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 std::hash::Hash;
use std::collections::HashMap;
use crate::math::num::RealNumber;
use crate::error::Failed; use crate::error::Failed;
use crate::math::num::RealNumber;
use std::collections::HashMap;
use std::hash::Hash;
/// Turn a collection of label types into a one-hot vectors. /// Turn a collection of label types into a one-hot vectors.
/// This struct encodes single class per exmample /// This struct encodes single class per exmample
pub struct OneHotEncoder<T> { pub struct OneHotEncoder<T> {
label_to_idx: HashMap<T, usize>, label_to_idx: HashMap<T, usize>,
labels: Vec<T>, labels: Vec<T>,
num_classes: usize num_classes: usize,
} }
enum LabelDefinition<T> { enum LabelDefinition<T> {
@@ -27,13 +23,18 @@ enum LabelDefinition<T> {
/// Crearte a vector of size num_labels with zeros everywhere and 1 at label_idx (one-hot vector) /// 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> { 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()); let (pos, neg) = (T::from_f64(1f64).unwrap(), T::from_f64(0f64).unwrap());
(0..num_labels).map(|idx| if idx == label_idx {pos.clone()} else {neg.clone()}).collect() (0..num_labels)
.map(|idx| {
if idx == label_idx {
pos.clone()
} else {
neg.clone()
}
})
.collect()
} }
impl<'a, T: Hash + Eq + Clone> OneHotEncoder<T> impl<'a, T: Hash + Eq + Clone> OneHotEncoder<T> {
{
/// Fit an encoder to a lable list /// Fit an encoder to a lable list
/// ///
/// Label numbers will be assigned in the order they are encountered /// Label numbers will be assigned in the order they are encountered
@@ -45,23 +46,24 @@ impl<'a, T: Hash + Eq + Clone> OneHotEncoder<T>
/// assert_eq!(oh_vec, vec![1f64,0f64,0f64,0f64,0f64]); /// assert_eq!(oh_vec, vec![1f64,0f64,0f64,0f64,0f64]);
/// ``` /// ```
pub fn fit(labels: &[T]) -> Self { pub fn fit(labels: &[T]) -> Self {
let mut label_map: HashMap<T, usize> = HashMap::new(); let mut label_map: HashMap<T, usize> = HashMap::new();
let mut class_num = 0usize; let mut class_num = 0usize;
let mut unique_lables: Vec<T> = Vec::new(); let mut unique_lables: Vec<T> = Vec::new();
for l in labels for l in labels {
{
if !label_map.contains_key(&l) { if !label_map.contains_key(&l) {
label_map.insert(l.clone(), class_num); label_map.insert(l.clone(), class_num);
unique_lables.push(l.clone()); unique_lables.push(l.clone());
class_num += 1; class_num += 1;
} }
} }
Self {label_to_idx: label_map, num_classes: class_num, labels:unique_lables} Self {
label_to_idx: label_map,
num_classes: class_num,
labels: unique_lables,
}
} }
/// Build an encoder from a predefined (label -> class number) map /// Build an encoder from a predefined (label -> class number) map
/// ///
/// Definition example: /// Definition example:
@@ -88,17 +90,14 @@ impl<'a, T: Hash + Eq + Clone> OneHotEncoder<T>
/// Transform a slice of label types into one-hot vectors /// Transform a slice of label types into one-hot vectors
/// None is returned if unknown label is encountered /// None is returned if unknown label is encountered
pub fn transform(&self, labels: &[T]) -> Vec<Option<Vec<f64>>> { pub fn transform(&self, labels: &[T]) -> Vec<Option<Vec<f64>>> {
labels labels.into_iter().map(|l| self.transform_one(l)).collect()
.into_iter()
.map(|l| self.transform_one(l))
.collect()
} }
/// Transform a single label type into a one-hot vector /// Transform a single label type into a one-hot vector
pub fn transform_one(&self, label: &T) -> Option<Vec<f64>> { pub fn transform_one(&self, label: &T) -> Option<Vec<f64>> {
match self.label_to_idx.get(label) { match self.label_to_idx.get(label) {
None => None, None => None,
Some(&idx) => Some(make_one_hot(idx, self.num_classes)) Some(&idx) => Some(make_one_hot(idx, self.num_classes)),
} }
} }
@@ -111,99 +110,104 @@ impl<'a, T: Hash + Eq + Clone> OneHotEncoder<T>
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
.into_iter() .into_iter()
.enumerate() .enumerate()
.filter_map(|(idx, v)| if v == pos {Some(idx)} else {None}) .filter_map(|(idx, v)| if v == pos { Some(idx) } else { None })
.collect(); .collect();
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.labels[idx].clone());
} }
let pos_entries = format!("Expected a single positive entry, {} entires found", s.len()); let pos_entries = format!(
"Expected a single positive entry, {} entires found",
s.len()
);
Err(Failed::transform(&pos_entries[..])) Err(Failed::transform(&pos_entries[..]))
} }
fn from_label_def(labels: LabelDefinition<T>) -> Self { fn from_label_def(labels: LabelDefinition<T>) -> Self {
let (label_map, class_num, unique_lables) = match labels { let (label_map, class_num, unique_lables) = match labels {
LabelDefinition::LabelToClsNumMap(h) => { LabelDefinition::LabelToClsNumMap(h) => {
let mut _unique_lab: Vec<(T, usize)> = h.iter().map(|(k,v)| (k.clone(), v.clone())).collect(); let mut _unique_lab: Vec<(T, usize)> =
_unique_lab.sort_by(|a,b| a.1.cmp(&b.1)); h.iter().map(|(k, v)| (k.clone(), v.clone())).collect();
_unique_lab.sort_by(|a, b| a.1.cmp(&b.1));
let unique_lab: Vec<T> = _unique_lab.into_iter().map(|a| a.0).collect(); let unique_lab: Vec<T> = _unique_lab.into_iter().map(|a| a.0).collect();
(h, unique_lab.len(), unique_lab) (h, unique_lab.len(), unique_lab)
}, }
LabelDefinition::PositionalLabel(unique_lab) => { LabelDefinition::PositionalLabel(unique_lab) => {
let h: HashMap<T, usize> = unique_lab.iter().enumerate().map(|(v, k)| (k.clone(),v)).collect(); let h: HashMap<T, usize> = unique_lab
.iter()
.enumerate()
.map(|(v, k)| (k.clone(), v))
.collect();
(h, unique_lab.len(), unique_lab) (h, unique_lab.len(), unique_lab)
} }
}; };
Self {label_to_idx: label_map, num_classes: class_num, labels:unique_lables} Self {
label_to_idx: label_map,
num_classes: class_num,
labels: unique_lables,
}
} }
} }
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::*; use super::*;
#[test] #[test]
fn from_labels() { fn from_labels() {
let fake_labels: Vec<usize> = vec![1,2,3,4,5,3,5,3,1,2,4]; let fake_labels: 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(&fake_labels[0..]);
let oh_vec = match enc.transform_one(&1) { let oh_vec = match enc.transform_one(&1) {
None => panic!("Wrong labels"), None => panic!("Wrong labels"),
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];
assert_eq!(oh_vec, res); assert_eq!(oh_vec, res);
} }
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_label_pos = vec!["background","dog", "cat"];
let enc = OneHotEncoder::<&str>::from_positional_label_vec(fake_label_pos); let enc = OneHotEncoder::<&str>::from_positional_label_vec(fake_label_pos);
enc enc
} }
#[test] #[test]
fn label_map_and_vec() { fn label_map_and_vec() {
let fake_label_map: HashMap<&str, usize> = vec![("background",0), ("dog", 1), ("cat", 2)].into_iter().collect(); let fake_label_map: HashMap<&str, usize> = vec![("background", 0), ("dog", 1), ("cat", 2)]
let enc = OneHotEncoder::<&str>::from_label_map(fake_label_map); .into_iter()
let oh_vec = match enc.transform_one(&"dog") { .collect();
None => panic!("Wrong labels"), let enc = OneHotEncoder::<&str>::from_label_map(fake_label_map);
Some(v) => v let oh_vec = match enc.transform_one(&"dog") {
}; None => panic!("Wrong labels"),
let res: Vec<f64> = vec![0f64, 1f64,0f64]; Some(v) => v,
assert_eq!(oh_vec, res); };
} let res: Vec<f64> = vec![0f64, 1f64, 0f64];
assert_eq!(oh_vec, res);
}
#[test] #[test]
fn positional_labels_vec() { fn positional_labels_vec() {
let enc = build_fake_str_enc(); let enc = build_fake_str_enc();
let oh_vec = match enc.transform_one(&"dog") { let oh_vec = match enc.transform_one(&"dog") {
None => panic!("Wrong labels"), None => panic!("Wrong labels"),
Some(v) => v Some(v) => v,
}; };
let res: Vec<f64> = vec![0f64, 1f64,0f64]; let res: Vec<f64> = vec![0.0, 1.0, 0.0];
assert_eq!(oh_vec, res); assert_eq!(oh_vec, res);
} }
#[test] #[test]
fn invert_label_test() { fn invert_label_test() {
let enc = build_fake_str_enc(); let enc = build_fake_str_enc();
let res: Vec<f64> = vec![0f64, 1f64,0f64]; let res: Vec<f64> = vec![0.0, 1.0, 0.0];
let lab = enc.invert_one(res).unwrap(); let lab = enc.invert_one(res).unwrap();
assert_eq!(lab, "dog"); assert_eq!(lab, "dog");
if let Err(e) = enc.invert_one(vec![0.0, 0.0, 0.0]) {
if let Err(e) = enc.invert_one(vec![0.0, 0.0,0.0]) {
let pos_entries = format!("Expected a single positive entry, 0 entires found"); let pos_entries = format!("Expected a single positive entry, 0 entires found");
assert_eq!(e, Failed::transform(&pos_entries[..])); assert_eq!(e, Failed::transform(&pos_entries[..]));
}; };
} }
} }