phasmanet 0.1.0__py3-none-any.whl

phasmanet/__init__.py

@@ -0,0 +1,23 @@
+"""PhasmaNet: a staged spectral token-refinement architecture for tabular data.
+
+Quick start::
+
+    from phasmanet import PhasmaNetRegressor
+    reg = PhasmaNetRegressor(random_state=0).fit(X_train, y_train)
+    y_pred = reg.predict(X_test)
+"""
+from ._version import __version__
+from .calibration import MonotoneCalibrator
+from .estimators import PhasmaNetClassifier, PhasmaNetRegressor
+from .model import PhasmaNet, PhiRefractor, PhiStage, convert_legacy_state_dict
+
+__all__ = [
+    "__version__",
+    "PhasmaNet",
+    "PhiStage",
+    "PhiRefractor",
+    "PhasmaNetRegressor",
+    "PhasmaNetClassifier",
+    "MonotoneCalibrator",
+    "convert_legacy_state_dict",
+]

phasmanet/_version.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

phasmanet/calibration.py

@@ -0,0 +1,96 @@
+"""Rank-preserving monotonic (PCHIP) recalibration of point predictions.
+
+Knots are the medians of (prediction, target) in quantile bins of the predictions,
+made non-decreasing and extended to the observed range, then joined by a monotone
+piecewise cubic Hermite interpolant. The calibrator is fitted on a validation split and
+applied unchanged to new predictions.
+"""
+from __future__ import annotations
+
+from typing import Dict, Optional
+
+import numpy as np
+
+__all__ = ["MonotoneCalibrator"]
+
+
+class MonotoneCalibrator:
+    """Smooth monotonic calibrator mapping raw predictions to calibrated predictions."""
+
+    def __init__(self, xk: Optional[np.ndarray] = None, yk: Optional[np.ndarray] = None):
+        self.xk = None if xk is None else np.asarray(xk, dtype=np.float64)
+        self.yk = None if yk is None else np.asarray(yk, dtype=np.float64)
+        self._pchip = None
+        if self.xk is not None:
+            self._build()
+
+    @property
+    def is_identity(self) -> bool:
+        return self.xk is None
+
+    def _build(self) -> None:
+        from scipy.interpolate import PchipInterpolator
+
+        if self.xk.size < 3 or self.yk.size != self.xk.size:
+            raise ValueError("need at least 3 knots with matching xk and yk")
+        if np.any(np.diff(self.xk) <= 0):
+            raise ValueError("xk must be strictly increasing")
+        self._pchip = PchipInterpolator(self.xk, self.yk, extrapolate=True)
+
+    def fit(self, pred, true, bins: int = 60, min_bin: int = 20) -> "MonotoneCalibrator":
+        """Fit knots from validation predictions ``pred`` and targets ``true``.
+
+        If there are too few distinct bins the calibrator stays the identity map.
+        """
+        pred = np.asarray(pred, dtype=np.float64).ravel()
+        true = np.asarray(true, dtype=np.float64).ravel()
+        if pred.shape != true.shape:
+            raise ValueError("pred and true must have the same length")
+        self.xk = self.yk = self._pchip = None
+
+        edges = np.unique(np.quantile(pred, np.linspace(0.0, 1.0, bins + 1)))
+        if len(edges) < 4:
+            return self
+
+        xk, yk = [], []
+        for lo, hi in zip(edges[:-1], edges[1:]):
+            m = (pred >= lo) & (pred < hi)
+            if m.sum() >= min_bin:
+                xk.append(np.median(pred[m]))
+                yk.append(np.median(true[m]))
+        xk = np.asarray(xk, dtype=np.float64)
+        yk = np.asarray(yk, dtype=np.float64)
+        if xk.size < 3:
+            return self
+
+        yk = np.maximum.accumulate(yk)
+        xk, keep = np.unique(xk, return_index=True)
+        yk = yk[keep]
+
+        x_min, x_max = pred.min(), pred.max()
+        y_min, y_max = true.min(), true.max()
+        if x_min < xk[0]:
+            xk = np.r_[x_min, xk]
+            yk = np.r_[min(y_min, yk[0]), yk]
+        if x_max > xk[-1]:
+            xk = np.r_[xk, x_max]
+            yk = np.r_[yk, max(y_max, yk[-1])]
+        self.xk, self.yk = xk, np.maximum.accumulate(yk)
+        self._build()
+        return self
+
+    def __call__(self, x) -> np.ndarray:
+        x = np.asarray(x, dtype=np.float64)
+        return x.copy() if self._pchip is None else self._pchip(x)
+
+    transform = __call__
+
+    def to_dict(self) -> Dict[str, list]:
+        if self.is_identity:
+            return {"xk": [], "yk": []}
+        return {"xk": self.xk.tolist(), "yk": self.yk.tolist()}
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, list]) -> "MonotoneCalibrator":
+        xk, yk = d.get("xk") or [], d.get("yk") or []
+        return cls() if len(xk) == 0 else cls(xk, yk)