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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scm2cpp-lasso
-Version: 0.13.0
+Version: 0.13.2
 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,9 +30,20 @@ path.  The solver is Scheme, translated to C++ by
 $ pip install scm2cpp-lasso
 ```
 
-Installing needs a C++17 compiler and nothing else.  If `nvcc` is on
-the path, the batched GPU solver is built as well; if it is not, the
-package installs and works exactly the same, minus that one method.
+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:
+
+```console
+$ pip install --no-binary scm2cpp-lasso scm2cpp-lasso
+```
+
+The batched GPU solver, the cuBLAS variants and the `--cuda`
+estimators are then built as well; without `nvcc` the package installs
+and works exactly the same, minus those.
 
 Three of a hundred candidate columns carry the signal; the solver is
 asked which, and answers with them and nothing else:
@@ -89,6 +102,63 @@ 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.
 
+## Estimators at a glance
+
+Every estimator, the scikit-learn estimator it reproduces, the Scheme
+kernel under `examples/kernel-only/` it is translated from, the builds
+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.
+
+| class | scikit-learn | Scheme kernel | builds | sklearnex accelerates |
+|---|---|---|---|---|
+| `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 |
+| `CovMultiTaskLasso` | MultiTaskLasso, MultiTaskElasticNet | `lasso-cov.scm` | CPU | no |
+| `CovMultiTaskLassoCV` | MultiTaskLassoCV, MultiTaskElasticNetCV | `lasso-cov.scm` | CPU; GPU batch | no |
+| `CovGroupLasso` | (none; skglm GroupLasso) | `lasso-cov.scm` | CPU | - |
+| `CovLogistic` | LogisticRegression(penalty='l1'), by majorization | `lasso-cov.scm` | CPU | no |
+| `CovRidge` | Ridge(fit_intercept=False), a whole alpha path | `lasso-cov.scm` | CPU | Ridge |
+| `CovBayesianRidge` | BayesianRidge | `lasso-cov.scm` | CPU | no |
+| `CovARDRegression` | ARDRegression (n >= p) | `ard.scm` | loops / BLAS | no |
+| `GramLars` | Lars | `lars.scm` | CPU | no |
+| `GramLassoLars` | LassoLars | `lars.scm` | CPU | no |
+| `GramLassoLarsIC` | LassoLarsIC | `lars.scm` | CPU; device Gram | no |
+| `GramLarsCV` | LarsCV | `lars.scm` | CPU | no |
+| `GramLassoLarsCV` | LassoLarsCV | `lars.scm` | CPU; device Gram | no |
+| `GramOMP` | OrthogonalMatchingPursuit | `omp.scm` | loops / BLAS | no |
+| `GramOMPCV` | OrthogonalMatchingPursuitCV | `omp.scm` | loops / BLAS | no |
+| `LBFGSLogisticRegression` | LogisticRegression(solver='lbfgs') | `logistic-lbfgs.scm, lbfgs.scm` | loops / BLAS / --cuda | LogisticRegression |
+| `LBFGSLogisticRegressionCV` | LogisticRegressionCV | `logistic-lbfgs.scm, lbfgs.scm` | loops / BLAS / --cuda | no |
+| `LBFGSHuberRegressor` | HuberRegressor | `huber.scm, lbfgs.scm` | loops / BLAS / --cuda | no |
+| `LBFGSPoissonRegressor` | PoissonRegressor | `glm.scm, lbfgs.scm` | loops / BLAS / --cuda | no |
+| `LBFGSGammaRegressor` | GammaRegressor | `glm.scm, lbfgs.scm` | loops / BLAS / --cuda | no |
+| `LBFGSTweedieRegressor` | TweedieRegressor | `glm.scm, lbfgs.scm` | loops / BLAS / --cuda | no |
+| `LinearSVM` | LinearSVC(loss='hinge') | `svm-liblinear.scm` | CPU | no |
+| `L1LinearSVM` | LinearSVC(penalty='l1', dual=False) | `svm-l1.scm` | CPU | no |
+| `KernelSVM` | SVC | `svm-smo.scm` | CPU | SVC |
+| `LinearSVR` | LinearSVR | `svr-liblinear.scm` | CPU | no |
+| `KernelSVR` | SVR | `svm-smo.scm` | CPU | SVR |
+| `L1LogisticRegression` | LogisticRegression(penalty='l1', solver='liblinear') | `logistic-l1.scm` | CPU | no |
+| `SGDLinearClassifier` | SGDClassifier(shuffle=False) | `sgd.scm` | CPU | no |
+| `SGDLinearRegressor` | SGDRegressor(shuffle=False) | `sgd.scm` | CPU | no |
+| `SGDPerceptron` | Perceptron(shuffle=False) | `sgd.scm` | CPU | no |
+| `LinearRANSAC` | RANSACRegressor (given subsets) | `ransac.scm` | CPU | no |
+| `WeiszfeldTheilSen` | TheilSenRegressor | `theilsen.scm` | CPU | no |
+| `CDNMF` | NMF(solver='cd') | `nmf-cd.scm (--derive)` | loops / BLAS / cuBLAS | no |
+| `CDGraphicalLasso` | GraphicalLasso | `graphical-lasso.scm` | loops / BLAS | no |
+| `EMGaussianMixture` | GaussianMixture(covariance_type='full') | `gmm.scm` | loops / BLAS / --cuda | no |
+| `ParallelFastICA` | FastICA | `fastica.scm` | loops / BLAS / --cuda | no |
+| `CovPCA` | PCA(svd_solver='covariance_eigh') | `pca.scm` | loops / BLAS / cuBLAS | PCA |
+| `f_regression, f_classif` | f_regression, f_classif | `fscore.scm` | loops / BLAS / cuBLAS | no |
+| `SelectKBest, SelectPercentile` | SelectKBest, SelectPercentile | `fscore.scm` | loops / BLAS / cuBLAS | no |
+| `GramRFE` | RFE(Ridge), RFE(LinearRegression) | `rfe.scm` | loops / BLAS / cuBLAS | inside: Ridge |
+
 ## Two kernels: `CovLasso` and `DerivedLasso`
 
 Everything above, and the cross-validation, bootstrap and GPU methods
@@ -733,6 +803,39 @@ estimators (`GramLassoLarsIC`, `GramLarsCV`, `GramLassoLarsCV`,
 `GramLars`, `GramLassoLars`, `CovPCA`) form a large X'X on the device
 when one answers. `SCM2CPP_NO_DEVICE=1` keeps everything on the CPU.
 
+## Against Intel's sklearnex
+
+sklearnex (scikit-learn-intelex 2026.2, oneDAL underneath) replaces
+some scikit-learn estimators with its own. `bench/sklearnex-compare.py`
+times the ones with a counterpart here, sklearnex's estimators
+imported directly (not patched in) so that scikit-learn itself is
+timed in the same process. The ratios are scikit-learn's or
+sklearnex's time over the package's best (its CPU build, or the device
+build where one answers); the load average was 8 to 11, so the times
+move by some tens of percent.
+
+| estimator, n x p | iterations (sk / sklearnex / ours) | vs scikit-learn, one core | vs sklearnex, one core | vs sklearnex, 20 cores |
+|---|---|---|---|---|
+| LogisticRegression, 200,000 x 100 | 6 / 12 / 6 | 10.6x (device) | 8.4x (device) | 4.4x (device); on the CPU 0.5x |
+| Ridge (alpha 1), 200,000 x 200 | - | 2.1x | 1.2x | 0.3x |
+| PCA (10 components), 100,000 x 50 | - | 1.5x | 2.4x | 1.7x |
+| PCA (10 components), 50,000 x 500 | - | 1.1x | 1.4x | 0.5x |
+| SVC (rbf), 5,000 x 20 | 4,858 / 7 / 4,882 | 1.2x | 1.4x | 0.5x |
+| SVR (rbf), 5,000 x 20 | 12,821 / 10 / 12,824 | 1.3x | 1.4x | 0.4x |
+| RFE(Ridge), 20 of 200 kept, 20,000 x 200 | - | 216x | 128x | 78x |
+
+On one core the package is ahead everywhere. sklearnex uses every
+core by default, and the package's kernels are single-threaded, so
+with 20 cores sklearnex is faster on Ridge, the larger PCA and the
+SVMs; what stays ahead is the device build (logistic regression) and
+an algorithm that does less work (RFE: the Gram once, the Cholesky
+factor downdated per drop, where scikit-learn refits). sklearnex is
+not scikit-learn's arithmetic: its logistic regression takes 12
+iterations to scikit-learn's 6 and its coefficients differ from
+scikit-learn's by 6e-3, where the package's agree to 4e-15; its SVMs
+report a different iteration count. This sklearnex accelerates no
+lasso, so the lasso tables above stand against scikit-learn alone.
+
 ## The GPU build
 
 Where the CUDA toolkit is at install time, `ParallelFastICA`,

{scm2cpp_lasso-0.13.0 → scm2cpp_lasso-0.13.2}/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,9 +12,20 @@ path.  The solver is Scheme, translated to C++ by
 $ pip install scm2cpp-lasso
 ```
 
-Installing needs a C++17 compiler and nothing else.  If `nvcc` is on
-the path, the batched GPU solver is built as well; if it is not, the
-package installs and works exactly the same, minus that one method.
+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:
+
+```console
+$ pip install --no-binary scm2cpp-lasso scm2cpp-lasso
+```
+
+The batched GPU solver, the cuBLAS variants and the `--cuda`
+estimators are then built as well; without `nvcc` the package installs
+and works exactly the same, minus those.
 
 Three of a hundred candidate columns carry the signal; the solver is
 asked which, and answers with them and nothing else:
@@ -71,6 +84,63 @@ 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.
 
+## Estimators at a glance
+
+Every estimator, the scikit-learn estimator it reproduces, the Scheme
+kernel under `examples/kernel-only/` it is translated from, the builds
+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.
+
+| class | scikit-learn | Scheme kernel | builds | sklearnex accelerates |
+|---|---|---|---|---|
+| `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 |
+| `CovMultiTaskLasso` | MultiTaskLasso, MultiTaskElasticNet | `lasso-cov.scm` | CPU | no |
+| `CovMultiTaskLassoCV` | MultiTaskLassoCV, MultiTaskElasticNetCV | `lasso-cov.scm` | CPU; GPU batch | no |
+| `CovGroupLasso` | (none; skglm GroupLasso) | `lasso-cov.scm` | CPU | - |
+| `CovLogistic` | LogisticRegression(penalty='l1'), by majorization | `lasso-cov.scm` | CPU | no |
+| `CovRidge` | Ridge(fit_intercept=False), a whole alpha path | `lasso-cov.scm` | CPU | Ridge |
+| `CovBayesianRidge` | BayesianRidge | `lasso-cov.scm` | CPU | no |
+| `CovARDRegression` | ARDRegression (n >= p) | `ard.scm` | loops / BLAS | no |
+| `GramLars` | Lars | `lars.scm` | CPU | no |
+| `GramLassoLars` | LassoLars | `lars.scm` | CPU | no |
+| `GramLassoLarsIC` | LassoLarsIC | `lars.scm` | CPU; device Gram | no |
+| `GramLarsCV` | LarsCV | `lars.scm` | CPU | no |
+| `GramLassoLarsCV` | LassoLarsCV | `lars.scm` | CPU; device Gram | no |
+| `GramOMP` | OrthogonalMatchingPursuit | `omp.scm` | loops / BLAS | no |
+| `GramOMPCV` | OrthogonalMatchingPursuitCV | `omp.scm` | loops / BLAS | no |
+| `LBFGSLogisticRegression` | LogisticRegression(solver='lbfgs') | `logistic-lbfgs.scm, lbfgs.scm` | loops / BLAS / --cuda | LogisticRegression |
+| `LBFGSLogisticRegressionCV` | LogisticRegressionCV | `logistic-lbfgs.scm, lbfgs.scm` | loops / BLAS / --cuda | no |
+| `LBFGSHuberRegressor` | HuberRegressor | `huber.scm, lbfgs.scm` | loops / BLAS / --cuda | no |
+| `LBFGSPoissonRegressor` | PoissonRegressor | `glm.scm, lbfgs.scm` | loops / BLAS / --cuda | no |
+| `LBFGSGammaRegressor` | GammaRegressor | `glm.scm, lbfgs.scm` | loops / BLAS / --cuda | no |
+| `LBFGSTweedieRegressor` | TweedieRegressor | `glm.scm, lbfgs.scm` | loops / BLAS / --cuda | no |
+| `LinearSVM` | LinearSVC(loss='hinge') | `svm-liblinear.scm` | CPU | no |
+| `L1LinearSVM` | LinearSVC(penalty='l1', dual=False) | `svm-l1.scm` | CPU | no |
+| `KernelSVM` | SVC | `svm-smo.scm` | CPU | SVC |
+| `LinearSVR` | LinearSVR | `svr-liblinear.scm` | CPU | no |
+| `KernelSVR` | SVR | `svm-smo.scm` | CPU | SVR |
+| `L1LogisticRegression` | LogisticRegression(penalty='l1', solver='liblinear') | `logistic-l1.scm` | CPU | no |
+| `SGDLinearClassifier` | SGDClassifier(shuffle=False) | `sgd.scm` | CPU | no |
+| `SGDLinearRegressor` | SGDRegressor(shuffle=False) | `sgd.scm` | CPU | no |
+| `SGDPerceptron` | Perceptron(shuffle=False) | `sgd.scm` | CPU | no |
+| `LinearRANSAC` | RANSACRegressor (given subsets) | `ransac.scm` | CPU | no |
+| `WeiszfeldTheilSen` | TheilSenRegressor | `theilsen.scm` | CPU | no |
+| `CDNMF` | NMF(solver='cd') | `nmf-cd.scm (--derive)` | loops / BLAS / cuBLAS | no |
+| `CDGraphicalLasso` | GraphicalLasso | `graphical-lasso.scm` | loops / BLAS | no |
+| `EMGaussianMixture` | GaussianMixture(covariance_type='full') | `gmm.scm` | loops / BLAS / --cuda | no |
+| `ParallelFastICA` | FastICA | `fastica.scm` | loops / BLAS / --cuda | no |
+| `CovPCA` | PCA(svd_solver='covariance_eigh') | `pca.scm` | loops / BLAS / cuBLAS | PCA |
+| `f_regression, f_classif` | f_regression, f_classif | `fscore.scm` | loops / BLAS / cuBLAS | no |
+| `SelectKBest, SelectPercentile` | SelectKBest, SelectPercentile | `fscore.scm` | loops / BLAS / cuBLAS | no |
+| `GramRFE` | RFE(Ridge), RFE(LinearRegression) | `rfe.scm` | loops / BLAS / cuBLAS | inside: Ridge |
+
 ## Two kernels: `CovLasso` and `DerivedLasso`
 
 Everything above, and the cross-validation, bootstrap and GPU methods
@@ -715,6 +785,39 @@ estimators (`GramLassoLarsIC`, `GramLarsCV`, `GramLassoLarsCV`,
 `GramLars`, `GramLassoLars`, `CovPCA`) form a large X'X on the device
 when one answers. `SCM2CPP_NO_DEVICE=1` keeps everything on the CPU.
 
+## Against Intel's sklearnex
+
+sklearnex (scikit-learn-intelex 2026.2, oneDAL underneath) replaces
+some scikit-learn estimators with its own. `bench/sklearnex-compare.py`
+times the ones with a counterpart here, sklearnex's estimators
+imported directly (not patched in) so that scikit-learn itself is
+timed in the same process. The ratios are scikit-learn's or
+sklearnex's time over the package's best (its CPU build, or the device
+build where one answers); the load average was 8 to 11, so the times
+move by some tens of percent.
+
+| estimator, n x p | iterations (sk / sklearnex / ours) | vs scikit-learn, one core | vs sklearnex, one core | vs sklearnex, 20 cores |
+|---|---|---|---|---|
+| LogisticRegression, 200,000 x 100 | 6 / 12 / 6 | 10.6x (device) | 8.4x (device) | 4.4x (device); on the CPU 0.5x |
+| Ridge (alpha 1), 200,000 x 200 | - | 2.1x | 1.2x | 0.3x |
+| PCA (10 components), 100,000 x 50 | - | 1.5x | 2.4x | 1.7x |
+| PCA (10 components), 50,000 x 500 | - | 1.1x | 1.4x | 0.5x |
+| SVC (rbf), 5,000 x 20 | 4,858 / 7 / 4,882 | 1.2x | 1.4x | 0.5x |
+| SVR (rbf), 5,000 x 20 | 12,821 / 10 / 12,824 | 1.3x | 1.4x | 0.4x |
+| RFE(Ridge), 20 of 200 kept, 20,000 x 200 | - | 216x | 128x | 78x |
+
+On one core the package is ahead everywhere. sklearnex uses every
+core by default, and the package's kernels are single-threaded, so
+with 20 cores sklearnex is faster on Ridge, the larger PCA and the
+SVMs; what stays ahead is the device build (logistic regression) and
+an algorithm that does less work (RFE: the Gram once, the Cholesky
+factor downdated per drop, where scikit-learn refits). sklearnex is
+not scikit-learn's arithmetic: its logistic regression takes 12
+iterations to scikit-learn's 6 and its coefficients differ from
+scikit-learn's by 6e-3, where the package's agree to 4e-15; its SVMs
+report a different iteration count. This sklearnex accelerates no
+lasso, so the lasso tables above stand against scikit-learn alone.
+
 ## The GPU build
 
 Where the CUDA toolkit is at install time, `ParallelFastICA`,

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "scm2cpp-lasso"
-version = "0.13.0"
+version = "0.13.2"
 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.0 → scm2cpp_lasso-0.13.2}/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"],
@@ -242,4 +257,27 @@ if _cuda is not None:
         extra_compile_args=CXXFLAGS + ["-O3", "-fstrict-overflow"],
     ))
 
-setup(ext_modules=extensions, cmdclass={"build_ext": BuildWithCuda})
+# A wheel is tagged py3-none-<platform>: the extensions are shared
+# libraries the package loads through ctypes, using no Python API, so
+# one build serves every Python on that platform.
+try:
+    from setuptools.command.bdist_wheel import bdist_wheel
+except ImportError:  # setuptools before 70.1
+    try:
+        from wheel.bdist_wheel import bdist_wheel
+    except ImportError:
+        bdist_wheel = None
+
+cmdclass = {"build_ext": BuildWithCuda}
+if bdist_wheel is not None:
+    class PlatformWheel(bdist_wheel):
+        def finalize_options(self):
+            super().finalize_options()
+            self.root_is_pure = False
+
+        def get_tag(self):
+            return ("py3", "none", super().get_tag()[2])
+
+    cmdclass["bdist_wheel"] = PlatformWheel
+
+setup(ext_modules=extensions, cmdclass=cmdclass)

{scm2cpp_lasso-0.13.0 → scm2cpp_lasso-0.13.2}/src/scm2cpp_lasso/__init__.py

@@ -51,7 +51,7 @@ __all__ = ["CovLasso", "CovRidge", "CovBayesianRidge", "CovLogistic", "CovGroupL
            "SelectPercentile", "GramRFE",
            "CovMultiTaskLasso", "CovMultiTaskLassoCV", "DerivedLasso",
            "cuda_available", "derived_backend", "kernel"]
-__version__ = "0.13.0"
+__version__ = "0.13.2"
 
 _BATCH = load_batch_lib()
 _DP = ctypes.POINTER(ctypes.c_double)

{scm2cpp_lasso-0.13.0 → scm2cpp_lasso-0.13.2}/src/scm2cpp_lasso/_generated/scm2cpp.hpp

@@ -3,6 +3,7 @@
 
 #include <iostream>
 #include <vector>
+#include <string>
 #include <list>
 #include <map>
 #include <algorithm>
@@ -1459,6 +1460,36 @@ namespace scm2cpp {
     std::size_t size() const { return n; }
   };
 
+  // A memo for a pure call: (memo-call M E KEY ...) is
+  //   memo_get(M, memo_key().add(KEY)...str(), [&]() { return E; })
+  // M a hash table from the key's bytes to E's value (the translator's
+  // (make-hash), an std::unordered_map<std::string, V>), so E runs once
+  // per distinct key.  A key is scalars by value and, through
+  // add_range, the first N elements of an array -- the index set a
+  // gather read, say.  The bytes are the values' object representation,
+  // so 0.0 and -0.0 are different keys (a miss, never a wrong hit).
+  struct memo_key {
+    std::string b;
+    template<typename T> memo_key& add(const T& v) {
+      b.append(reinterpret_cast<const char*>(&v), sizeof(T));
+      return *this;
+    }
+    template<typename V> memo_key& add_range(const V& v, long n) {
+      add(n);
+      for (long i = 0; i < n; ++i) add(v[i]);
+      return *this;
+    }
+    const std::string& str() const { return b; }
+  };
+  template<typename M, typename F>
+  inline typename M::mapped_type memo_get(M& m, const std::string& k, F f) {
+    auto it = m.find(k);
+    if (it != m.end()) return it->second;
+    typename M::mapped_type v = f();
+    m.emplace(k, v);
+    return v;
+  }
+
   template<typename T, int N> struct integral_image {
     std::vector<T> table;      // padded with a zero border: dim[k]+1 per axis
     int dim[N];                // extents of the source array

{scm2cpp_lasso-0.13.0 → scm2cpp_lasso-0.13.2}/src/scm2cpp_lasso.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scm2cpp-lasso
-Version: 0.13.0
+Version: 0.13.2
 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,9 +30,20 @@ path.  The solver is Scheme, translated to C++ by
 $ pip install scm2cpp-lasso
 ```
 
-Installing needs a C++17 compiler and nothing else.  If `nvcc` is on
-the path, the batched GPU solver is built as well; if it is not, the
-package installs and works exactly the same, minus that one method.
+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:
+
+```console
+$ pip install --no-binary scm2cpp-lasso scm2cpp-lasso
+```
+
+The batched GPU solver, the cuBLAS variants and the `--cuda`
+estimators are then built as well; without `nvcc` the package installs
+and works exactly the same, minus those.
 
 Three of a hundred candidate columns carry the signal; the solver is
 asked which, and answers with them and nothing else:
@@ -89,6 +102,63 @@ 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.
 
+## Estimators at a glance
+
+Every estimator, the scikit-learn estimator it reproduces, the Scheme
+kernel under `examples/kernel-only/` it is translated from, the builds
+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.
+
+| class | scikit-learn | Scheme kernel | builds | sklearnex accelerates |
+|---|---|---|---|---|
+| `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 |
+| `CovMultiTaskLasso` | MultiTaskLasso, MultiTaskElasticNet | `lasso-cov.scm` | CPU | no |
+| `CovMultiTaskLassoCV` | MultiTaskLassoCV, MultiTaskElasticNetCV | `lasso-cov.scm` | CPU; GPU batch | no |
+| `CovGroupLasso` | (none; skglm GroupLasso) | `lasso-cov.scm` | CPU | - |
+| `CovLogistic` | LogisticRegression(penalty='l1'), by majorization | `lasso-cov.scm` | CPU | no |
+| `CovRidge` | Ridge(fit_intercept=False), a whole alpha path | `lasso-cov.scm` | CPU | Ridge |
+| `CovBayesianRidge` | BayesianRidge | `lasso-cov.scm` | CPU | no |
+| `CovARDRegression` | ARDRegression (n >= p) | `ard.scm` | loops / BLAS | no |
+| `GramLars` | Lars | `lars.scm` | CPU | no |
+| `GramLassoLars` | LassoLars | `lars.scm` | CPU | no |
+| `GramLassoLarsIC` | LassoLarsIC | `lars.scm` | CPU; device Gram | no |
+| `GramLarsCV` | LarsCV | `lars.scm` | CPU | no |
+| `GramLassoLarsCV` | LassoLarsCV | `lars.scm` | CPU; device Gram | no |
+| `GramOMP` | OrthogonalMatchingPursuit | `omp.scm` | loops / BLAS | no |
+| `GramOMPCV` | OrthogonalMatchingPursuitCV | `omp.scm` | loops / BLAS | no |
+| `LBFGSLogisticRegression` | LogisticRegression(solver='lbfgs') | `logistic-lbfgs.scm, lbfgs.scm` | loops / BLAS / --cuda | LogisticRegression |
+| `LBFGSLogisticRegressionCV` | LogisticRegressionCV | `logistic-lbfgs.scm, lbfgs.scm` | loops / BLAS / --cuda | no |
+| `LBFGSHuberRegressor` | HuberRegressor | `huber.scm, lbfgs.scm` | loops / BLAS / --cuda | no |
+| `LBFGSPoissonRegressor` | PoissonRegressor | `glm.scm, lbfgs.scm` | loops / BLAS / --cuda | no |
+| `LBFGSGammaRegressor` | GammaRegressor | `glm.scm, lbfgs.scm` | loops / BLAS / --cuda | no |
+| `LBFGSTweedieRegressor` | TweedieRegressor | `glm.scm, lbfgs.scm` | loops / BLAS / --cuda | no |
+| `LinearSVM` | LinearSVC(loss='hinge') | `svm-liblinear.scm` | CPU | no |
+| `L1LinearSVM` | LinearSVC(penalty='l1', dual=False) | `svm-l1.scm` | CPU | no |
+| `KernelSVM` | SVC | `svm-smo.scm` | CPU | SVC |
+| `LinearSVR` | LinearSVR | `svr-liblinear.scm` | CPU | no |
+| `KernelSVR` | SVR | `svm-smo.scm` | CPU | SVR |
+| `L1LogisticRegression` | LogisticRegression(penalty='l1', solver='liblinear') | `logistic-l1.scm` | CPU | no |
+| `SGDLinearClassifier` | SGDClassifier(shuffle=False) | `sgd.scm` | CPU | no |
+| `SGDLinearRegressor` | SGDRegressor(shuffle=False) | `sgd.scm` | CPU | no |
+| `SGDPerceptron` | Perceptron(shuffle=False) | `sgd.scm` | CPU | no |
+| `LinearRANSAC` | RANSACRegressor (given subsets) | `ransac.scm` | CPU | no |
+| `WeiszfeldTheilSen` | TheilSenRegressor | `theilsen.scm` | CPU | no |
+| `CDNMF` | NMF(solver='cd') | `nmf-cd.scm (--derive)` | loops / BLAS / cuBLAS | no |
+| `CDGraphicalLasso` | GraphicalLasso | `graphical-lasso.scm` | loops / BLAS | no |
+| `EMGaussianMixture` | GaussianMixture(covariance_type='full') | `gmm.scm` | loops / BLAS / --cuda | no |
+| `ParallelFastICA` | FastICA | `fastica.scm` | loops / BLAS / --cuda | no |
+| `CovPCA` | PCA(svd_solver='covariance_eigh') | `pca.scm` | loops / BLAS / cuBLAS | PCA |
+| `f_regression, f_classif` | f_regression, f_classif | `fscore.scm` | loops / BLAS / cuBLAS | no |
+| `SelectKBest, SelectPercentile` | SelectKBest, SelectPercentile | `fscore.scm` | loops / BLAS / cuBLAS | no |
+| `GramRFE` | RFE(Ridge), RFE(LinearRegression) | `rfe.scm` | loops / BLAS / cuBLAS | inside: Ridge |
+
 ## Two kernels: `CovLasso` and `DerivedLasso`
 
 Everything above, and the cross-validation, bootstrap and GPU methods
@@ -733,6 +803,39 @@ estimators (`GramLassoLarsIC`, `GramLarsCV`, `GramLassoLarsCV`,
 `GramLars`, `GramLassoLars`, `CovPCA`) form a large X'X on the device
 when one answers. `SCM2CPP_NO_DEVICE=1` keeps everything on the CPU.
 
+## Against Intel's sklearnex
+
+sklearnex (scikit-learn-intelex 2026.2, oneDAL underneath) replaces
+some scikit-learn estimators with its own. `bench/sklearnex-compare.py`
+times the ones with a counterpart here, sklearnex's estimators
+imported directly (not patched in) so that scikit-learn itself is
+timed in the same process. The ratios are scikit-learn's or
+sklearnex's time over the package's best (its CPU build, or the device
+build where one answers); the load average was 8 to 11, so the times
+move by some tens of percent.
+
+| estimator, n x p | iterations (sk / sklearnex / ours) | vs scikit-learn, one core | vs sklearnex, one core | vs sklearnex, 20 cores |
+|---|---|---|---|---|
+| LogisticRegression, 200,000 x 100 | 6 / 12 / 6 | 10.6x (device) | 8.4x (device) | 4.4x (device); on the CPU 0.5x |
+| Ridge (alpha 1), 200,000 x 200 | - | 2.1x | 1.2x | 0.3x |
+| PCA (10 components), 100,000 x 50 | - | 1.5x | 2.4x | 1.7x |
+| PCA (10 components), 50,000 x 500 | - | 1.1x | 1.4x | 0.5x |
+| SVC (rbf), 5,000 x 20 | 4,858 / 7 / 4,882 | 1.2x | 1.4x | 0.5x |
+| SVR (rbf), 5,000 x 20 | 12,821 / 10 / 12,824 | 1.3x | 1.4x | 0.4x |
+| RFE(Ridge), 20 of 200 kept, 20,000 x 200 | - | 216x | 128x | 78x |
+
+On one core the package is ahead everywhere. sklearnex uses every
+core by default, and the package's kernels are single-threaded, so
+with 20 cores sklearnex is faster on Ridge, the larger PCA and the
+SVMs; what stays ahead is the device build (logistic regression) and
+an algorithm that does less work (RFE: the Gram once, the Cholesky
+factor downdated per drop, where scikit-learn refits). sklearnex is
+not scikit-learn's arithmetic: its logistic regression takes 12
+iterations to scikit-learn's 6 and its coefficients differ from
+scikit-learn's by 6e-3, where the package's agree to 4e-15; its SVMs
+report a different iteration count. This sklearnex accelerates no
+lasso, so the lasso tables above stand against scikit-learn alone.
+
 ## The GPU build
 
 Where the CUDA toolkit is at install time, `ParallelFastICA`,