Pls bench (rust-ml#263)

* Create ols_bench.rs

* add bench

* criterion benchmark

* use make_dataset function

* make return Dim compatiable with Fit methods

* dev-depenences: add generate to linfa-datasets

* omit dataset creation from bench timing

* pub use pls_generics

* added CCA and Canonical benches

* reduce future count

Author: oojo12

algorithms/linfa-linear/benches/ols_bench.rs

@@ -20,42 +20,39 @@ fn perform_glm(dataset: &Dataset<f64, f64, Ix1>) {
 
 fn bench(c: &mut Criterion) {
     let mut group = c.benchmark_group("Linfa_linear");
-    let sizes: [usize; 3] = [1_000, 10_000, 100_000];
-    let num_feats: [usize; 2] = [5, 10];
+    let params: [(usize, usize); 4] = [(1_000, 5), (10_000, 5), (100_000, 5), (100_000, 10)];
 
     let feat_distr = Laplace::new(0.5, 5.).unwrap();
     let target_distr = DiscreteUniform::new(0, 5).unwrap();
 
     let ols_id = "OLS-".to_string();
     let glm_id = "GLM-".to_string();
 
-    for size in sizes {
-        for num_feat in num_feats {
-            let suffix = format!("{}Feats", num_feat);
-            let mut func_name = ols_id.clone();
-            func_name.push_str(&suffix);
-
-            let dataset = make_dataset(size, num_feat, 1, feat_distr, target_distr);
-            let dataset = dataset.into_single_target();
-
-            group.bench_with_input(
-                BenchmarkId::new(&func_name, size),
-                &dataset,
-                |b, dataset| {
-                    b.iter(|| perform_ols(&dataset));
-                },
-            );
-
-            let mut func_name = glm_id.clone();
-            func_name.push_str(&suffix);
-            group.bench_with_input(
-                BenchmarkId::new(&func_name, size),
-                &dataset,
-                |b, dataset| {
-                    b.iter(|| perform_glm(&dataset));
-                },
-            );
-        }
+    for (size, num_feat) in params {
+        let suffix = format!("{}Feats", num_feat);
+        let mut func_name = ols_id.clone();
+        func_name.push_str(&suffix);
+
+        let dataset = make_dataset(size, num_feat, 1, feat_distr, target_distr);
+        let dataset = dataset.into_single_target();
+
+        group.bench_with_input(
+            BenchmarkId::new(&func_name, size),
+            &dataset,
+            |b, dataset| {
+                b.iter(|| perform_ols(&dataset));
+            },
+        );
+
+        let mut func_name = glm_id.clone();
+        func_name.push_str(&suffix);
+        group.bench_with_input(
+            BenchmarkId::new(&func_name, size),
+            &dataset,
+            |b, dataset| {
+                b.iter(|| perform_glm(&dataset));
+            },
+        );
     }
     group.finish();
 }

algorithms/linfa-pls/Cargo.toml

@@ -39,3 +39,9 @@ linfa = { version = "0.6.0", path = "../.." }
 linfa-datasets = { version = "0.6.0", path = "../../datasets", features = ["linnerud"] }
 approx = "0.4"
 rand_xoshiro = "0.6"
+criterion = "0.4.0"
+statrs = "0.16.0"
+
+[[bench]]
+name = "pls"
+harness = false

algorithms/linfa-pls/benches/pls.rs

@@ -0,0 +1,90 @@
+use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
+use linfa::traits::Fit;
+use linfa::Dataset;
+use linfa_datasets::generate::make_dataset;
+use linfa_pls::Algorithm;
+use linfa_pls::{PlsCanonical, PlsCca, PlsRegression};
+use statrs::distribution::{DiscreteUniform, Laplace};
+
+#[allow(unused_must_use)]
+fn pls_regression(dataset: &Dataset<f64, f64>, alg: Algorithm) {
+    let model = PlsRegression::params(3)
+        .scale(true)
+        .max_iterations(200)
+        .algorithm(alg);
+    model.fit(&dataset);
+}
+
+#[allow(unused_must_use)]
+fn pls_canonical(dataset: &Dataset<f64, f64>, alg: Algorithm) {
+    let model = PlsCanonical::params(3)
+        .scale(true)
+        .max_iterations(200)
+        .algorithm(alg);
+    model.fit(&dataset);
+}
+#[allow(unused_must_use)]
+fn pls_cca(dataset: &Dataset<f64, f64>, alg: Algorithm) {
+    let model = PlsCca::params(3)
+        .scale(true)
+        .max_iterations(200)
+        .algorithm(alg);
+    model.fit(&dataset);
+}
+
+fn bench(c: &mut Criterion) {
+    let mut group = c.benchmark_group("Linfa_pls");
+    let params: [(usize, usize); 4] = [(1_000, 5), (10_000, 5), (100_000, 5), (100_000, 10)];
+
+    for (alg, name) in [(Algorithm::Nipals, "Nipals-"), (Algorithm::Svd, "Svd-")] {
+        let feat_distr = Laplace::new(0.5, 5.).unwrap();
+        let target_distr = DiscreteUniform::new(0, 5).unwrap();
+
+        let mut pls_regression_id = "Regression-".to_string();
+        pls_regression_id.push_str(name);
+        let mut pls_canonical_id = "Canonical-".to_string();
+        pls_canonical_id.push_str(name);
+        let mut pls_cca_id = "Cca-".to_string();
+        pls_cca_id.push_str(name);
+
+        for (size, num_feat) in params {
+            let suffix = format!("{}Feats", num_feat);
+            let mut func_name = pls_regression_id.clone();
+            func_name.push_str(&suffix);
+            let dataset = make_dataset(size, num_feat, 1, feat_distr, target_distr);
+            let input = (dataset, alg);
+
+            group.bench_with_input(
+                BenchmarkId::new(&func_name, size),
+                &input,
+                |b, (dataset, alg)| {
+                    b.iter(|| pls_regression(dataset, *alg));
+                },
+            );
+
+            let mut func_name = pls_canonical_id.clone();
+            func_name.push_str(&suffix);
+            group.bench_with_input(
+                BenchmarkId::new(&func_name, size),
+                &input,
+                |b, (dataset, alg)| {
+                    b.iter(|| pls_canonical(dataset, *alg));
+                },
+            );
+
+            let mut func_name = pls_cca_id.clone();
+            func_name.push_str(&suffix);
+            group.bench_with_input(
+                BenchmarkId::new(&func_name, size),
+                &input,
+                |b, (dataset, alg)| {
+                    b.iter(|| pls_cca(dataset, *alg));
+                },
+            );
+        }
+    }
+    group.finish();
+}
+
+criterion_group!(benches, bench);
+criterion_main!(benches);

algorithms/linfa-pls/src/lib.rs

@@ -40,6 +40,7 @@
 mod errors;
 mod hyperparams;
 mod pls_generic;
+pub use pls_generic::*;
 mod pls_svd;
 mod utils;