scm2cpp-lasso 0.13.2__tar.gz → 0.15.0__tar.gz

{scm2cpp_lasso-0.13.2 → scm2cpp_lasso-0.15.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scm2cpp-lasso
-Version: 0.13.2
+Version: 0.15.0
 Summary: scikit-learn estimators (lasso, elastic net, ridge, ARD, SVM, SVR, logistic regression, GLMs, Huber, Theil-Sen, F-score selection, RFE, NMF, Gaussian mixture, FastICA, PCA, graphical lasso, RANSAC, SGD, OMP, LARS) translated from Scheme to C++ by scm2cpp; GPU batch solver and CUDA kernels included
 Author: Hirotaka Niitsuma
 License: MIT
@@ -102,6 +102,83 @@ at zero, and `lambda_grid()` walks down from it -- the construction
 scikit-learn uses.  If your columns differ wildly in scale, standardize
 them first; this solver does not do it for you.
 
+## scikit-learn compatibility
+
+From 0.14.0 every estimator with a `fit(X, y)` (or `fit(X)`) derives
+from scikit-learn's `BaseEstimator` and the matching mixin, so `clone`,
+`get_params` / `set_params`, `GridSearchCV`, `Pipeline` and
+`cross_val_score` take them, and all 44 pass
+`sklearn.utils.estimator_checks.check_estimator` (`check-sklearn.py`
+runs it; the expected failures are `DesignLasso`'s missing `n_iter_`,
+since the derived kernel does not count its sweeps, and
+`LBFGSLogisticRegressionCV`'s
+`n_iter_` of 0 for a C whose warm start is already converged, which
+scikit-learn's own `LogisticRegressionCV` reports on the same data).
+scikit-learn stays optional: without it a numpy-only stand-in gives
+`get_params`, `set_params`, `score` and the same input checks.
+
+```python
+from sklearn.model_selection import GridSearchCV
+from scm2cpp_lasso import GramLasso
+
+GridSearchCV(GramLasso(), {"alpha": [0.01, 0.1, 1.0]}, cv=5).fit(X, y)
+```
+
+`CovLasso`, `CovRidge`, `DerivedLasso`, `CovLogistic`,
+`CovGroupLasso` and `CovMultiTaskLasso` keep their
+data-in-the-constructor interface, which solves a whole path at once;
+each has a `fit(X, y)` form with the intercept beside it (0.15.0):
+
+| data in the constructor | `fit(X, y)` | scikit-learn |
+|---|---|---|
+| `CovLasso` | `GramLasso`, `GramElasticNet` | Lasso, ElasticNet |
+| `CovRidge` | `GramRidge` | Ridge |
+| `DerivedLasso` | `DesignLasso` | Lasso |
+| `CovLogistic` | `GramLogisticRegression` | LogisticRegression(l1_ratio=1, solver="liblinear") |
+| `CovGroupLasso` | `GramGroupLasso` (`groups=None`: the lasso) | (none) |
+| `CovMultiTaskLasso` | `GramMultiTaskLasso`, `GramMultiTaskElasticNet` | MultiTaskLasso, MultiTaskElasticNet |
+
+Against scikit-learn on 400 x 30 with an intercept: `DesignLasso` and
+`GramGroupLasso(groups=None)` agree with `Lasso` to 1.5e-10, the
+multi-task pair with `MultiTaskLasso` / `MultiTaskElasticNet` to
+5e-14, and `GramLogisticRegression` reaches liblinear's objective to
+eight digits with the same predictions.
+
+Against the class each one wraps (one alpha, one core), which fits no
+intercept and is unchanged: with `fit_intercept=False` the input checks
+add 15 to 30 us a call (up to +50% on a 0.06 ms fit) and the finiteness
+sum 8 to 14% on 20000 x 200 (none under `assume_finite`); with the
+intercept, the column means add 20 to 30% on 20000 x 200 for the
+Gram-matrix ones, which correct X'X
+for the means rather than copy X to centre it, and about 55% for
+`DesignLasso`, whose kernel needs the centred X itself.
+`GramLogisticRegression` is slower than liblinear by its algorithm, 2.5x
+at 20000 x 200 and more on small problems; `L1LogisticRegression` is
+the fast one for that problem.
+
+What it costs is the input checks: X must be a finite 2-D float64
+array with the feature count of the fit.  A plain C-ordered float64
+ndarray is checked directly (one sum for finiteness); anything else (a
+list, a DataFrame, another dtype) goes through scikit-learn's
+`validate_data`, which raises the errors scikit-learn raises.  The
+checks alone, per call (`bench/sklearn-compat-overhead.py --checks`):
+
+| X | fit | predict | predict, 50 rows | validate_data |
+|---|---|---|---|---|
+| 200 x 10 | 13 us | 7 us | 9 us | 173 us |
+| 2000 x 50 | 47 us | 36 us | 9 us | 224 us |
+| 20000 x 200 | 2.7 ms | 3.2 ms | 13 us | 3.2 ms |
+
+The finiteness sum is the size-dependent part; under
+`sklearn.set_config(assume_finite=True)` every row is about 3 us.
+Whole calls, before and after (`bench/sklearn-compat-overhead.py`, 30
+estimators, three shapes, the two packages alternating on one core of
+a loaded machine): fits of a millisecond or more are unchanged within
+the run-to-run spread (about 10%); fits of about 0.1 ms take 10 to
+30% (10 to 40 us) longer; predict on 20000 x 200 takes about twice as
+long (3 ms to 6 ms, the finiteness sum costing as much as the product
+itself), and on small inputs 5 to 10 us longer.
+
 ## Estimators at a glance
 
 Every estimator, the scikit-learn estimator it reproduces, the Scheme
@@ -110,12 +187,18 @@ it runs on, and whether Intel's sklearnex accelerates the scikit-learn
 side. Builds: *loops* is the plain translation, *BLAS* / *cuBLAS* the
 products handed to (cu)BLAS, *--cuda* the translator's GPU kernels
 (`gpu_cuda/`), *GPU batch* the hand-written CUDA batch solver; the
-package picks the fastest one present. None of the classes derives
-from scikit-learn's `BaseEstimator` yet, so `clone`, `GridSearchCV`
-and `check_estimator` do not apply to them.
+package picks the fastest one present.
 
 | class | scikit-learn | Scheme kernel | builds | sklearnex accelerates |
 |---|---|---|---|---|
+| `GramLasso` | Lasso(precompute=True), fit(X, y) with the intercept | `lasso-cov.scm` | CPU | no |
+| `GramElasticNet` | ElasticNet(precompute=True), fit(X, y) with the intercept | `lasso-cov.scm` | CPU | no |
+| `GramRidge` | Ridge, fit(X, y) with the intercept, one or many targets | numpy (Cholesky) | CPU | Ridge |
+| `GramMultiTaskLasso` | MultiTaskLasso, fit(X, Y) with the intercept | `lasso-cov.scm` | CPU | no |
+| `GramMultiTaskElasticNet` | MultiTaskElasticNet, fit(X, Y) with the intercept | `lasso-cov.scm` | CPU | no |
+| `GramGroupLasso` | (none; skglm GroupLasso), fit(X, y) with the intercept | `lasso-cov.scm` | CPU | - |
+| `GramLogisticRegression` | LogisticRegression(l1_ratio=1, solver='liblinear'), by majorization | `lasso-cov.scm` | CPU | no |
+| `DesignLasso` | Lasso, fit(X, y) with the intercept, from the design | `lasso-design.scm (--derive)` | loops / BLAS / cuBLAS | no |
 | `CovLasso` | Lasso, ElasticNet, lasso_path(precompute=True) | `lasso-cov.scm` | CPU; GPU batch (fit_path_batch, bootstrap) | no |
 | `CovLassoCV` | LassoCV, ElasticNetCV | `lasso-cov.scm` | CPU; GPU batch | no |
 | `DerivedLasso` | lasso_path, from the design | `lasso-design.scm (--derive)` | loops / BLAS / cuBLAS | no |

{scm2cpp_lasso-0.13.2 → scm2cpp_lasso-0.15.0}/README.md

@@ -84,6 +84,83 @@ at zero, and `lambda_grid()` walks down from it -- the construction
 scikit-learn uses.  If your columns differ wildly in scale, standardize
 them first; this solver does not do it for you.
 
+## scikit-learn compatibility
+
+From 0.14.0 every estimator with a `fit(X, y)` (or `fit(X)`) derives
+from scikit-learn's `BaseEstimator` and the matching mixin, so `clone`,
+`get_params` / `set_params`, `GridSearchCV`, `Pipeline` and
+`cross_val_score` take them, and all 44 pass
+`sklearn.utils.estimator_checks.check_estimator` (`check-sklearn.py`
+runs it; the expected failures are `DesignLasso`'s missing `n_iter_`,
+since the derived kernel does not count its sweeps, and
+`LBFGSLogisticRegressionCV`'s
+`n_iter_` of 0 for a C whose warm start is already converged, which
+scikit-learn's own `LogisticRegressionCV` reports on the same data).
+scikit-learn stays optional: without it a numpy-only stand-in gives
+`get_params`, `set_params`, `score` and the same input checks.
+
+```python
+from sklearn.model_selection import GridSearchCV
+from scm2cpp_lasso import GramLasso
+
+GridSearchCV(GramLasso(), {"alpha": [0.01, 0.1, 1.0]}, cv=5).fit(X, y)
+```
+
+`CovLasso`, `CovRidge`, `DerivedLasso`, `CovLogistic`,
+`CovGroupLasso` and `CovMultiTaskLasso` keep their
+data-in-the-constructor interface, which solves a whole path at once;
+each has a `fit(X, y)` form with the intercept beside it (0.15.0):
+
+| data in the constructor | `fit(X, y)` | scikit-learn |
+|---|---|---|
+| `CovLasso` | `GramLasso`, `GramElasticNet` | Lasso, ElasticNet |
+| `CovRidge` | `GramRidge` | Ridge |
+| `DerivedLasso` | `DesignLasso` | Lasso |
+| `CovLogistic` | `GramLogisticRegression` | LogisticRegression(l1_ratio=1, solver="liblinear") |
+| `CovGroupLasso` | `GramGroupLasso` (`groups=None`: the lasso) | (none) |
+| `CovMultiTaskLasso` | `GramMultiTaskLasso`, `GramMultiTaskElasticNet` | MultiTaskLasso, MultiTaskElasticNet |
+
+Against scikit-learn on 400 x 30 with an intercept: `DesignLasso` and
+`GramGroupLasso(groups=None)` agree with `Lasso` to 1.5e-10, the
+multi-task pair with `MultiTaskLasso` / `MultiTaskElasticNet` to
+5e-14, and `GramLogisticRegression` reaches liblinear's objective to
+eight digits with the same predictions.
+
+Against the class each one wraps (one alpha, one core), which fits no
+intercept and is unchanged: with `fit_intercept=False` the input checks
+add 15 to 30 us a call (up to +50% on a 0.06 ms fit) and the finiteness
+sum 8 to 14% on 20000 x 200 (none under `assume_finite`); with the
+intercept, the column means add 20 to 30% on 20000 x 200 for the
+Gram-matrix ones, which correct X'X
+for the means rather than copy X to centre it, and about 55% for
+`DesignLasso`, whose kernel needs the centred X itself.
+`GramLogisticRegression` is slower than liblinear by its algorithm, 2.5x
+at 20000 x 200 and more on small problems; `L1LogisticRegression` is
+the fast one for that problem.
+
+What it costs is the input checks: X must be a finite 2-D float64
+array with the feature count of the fit.  A plain C-ordered float64
+ndarray is checked directly (one sum for finiteness); anything else (a
+list, a DataFrame, another dtype) goes through scikit-learn's
+`validate_data`, which raises the errors scikit-learn raises.  The
+checks alone, per call (`bench/sklearn-compat-overhead.py --checks`):
+
+| X | fit | predict | predict, 50 rows | validate_data |
+|---|---|---|---|---|
+| 200 x 10 | 13 us | 7 us | 9 us | 173 us |
+| 2000 x 50 | 47 us | 36 us | 9 us | 224 us |
+| 20000 x 200 | 2.7 ms | 3.2 ms | 13 us | 3.2 ms |
+
+The finiteness sum is the size-dependent part; under
+`sklearn.set_config(assume_finite=True)` every row is about 3 us.
+Whole calls, before and after (`bench/sklearn-compat-overhead.py`, 30
+estimators, three shapes, the two packages alternating on one core of
+a loaded machine): fits of a millisecond or more are unchanged within
+the run-to-run spread (about 10%); fits of about 0.1 ms take 10 to
+30% (10 to 40 us) longer; predict on 20000 x 200 takes about twice as
+long (3 ms to 6 ms, the finiteness sum costing as much as the product
+itself), and on small inputs 5 to 10 us longer.
+
 ## Estimators at a glance
 
 Every estimator, the scikit-learn estimator it reproduces, the Scheme
@@ -92,12 +169,18 @@ it runs on, and whether Intel's sklearnex accelerates the scikit-learn
 side. Builds: *loops* is the plain translation, *BLAS* / *cuBLAS* the
 products handed to (cu)BLAS, *--cuda* the translator's GPU kernels
 (`gpu_cuda/`), *GPU batch* the hand-written CUDA batch solver; the
-package picks the fastest one present. None of the classes derives
-from scikit-learn's `BaseEstimator` yet, so `clone`, `GridSearchCV`
-and `check_estimator` do not apply to them.
+package picks the fastest one present.
 
 | class | scikit-learn | Scheme kernel | builds | sklearnex accelerates |
 |---|---|---|---|---|
+| `GramLasso` | Lasso(precompute=True), fit(X, y) with the intercept | `lasso-cov.scm` | CPU | no |
+| `GramElasticNet` | ElasticNet(precompute=True), fit(X, y) with the intercept | `lasso-cov.scm` | CPU | no |
+| `GramRidge` | Ridge, fit(X, y) with the intercept, one or many targets | numpy (Cholesky) | CPU | Ridge |
+| `GramMultiTaskLasso` | MultiTaskLasso, fit(X, Y) with the intercept | `lasso-cov.scm` | CPU | no |
+| `GramMultiTaskElasticNet` | MultiTaskElasticNet, fit(X, Y) with the intercept | `lasso-cov.scm` | CPU | no |
+| `GramGroupLasso` | (none; skglm GroupLasso), fit(X, y) with the intercept | `lasso-cov.scm` | CPU | - |
+| `GramLogisticRegression` | LogisticRegression(l1_ratio=1, solver='liblinear'), by majorization | `lasso-cov.scm` | CPU | no |
+| `DesignLasso` | Lasso, fit(X, y) with the intercept, from the design | `lasso-design.scm (--derive)` | loops / BLAS / cuBLAS | no |
 | `CovLasso` | Lasso, ElasticNet, lasso_path(precompute=True) | `lasso-cov.scm` | CPU; GPU batch (fit_path_batch, bootstrap) | no |
 | `CovLassoCV` | LassoCV, ElasticNetCV | `lasso-cov.scm` | CPU; GPU batch | no |
 | `DerivedLasso` | lasso_path, from the design | `lasso-design.scm (--derive)` | loops / BLAS / cuBLAS | no |

{scm2cpp_lasso-0.13.2 → scm2cpp_lasso-0.15.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "scm2cpp-lasso"
-version = "0.13.2"
+version = "0.15.0"
 description = "scikit-learn estimators (lasso, elastic net, ridge, ARD, SVM, SVR, logistic regression, GLMs, Huber, Theil-Sen, F-score selection, RFE, NMF, Gaussian mixture, FastICA, PCA, graphical lasso, RANSAC, SGD, OMP, LARS) translated from Scheme to C++ by scm2cpp; GPU batch solver and CUDA kernels included"
 readme = "README.md"
 requires-python = ">=3.8"