scm2cpp-lasso 0.5.0__tar.gz → 0.5.2__tar.gz

{scm2cpp_lasso-0.5.0 → scm2cpp_lasso-0.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scm2cpp-lasso
-Version: 0.5.0
+Version: 0.5.2
 Summary: Lasso by covariance-update coordinate descent, translated from Scheme to C++ by scm2cpp; GPU batch solver included
 Author: Hirotaka Niitsuma
 License: MIT
@@ -32,13 +32,42 @@ 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.
 
+Three of a hundred candidate columns carry the signal; the solver is
+asked which, and answers with them and nothing else:
+
 ```python
 import numpy as np
-from scm2cpp_lasso import CovLasso, cuda_available
+from scm2cpp_lasso import CovLasso
 
-model = CovLasso(X, y)                      # forms X'X and X'y
-lambdas = model.lambda_grid(num=100)        # from lambda_max down
+rng = np.random.default_rng(0)
+X = rng.standard_normal((500, 100))          # 500 rows, 100 candidates
+beta = np.zeros(100)
+beta[[7, 23, 61]] = [2.0, -1.5, 0.8]         # only three of them matter
+y = X @ beta + 0.1 * rng.standard_normal(500)
 
+model = CovLasso(X, y)                       # the Gram matrix, built once
+path = model.fit_path(model.lambda_grid())   # 100 lambdas, warm-started
+
+fit = path[60]
+for j in np.flatnonzero(np.abs(fit) > 1e-6):
+    print(f"  x{j:<3} {fit[j]:+.3f}")
+```
+
+```console
+  x7   +1.965
+  x23  -1.474
+  x61  +0.770
+```
+
+The other 97 are exactly zero -- that is what the penalty is for -- and
+the coefficients are the planted ones, shrunk toward zero by it.
+
+The rest of the interface:
+
+```python
+from scm2cpp_lasso import cuda_available
+
+lambdas = model.lambda_grid(num=100)        # from lambda_max down
 path = model.fit_path(lambdas)              # warm-started, sequential
 grid = model.fit_path_batch(lambdas)        # every lambda from zero
 print("GPU:", cuda_available())

{scm2cpp_lasso-0.5.0 → scm2cpp_lasso-0.5.2}/README.md

@@ -14,13 +14,42 @@ 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.
 
+Three of a hundred candidate columns carry the signal; the solver is
+asked which, and answers with them and nothing else:
+
 ```python
 import numpy as np
-from scm2cpp_lasso import CovLasso, cuda_available
+from scm2cpp_lasso import CovLasso
 
-model = CovLasso(X, y)                      # forms X'X and X'y
-lambdas = model.lambda_grid(num=100)        # from lambda_max down
+rng = np.random.default_rng(0)
+X = rng.standard_normal((500, 100))          # 500 rows, 100 candidates
+beta = np.zeros(100)
+beta[[7, 23, 61]] = [2.0, -1.5, 0.8]         # only three of them matter
+y = X @ beta + 0.1 * rng.standard_normal(500)
 
+model = CovLasso(X, y)                       # the Gram matrix, built once
+path = model.fit_path(model.lambda_grid())   # 100 lambdas, warm-started
+
+fit = path[60]
+for j in np.flatnonzero(np.abs(fit) > 1e-6):
+    print(f"  x{j:<3} {fit[j]:+.3f}")
+```
+
+```console
+  x7   +1.965
+  x23  -1.474
+  x61  +0.770
+```
+
+The other 97 are exactly zero -- that is what the penalty is for -- and
+the coefficients are the planted ones, shrunk toward zero by it.
+
+The rest of the interface:
+
+```python
+from scm2cpp_lasso import cuda_available
+
+lambdas = model.lambda_grid(num=100)        # from lambda_max down
 path = model.fit_path(lambdas)              # warm-started, sequential
 grid = model.fit_path_batch(lambdas)        # every lambda from zero
 print("GPU:", cuda_available())

{scm2cpp_lasso-0.5.0 → scm2cpp_lasso-0.5.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "scm2cpp-lasso"
-version = "0.5.0"
+version = "0.5.2"
 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.0 → scm2cpp_lasso-0.5.2}/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.0"
+__version__ = "0.5.2"
 
 _BATCH = load_batch_lib()
 _DP = ctypes.POINTER(ctypes.c_double)
@@ -141,6 +141,17 @@ class CovLasso:
 
     # ---------------------------- fitting ----------------------------
 
+    def fit(self, lam, **kw):
+        """Coefficients at one lambda.
+
+        A single penalty is the one-element special case of the path:
+        the Gram matrix was built in the constructor, so this costs one
+        descent and nothing per row -- and a warm-started path over a
+        whole grid costs barely more, which is why fit_path is the
+        primary interface rather than this convenience.
+        """
+        return self.fit_path([lam], **kw)[0]
+
     def fit_path(self, lambdas, tol=1e-8, chunk=20, max_sweeps=100000,
                  l1_ratio=1.0):
         """Coefficients per lambda, each warm-started from the last.

{scm2cpp_lasso-0.5.0 → scm2cpp_lasso-0.5.2}/src/scm2cpp_lasso.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scm2cpp-lasso
-Version: 0.5.0
+Version: 0.5.2
 Summary: Lasso by covariance-update coordinate descent, translated from Scheme to C++ by scm2cpp; GPU batch solver included
 Author: Hirotaka Niitsuma
 License: MIT
@@ -32,13 +32,42 @@ 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.
 
+Three of a hundred candidate columns carry the signal; the solver is
+asked which, and answers with them and nothing else:
+
 ```python
 import numpy as np
-from scm2cpp_lasso import CovLasso, cuda_available
+from scm2cpp_lasso import CovLasso
 
-model = CovLasso(X, y)                      # forms X'X and X'y
-lambdas = model.lambda_grid(num=100)        # from lambda_max down
+rng = np.random.default_rng(0)
+X = rng.standard_normal((500, 100))          # 500 rows, 100 candidates
+beta = np.zeros(100)
+beta[[7, 23, 61]] = [2.0, -1.5, 0.8]         # only three of them matter
+y = X @ beta + 0.1 * rng.standard_normal(500)
 
+model = CovLasso(X, y)                       # the Gram matrix, built once
+path = model.fit_path(model.lambda_grid())   # 100 lambdas, warm-started
+
+fit = path[60]
+for j in np.flatnonzero(np.abs(fit) > 1e-6):
+    print(f"  x{j:<3} {fit[j]:+.3f}")
+```
+
+```console
+  x7   +1.965
+  x23  -1.474
+  x61  +0.770
+```
+
+The other 97 are exactly zero -- that is what the penalty is for -- and
+the coefficients are the planted ones, shrunk toward zero by it.
+
+The rest of the interface:
+
+```python
+from scm2cpp_lasso import cuda_available
+
+lambdas = model.lambda_grid(num=100)        # from lambda_max down
 path = model.fit_path(lambdas)              # warm-started, sequential
 grid = model.fit_path_batch(lambdas)        # every lambda from zero
 print("GPU:", cuda_available())