feat: + cluster metrics

Author: Volodymyr Orlov

src/algorithm/neighbour/bbd_tree.rs

@@ -71,11 +71,11 @@ impl<T: RealNumber> BBDTree<T> {
     ) -> T {
         let k = centroids.len();
 
-        counts.iter_mut().for_each(|x| *x = 0);
+        counts.iter_mut().for_each(|v| *v = 0);
         let mut candidates = vec![0; k];
         for i in 0..k {
             candidates[i] = i;
-            sums[i].iter_mut().for_each(|x| *x = T::zero());
+            sums[i].iter_mut().for_each(|v| *v = T::zero());
         }
 
         self.filter(
@@ -124,7 +124,7 @@ impl<T: RealNumber> BBDTree<T> {
                 if !BBDTree::prune(
                     &self.nodes[node].center,
                     &self.nodes[node].radius,
-                    &centroids,
+                    centroids,
                     closest,
                     candidates[i],
                 ) {
@@ -135,7 +135,7 @@ impl<T: RealNumber> BBDTree<T> {
 
             // Recurse if there's at least two
             if newk > 1 {
-                let result = self.filter(
+                return self.filter(
                     self.nodes[node].lower.unwrap(),
                     centroids,
                     &mut new_candidates,
@@ -152,7 +152,6 @@ impl<T: RealNumber> BBDTree<T> {
                     counts,
                     membership,
                 );
-                return result;
             }
         }
 
@@ -198,7 +197,7 @@ impl<T: RealNumber> BBDTree<T> {
             }
         }
 
-        return lhs >= T::two() * rhs;
+        lhs >= T::two() * rhs
     }
 
     fn build_node<M: Matrix<T>>(&mut self, data: &M, begin: usize, end: usize) -> usize {
@@ -336,7 +335,7 @@ mod tests {
     use crate::linalg::naive::dense_matrix::DenseMatrix;
 
     #[test]
-    fn fit_predict_iris() {
+    fn bbdtree_iris() {
         let data = DenseMatrix::from_2d_array(&[
             &[5.1, 3.5, 1.4, 0.2],
             &[4.9, 3.0, 1.4, 0.2],

src/cluster/kmeans.rs

@@ -189,15 +189,18 @@ impl<T: RealNumber + Sum> KMeans<T> {
     /// Predict clusters for `x`
     /// * `x` - matrix with new data to transform of size _KxM_ , where _K_ is number of new samples and _M_ is number of features.
     pub fn predict<M: Matrix<T>>(&self, x: &M) -> Result<M::RowVector, Failed> {
-        let (n, _) = x.shape();
+        let (n, m) = x.shape();
         let mut result = M::zeros(1, n);
 
+        let mut row = vec![T::zero(); m];
+
         for i in 0..n {
             let mut min_dist = T::max_value();
             let mut best_cluster = 0;
 
             for j in 0..self.k {
-                let dist = Euclidian::squared_distance(&x.get_row_as_vec(i), &self.centroids[j]);
+                x.copy_row_as_vec(i, &mut row);
+                let dist = Euclidian::squared_distance(&row, &self.centroids[j]);
                 if dist < min_dist {
                     min_dist = dist;
                     best_cluster = j;
@@ -211,19 +214,22 @@ impl<T: RealNumber + Sum> KMeans<T> {
 
     fn kmeans_plus_plus<M: Matrix<T>>(data: &M, k: usize) -> Vec<usize> {
         let mut rng = rand::thread_rng();
-        let (n, _) = data.shape();
+        let (n, m) = data.shape();
         let mut y = vec![0; n];
         let mut centroid = data.get_row_as_vec(rng.gen_range(0, n));
 
         let mut d = vec![T::max_value(); n];
 
+        let mut row = vec![T::zero(); m];
+
         // pick the next center
         for j in 1..k {
             // Loop over the samples and compare them to the most recent center.  Store
             // the distance from each sample to its closest center in scores.
             for i in 0..n {
                 // compute the distance between this sample and the current center
-                let dist = Euclidian::squared_distance(&data.get_row_as_vec(i), &centroid);
+                data.copy_row_as_vec(i, &mut row);
+                let dist = Euclidian::squared_distance(&row, &centroid);
 
                 if dist < d[i] {
                     d[i] = dist;
@@ -237,20 +243,22 @@ impl<T: RealNumber + Sum> KMeans<T> {
             }
             let cutoff = T::from(rng.gen::<f64>()).unwrap() * sum;
             let mut cost = T::zero();
-            let index = 0;
-            for index in 0..n {
+            let mut index = 0;
+            while index < n {
                 cost = cost + d[index];
                 if cost >= cutoff {
                     break;
                 }
+                index += 1;
             }
 
-            centroid = data.get_row_as_vec(index);
+            data.copy_row_as_vec(index, &mut centroid);
         }
 
         for i in 0..n {
+            data.copy_row_as_vec(i, &mut row);
             // compute the distance between this sample and the current center
-            let dist = Euclidian::squared_distance(&data.get_row_as_vec(i), &centroid);
+            let dist = Euclidian::squared_distance(&row, &centroid);
 
             if dist < d[i] {
                 d[i] = dist;

src/dataset/digits.rs

@@ -0,0 +1,67 @@
+//! # Optical Recognition of Handwritten Digits Data Set
+//!
+//! | Number of Instances | Number of Attributes | Missing Values? | Associated Tasks: |
+//! |-|-|-|-|
+//! | 1797 | 64 | No | Classification, Clusteing |
+//!
+//! [Digits dataset](https://archive.ics.uci.edu/ml/datasets/Optical+Recognition+of+Handwritten+Digits) contains normalized bitmaps of handwritten digits (0-9) from a preprinted form.
+//! This multivariate dataset is frequently used to demonstrate various machine learning algorithms.
+//!
+//! All input attributes are integers in the range 0..16.
+//!
+use crate::dataset::deserialize_data;
+use crate::dataset::Dataset;
+
+/// Get dataset
+pub fn load_dataset() -> Dataset<f32, f32> {
+    let (x, y, num_samples, num_features) = match deserialize_data(std::include_bytes!("digits.xy"))
+    {
+        Err(why) => panic!("Can't deserialize digits.xy. {}", why),
+        Ok((x, y, num_samples, num_features)) => (x, y, num_samples, num_features),
+    };
+
+    Dataset {
+        data: x,
+        target: y,
+        num_samples: num_samples,
+        num_features: num_features,
+        feature_names: vec![
+            "sepal length (cm)",
+            "sepal width (cm)",
+            "petal length (cm)",
+            "petal width (cm)",
+        ]
+        .iter()
+        .map(|s| s.to_string())
+        .collect(),
+        target_names: vec!["setosa", "versicolor", "virginica"]
+            .iter()
+            .map(|s| s.to_string())
+            .collect(),
+        description: "Digits dataset: https://archive.ics.uci.edu/ml/datasets/Optical+Recognition+of+Handwritten+Digits".to_string(),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+
+    use super::super::*;
+    use super::*;
+
+    #[test]
+    #[ignore]
+    fn refresh_digits_dataset() {
+        // run this test to generate digits.xy file.
+        let dataset = load_dataset();
+        assert!(serialize_data(&dataset, "digits.xy").is_ok());
+    }
+
+    #[test]
+    fn digits_dataset() {
+        let dataset = load_dataset();
+        assert_eq!(dataset.data.len(), 1797 * 64);
+        assert_eq!(dataset.target.len(), 1797);
+        assert_eq!(dataset.num_features, 64);
+        assert_eq!(dataset.num_samples, 1797);
+    }
+}

src/dataset/digits.xy

@@ -4,6 +4,7 @@
 pub mod boston;
 pub mod breast_cancer;
 pub mod diabetes;
+pub mod digits;
 pub mod iris;
 
 use crate::math::num::RealNumber;

src/dataset/mod.rs

@@ -110,10 +110,20 @@ pub trait BaseMatrix<T: RealNumber>: Clone + Debug {
     /// * `row` - row number
     fn get_row_as_vec(&self, row: usize) -> Vec<T>;
 
+    /// Copies a vector with elements of the `row`'th row into `result`
+    /// * `row` - row number
+    /// * `result` - receiver for the row
+    fn copy_row_as_vec(&self, row: usize, result: &mut Vec<T>);
+
     /// Get a vector with elements of the `col`'th column
     /// * `col` - column number
     fn get_col_as_vec(&self, col: usize) -> Vec<T>;
 
+    /// Copies a vector with elements of the `col`'th column into `result`
+    /// * `col` - column number
+    /// * `result` - receiver for the col
+    fn copy_col_as_vec(&self, col: usize, result: &mut Vec<T>);
+
     /// Set an element at `col`, `row` to `x`
     fn set(&mut self, row: usize, col: usize, x: T);
 

src/linalg/mod.rs

@@ -54,6 +54,16 @@ pub struct DenseMatrix<T: RealNumber> {
     values: Vec<T>,
 }
 
+/// Column-major, dense matrix. See [Simple Dense Matrix](../index.html).
+#[derive(Debug)]
+pub struct DenseMatrixIterator<'a, T: RealNumber> {
+    cur_c: usize,
+    cur_r: usize,
+    max_c: usize,
+    max_r: usize,
+    m: &'a DenseMatrix<T>,
+}
+
 impl<T: RealNumber> fmt::Display for DenseMatrix<T> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let mut rows: Vec<Vec<f64>> = Vec::new();
@@ -162,6 +172,36 @@ impl<T: RealNumber> DenseMatrix<T> {
             values: values,
         }
     }
+
+    /// Creates new column vector (_1xN_ matrix) from a vector.     
+    /// * `values` - values to initialize the matrix.
+    pub fn iter<'a>(&'a self) -> DenseMatrixIterator<'a, T> {
+        DenseMatrixIterator {
+            cur_c: 0,
+            cur_r: 0,
+            max_c: self.ncols,
+            max_r: self.nrows,
+            m: &self,
+        }
+    }
+}
+
+impl<'a, T: RealNumber> Iterator for DenseMatrixIterator<'a, T> {
+    type Item = T;
+
+    fn next(&mut self) -> Option<T> {
+        if self.cur_r * self.max_c + self.cur_c >= self.max_c * self.max_r {
+            None
+        } else {
+            let v = self.m.get(self.cur_r, self.cur_c);
+            self.cur_c += 1;
+            if self.cur_c >= self.max_c {
+                self.cur_c = 0;
+                self.cur_r += 1;
+            }
+            Some(v)
+        }
+    }
 }
 
 impl<'de, T: RealNumber + fmt::Debug + Deserialize<'de>> Deserialize<'de> for DenseMatrix<T> {
@@ -339,6 +379,12 @@ impl<T: RealNumber> BaseMatrix<T> for DenseMatrix<T> {
         result
     }
 
+    fn copy_row_as_vec(&self, row: usize, result: &mut Vec<T>) {
+        for c in 0..self.ncols {
+            result[c] = self.get(row, c);
+        }
+    }
+
     fn get_col_as_vec(&self, col: usize) -> Vec<T> {
         let mut result = vec![T::zero(); self.nrows];
         for r in 0..self.nrows {
@@ -347,6 +393,12 @@ impl<T: RealNumber> BaseMatrix<T> for DenseMatrix<T> {
         result
     }
 
+    fn copy_col_as_vec(&self, col: usize, result: &mut Vec<T>) {
+        for r in 0..self.nrows {
+            result[r] = self.get(r, col);
+        }
+    }
+
     fn set(&mut self, row: usize, col: usize, x: T) {
         self.values[col * self.nrows + row] = x;
     }
@@ -852,6 +904,13 @@ mod tests {
         );
     }
 
+    #[test]
+    fn iter() {
+        let vec = vec![1., 2., 3., 4., 5., 6.];
+        let m = DenseMatrix::from_array(3, 2, &vec);
+        assert_eq!(vec, m.iter().collect::<Vec<f32>>());
+    }
+
     #[test]
     fn v_stack() {
         let a = DenseMatrix::from_2d_array(&[&[1., 2., 3.], &[4., 5., 6.], &[7., 8., 9.]]);

src/linalg/naive/dense_matrix.rs

@@ -102,10 +102,26 @@ impl<T: RealNumber + Scalar + AddAssign + SubAssign + MulAssign + DivAssign + Su
         self.row(row).iter().map(|v| *v).collect()
     }
 
+    fn copy_row_as_vec(&self, row: usize, result: &mut Vec<T>) {
+        let mut r = 0;
+        for e in self.row(row).iter() {
+            result[r] = *e;
+            r += 1;
+        }
+    }
+
     fn get_col_as_vec(&self, col: usize) -> Vec<T> {
         self.column(col).iter().map(|v| *v).collect()
     }
 
+    fn copy_col_as_vec(&self, col: usize, result: &mut Vec<T>) {
+        let mut r = 0;
+        for e in self.column(col).iter() {
+            result[r] = *e;
+            r += 1;
+        }
+    }
+
     fn set(&mut self, row: usize, col: usize, x: T) {
         *self.get_mut((row, col)).unwrap() = x;
     }
@@ -563,6 +579,17 @@ mod tests {
         assert_eq!(m.get_col_as_vec(1), vec!(2., 5., 8.));
     }
 
+    #[test]
+    fn copy_row_col_as_vec() {
+        let m = DMatrix::from_row_slice(3, 3, &[1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0]);
+        let mut v = vec![0f32; 3];
+
+        m.copy_row_as_vec(1, &mut v);
+        assert_eq!(v, vec!(4., 5., 6.));
+        m.copy_col_as_vec(1, &mut v);
+        assert_eq!(v, vec!(2., 5., 8.));
+    }
+
     #[test]
     fn element_add_sub_mul_div() {
         let mut m = DMatrix::from_row_slice(2, 2, &[1.0, 2.0, 3.0, 4.0]);