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

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

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: scm2cpp-lasso
-Version: 0.12.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 included
+Version: 0.13.1
+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
 Project-URL: Homepage, https://github.com/niitsuma/scm2cpp
@@ -28,9 +28,19 @@ 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 and macOS arm64 (macOS 14 or later) this installs a wheel: compiled, with
+OpenBLAS inside, nothing to build.  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 +99,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 +800,53 @@ 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`,
+`EMGaussianMixture`, `LBFGSLogisticRegression`,
+`LBFGSLogisticRegressionCV`, `LBFGSHuberRegressor` and the `LBFGS*`
+GLMs also get the same Scheme translated with `--cuda`
+(`libscm2cpp_gpu.so`). Its loops are CUDA kernels and its products
+cuBLAS, on arrays that stay on the device. The classes take it when a
+device answers and the data has a million entries or more, and give
+the CPU build's iterations and results to the last digits. Measured
+against scikit-learn: 10-22x for the L-BFGS fits, 6.7x FastICA, 3x the
+mixture and LogisticRegressionCV (the repository README's table).
+`SCM2CPP_NO_DEVICE=1` keeps everything on the CPU.
+
 ## Logistic regression with L1
 
 `CovLogistic` solves L1-penalized logistic regression by

{scm2cpp_lasso-0.12.0 → scm2cpp_lasso-0.13.1}/README.md

@@ -10,9 +10,19 @@ 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 and macOS arm64 (macOS 14 or later) this installs a wheel: compiled, with
+OpenBLAS inside, nothing to build.  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 +81,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 +782,53 @@ 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`,
+`EMGaussianMixture`, `LBFGSLogisticRegression`,
+`LBFGSLogisticRegressionCV`, `LBFGSHuberRegressor` and the `LBFGS*`
+GLMs also get the same Scheme translated with `--cuda`
+(`libscm2cpp_gpu.so`). Its loops are CUDA kernels and its products
+cuBLAS, on arrays that stay on the device. The classes take it when a
+device answers and the data has a million entries or more, and give
+the CPU build's iterations and results to the last digits. Measured
+against scikit-learn: 10-22x for the L-BFGS fits, 6.7x FastICA, 3x the
+mixture and LogisticRegressionCV (the repository README's table).
+`SCM2CPP_NO_DEVICE=1` keeps everything on the CPU.
+
 ## Logistic regression with L1
 
 `CovLogistic` solves L1-penalized logistic regression by

{scm2cpp_lasso-0.12.0 → scm2cpp_lasso-0.13.1}/pyproject.toml

@@ -4,8 +4,8 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "scm2cpp-lasso"
-version = "0.12.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 included"
+version = "0.13.1"
+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"
 license = {text = "MIT"}
@@ -31,4 +31,4 @@ package-dir = {"" = "src"}
 where = ["src"]
 
 [tool.setuptools.package-data]
-scm2cpp_lasso = ["_generated/*.hpp", "_generated/*.cpp", "_generated/derived_*/*.hpp", "_generated/derived_*/*.cpp", "_generated/nmf_*/*.hpp", "_generated/nmf_*/*.cpp", "_generated/gramops_*/*.hpp", "_generated/gramops_*/*.cpp", "_generated/accel_*/*.hpp", "_generated/accel_*/*.cpp", "*.cu"]
+scm2cpp_lasso = ["_generated/*.hpp", "_generated/*.cpp", "_generated/derived_*/*.hpp", "_generated/derived_*/*.cpp", "_generated/nmf_*/*.hpp", "_generated/nmf_*/*.cpp", "_generated/gramops_*/*.hpp", "_generated/gramops_*/*.cpp", "_generated/accel_*/*.hpp", "_generated/accel_*/*.cpp", "_generated/gpu_*/*.hpp", "_generated/gpu_*/*.cpp", "*.cu"]

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

@@ -120,6 +120,28 @@ class BuildWithCuda(build_ext):
         except (subprocess.CalledProcessError, OSError) as exc:
             print(f"scm2cpp_lasso: no CUDA batch path ({exc}); "
                   "the CPU solver is unaffected", file=sys.stderr)
+        # the --cuda translation (kernels + device-resident cuBLAS):
+        # FastICA, the mixture, the L-BFGS fits
+        gpu = GEN / "gpu_cuda" / "gpu_capi.cpp"
+        if gpu.exists():
+            out2 = Path(self.build_lib) / "scm2cpp_lasso" / "libscm2cpp_gpu.so"
+            # the installed device's architecture when one answers
+            arch = []
+            try:
+                if subprocess.run(["nvidia-smi"], capture_output=True).returncode == 0:
+                    arch = ["-arch=native"]
+            except OSError:
+                pass
+            cmd2 = [nvcc, "-O3", "-std=c++17", "-shared", "-x", "cu", *arch,
+                    "-Xcompiler", "-fPIC", "-I", str(GEN / "gpu_cuda"), "-I", str(GEN),
+                    str(gpu), "-o", str(out2), "-lcublas",
+                    "-Wno-deprecated-gpu-targets", "-diag-suppress", "174,177,550"]
+            try:
+                subprocess.run(cmd2, check=True)
+                print("scm2cpp_lasso: built the --cuda estimators")
+            except (subprocess.CalledProcessError, OSError) as exc:
+                print(f"scm2cpp_lasso: no --cuda estimators ({exc}); "
+                      "the CPU paths are unaffected", file=sys.stderr)
 
 
 # The cuBLAS variant of the derived kernel: host C++ against the CUDA
@@ -220,4 +242,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.12.0 → scm2cpp_lasso-0.13.1}/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.12.0"
+__version__ = "0.13.1"
 
 _BATCH = load_batch_lib()
 _DP = ctypes.POINTER(ctypes.c_double)
@@ -1350,7 +1350,7 @@ class LBFGSLogisticRegression:
         k = nc if multi else 1
         coef = np.zeros(k * (p + 1))
         out = np.zeros(2)
-        it = _gramops_kernels().logistic_lbfgs(
+        it = _gpu_or_cpu(n * p, getattr(self, "backend", None)).logistic_lbfgs(
             X, yi.astype(np.float64), coef, out, float(self.C), int(self.max_iter),
             float(self.tol), multi, 1 if self.fit_intercept else 0, n, p, k)
         self.coef_ = coef[:k * p].reshape(k, p).copy()
@@ -1418,7 +1418,7 @@ class _LBFGSGLM:
         coef = np.zeros(p + 1)
         out = np.zeros(2)
         fam, power = self._family_power()
-        it = _gramops_kernels().glm(X, y, coef, out, fam, float(power), float(self.alpha),
+        it = _gpu_or_cpu(n * p, getattr(self, "backend", None)).glm(X, y, coef, out, fam, float(power), float(self.alpha),
                                     int(self.max_iter), float(self.tol),
                                     1 if self.fit_intercept else 0, n, p)
         self.coef_, self.intercept_ = coef[:p].copy(), float(coef[p])
@@ -1499,7 +1499,7 @@ class LBFGSLogisticRegressionCV:
 
     def _path(self, X, yi, Cs, coef, multi, k):
         n, p = X.shape
-        lib = _gramops_kernels()
+        lib = _gpu_or_cpu(n * p, getattr(self, "backend", None))
         coefs, iters = [], []
         out = np.zeros(2)
         for C in Cs:
@@ -1582,7 +1582,7 @@ class LBFGSHuberRegressor:
         coef = np.zeros(p + 2)
         coef[-1] = 1.0
         out = np.zeros(2)
-        it = _gramops_kernels().huber(
+        it = _gpu_or_cpu(n * p, getattr(self, "backend", None)).huber(
             X, y, coef, out, float(self.epsilon), float(self.alpha), int(self.max_iter),
             float(self.tol), 1 if self.fit_intercept else 0, n, p)
         self.coef_ = coef[:p].copy()
@@ -1643,7 +1643,7 @@ class EMGaussianMixture:
         self.precisions_cholesky_ = np.zeros((k, p, p))
         labels = np.zeros(n)
         out = np.zeros(2)
-        it = _gramops_kernels().gmm(X, resp, self.weights_, self.means_,
+        it = _gpu_or_cpu(n * p, getattr(self, "backend", None)).gmm(X, resp, self.weights_, self.means_,
                                     self.precisions_cholesky_, labels, out,
                                     int(self.max_iter), float(self.tol),
                                     float(self.reg_covar), n, p, k)
@@ -1744,7 +1744,7 @@ class ParallelFastICA:
         w0 = np.ascontiguousarray(w0)
         self.components_ = np.zeros((k, p)); self.whitening_ = np.zeros((k, p))
         self._unmixing = np.zeros((k, k)); self.mean_ = np.zeros(p)
-        self.n_iter_ = _gramops_kernels().fastica(
+        self.n_iter_ = _gpu_or_cpu(n * p, getattr(self, "backend", None)).fastica(
             X, w0, self.components_, self.whitening_, self._unmixing, self.mean_,
             int(self.max_iter), float(self.tol), n, p, k)
         self.mixing_ = np.linalg.pinv(self.components_)
@@ -1803,6 +1803,19 @@ class CovARDRegression:
         return np.ascontiguousarray(X, dtype=np.float64) @ self.coef_ + self.intercept_
 
 
+def _gpu_or_cpu(size, backend=None):
+    """The --cuda translation (kernels and device-resident cuBLAS) when it
+    was built, a device answers, the backend allows it and the problem has
+    at least a million entries; the CPU library otherwise."""
+    import os
+    from ._libfind import gpu_built
+    if (backend in (None, "cuda") and size >= 1e6 and not os.environ.get("SCM2CPP_NO_DEVICE")
+            and gpu_built() and cuda_available()):
+        import importlib
+        return importlib.import_module(f"{__name__}._generated._loader_gpu_cuda")
+    return _gramops_kernels()
+
+
 def _accel(work):
     """The --cublas build of the selection and Gram products, when it was
     built, a device answers, and WORK (flops) is large enough to pay for