squeeze-kernel 3.1.0__tar.gz → 3.1.1__tar.gz

{squeeze_kernel-3.1.0 → squeeze_kernel-3.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: squeeze-kernel
-Version: 3.1.0
+Version: 3.1.1
 Summary: Streaming, PSD-by-construction covariance estimator with Fisher-kernel weighting and adaptive shrinkage
 Keywords: covariance,correlation,ewma,kernel,risk,streaming
 Author: Robert Kende
@@ -35,6 +35,7 @@ Description-Content-Type: text/markdown
 [![PyPI](https://img.shields.io/pypi/v/squeeze-kernel.svg)](https://pypi.org/project/squeeze-kernel/)
 [![Python](https://img.shields.io/pypi/pyversions/squeeze-kernel.svg)](https://pypi.org/project/squeeze-kernel/)
 [![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
+[![DOI](https://zenodo.org/badge/1188987927.svg)](https://doi.org/10.5281/zenodo.19170801)
 
 A **streaming covariance estimator for panels of financial returns** whose entire public surface is **one number** — the decay `lam` of the anchor correlation timescale. Every other quantity is derived from it, fixed by a structural argument, or computed online from the estimator's own state. An `O(Kn²)` state update per day, positive semi-definite **by construction**, missing values handled **natively**, no tuning, no refits. Only dependency: NumPy.
 

{squeeze_kernel-3.1.0 → squeeze_kernel-3.1.1}/README.md

@@ -4,6 +4,7 @@
 [![PyPI](https://img.shields.io/pypi/v/squeeze-kernel.svg)](https://pypi.org/project/squeeze-kernel/)
 [![Python](https://img.shields.io/pypi/pyversions/squeeze-kernel.svg)](https://pypi.org/project/squeeze-kernel/)
 [![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
+[![DOI](https://zenodo.org/badge/1188987927.svg)](https://doi.org/10.5281/zenodo.19170801)
 
 A **streaming covariance estimator for panels of financial returns** whose entire public surface is **one number** — the decay `lam` of the anchor correlation timescale. Every other quantity is derived from it, fixed by a structural argument, or computed online from the estimator's own state. An `O(Kn²)` state update per day, positive semi-definite **by construction**, missing values handled **natively**, no tuning, no refits. Only dependency: NumPy.
 

{squeeze_kernel-3.1.0 → squeeze_kernel-3.1.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "squeeze-kernel"
-version = "3.1.0"
+version = "3.1.1"
 description = "Streaming, PSD-by-construction covariance estimator with Fisher-kernel weighting and adaptive shrinkage"
 readme = "README.md"
 license = "MIT"

{squeeze_kernel-3.1.0 → squeeze_kernel-3.1.1}/pyproject.toml.orig

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "squeeze-kernel"
-version = "3.1.0"
+version = "3.1.1"
 description = "Streaming, PSD-by-construction covariance estimator with Fisher-kernel weighting and adaptive shrinkage"
 readme = "README.md"
 license = "MIT"

{squeeze_kernel-3.1.0 → squeeze_kernel-3.1.1}/src/squeeze_kernel/__init__.py

@@ -39,4 +39,4 @@ __all__ = [
     "kernel_fisher",
 ]
 
-__version__ = "3.1.0"
+__version__ = "3.1.1"

{squeeze_kernel-3.1.0 → squeeze_kernel-3.1.1}/src/squeeze_kernel/estimator.py

@@ -153,6 +153,18 @@ class _BlendGradient:
     """
 
     _JITTER = 1e-12
+    _FLOOR = 1e-8   # spectral floor of the scored blend
+    _CERT = 10.0    # certify lambda_min >= _CERT * _FLOOR before skipping the floor
+
+    @staticmethod
+    def _solve(sig: np.ndarray, r: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
+        """(sig^-1 r, sig^-1) from one Cholesky factorisation."""
+        if _cho_factor is not None:
+            cf = _cho_factor(sig, lower=True, check_finite=False)
+            return (_cho_solve(cf, r, check_finite=False),
+                    _cho_solve(cf, np.eye(sig.shape[0]), check_finite=False))
+        sinv = np.linalg.inv(sig)
+        return sinv @ r, sinv
 
     def __init__(self, half_lives: np.ndarray, prior: np.ndarray,
                  split: bool = False, n_experts: int = 3) -> None:
@@ -224,23 +236,31 @@ class _BlendGradient:
             for k in range(K):
                 sig += self.prev_w[k] * self.prev_sig[k][np.ix_(idx, idx)]
             sig = 0.5 * (sig + sig.T)
-        # Floor the spectrum before factorising, exactly as the research
-        # engine's scoring path does: a near-singular early blend would
-        # otherwise hand the running scale one enormous gradient and
-        # silence the mixer for years.
-        min_eig = float(np.linalg.eigvalsh(sig).min())
-        if min_eig < 1e-8:
-            sig = sig + np.eye(idx.size) * (1e-8 - min_eig)
+        # The spectrum is floored at _FLOOR before factorising, exactly as
+        # the research engine's scoring path does: a near-singular early
+        # blend would otherwise hand the running scale one enormous
+        # gradient and silence the mixer for years.  The floor acts only
+        # when lambda_min < _FLOOR, so factorise first and certify: the
+        # inverse gives lambda_min >= 1/||sig^-1||_F, and a certified day
+        # is bit-identical to the floored path (no floor, same factor).
+        # Uncertified or failed days take the eigenvalue floor as before.
+        sol: tuple[np.ndarray, np.ndarray] | None = None
         try:
-            if _cho_factor is not None:
-                cf = _cho_factor(sig, lower=True, check_finite=False)
-                u = _cho_solve(cf, r_t[idx], check_finite=False)
-                sinv = _cho_solve(cf, np.eye(idx.size), check_finite=False)
-            else:
-                sinv = np.linalg.inv(sig)
-                u = sinv @ r_t[idx]
+            sol = self._solve(sig, r_t[idx])
+            fro = float(np.linalg.norm(sol[1]))
+            if not (np.isfinite(fro) and fro * self._CERT * self._FLOOR <= 1.0):
+                sol = None
         except (np.linalg.LinAlgError, ValueError):
-            return None
+            sol = None
+        if sol is None:
+            min_eig = float(np.linalg.eigvalsh(sig).min())
+            if min_eig < self._FLOOR:
+                sig = sig + np.eye(idx.size) * (self._FLOOR - min_eig)
+            try:
+                sol = self._solve(sig, r_t[idx])
+            except (np.linalg.LinAlgError, ValueError):
+                return None
+        u, sinv = sol
         g = np.empty(K)
         self._gc = None
         if self.split and self.prev_comps is not None: