Split AsTargets into 1D and 2D variants (rust-ml#206)

* Finish refactoring most of linfa main crate

* Fix cross_validate and fix errors

* Make split_ratio panic when input is not row-major

* Fix external uses of single_targets

* Fix algorithm examples and dataset

* Fix cross_validation

* Fix SVM

* Add all-targets flag to checking step

* Fix doc tests

* Remove multitarget error variant

* Document breaking changes in changelog


Co-authored-by: Pierre-Antoine Bannier <[email protected]>

Author: YuhanLiin

.github/workflows/checking.yml

@@ -40,11 +40,11 @@ jobs:
         uses: actions-rs/cargo@v1
         with:
           command: check
-          args: --workspace
+          args: --workspace --all-targets
 
       - name: Run cargo check (with serde)
         if: ${{ matrix.toolchain != '1.54.0' }} # The following args don't work on older versions of Cargo
         uses: actions-rs/cargo@v1
         with:
           command: check
-          args: --workspace --features "linfa-clustering/serde linfa-ica/serde linfa-kernel/serde linfa-reduction/serde linfa-svm/serde linfa-elasticnet/serde linfa-pls/serde linfa-trees/serde linfa-nn/serde"
+          args: --workspace --all-targets --features "linfa-clustering/serde linfa-ica/serde linfa-kernel/serde linfa-reduction/serde linfa-svm/serde linfa-elasticnet/serde linfa-pls/serde linfa-trees/serde linfa-nn/serde"

CHANGELOG.md

@@ -1,3 +1,14 @@
+Unreleased
+========================
+
+Breaking Changes
+----------------------
+ * parametrize `AsTargets` by the dimensionality of the targets and introduce `AsSingleTargets` and `AsMultiTargets`
+ * 1D target arrays are no longer converted to 2D when constructing `Dataset`s
+ * `Dataset` and `DatasetView` can now be parametrized by target dimensionality, with 2D being the default
+ * single-target algorithms no longer accept 2D target arrays as input
+ * `cross_validate_multi` has been merged with `cross_validate`, which is now generic across single and multi-targets
+
 Version 0.5.1 - 2022-02-28
 ========================
 

algorithms/linfa-bayes/src/gaussian_nb.rs

@@ -1,4 +1,4 @@
-use linfa::dataset::{AsTargets, DatasetBase, Labels};
+use linfa::dataset::{AsSingleTargets, DatasetBase, Labels};
 use linfa::traits::{Fit, FitWith, PredictInplace};
 use linfa::{Float, Label};
 use ndarray::{Array1, ArrayBase, ArrayView2, Axis, Data, Ix2};
@@ -14,7 +14,7 @@ where
     F: Float,
     L: Label + 'a,
     D: Data<Elem = F>,
-    T: AsTargets<Elem = L> + Labels<Elem = L>,
+    T: AsSingleTargets<Elem = L> + Labels<Elem = L>,
 {
 }
 
@@ -23,7 +23,7 @@ where
     F: Float,
     L: Label + Ord,
     D: Data<Elem = F>,
-    T: AsTargets<Elem = L> + Labels<Elem = L>,
+    T: AsSingleTargets<Elem = L> + Labels<Elem = L>,
 {
     type Object = GaussianNb<F, L>;
 
@@ -40,7 +40,7 @@ where
     F: Float,
     L: Label + 'a,
     D: Data<Elem = F>,
-    T: AsTargets<Elem = L> + Labels<Elem = L>,
+    T: AsSingleTargets<Elem = L> + Labels<Elem = L>,
 {
     type ObjectIn = Option<GaussianNb<F, L>>;
     type ObjectOut = Option<GaussianNb<F, L>>;
@@ -51,7 +51,7 @@ where
         dataset: &DatasetBase<ArrayBase<D, Ix2>, T>,
     ) -> Result<Self::ObjectOut> {
         let x = dataset.records();
-        let y = dataset.try_single_target()?;
+        let y = dataset.as_single_targets();
 
         // If the ratio of the variance between dimensions is too small, it will cause
         // numerical errors. We address this by artificially boosting the variance

algorithms/linfa-bayes/src/multinomial_nb.rs

@@ -1,4 +1,4 @@
-use linfa::dataset::{AsTargets, DatasetBase, Labels};
+use linfa::dataset::{AsSingleTargets, DatasetBase, Labels};
 use linfa::traits::{Fit, FitWith, PredictInplace};
 use linfa::{Float, Label};
 use ndarray::{Array1, ArrayBase, ArrayView2, Axis, Data, Ix2};
@@ -13,7 +13,7 @@ where
     F: Float,
     L: Label + 'a,
     D: Data<Elem = F>,
-    T: AsTargets<Elem = L> + Labels<Elem = L>,
+    T: AsSingleTargets<Elem = L> + Labels<Elem = L>,
 {
 }
 
@@ -22,7 +22,7 @@ where
     F: Float,
     L: Label + Ord,
     D: Data<Elem = F>,
-    T: AsTargets<Elem = L> + Labels<Elem = L>,
+    T: AsSingleTargets<Elem = L> + Labels<Elem = L>,
 {
     type Object = MultinomialNb<F, L>;
     // Thin wrapper around the corresponding method of NaiveBayesValidParams
@@ -38,7 +38,7 @@ where
     F: Float,
     L: Label + 'a,
     D: Data<Elem = F>,
-    T: AsTargets<Elem = L> + Labels<Elem = L>,
+    T: AsSingleTargets<Elem = L> + Labels<Elem = L>,
 {
     type ObjectIn = Option<MultinomialNb<F, L>>;
     type ObjectOut = Option<MultinomialNb<F, L>>;
@@ -49,7 +49,7 @@ where
         dataset: &DatasetBase<ArrayBase<D, Ix2>, T>,
     ) -> Result<Self::ObjectOut> {
         let x = dataset.records();
-        let y = dataset.try_single_target()?;
+        let y = dataset.as_single_targets();
 
         let mut model = match model_in {
             Some(temp) => temp,

algorithms/linfa-elasticnet/examples/elasticnet_cv.rs

@@ -1,5 +1,6 @@
 use linfa::prelude::*;
 use linfa_elasticnet::{ElasticNet, Result};
+use ndarray::arr0;
 
 fn main() -> Result<()> {
     // load Diabetes dataset (mutable to allow fast k-folding)
@@ -15,8 +16,9 @@ fn main() -> Result<()> {
         .collect::<Vec<_>>();
 
     // get the mean r2 validation score across all folds for each model
-    let r2_values =
-        dataset.cross_validate(5, &models, |prediction, truth| prediction.r2(&truth))?;
+    let r2_values = dataset.cross_validate(5, &models, |prediction, truth| {
+        prediction.r2(&truth).map(arr0)
+    })?;
 
     for (ratio, r2) in ratios.iter().zip(r2_values.iter()) {
         println!("L1 ratio: {}, r2 score: {}", ratio, r2);

algorithms/linfa-elasticnet/src/algorithm.rs

@@ -1,20 +1,18 @@
 use approx::{abs_diff_eq, abs_diff_ne};
+use linfa::dataset::AsSingleTargets;
 use ndarray::{s, Array1, ArrayBase, ArrayView1, ArrayView2, Axis, CowArray, Data, Ix1, Ix2};
 use ndarray_linalg::{Inverse, Lapack};
 
 use linfa::traits::{Fit, PredictInplace};
-use linfa::{
-    dataset::{AsTargets, Records},
-    DatasetBase, Float,
-};
+use linfa::{dataset::Records, DatasetBase, Float};
 
 use super::{hyperparams::ElasticNetValidParams, ElasticNet, ElasticNetError, Result};
 
 impl<F, D, T> Fit<ArrayBase<D, Ix2>, T, ElasticNetError> for ElasticNetValidParams<F>
 where
     F: Float + Lapack,
     D: Data<Elem = F>,
-    T: AsTargets<Elem = F>,
+    T: AsSingleTargets<Elem = F>,
 {
     type Object = ElasticNet<F>;
 
@@ -29,7 +27,7 @@ where
     /// parameters and can be used to `predict` values of the target variable
     /// for new feature values.
     fn fit(&self, dataset: &DatasetBase<ArrayBase<D, Ix2>, T>) -> Result<Self::Object> {
-        let target = dataset.try_single_target()?;
+        let target = dataset.as_single_targets();
 
         let (intercept, y) = compute_intercept(self.with_intercept(), target);
         let (hyperplane, duality_gap, n_steps) = coordinate_descent(
@@ -217,15 +215,15 @@ fn duality_gap<'a, F: Float>(
     gap
 }
 
-fn variance_params<F: Float + Lapack, T: AsTargets<Elem = F>, D: Data<Elem = F>>(
+fn variance_params<F: Float + Lapack, T: AsSingleTargets<Elem = F>, D: Data<Elem = F>>(
     ds: &DatasetBase<ArrayBase<D, Ix2>, T>,
     y_est: Array1<F>,
 ) -> Result<Array1<F>> {
     let nfeatures = ds.nfeatures();
     let nsamples = ds.nsamples();
 
     // try to convert targets into a single target
-    let target = ds.try_single_target()?;
+    let target = ds.as_single_targets();
 
     // check that we have enough samples
     if nsamples < nfeatures + 1 {

algorithms/linfa-kernel/src/lib.rs

@@ -409,7 +409,7 @@ impl<'a, F: Float, T: AsTargets, N: NearestNeighbour>
     }
 }
 
-impl<'a, F: Float, L: 'a, T: AsTargets<Elem = L> + FromTargetArray<'a, L>, N: NearestNeighbour>
+impl<'a, F: Float, L: 'a, T: AsTargets<Elem = L> + FromTargetArray<'a>, N: NearestNeighbour>
     Transformer<&'a DatasetBase<Array2<F>, T>, DatasetBase<Kernel<F>, T::View>>
     for KernelParams<F, N>
 {
@@ -432,7 +432,7 @@ impl<'a, F: Float, L: 'a, T: AsTargets<Elem = L> + FromTargetArray<'a, L>, N: Ne
     /// not between 1 and #records-1
     fn transform(&self, x: &'a DatasetBase<Array2<F>, T>) -> DatasetBase<Kernel<F>, T::View> {
         let kernel = Kernel::new(x.records.view(), self);
-        DatasetBase::new(kernel, T::new_targets_view(x.as_multi_targets()))
+        DatasetBase::new(kernel, T::new_targets_view(x.as_targets()))
     }
 }
 
@@ -443,7 +443,7 @@ impl<
         'b,
         F: Float,
         L: 'b,
-        T: AsTargets<Elem = L> + FromTargetArray<'b, L>,
+        T: AsTargets<Elem = L> + FromTargetArray<'b>,
         N: NearestNeighbour,
     > Transformer<&'b DatasetBase<ArrayView2<'a, F>, T>, DatasetBase<Kernel<F>, T::View>>
     for KernelParams<F, N>
@@ -471,7 +471,7 @@ impl<
     ) -> DatasetBase<Kernel<F>, T::View> {
         let kernel = Kernel::new(x.records.view(), self);
 
-        DatasetBase::new(kernel, T::new_targets_view(x.as_multi_targets()))
+        DatasetBase::new(kernel, T::new_targets_view(x.as_targets()))
     }
 }
 
@@ -850,11 +850,7 @@ mod tests {
         check_kernel_from_dataset_view_type(&input.view(), KernelType::Sparse(3));
     }
 
-    fn check_kernel_from_dataset_type<
-        'a,
-        L: 'a,
-        T: AsTargets<Elem = L> + FromTargetArray<'a, L>,
-    >(
+    fn check_kernel_from_dataset_type<'a, L: 'a, T: AsTargets<Elem = L> + FromTargetArray<'a>>(
         input: &'a DatasetBase<Array2<f64>, T>,
         k_type: KernelType,
     ) {
@@ -889,7 +885,7 @@ mod tests {
     fn check_kernel_from_dataset_view_type<
         'a,
         L: 'a,
-        T: AsTargets<Elem = L> + FromTargetArray<'a, L>,
+        T: AsTargets<Elem = L> + FromTargetArray<'a>,
     >(
         input: &'a DatasetBase<ArrayView2<'a, f64>, T>,
         k_type: KernelType,

algorithms/linfa-linear/src/glm/mod.rs

@@ -8,6 +8,7 @@ use crate::error::{LinearError, Result};
 use crate::float::{ArgminParam, Float};
 use distribution::TweedieDistribution;
 use hyperparams::TweedieRegressorValidParams;
+use linfa::dataset::AsSingleTargets;
 pub use link::Link;
 
 use argmin::core::{ArgminOp, Executor};
@@ -18,15 +19,15 @@ use ndarray::{Array, Array1, ArrayBase, ArrayView1, ArrayView2, Axis, Data, Ix2}
 use serde::{Deserialize, Serialize};
 
 use linfa::traits::*;
-use linfa::{dataset::AsTargets, DatasetBase};
+use linfa::DatasetBase;
 
-impl<F: Float, D: Data<Elem = F>, T: AsTargets<Elem = F>> Fit<ArrayBase<D, Ix2>, T, LinearError<F>>
-    for TweedieRegressorValidParams<F>
+impl<F: Float, D: Data<Elem = F>, T: AsSingleTargets<Elem = F>>
+    Fit<ArrayBase<D, Ix2>, T, LinearError<F>> for TweedieRegressorValidParams<F>
 {
     type Object = TweedieRegressor<F>;
 
     fn fit(&self, ds: &DatasetBase<ArrayBase<D, Ix2>, T>) -> Result<Self::Object, F> {
-        let (x, y) = (ds.records(), ds.try_single_target()?);
+        let (x, y) = (ds.records(), ds.as_single_targets());
 
         let dist = TweedieDistribution::new(self.power())?;
         let link = self.link();

algorithms/linfa-linear/src/ols.rs

@@ -5,7 +5,7 @@ use ndarray::{concatenate, s, Array, Array1, Array2, ArrayBase, Axis, Data, Ix1,
 use ndarray_linalg::{Lapack, LeastSquaresSvdInto, Scalar};
 use serde::{Deserialize, Serialize};
 
-use linfa::dataset::{AsTargets, DatasetBase};
+use linfa::dataset::{AsSingleTargets, DatasetBase};
 use linfa::traits::{Fit, PredictInplace};
 
 pub trait Float: linfa::Float + Lapack + Scalar {}
@@ -76,8 +76,8 @@ impl LinearRegression {
     }
 }
 
-impl<F: Float, D: Data<Elem = F>, T: AsTargets<Elem = F>> Fit<ArrayBase<D, Ix2>, T, LinearError<F>>
-    for LinearRegression
+impl<F: Float, D: Data<Elem = F>, T: AsSingleTargets<Elem = F>>
+    Fit<ArrayBase<D, Ix2>, T, LinearError<F>> for LinearRegression
 {
     type Object = FittedLinearRegression<F>;
 
@@ -93,7 +93,7 @@ impl<F: Float, D: Data<Elem = F>, T: AsTargets<Elem = F>> Fit<ArrayBase<D, Ix2>,
     /// for new feature values.
     fn fit(&self, dataset: &DatasetBase<ArrayBase<D, Ix2>, T>) -> Result<Self::Object, F> {
         let X = dataset.records();
-        let y = dataset.try_single_target()?;
+        let y = dataset.as_single_targets();
 
         let (n_samples, _) = X.dim();
 

algorithms/linfa-logistic/examples/logistic_cv.rs

@@ -1,6 +1,7 @@
 use linfa::prelude::*;
 use linfa_logistic::error::Result;
 use linfa_logistic::LogisticRegression;
+use ndarray::arr0;
 
 fn main() -> Result<()> {
     // Load dataset. Mutability is needed for fast cross validation
@@ -22,7 +23,7 @@ fn main() -> Result<()> {
     // use cross validation to compute the validation accuracy of each model. The
     // accuracy of each model will be averaged across the folds, 5 in this case
     let accuracies = dataset.cross_validate(5, &models, |prediction, truth| {
-        Ok(prediction.confusion_matrix(truth)?.accuracy())
+        Ok(arr0(prediction.confusion_matrix(truth)?.accuracy()))
     })?;
 
     // display the accuracy of the models along with their regularization coefficient