LinRegressor to use solve rather than inverse (#165)

* Use solve rather than inverse

* add trees dataset

* update error message

Author: sinhrks

src/datasets/mod.rs

@@ -2,6 +2,8 @@ use std::fmt::Debug;
 
 /// Module for iris dataset.
 pub mod iris;
+/// Module for trees dataset.
+pub mod trees;
 
 /// Dataset container
 #[derive(Clone, Debug)]

src/datasets/trees.rs

@@ -0,0 +1,64 @@
+use rulinalg::matrix::Matrix;
+use rulinalg::vector::Vector;
+
+use super::Dataset;
+
+/// Load trees dataset.
+///
+/// The data set contains a sample of 31 black cherry trees in the
+/// Allegheny National Forest, Pennsylvania.
+///
+/// ## Attribute Information
+///
+/// ### Data
+///
+/// ``Matrix<f64>`` contains following columns.
+///
+///   - diameter (inches)
+///   - height (feet)
+///
+/// ### Target
+///
+/// ``Vector<f64>`` contains volume (cubic feet) of trees.
+///
+/// Thomas A. Ryan, Brian L. Joiner, Barbara F. Ryan. (1976).
+/// Minitab student handbook. Duxbury Press
+pub fn load() -> Dataset<Matrix<f64>, Vector<f64>> {
+    let data = matrix![8.3, 70.;
+                       8.6, 65.;
+                       8.8, 63.;
+                       10.5, 72.;
+                       10.7, 81.;
+                       10.8, 83.;
+                       11.0, 66.;
+                       11.0, 75.;
+                       11.1, 80.;
+                       11.2, 75.;
+                       11.3, 79.;
+                       11.4, 76.;
+                       11.4, 76.;
+                       11.7, 69.;
+                       12.0, 75.;
+                       12.9, 74.;
+                       12.9, 85.;
+                       13.3, 86.;
+                       13.7, 71.;
+                       13.8, 64.;
+                       14.0, 78.;
+                       14.2, 80.;
+                       14.5, 74.;
+                       16.0, 72.;
+                       16.3, 77.;
+                       17.3, 81.;
+                       17.5, 82.;
+                       17.9, 80.;
+                       18.0, 80.;
+                       18.0, 80.;
+                       20.6, 87.];
+    let target = vec![10.3, 10.3, 10.2, 16.4, 18.8, 19.7, 15.6, 18.2, 22.6, 19.9,
+                      24.2, 21.0, 21.4, 21.3, 19.1, 22.2, 33.8, 27.4, 25.7, 24.9,
+                      34.5, 31.7, 36.3, 38.3, 42.6, 55.4, 55.7, 58.3, 51.5, 51.0,
+                      77.0];
+    Dataset{ data: data,
+             target: Vector::new(target) }
+}

src/learning/lin_reg.rs

@@ -87,11 +87,8 @@ impl SupModel<Matrix<f64>, Vector<f64>> for LinRegressor {
         let full_inputs = ones.hcat(inputs);
 
         let xt = full_inputs.transpose();
-
-        self.parameters =
-            Some(((&xt * full_inputs).inverse().expect("Could not compute (X_T X) inverse.") *
-                  &xt) * targets);
-
+        self.parameters = Some((&xt * full_inputs).solve(&xt * targets)
+                                                  .expect("Unable to solve linear equation."));
         Ok(())
     }
 

tests/datasets.rs

@@ -1,18 +1,26 @@
 extern crate rusty_machine as rm;
 
-
-#[cfg(datasets)]
+#[cfg(feature = "datasets")]
 mod test {
 
-    use rm::datasets::iris;
+    use rm::datasets;
     use rm::linalg::BaseMatrix;
 
     #[test]
     fn test_iris() {
-        let dt = iris::load_();
+        let dt = datasets::iris::load();
         assert_eq!(dt.data().rows(), 150);
         assert_eq!(dt.data().cols(), 4);
 
         assert_eq!(dt.target().size(), 150);
     }
-}
+
+    #[test]
+    fn test_trees() {
+        let dt = datasets::trees::load();
+        assert_eq!(dt.data().rows(), 31);
+        assert_eq!(dt.data().cols(), 2);
+
+        assert_eq!(dt.target().size(), 31);
+    }
+}

tests/learning/lin_reg.rs

@@ -47,4 +47,27 @@ fn test_no_train_predict() {
     let inputs = Matrix::new(3, 2, vec![1.0, 2.0, 1.0, 3.0, 1.0, 4.0]);
 
     let _ = lin_mod.predict(&inputs).unwrap();
+}
+
+#[cfg(feature = "datasets")]
+#[test]
+fn test_regression_datasets_trees() {
+    use rm::datasets::trees;
+    let trees = trees::load();
+
+    let mut lin_mod = LinRegressor::default();
+    lin_mod.train(&trees.data(), &trees.target()).unwrap();
+    let params = lin_mod.parameters().unwrap();
+    assert_eq!(params, &Vector::new(vec![-57.98765891838409, 4.708160503017506, 0.3392512342447438]));
+
+    let predicted = lin_mod.predict(&trees.data()).unwrap();
+    let expected = vec![4.837659653793278, 4.55385163347481, 4.816981265588826, 15.874115228921276,
+                        19.869008437727473, 21.018326956518717, 16.192688074961563, 19.245949183164257,
+                        21.413021404689726, 20.187581283767756, 22.015402271048487, 21.468464618616007,
+                        21.468464618616007, 20.50615412980805, 23.954109686181766, 27.852202904652785,
+                        31.583966481344966, 33.806481916796706, 30.60097760433255, 28.697035014921106,
+                        34.388184394951004, 36.008318964043994, 35.38525970948079, 41.76899799551756,
+                        44.87770231764652, 50.942867757643015, 52.223751092491256, 53.42851282520877,
+                        53.899328875510534, 53.899328875510534, 68.51530482306926];
+    assert_eq!(predicted, Vector::new(expected));
 }

tests/lib.rs

@@ -1,3 +1,5 @@
+#[macro_use]
+extern crate rulinalg;
 extern crate rusty_machine as rm;
 extern crate num as libnum;
 
@@ -12,5 +14,4 @@ pub mod learning {
     }
 }
 
-#[cfg(datasets)]
 pub mod datasets;