Merge pull request #47 from smartcorelib/development

Release, v0.2.0

Author: VolodymyrOrlov

.circleci/config.yml

@@ -1,5 +1,11 @@
 version: 2.1
 
+workflows:
+  version: 2.1
+  build:
+    jobs:
+      - build
+      - clippy
 jobs:
   build:
     docker:
@@ -24,3 +30,14 @@ jobs:
           paths:
             - "~/.cargo"
             - "./target"
+  clippy:
+    docker:
+      - image: circleci/rust:latest
+    steps:
+      - checkout
+      - run:
+          name: Install cargo clippy
+          command: rustup component add clippy
+      - run:
+          name: Run cargo clippy
+          command: cargo clippy --all-features -- -Drust-2018-idioms -Dwarnings

Cargo.toml

@@ -2,7 +2,7 @@
 name = "smartcore"
 description = "The most advanced machine learning library in rust."
 homepage = "https://smartcorelib.org"
-version = "0.1.0"
+version = "0.2.0"
 authors = ["SmartCore Developers"]
 edition = "2018"
 license = "Apache-2.0"
@@ -19,11 +19,12 @@ nalgebra-bindings = ["nalgebra"]
 datasets = []
 
 [dependencies]
-ndarray = { version = "0.13", optional = true }
-nalgebra = { version = "0.22.0", optional = true }
+ndarray = { version = "0.14", optional = true }
+nalgebra = { version = "0.23.0", optional = true }
 num-traits = "0.2.12"
 num = "0.3.0"
 rand = "0.7.3"
+rand_distr = "0.3.0"
 serde = { version = "1.0.115", features = ["derive"] }
 serde_derive = "1.0.115"
 
@@ -34,4 +35,9 @@ bincode = "1.3.1"
 
 [[bench]]
 name = "distance"
-harness = false
+harness = false
+
+[[bench]]
+name = "naive_bayes"
+harness = false
+required-features = ["ndarray-bindings", "nalgebra-bindings"]

benches/naive_bayes.rs

@@ -0,0 +1,73 @@
+use criterion::BenchmarkId;
+use criterion::{black_box, criterion_group, criterion_main, Criterion};
+
+use nalgebra::DMatrix;
+use ndarray::Array2;
+use smartcore::linalg::naive::dense_matrix::DenseMatrix;
+use smartcore::linalg::BaseMatrix;
+use smartcore::linalg::BaseVector;
+use smartcore::naive_bayes::gaussian::GaussianNB;
+
+pub fn gaussian_naive_bayes_fit_benchmark(c: &mut Criterion) {
+    let mut group = c.benchmark_group("GaussianNB::fit");
+
+    for n_samples in [100_usize, 1000_usize, 10000_usize].iter() {
+        for n_features in [10_usize, 100_usize, 1000_usize].iter() {
+            let x = DenseMatrix::<f64>::rand(*n_samples, *n_features);
+            let y: Vec<f64> = (0..*n_samples)
+                .map(|i| (i % *n_samples / 5_usize) as f64)
+                .collect::<Vec<f64>>();
+            group.bench_with_input(
+                BenchmarkId::from_parameter(format!(
+                    "n_samples: {}, n_features: {}",
+                    n_samples, n_features
+                )),
+                n_samples,
+                |b, _| {
+                    b.iter(|| {
+                        GaussianNB::fit(black_box(&x), black_box(&y), Default::default()).unwrap();
+                    })
+                },
+            );
+        }
+    }
+    group.finish();
+}
+
+pub fn gaussian_naive_matrix_datastructure(c: &mut Criterion) {
+    let mut group = c.benchmark_group("GaussianNB");
+    let classes = (0..10000).map(|i| (i % 25) as f64).collect::<Vec<f64>>();
+
+    group.bench_function("DenseMatrix", |b| {
+        let x = DenseMatrix::<f64>::rand(10000, 500);
+        let y = <DenseMatrix<f64> as BaseMatrix<f64>>::RowVector::from_array(&classes);
+
+        b.iter(|| {
+            GaussianNB::fit(black_box(&x), black_box(&y), Default::default()).unwrap();
+        })
+    });
+
+    group.bench_function("ndarray", |b| {
+        let x = Array2::<f64>::rand(10000, 500);
+        let y = <Array2<f64> as BaseMatrix<f64>>::RowVector::from_array(&classes);
+
+        b.iter(|| {
+            GaussianNB::fit(black_box(&x), black_box(&y), Default::default()).unwrap();
+        })
+    });
+
+    group.bench_function("ndalgebra", |b| {
+        let x = DMatrix::<f64>::rand(10000, 500);
+        let y = <DMatrix<f64> as BaseMatrix<f64>>::RowVector::from_array(&classes);
+
+        b.iter(|| {
+            GaussianNB::fit(black_box(&x), black_box(&y), Default::default()).unwrap();
+        })
+    });
+}
+criterion_group!(
+    benches,
+    gaussian_naive_bayes_fit_benchmark,
+    gaussian_naive_matrix_datastructure
+);
+criterion_main!(benches);

src/algorithm/neighbour/bbd_tree.rs

@@ -44,14 +44,11 @@ impl<T: RealNumber> BBDTree<T> {
 
         let (n, _) = data.shape();
 
-        let mut index = vec![0; n];
-        for i in 0..n {
-            index[i] = i;
-        }
+        let index = (0..n).collect::<Vec<_>>();
 
         let mut tree = BBDTree {
-            nodes: nodes,
-            index: index,
+            nodes,
+            index,
             root: 0,
         };
 
@@ -64,7 +61,7 @@ impl<T: RealNumber> BBDTree<T> {
 
     pub(in crate) fn clustering(
         &self,
-        centroids: &Vec<Vec<T>>,
+        centroids: &[Vec<T>],
         sums: &mut Vec<Vec<T>>,
         counts: &mut Vec<usize>,
         membership: &mut Vec<usize>,
@@ -92,8 +89,8 @@ impl<T: RealNumber> BBDTree<T> {
     fn filter(
         &self,
         node: usize,
-        centroids: &Vec<Vec<T>>,
-        candidates: &Vec<usize>,
+        centroids: &[Vec<T>],
+        candidates: &[usize],
         k: usize,
         sums: &mut Vec<Vec<T>>,
         counts: &mut Vec<usize>,
@@ -113,19 +110,19 @@ impl<T: RealNumber> BBDTree<T> {
             }
         }
 
-        if !self.nodes[node].lower.is_none() {
+        if self.nodes[node].lower.is_some() {
             let mut new_candidates = vec![0; k];
             let mut newk = 0;
 
-            for i in 0..k {
+            for candidate in candidates.iter().take(k) {
                 if !BBDTree::prune(
                     &self.nodes[node].center,
                     &self.nodes[node].radius,
                     centroids,
                     closest,
-                    candidates[i],
+                    *candidate,
                 ) {
-                    new_candidates[newk] = candidates[i];
+                    new_candidates[newk] = *candidate;
                     newk += 1;
                 }
             }
@@ -134,15 +131,15 @@ impl<T: RealNumber> BBDTree<T> {
                 return self.filter(
                     self.nodes[node].lower.unwrap(),
                     centroids,
-                    &mut new_candidates,
+                    &new_candidates,
                     newk,
                     sums,
                     counts,
                     membership,
                 ) + self.filter(
                     self.nodes[node].upper.unwrap(),
                     centroids,
-                    &mut new_candidates,
+                    &new_candidates,
                     newk,
                     sums,
                     counts,
@@ -152,7 +149,7 @@ impl<T: RealNumber> BBDTree<T> {
         }
 
         for i in 0..d {
-            sums[closest][i] = sums[closest][i] + self.nodes[node].sum[i];
+            sums[closest][i] += self.nodes[node].sum[i];
         }
 
         counts[closest] += self.nodes[node].count;
@@ -166,9 +163,9 @@ impl<T: RealNumber> BBDTree<T> {
     }
 
     fn prune(
-        center: &Vec<T>,
-        radius: &Vec<T>,
-        centroids: &Vec<Vec<T>>,
+        center: &[T],
+        radius: &[T],
+        centroids: &[Vec<T>],
         best_index: usize,
         test_index: usize,
     ) -> bool {
@@ -184,11 +181,11 @@ impl<T: RealNumber> BBDTree<T> {
         let mut rhs = T::zero();
         for i in 0..d {
             let diff = test[i] - best[i];
-            lhs = lhs + diff * diff;
+            lhs += diff * diff;
             if diff > T::zero() {
-                rhs = rhs + (center[i] + radius[i] - best[i]) * diff;
+                rhs += (center[i] + radius[i] - best[i]) * diff;
             } else {
-                rhs = rhs + (center[i] - radius[i] - best[i]) * diff;
+                rhs += (center[i] - radius[i] - best[i]) * diff;
             }
         }
 
@@ -244,7 +241,7 @@ impl<T: RealNumber> BBDTree<T> {
             if end > begin + 1 {
                 let len = end - begin;
                 for i in 0..d {
-                    node.sum[i] = node.sum[i] * T::from(len).unwrap();
+                    node.sum[i] *= T::from(len).unwrap();
                 }
             }
 
@@ -261,9 +258,7 @@ impl<T: RealNumber> BBDTree<T> {
             let mut i2_good = data.get(self.index[i2], split_index) >= split_cutoff;
 
             if !i1_good && !i2_good {
-                let temp = self.index[i1];
-                self.index[i1] = self.index[i2];
-                self.index[i2] = temp;
+                self.index.swap(i1, i2);
                 i1_good = true;
                 i2_good = true;
             }
@@ -287,8 +282,8 @@ impl<T: RealNumber> BBDTree<T> {
         }
 
         let mut mean = vec![T::zero(); d];
-        for i in 0..d {
-            mean[i] = node.sum[i] / T::from(node.count).unwrap();
+        for (i, mean_i) in mean.iter_mut().enumerate().take(d) {
+            *mean_i = node.sum[i] / T::from(node.count).unwrap();
         }
 
         node.cost = BBDTree::node_cost(&self.nodes[node.lower.unwrap()], &mean)
@@ -297,12 +292,12 @@ impl<T: RealNumber> BBDTree<T> {
         self.add_node(node)
     }
 
-    fn node_cost(node: &BBDTreeNode<T>, center: &Vec<T>) -> T {
+    fn node_cost(node: &BBDTreeNode<T>, center: &[T]) -> T {
         let d = center.len();
         let mut scatter = T::zero();
-        for i in 0..d {
-            let x = (node.sum[i] / T::from(node.count).unwrap()) - center[i];
-            scatter = scatter + x * x;
+        for (i, center_i) in center.iter().enumerate().take(d) {
+            let x = (node.sum[i] / T::from(node.count).unwrap()) - *center_i;
+            scatter += x * x;
         }
         node.cost + T::from(node.count).unwrap() * scatter
     }