statgpu 0.1.0__py3-none-any.whl

statgpu/linear_model/wrappers/_mcp.py

@@ -0,0 +1,58 @@
+"""MCP-penalized regression (Zhang, Annals of Statistics 2010)."""
+
+from __future__ import annotations
+
+from typing import Union
+
+from statgpu._config import Device
+from statgpu.linear_model.penalized._penalized_linear import PenalizedLinearRegression
+
+
+class MCPRegression(PenalizedLinearRegression):
+    """MCP-penalized regression.
+
+    Non-convex penalty with oracle property. Uses LLA+FISTA for optimization.
+
+    Parameters
+    ----------
+    alpha : float, default=1.0
+        Regularization strength.
+    gamma : float, default=3.0
+        Concavity parameter (Zhang recommends gamma > 1).
+    fit_intercept : bool, default=True
+        Whether to calculate the intercept.
+    max_iter : int, default=1000
+        Maximum number of iterations.
+    tol : float, default=1e-4
+        Tolerance for convergence.
+    device : str or Device, default='auto'
+        Computation device.
+    compute_inference : bool, default=False
+        Whether to compute post-fit inference (MCP does not support debiased).
+    """
+
+    def __init__(
+        self,
+        alpha: float = 1.0,
+        gamma: float = 3.0,
+        fit_intercept: bool = True,
+        max_iter: int = 1000,
+        tol: float = 1e-4,
+        device: Union[str, Device] = Device.AUTO,
+        compute_inference: bool = False,
+        solver: str = "auto",
+        gpu_memory_cleanup: bool = False,
+    ):
+        self.gamma = gamma
+        super().__init__(
+            penalty="mcp",
+            alpha=alpha,
+            fit_intercept=fit_intercept,
+            max_iter=max_iter,
+            tol=tol,
+            device=device,
+            compute_inference=compute_inference,
+            solver=solver,
+            gpu_memory_cleanup=gpu_memory_cleanup,
+            penalty_kwargs={"gamma": gamma},
+        )

statgpu/linear_model/wrappers/_negative_binomial.py

@@ -0,0 +1,58 @@
+"""Negative Binomial regression (GLM, log link, fixed dispersion)."""
+
+import numpy as np
+
+from typing import Optional
+
+from statgpu._config import Device
+from statgpu.glm_core._family import NegativeBinomial
+from statgpu.linear_model._glm_base import GeneralizedLinearModel
+
+
+class NegativeBinomialRegression(GeneralizedLinearModel):
+    """Negative Binomial regression for overdispersed count data.
+
+    Parameters
+    ----------
+    alpha : float, default=1.0
+        Dispersion parameter. Var(Y) = mu + alpha * mu^2.
+    fit_intercept : bool, default=True
+    max_iter : int, default=100
+    tol : float, default=1e-4
+    C : float, default=1.0
+        Inverse regularization strength.
+    device : str or Device, default='auto'
+    """
+
+    def __init__(
+        self,
+        alpha: float = 1.0,
+        fit_intercept: bool = True,
+        max_iter: int = 100,
+        tol: float = 1e-4,
+        C: float = 1.0,
+        device: Device = Device.AUTO,
+        n_jobs: Optional[int] = None,
+        solver: str = "auto",
+        gpu_memory_cleanup: bool = False,
+    ):
+        if not np.isfinite(alpha) or alpha <= 0.0:
+            raise ValueError("alpha must be a finite positive scalar for negative binomial regression")
+        self._alpha = alpha
+        super().__init__(
+            family="negative_binomial",
+            fit_intercept=fit_intercept,
+            max_iter=max_iter,
+            tol=tol,
+            C=C,
+            device=device,
+            n_jobs=n_jobs,
+            solver=solver,
+            gpu_memory_cleanup=gpu_memory_cleanup,
+        )
+
+    def _get_family(self):
+        return NegativeBinomial(alpha=self._alpha)
+
+    def _get_loss_kwargs(self):
+        return {"alpha": self._alpha}

statgpu/linear_model/wrappers/_poisson.py

@@ -0,0 +1,48 @@
+"""Poisson regression (GLM version, no inference)."""
+
+from typing import Optional
+from statgpu._config import Device
+from statgpu.glm_core._family import Poisson
+from statgpu.linear_model._glm_base import GeneralizedLinearModel
+
+
+class PoissonRegression(GeneralizedLinearModel):
+    """Poisson regression with GPU support.
+
+    Uses IRLS for fitting. No inference/summary (use statgpu's
+    existing GLM for inference).
+
+    Parameters
+    ----------
+    fit_intercept : bool, default=True
+    max_iter : int, default=100
+    tol : float, default=1e-4
+    C : float, default=1.0
+        Inverse regularization strength.
+    device : str or Device, default='auto'
+    """
+
+    def __init__(
+        self,
+        fit_intercept: bool = True,
+        max_iter: int = 100,
+        tol: float = 1e-4,
+        C: float = 1.0,
+        device: Device = Device.AUTO,
+        n_jobs: Optional[int] = None,
+        gpu_memory_cleanup: bool = False,
+    ):
+        super().__init__(
+            family="poisson",
+            fit_intercept=fit_intercept,
+            max_iter=max_iter,
+            tol=tol,
+            C=C,
+            device=device,
+            n_jobs=n_jobs,
+            solver="auto",
+            gpu_memory_cleanup=gpu_memory_cleanup,
+        )
+
+    def _get_family(self):
+        return Poisson()

statgpu/linear_model/wrappers/_ridge.py

@@ -0,0 +1,166 @@
+"""
+Ridge regression (L2 penalty) via PenalizedLinearRegression.
+
+The V9 ``Ridge`` class is a thin wrapper over ``PenalizedLinearRegression``
+with ``penalty="l2"`` and ``solver="exact"``.
+
+The legacy standalone implementation has been moved to ``_ridge_legacy.py``.
+"""
+
+from __future__ import annotations
+
+__all__ = ["Ridge"]
+
+from typing import Optional, Union
+
+import numpy as np
+
+from statgpu._config import Device
+
+from statgpu.linear_model.penalized._penalized_linear import PenalizedLinearRegression as _PenalizedLinearRegression
+
+
+class Ridge(_PenalizedLinearRegression):
+    """Thin sklearn-style wrapper over ``PenalizedLinearRegression`` with L2 penalty."""
+
+    def __init__(
+        self,
+        alpha: float = 1.0,
+        fit_intercept: bool = True,
+        device: Union[str, Device] = Device.AUTO,
+        n_jobs: Optional[int] = None,
+        gpu_memory_cleanup: bool = False,
+        compute_inference: bool = True,
+        cov_type: str = "nonrobust",
+        hac_maxlags: Optional[int] = None,
+        max_iter: int = 1000,
+        tol: float = 1e-4,
+        solver: str = "exact",
+        cpu_solver: str = "fista",
+        lipschitz_L: Optional[float] = None,
+    ):
+        _ct = str(cov_type).lower()
+        self.cov_type = cov_type if cov_type == _ct else _ct
+        self.hac_maxlags = hac_maxlags
+        super().__init__(
+            penalty="l2",
+            alpha=alpha,
+            fit_intercept=fit_intercept,
+            max_iter=max_iter,
+            tol=tol,
+            device=device,
+            n_jobs=n_jobs,
+            gpu_memory_cleanup=gpu_memory_cleanup,
+            compute_inference=compute_inference,
+            cov_type=cov_type,
+            hac_maxlags=hac_maxlags,
+            solver=solver,
+            cpu_solver=cpu_solver,
+            lipschitz_L=lipschitz_L,
+        )
+
+    def fit(self, X=None, y=None, sample_weight=None, formula=None, data=None):
+        """Fit Ridge regression model with optimized memory-efficient path.
+
+        Uses centering formulas to avoid allocating the full centered design matrix,
+        and skips expensive inference computations when ``compute_inference=False``.
+        """
+        if (formula is not None
+                or self._get_compute_device() != Device.CPU
+                or self.solver != "exact"):
+            # Fall back to parent for formula, GPU, or non-exact solver
+            return super().fit(X=X, y=y, sample_weight=sample_weight, formula=formula, data=data)
+
+        X_np = np.asarray(self._to_array(X, Device.CPU), dtype=np.float64)
+        y_np = np.asarray(self._to_array(y, Device.CPU), dtype=np.float64)
+
+        n_samples, n_features = X_np.shape
+        self._nobs = n_samples
+        self._fitted = False
+
+        sw = np.asarray(sample_weight, dtype=np.float64).ravel() if sample_weight is not None else None
+
+        if self.fit_intercept:
+            if sw is not None:
+                w_sum = float(sw.sum())
+                X_wmean = np.average(X_np, axis=0, weights=sw)
+                y_wmean = float(np.average(y_np, weights=sw))
+            else:
+                X_wmean = np.mean(X_np, axis=0)
+                y_wmean = np.mean(y_np)
+
+        # Build Gram matrix and RHS.
+        # Weighted: X'WX, X'Wy.  Unweighted: X'X, X'y.
+        # Centering for intercept: subtract weighted/unweighted outer product.
+        if sw is not None:
+            # Weighted normal equations: (X'WX + alpha*I) coef = X'Wy
+            sw_col = sw[:, None]
+            XtX = (X_np * sw_col).T @ X_np
+            Xty = (X_np * sw_col).T @ y_np
+            if self.fit_intercept:
+                XtX -= w_sum * np.outer(X_wmean, X_wmean)
+                Xty -= w_sum * X_wmean * y_wmean
+                n_eff = w_sum
+            else:
+                n_eff = float(sw.sum())
+        else:
+            if self.fit_intercept:
+                X_mean = np.mean(X_np, axis=0)
+                y_mean = np.mean(y_np)
+                XtX = X_np.T @ X_np
+                XtX -= n_samples * np.outer(X_mean, X_mean)
+                Xty = X_np.T @ y_np
+                Xty -= n_samples * X_mean * y_mean
+            else:
+                XtX = X_np.T @ X_np
+                Xty = X_np.T @ y_np
+            n_eff = float(n_samples)
+
+        if Xty.ndim == 0:
+            Xty = Xty.reshape(1)
+        if Xty.ndim == 1:
+            Xty = Xty.reshape(-1, 1)
+
+        # Solve (XtX + n_eff*alpha*I) @ coef = Xty
+        # n_eff scaling matches PenalizedGeneralizedLinearModel exact ridge
+        # and sklearn Ridge convention.
+        A = XtX + float(self.alpha) * n_eff * np.eye(n_features, dtype=np.float64)
+        try:
+            coef = np.linalg.solve(A, Xty).flatten()
+        except np.linalg.LinAlgError:
+            coef = np.linalg.lstsq(A, Xty, rcond=None)[0].flatten()
+
+        if self.fit_intercept:
+            self.intercept_ = float(y_wmean - X_wmean @ coef)
+            self.coef_ = coef
+            self._params = np.concatenate([[self.intercept_], self.coef_])
+        else:
+            self.intercept_ = 0.0
+            self.coef_ = coef
+            self._params = self.coef_.copy()
+
+        self._X_design = None
+        self._resid = None
+        self._scale = np.nan
+        self.n_iter_ = 1
+        self._df_resid = n_samples - (n_features + (1 if self.fit_intercept else 0))
+
+        # Build design matrix and compute residuals only when inference is needed
+        if self.compute_inference:
+            if self.fit_intercept:
+                self._X_design = np.column_stack([np.ones(n_samples, dtype=X_np.dtype), X_np])
+            else:
+                self._X_design = X_np.copy()
+            y_pred = self._X_design @ self._params
+            self._resid = y_np - y_pred
+            if self._df_resid > 0:
+                resid_sq = self._resid ** 2
+                self._scale = float(np.sum(resid_sq)) / self._df_resid
+            # Compute inference statistics (bse, tvalues, pvalues, conf_int).
+            # For weighted fits, _compute_post_fit_gaussian_inference uses
+            # sqrt(w)*X internally, producing correct weighted scale and
+            # consistent inference attributes.
+            self._compute_post_fit_gaussian_inference(X_np, y_np, sample_weight=sample_weight)
+
+        self._fitted = True
+        return self

statgpu/linear_model/wrappers/_scad.py

@@ -0,0 +1,58 @@
+"""SCAD-penalized regression (Fan & Li, JASA 2001)."""
+
+from __future__ import annotations
+
+from typing import Union
+
+from statgpu._config import Device
+from statgpu.linear_model.penalized._penalized_linear import PenalizedLinearRegression
+
+
+class SCADRegression(PenalizedLinearRegression):
+    """SCAD-penalized regression.
+
+    Non-convex penalty with oracle property. Uses LLA+FISTA for optimization.
+
+    Parameters
+    ----------
+    alpha : float, default=1.0
+        Regularization strength.
+    a : float, default=3.7
+        Concavity parameter (Fan & Li recommend 3.7).
+    fit_intercept : bool, default=True
+        Whether to calculate the intercept.
+    max_iter : int, default=1000
+        Maximum number of iterations.
+    tol : float, default=1e-4
+        Tolerance for convergence.
+    device : str or Device, default='auto'
+        Computation device.
+    compute_inference : bool, default=False
+        Whether to compute post-fit inference (SCAD does not support debiased).
+    """
+
+    def __init__(
+        self,
+        alpha: float = 1.0,
+        a: float = 3.7,
+        fit_intercept: bool = True,
+        max_iter: int = 1000,
+        tol: float = 1e-4,
+        device: Union[str, Device] = Device.AUTO,
+        compute_inference: bool = False,
+        solver: str = "auto",
+        gpu_memory_cleanup: bool = False,
+    ):
+        self.a = a
+        super().__init__(
+            penalty="scad",
+            alpha=alpha,
+            fit_intercept=fit_intercept,
+            max_iter=max_iter,
+            tol=tol,
+            device=device,
+            compute_inference=compute_inference,
+            solver=solver,
+            gpu_memory_cleanup=gpu_memory_cleanup,
+            penalty_kwargs={"a": a},
+        )

statgpu/linear_model/wrappers/_tweedie.py

@@ -0,0 +1,57 @@
+"""Tweedie regression (GLM, log link, power parameter)."""
+
+from typing import Optional
+
+from statgpu._config import Device
+from statgpu.glm_core._family import Tweedie
+from statgpu.linear_model._glm_base import GeneralizedLinearModel
+
+
+class TweedieRegression(GeneralizedLinearModel):
+    """Tweedie regression for compound Poisson-Gamma outcomes.
+
+    Parameters
+    ----------
+    power : float, default=1.5
+        Tweedie power parameter. Must be in (1, 2).
+        1 < power < 2: compound Poisson-Gamma.
+    fit_intercept : bool, default=True
+    max_iter : int, default=100
+    tol : float, default=1e-4
+    C : float, default=1.0
+        Inverse regularization strength.
+    device : str or Device, default='auto'
+    """
+
+    def __init__(
+        self,
+        power: float = 1.5,
+        fit_intercept: bool = True,
+        max_iter: int = 100,
+        tol: float = 1e-4,
+        C: float = 1.0,
+        device: Device = Device.AUTO,
+        n_jobs: Optional[int] = None,
+        solver: str = "auto",
+        gpu_memory_cleanup: bool = False,
+    ):
+        if not 1.0 < power < 2.0:
+            raise ValueError(f"Tweedie power must be in (1, 2), got {power}")
+        self._power = power
+        super().__init__(
+            family="tweedie",
+            fit_intercept=fit_intercept,
+            max_iter=max_iter,
+            tol=tol,
+            C=C,
+            device=device,
+            n_jobs=n_jobs,
+            solver=solver,
+            gpu_memory_cleanup=gpu_memory_cleanup,
+        )
+
+    def _get_family(self):
+        return Tweedie(power=self._power)
+
+    def _get_loss_kwargs(self):
+        return {"power": self._power}

statgpu/metrics/__init__.py

@@ -0,0 +1,21 @@
+"""Classification metrics utilities."""
+
+from ._classification import (
+    binary_average_precision_score,
+    binary_classification_table,
+    binary_confusion_matrix,
+    binary_precision_recall_curve,
+    binary_roc_auc_score,
+    binary_roc_curve,
+    evaluate_binary_classification,
+)
+
+__all__ = [
+    "binary_confusion_matrix",
+    "binary_classification_table",
+    "binary_precision_recall_curve",
+    "binary_average_precision_score",
+    "binary_roc_curve",
+    "binary_roc_auc_score",
+    "evaluate_binary_classification",
+]