scm2cpp-lasso 0.5.3__tar.gz → 0.5.3.1__tar.gz

{scm2cpp_lasso-0.5.3 → scm2cpp_lasso-0.5.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scm2cpp-lasso
-Version: 0.5.3
+Version: 0.5.3.1
 Summary: Lasso by covariance-update coordinate descent, translated from Scheme to C++ by scm2cpp; GPU batch solver included
 Author: Hirotaka Niitsuma
 License: MIT
@@ -117,15 +117,29 @@ this size its launch overhead dominates, while our GPU row
 parallelises *across* lambdas -- one CUDA thread per penalty, the axis
 a cross-validation grid actually offers.
 
-`CovLassoCV` is scikit-learn's `LassoCV` over this machinery: the same
-grid construction, the same contiguous folds, the same
-minimum-mean-MSE choice -- and where the two disagree it is by one
-grid step on a near-tie, which sklearn also resolves our way once its
-tolerance is tightened.  A fold's training Gram is a subtraction
-(G - Xf'Xf; the Gram is additive over rows), and on the GPU every fold
-and every alpha is one thread of a single launch.  At cv=10 with 1000
-alphas -- ten thousand independent problems -- that launch takes
-1.2 s against sklearn's 1.7 s, with GPU and CPU agreeing to 1e-14.
+`CovLassoCV` is scikit-learn's `LassoCV` over this machinery -- same
+grid construction, same contiguous folds, same minimum-mean-MSE choice
+-- with two structural savings.  A fold's training Gram is a
+*subtraction* (the Gram is additive over rows, so G - Xf'Xf costs one
+fold's work where rebuilding costs four folds'), and once the Grams
+exist nothing downstream ever touches the n rows again -- which is why
+the gap grows with n.  On the GPU every fold and every alpha can run
+as one thread of a single launch; that launch replicates each fold's
+Gram per alpha, so it is chosen only while the replication stays under
+512 MB, the CPU warm path taking over at large p.  Measured at cv=5,
+100 alphas, one CPU core:
+
+| n       | p    | `CovLassoCV` | sklearn `LassoCV` |
+|---------|------|--------------|-------------------|
+| 1,800   | 200  | 0.23 s       | 0.20 s            |
+| 5,000   | 1000 | 1.1 s        | 3.4 s             |
+| 100,000 | 200  | 0.44 s       | 5.7 s             |
+| 100,000 | 500  | 0.90 s       | 8.0 s             |
+
+At n=100,000 the chosen alpha is identical and the coefficients agree
+to 7e-7; at small n a near-tie can leave the picks one grid step
+apart, which sklearn resolves our way once its tolerance is
+tightened.  GPU and CPU agree to 1e-14 wherever both run.
 
 ## Which method
 

{scm2cpp_lasso-0.5.3 → scm2cpp_lasso-0.5.3.1}/README.md

@@ -99,15 +99,29 @@ this size its launch overhead dominates, while our GPU row
 parallelises *across* lambdas -- one CUDA thread per penalty, the axis
 a cross-validation grid actually offers.
 
-`CovLassoCV` is scikit-learn's `LassoCV` over this machinery: the same
-grid construction, the same contiguous folds, the same
-minimum-mean-MSE choice -- and where the two disagree it is by one
-grid step on a near-tie, which sklearn also resolves our way once its
-tolerance is tightened.  A fold's training Gram is a subtraction
-(G - Xf'Xf; the Gram is additive over rows), and on the GPU every fold
-and every alpha is one thread of a single launch.  At cv=10 with 1000
-alphas -- ten thousand independent problems -- that launch takes
-1.2 s against sklearn's 1.7 s, with GPU and CPU agreeing to 1e-14.
+`CovLassoCV` is scikit-learn's `LassoCV` over this machinery -- same
+grid construction, same contiguous folds, same minimum-mean-MSE choice
+-- with two structural savings.  A fold's training Gram is a
+*subtraction* (the Gram is additive over rows, so G - Xf'Xf costs one
+fold's work where rebuilding costs four folds'), and once the Grams
+exist nothing downstream ever touches the n rows again -- which is why
+the gap grows with n.  On the GPU every fold and every alpha can run
+as one thread of a single launch; that launch replicates each fold's
+Gram per alpha, so it is chosen only while the replication stays under
+512 MB, the CPU warm path taking over at large p.  Measured at cv=5,
+100 alphas, one CPU core:
+
+| n       | p    | `CovLassoCV` | sklearn `LassoCV` |
+|---------|------|--------------|-------------------|
+| 1,800   | 200  | 0.23 s       | 0.20 s            |
+| 5,000   | 1000 | 1.1 s        | 3.4 s             |
+| 100,000 | 200  | 0.44 s       | 5.7 s             |
+| 100,000 | 500  | 0.90 s       | 8.0 s             |
+
+At n=100,000 the chosen alpha is identical and the coefficients agree
+to 7e-7; at small n a near-tie can leave the picks one grid step
+apart, which sklearn resolves our way once its tolerance is
+tightened.  GPU and CPU agree to 1e-14 wherever both run.
 
 ## Which method
 

{scm2cpp_lasso-0.5.3 → scm2cpp_lasso-0.5.3.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "scm2cpp-lasso"
-version = "0.5.3"
+version = "0.5.3.1"
 description = "Lasso by covariance-update coordinate descent, translated from Scheme to C++ by scm2cpp; GPU batch solver included"
 readme = "README.md"
 requires-python = ">=3.8"

{scm2cpp_lasso-0.5.3 → scm2cpp_lasso-0.5.3.1}/src/scm2cpp_lasso/__init__.py

@@ -31,7 +31,7 @@ from ._libfind import load_batch_lib
 
 __all__ = ["CovLasso", "CovRidge", "CovLogistic", "CovGroupLasso",
            "cuda_available", "kernel"]
-__version__ = "0.5.3"
+__version__ = "0.5.3.1"
 
 _BATCH = load_batch_lib()
 _DP = ctypes.POINTER(ctypes.c_double)
@@ -323,7 +323,13 @@ class CovLassoCV:
         # sklearn's KFold(shuffle=False)
         bounds = np.linspace(0, n, self.cv + 1).astype(int)
         self.mse_path_ = np.empty((self.num, self.cv))
-        gpu = cuda_available() and not self.force_cpu
+        # The single GPU launch replicates each fold's Gram once per
+        # alpha; at large p that replication is gigabytes of transfer
+        # and the CPU warm path wins, so the choice is made by the
+        # replication's size rather than by the GPU's mere presence.
+        gram_bytes = self.cv * self.num * full.p * full.p * 8
+        gpu = (cuda_available() and not self.force_cpu
+               and gram_bytes <= (1 << 29))          # 512 MB
         G = full.g.reshape(full.p, full.p)
         if gpu:
             return self._fit_gpu(X, y, full, G, bounds, n)

{scm2cpp_lasso-0.5.3 → scm2cpp_lasso-0.5.3.1}/src/scm2cpp_lasso.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scm2cpp-lasso
-Version: 0.5.3
+Version: 0.5.3.1
 Summary: Lasso by covariance-update coordinate descent, translated from Scheme to C++ by scm2cpp; GPU batch solver included
 Author: Hirotaka Niitsuma
 License: MIT
@@ -117,15 +117,29 @@ this size its launch overhead dominates, while our GPU row
 parallelises *across* lambdas -- one CUDA thread per penalty, the axis
 a cross-validation grid actually offers.
 
-`CovLassoCV` is scikit-learn's `LassoCV` over this machinery: the same
-grid construction, the same contiguous folds, the same
-minimum-mean-MSE choice -- and where the two disagree it is by one
-grid step on a near-tie, which sklearn also resolves our way once its
-tolerance is tightened.  A fold's training Gram is a subtraction
-(G - Xf'Xf; the Gram is additive over rows), and on the GPU every fold
-and every alpha is one thread of a single launch.  At cv=10 with 1000
-alphas -- ten thousand independent problems -- that launch takes
-1.2 s against sklearn's 1.7 s, with GPU and CPU agreeing to 1e-14.
+`CovLassoCV` is scikit-learn's `LassoCV` over this machinery -- same
+grid construction, same contiguous folds, same minimum-mean-MSE choice
+-- with two structural savings.  A fold's training Gram is a
+*subtraction* (the Gram is additive over rows, so G - Xf'Xf costs one
+fold's work where rebuilding costs four folds'), and once the Grams
+exist nothing downstream ever touches the n rows again -- which is why
+the gap grows with n.  On the GPU every fold and every alpha can run
+as one thread of a single launch; that launch replicates each fold's
+Gram per alpha, so it is chosen only while the replication stays under
+512 MB, the CPU warm path taking over at large p.  Measured at cv=5,
+100 alphas, one CPU core:
+
+| n       | p    | `CovLassoCV` | sklearn `LassoCV` |
+|---------|------|--------------|-------------------|
+| 1,800   | 200  | 0.23 s       | 0.20 s            |
+| 5,000   | 1000 | 1.1 s        | 3.4 s             |
+| 100,000 | 200  | 0.44 s       | 5.7 s             |
+| 100,000 | 500  | 0.90 s       | 8.0 s             |
+
+At n=100,000 the chosen alpha is identical and the coefficients agree
+to 7e-7; at small n a near-tie can leave the picks one grid step
+apart, which sklearn resolves our way once its tolerance is
+tightened.  GPU and CPU agree to 1e-14 wherever both run.
 
 ## Which method