scm2cpp-lasso 0.9.0__tar.gz → 0.10.0__tar.gz

{scm2cpp_lasso-0.9.0/src/scm2cpp_lasso.egg-info → scm2cpp_lasso-0.10.0}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: scm2cpp-lasso
-Version: 0.9.0
-Summary: Lasso, elastic net, ridge, SVM, SVR, L1 logistic, NMF, graphical lasso, RANSAC, SGD, OMP and LARS translated from Scheme to C++ by scm2cpp; GPU batch solver included
+Version: 0.10.0
+Summary: scikit-learn estimators (lasso, elastic net, ridge, ARD, SVM, SVR, logistic regression, Huber, NMF, Gaussian mixture, FastICA, PCA, graphical lasso, RANSAC, SGD, OMP, LARS) translated from Scheme to C++ by scm2cpp; GPU batch solver included
 Author: Hirotaka Niitsuma
 License: MIT
 Project-URL: Homepage, https://github.com/niitsuma/scm2cpp
@@ -623,6 +623,73 @@ repository README's table: 1.0-3.3x for SGD, 1.1-2.8x for OMP and
 1.2-5.0x for LARS, largest on small problems, where scikit-learn's
 Python between steps dominates.
 
+## L2 logistic regression and Huber: `LBFGSLogisticRegression`, `LBFGSHuberRegressor`
+
+`LogisticRegression(solver="lbfgs")` (the default; two classes
+binomial, more multinomial) and `HuberRegressor`, with scipy's
+L-BFGS-B written out in the subset under them. The products are dgemm
+or dgemv where a CBLAS links.
+
+```python
+from scm2cpp_lasso import LBFGSLogisticRegression, LBFGSHuberRegressor
+LBFGSLogisticRegression(C=1.0).fit(X, y).predict_proba(X_new)
+LBFGSHuberRegressor(epsilon=1.35).fit(X, y).coef_
+```
+
+Both take scikit-learn's iterations one for one and give its
+coefficients to rounding (1e-13 at worst). The speed is the repository
+README's table: 1.1-8x for the logistic regression (near 1x on a large
+binary problem, where both sides are two matrix-vector products per
+evaluation) and 2.5-18x for Huber.
+
+## Gaussian mixture, FastICA, PCA: `EMGaussianMixture`, `ParallelFastICA`, `CovPCA`
+
+`GaussianMixture(covariance_type="full")`, `FastICA` at its defaults
+and `PCA` by the covariance's eigenvectors (scikit-learn's
+"covariance_eigh", what "auto" picks for a tall design), each
+scikit-learn's algorithm translated, the products dgemm / dsyrk where a
+CBLAS links and the eigenproblem written in the subset.
+
+```python
+from scm2cpp_lasso import EMGaussianMixture, ParallelFastICA, CovPCA
+EMGaussianMixture(4, random_state=0).fit(X).predict(X)   # KMeans start: scikit-learn's
+ParallelFastICA(random_state=0).fit(X).transform(X)
+CovPCA(n_components=10).fit(X).components_
+```
+
+From the same `random_state` each takes scikit-learn's iterations and
+lands on its parameters to rounding. The speed is the repository
+README's table: 1.6-2.4x for the mixture, 1.1-1.4x for FastICA, and
+for PCA 1.3-4x up to about 100 features, 0.6-0.8x at 200-500, where
+LAPACK's eigensolver wins.
+
+## Perceptron, ARD, LassoLarsIC, L1 linear SVM: `SGDPerceptron`, `CovARDRegression`, `GramLassoLarsIC`, `L1LinearSVM`
+
+- `SGDPerceptron` is `Perceptron`. `SGDLinearClassifier` /
+  `SGDLinearRegressor` also take `loss="perceptron"` /
+  `"epsilon_insensitive"`, `learning_rate="constant"` / `"pa1"` /
+  `"pa2"` and `penalty=None`, which covers scikit-learn's replacements
+  for the passive-aggressive estimators. All run with shuffle=False.
+- `CovARDRegression` is `ARDRegression` (n >= p). With `hoist=True`,
+  the default, the kept features' Gram comes from X'X formed once;
+  `hoist=False` forms it every iteration, as scikit-learn does.
+- `GramLassoLarsIC` is `LassoLarsIC`. The whole lasso path comes from
+  the translated LARS, and the criterion is evaluated from the Gram.
+- `L1LinearSVM` is `LinearSVC(penalty="l1", dual=False)`, liblinear's
+  solve_l1r_l2_svc. It agrees with scikit-learn to the tolerance,
+  because the coordinate order comes from another generator.
+
+```python
+from scm2cpp_lasso import SGDPerceptron, CovARDRegression, GramLassoLarsIC, L1LinearSVM
+SGDPerceptron().fit(X, y)
+CovARDRegression().fit(X, y).coef_
+GramLassoLarsIC("bic").fit(X, y).alpha_
+L1LinearSVM(C=1.0).fit(X, y).coef_
+```
+
+Speed, from the repository README's table: SGD 1.2-3x, ARD 1.6-1.9x
+(3x with the Gram hoisted), LassoLarsIC 8-20x, the L1 SVM 1.1-1.5x.
+
 ## Logistic regression with L1
 
 `CovLogistic` solves L1-penalized logistic regression by

scm2cpp_lasso-0.9.0/PKG-INFO → scm2cpp_lasso-0.10.0/README.md

@@ -1,21 +1,3 @@
-Metadata-Version: 2.4
-Name: scm2cpp-lasso
-Version: 0.9.0
-Summary: Lasso, elastic net, ridge, SVM, SVR, L1 logistic, NMF, graphical lasso, RANSAC, SGD, OMP and LARS translated from Scheme to C++ by scm2cpp; GPU batch solver included
-Author: Hirotaka Niitsuma
-License: MIT
-Project-URL: Homepage, https://github.com/niitsuma/scm2cpp
-Project-URL: Source, https://github.com/niitsuma/scm2cpp/tree/master/python/scm2cpp-lasso
-Keywords: lasso,elastic-net,ridge,svm,logistic-regression,coordinate-descent,cuda,compiler
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: C++
-Classifier: Topic :: Scientific/Engineering :: Mathematics
-Classifier: Intended Audience :: Science/Research
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-Requires-Dist: numpy>=1.17
-
 # scm2cpp-lasso
 
 *[Japanese (README.ja.md)](README.ja.md)*
@@ -623,6 +605,73 @@ repository README's table: 1.0-3.3x for SGD, 1.1-2.8x for OMP and
 1.2-5.0x for LARS, largest on small problems, where scikit-learn's
 Python between steps dominates.
 
+## L2 logistic regression and Huber: `LBFGSLogisticRegression`, `LBFGSHuberRegressor`
+
+`LogisticRegression(solver="lbfgs")` (the default; two classes
+binomial, more multinomial) and `HuberRegressor`, with scipy's
+L-BFGS-B written out in the subset under them. The products are dgemm
+or dgemv where a CBLAS links.
+
+```python
+from scm2cpp_lasso import LBFGSLogisticRegression, LBFGSHuberRegressor
+LBFGSLogisticRegression(C=1.0).fit(X, y).predict_proba(X_new)
+LBFGSHuberRegressor(epsilon=1.35).fit(X, y).coef_
+```
+
+Both take scikit-learn's iterations one for one and give its
+coefficients to rounding (1e-13 at worst). The speed is the repository
+README's table: 1.1-8x for the logistic regression (near 1x on a large
+binary problem, where both sides are two matrix-vector products per
+evaluation) and 2.5-18x for Huber.
+
+## Gaussian mixture, FastICA, PCA: `EMGaussianMixture`, `ParallelFastICA`, `CovPCA`
+
+`GaussianMixture(covariance_type="full")`, `FastICA` at its defaults
+and `PCA` by the covariance's eigenvectors (scikit-learn's
+"covariance_eigh", what "auto" picks for a tall design), each
+scikit-learn's algorithm translated, the products dgemm / dsyrk where a
+CBLAS links and the eigenproblem written in the subset.
+
+```python
+from scm2cpp_lasso import EMGaussianMixture, ParallelFastICA, CovPCA
+EMGaussianMixture(4, random_state=0).fit(X).predict(X)   # KMeans start: scikit-learn's
+ParallelFastICA(random_state=0).fit(X).transform(X)
+CovPCA(n_components=10).fit(X).components_
+```
+
+From the same `random_state` each takes scikit-learn's iterations and
+lands on its parameters to rounding. The speed is the repository
+README's table: 1.6-2.4x for the mixture, 1.1-1.4x for FastICA, and
+for PCA 1.3-4x up to about 100 features, 0.6-0.8x at 200-500, where
+LAPACK's eigensolver wins.
+
+## Perceptron, ARD, LassoLarsIC, L1 linear SVM: `SGDPerceptron`, `CovARDRegression`, `GramLassoLarsIC`, `L1LinearSVM`
+
+- `SGDPerceptron` is `Perceptron`. `SGDLinearClassifier` /
+  `SGDLinearRegressor` also take `loss="perceptron"` /
+  `"epsilon_insensitive"`, `learning_rate="constant"` / `"pa1"` /
+  `"pa2"` and `penalty=None`, which covers scikit-learn's replacements
+  for the passive-aggressive estimators. All run with shuffle=False.
+- `CovARDRegression` is `ARDRegression` (n >= p). With `hoist=True`,
+  the default, the kept features' Gram comes from X'X formed once;
+  `hoist=False` forms it every iteration, as scikit-learn does.
+- `GramLassoLarsIC` is `LassoLarsIC`. The whole lasso path comes from
+  the translated LARS, and the criterion is evaluated from the Gram.
+- `L1LinearSVM` is `LinearSVC(penalty="l1", dual=False)`, liblinear's
+  solve_l1r_l2_svc. It agrees with scikit-learn to the tolerance,
+  because the coordinate order comes from another generator.
+
+```python
+from scm2cpp_lasso import SGDPerceptron, CovARDRegression, GramLassoLarsIC, L1LinearSVM
+SGDPerceptron().fit(X, y)
+CovARDRegression().fit(X, y).coef_
+GramLassoLarsIC("bic").fit(X, y).alpha_
+L1LinearSVM(C=1.0).fit(X, y).coef_
+```
+
+Speed, from the repository README's table: SGD 1.2-3x, ARD 1.6-1.9x
+(3x with the Gram hoisted), LassoLarsIC 8-20x, the L1 SVM 1.1-1.5x.
+
 ## Logistic regression with L1
 
 `CovLogistic` solves L1-penalized logistic regression by

{scm2cpp_lasso-0.9.0 → scm2cpp_lasso-0.10.0}/pyproject.toml

@@ -4,8 +4,8 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "scm2cpp-lasso"
-version = "0.9.0"
-description = "Lasso, elastic net, ridge, SVM, SVR, L1 logistic, NMF, graphical lasso, RANSAC, SGD, OMP and LARS translated from Scheme to C++ by scm2cpp; GPU batch solver included"
+version = "0.10.0"
+description = "scikit-learn estimators (lasso, elastic net, ridge, ARD, SVM, SVR, logistic regression, Huber, NMF, Gaussian mixture, FastICA, PCA, graphical lasso, RANSAC, SGD, OMP, LARS) translated from Scheme to C++ by scm2cpp; GPU batch solver included"
 readme = "README.md"
 requires-python = ">=3.8"
 license = {text = "MIT"}

{scm2cpp_lasso-0.9.0 → scm2cpp_lasso-0.10.0}/setup.py

@@ -170,8 +170,9 @@ else:
         extra_compile_args=_cls_flags,
     )
 
-# The Gram solvers (graphical lasso, OMP): their products as dgemv /
-# dsyrk where a CBLAS links, loops otherwise.
+# The solvers with BLAS products (graphical lasso, OMP, L-BFGS for the
+# logistic and Huber objectives): dgemm / dgemv / dsyrk where a CBLAS
+# links, loops otherwise.
 if _blas is not None:
     gramops = Extension(
         "scm2cpp_lasso._gramops_blas",