scm2cpp-lasso 0.13.1__tar.gz → 0.14.0__tar.gz

{scm2cpp_lasso-0.13.1 → scm2cpp_lasso-0.14.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scm2cpp-lasso
-Version: 0.13.1
+Version: 0.14.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
@@ -18,6 +18,8 @@ Requires-Dist: numpy>=1.17
 
 # scm2cpp-lasso
 
+[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/niitsuma/scm2cpp/blob/master/notebooks/compare-sklearn.ipynb)
+
 *[Japanese (README.ja.md)](README.ja.md)*
 
 Lasso by coordinate descent over a Gram matrix, with an optional GPU
@@ -28,8 +30,9 @@ path.  The solver is Scheme, translated to C++ by
 $ pip install scm2cpp-lasso
 ```
 
-On Linux x86_64 and macOS arm64 (macOS 14 or later) this installs a wheel: compiled, with
-OpenBLAS inside, nothing to build.  Elsewhere pip builds the sdist,
+On Linux x86_64, macOS arm64 (macOS 14 or later) and Windows AMD64
+this installs a wheel: compiled, nothing to build (with OpenBLAS
+inside on Linux and macOS; Windows has the loop variants).  Elsewhere pip builds the sdist,
 which needs a C++17 compiler and nothing else.  The wheels carry no
 GPU code (a wheel cannot know the device); for the GPU builds, install
 from the sdist on a machine with `nvcc` on the path:
@@ -99,6 +102,55 @@ 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 39 pass
+`sklearn.utils.estimator_checks.check_estimator` (`check-sklearn.py`
+runs it; the one expected failure is `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)
+```
+
+`GramLasso`, `GramElasticNet` and `GramRidge` are the `fit(X, y)`
+forms, with the intercept, over the Gram-matrix solvers; `CovLasso`,
+`CovRidge`, `DerivedLasso`, `CovLogistic`, `CovGroupLasso` and
+`CovMultiTaskLasso` keep their data-in-the-constructor interface,
+which solves a whole path at once.
+
+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
@@ -107,12 +159,13 @@ 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 |
 | `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.1 → scm2cpp_lasso-0.14.0}/README.md

@@ -1,5 +1,7 @@
 # scm2cpp-lasso
 
+[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/niitsuma/scm2cpp/blob/master/notebooks/compare-sklearn.ipynb)
+
 *[Japanese (README.ja.md)](README.ja.md)*
 
 Lasso by coordinate descent over a Gram matrix, with an optional GPU
@@ -10,8 +12,9 @@ path.  The solver is Scheme, translated to C++ by
 $ pip install scm2cpp-lasso
 ```
 
-On Linux x86_64 and macOS arm64 (macOS 14 or later) this installs a wheel: compiled, with
-OpenBLAS inside, nothing to build.  Elsewhere pip builds the sdist,
+On Linux x86_64, macOS arm64 (macOS 14 or later) and Windows AMD64
+this installs a wheel: compiled, nothing to build (with OpenBLAS
+inside on Linux and macOS; Windows has the loop variants).  Elsewhere pip builds the sdist,
 which needs a C++17 compiler and nothing else.  The wheels carry no
 GPU code (a wheel cannot know the device); for the GPU builds, install
 from the sdist on a machine with `nvcc` on the path:
@@ -81,6 +84,55 @@ 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 39 pass
+`sklearn.utils.estimator_checks.check_estimator` (`check-sklearn.py`
+runs it; the one expected failure is `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)
+```
+
+`GramLasso`, `GramElasticNet` and `GramRidge` are the `fit(X, y)`
+forms, with the intercept, over the Gram-matrix solvers; `CovLasso`,
+`CovRidge`, `DerivedLasso`, `CovLogistic`, `CovGroupLasso` and
+`CovMultiTaskLasso` keep their data-in-the-constructor interface,
+which solves a whole path at once.
+
+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
@@ -89,12 +141,13 @@ 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 |
 | `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.1 → scm2cpp_lasso-0.14.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "scm2cpp-lasso"
-version = "0.13.1"
+version = "0.14.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"

{scm2cpp_lasso-0.13.1 → scm2cpp_lasso-0.14.0}/setup.py

@@ -12,6 +12,7 @@ device, or a failed nvcc all leave a working CPU package behind, and
 the batch path notices at import and falls back.
 """
 import os
+import re
 import shutil
 import subprocess
 import sys
@@ -28,7 +29,9 @@ GEN_REL = PKG_REL + "/_generated"
 PKG = HERE / "src" / "scm2cpp_lasso"
 GEN = PKG / "_generated"
 
-CXXFLAGS = ["-O2", "-std=c++17"] if os.name != "nt" else ["/O2", "/std:c++17"]
+# MSVC: /EHsc for C++ exceptions, /bigobj for the large generated files
+MSVC = ["/O2", "/std:c++17", "/EHsc", "/bigobj"]
+CXXFLAGS = ["-O2", "-std=c++17"] if os.name != "nt" else MSVC
 
 kernel = Extension(
     "scm2cpp_lasso._lasso_cov",
@@ -92,12 +95,24 @@ else:
         "scm2cpp_lasso._lasso_derived_loops",
         sources=[GEN_REL + "/derived_loops/lasso_design_capi.cpp"],
         include_dirs=[GEN_REL + "/derived_loops", GEN_REL],
-        extra_compile_args=(["-O3", "-std=c++17"] if os.name != "nt"
-                            else ["/O2", "/std:c++17"]),
+        extra_compile_args=(["-O3", "-std=c++17"] if os.name != "nt" else MSVC),
     )
 
 
 class BuildWithCuda(build_ext):
+    def get_export_symbols(self, ext):
+        # The extensions are plain shared libraries the package loads
+        # through ctypes, not Python modules: no PyInit_ entry point,
+        # and on Windows a DLL shows ctypes only what it exports, so the
+        # exports are the extern "C" wrappers of the -M C API.  (Unix
+        # linkers export everything and ignore this list.)
+        names = []
+        for src in ext.sources:
+            if src.endswith("_capi.cpp"):
+                text = (HERE / src).read_text()
+                names += re.findall(r'extern "C"[^(\n]*?\b(scm2cpp_\w+)\(', text)
+        return names
+
     def build_extensions(self):
         # the kernel is C++ compiled through the usual machinery, so
         # wheels and cross-compilation behave as they always do
@@ -165,7 +180,7 @@ def cuda_home():
 # flags carry: with signed overflow defined the compiler cannot treat
 # the flat index i*p + j as an induction variable, and the linear SVM's
 # sweep runs 25% slower.
-_cls_flags = ["-O3", "-std=c++17", "-fstrict-overflow"] if os.name != "nt" else ["/O2", "/std:c++17"]
+_cls_flags = ["-O3", "-std=c++17", "-fstrict-overflow"] if os.name != "nt" else MSVC
 classifiers = Extension(
     "scm2cpp_lasso._classifiers",
     sources=[GEN_REL + "/classifiers_capi.cpp"],