statgpu 0.1.0__py3-none-any.whl

statgpu/linear_model/penalized/_predict_mixin.py

@@ -0,0 +1,182 @@
+"""Prediction mixin for PenalizedGeneralizedLinearModel."""
+
+from __future__ import annotations
+
+import numpy as np
+from typing import TYPE_CHECKING
+
+from statgpu._config import Device
+from statgpu.backends import _to_numpy
+
+# Eta (linear predictor) clipping bound for numerical stability in GLM link functions.
+# Prevents overflow in exp(eta) for log-link families and sigmoid(eta) for logistic.
+# Value of 500 is safe because exp(500) ≈ 1.4e217 (within float64 range).
+_ETA_CLIP = 500.0
+
+if TYPE_CHECKING:
+    from ._base import PenalizedGeneralizedLinearModel as _Self
+
+
+class _PenalizedPredictMixin:
+
+    def _prepare_predict_X(self, X):
+        """Apply stored formula design metadata to DataFrame inputs."""
+        if self._design_info is not None:
+            try:
+                import pandas as pd
+            except ImportError:
+                pd = None
+            if pd is not None and isinstance(X, pd.DataFrame):
+                from statgpu.core.formula import FormulaParser
+
+                parser = FormulaParser.__new__(FormulaParser)
+                parser._design_info = self._design_info
+                parser.formula = None
+                X = parser.transform(X)
+                col_names = list(self._design_info.column_names)
+                if self._formula_has_intercept and "Intercept" in col_names:
+                    X = np.delete(X, col_names.index("Intercept"), axis=1)
+            # Formula processing produces numpy arrays
+            return np.asarray(X)
+        # No formula: return X as-is to avoid unnecessary GPU→CPU→GPU round-trip
+        return X
+
+    def _prediction_backend_name(self):
+        backend_name = getattr(self, "_selected_backend_name", None)
+        if backend_name == "cupy" and self._cupy_available():
+            return "cupy"
+        if backend_name == "torch" and self._torch_cuda_available():
+            return "torch"
+        if backend_name == "numpy":
+            return "numpy"
+        if self.device == Device.AUTO:
+            return "numpy"
+        device = self._get_compute_device()
+        if device == Device.CUDA:
+            if self._cupy_available():
+                return "cupy"
+            raise RuntimeError(
+                "device='cuda' was explicitly requested, but CuPy/CUDA is unavailable at prediction time."
+            )
+        if device == Device.TORCH:
+            if self._torch_cuda_available():
+                return "torch"
+            raise RuntimeError(
+                "device='torch' was explicitly requested, but Torch CUDA is unavailable at prediction time."
+            )
+        return "numpy"
+
+    def predict(self, X, return_cpu=True):
+        """
+        Predict using fitted model.
+
+        For squared_error: returns linear prediction.
+        For logistic: returns binary class labels.
+        For poisson: returns exp(linear prediction) (count values).
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_features)
+            Test data.
+        return_cpu : bool, default=True
+            If True, always return a numpy ndarray (GPU→CPU transfer happens
+            automatically when the model was fitted on GPU).  If False, return
+            the result in the same backend as the fitted coefficients (cupy/
+            torch when fitted on GPU, numpy when fitted on CPU).  Setting to
+            False avoids an unnecessary D→H transfer when chaining GPU
+            operations (e.g., ``model.predict(X_gpu) - y_gpu``).
+
+        Returns
+        -------
+        y_pred : ndarray of shape (n_samples,)
+            Predicted values.
+        """
+        if self.coef_ is None:
+            raise RuntimeError("Model has not been fitted yet.")
+
+        X = self._prepare_predict_X(X)
+        backend_name = self._prediction_backend_name()
+        if backend_name == "cupy":
+            import cupy as cp
+            Xb = cp.asarray(self._to_array(X, Device.CUDA))
+            coef = cp.asarray(self.coef_)
+            raw = Xb @ coef
+            if self._effective_intercept:
+                raw += cp.asarray(self.intercept_, dtype=raw.dtype)
+            if self.loss == "logistic":
+                p = 1.0 / (1.0 + cp.exp(-cp.clip(raw, -_ETA_CLIP, _ETA_CLIP)))
+                result = (p > 0.5).astype(float)
+            elif self.loss != "squared_error":
+                result = self._family_for_loss().link.inverse(raw)
+            else:
+                result = raw
+            return _to_numpy(result) if return_cpu else result
+        if backend_name == "torch":
+            import torch
+            Xb = self._to_array(X, Device.TORCH, backend="torch").to(torch.float64)
+            coef = torch.as_tensor(self.coef_, dtype=Xb.dtype, device=Xb.device)
+            raw = Xb @ coef
+            if self._effective_intercept:
+                raw = raw + torch.as_tensor(
+                    self.intercept_, dtype=raw.dtype, device=raw.device
+                )
+            if self.loss == "logistic":
+                p = 1.0 / (1.0 + torch.exp(-torch.clamp(raw, -_ETA_CLIP, _ETA_CLIP)))
+                result = (p > 0.5).to(raw.dtype)
+            elif self.loss != "squared_error":
+                result = self._family_for_loss().link.inverse(raw)
+            else:
+                result = raw
+            return _to_numpy(result) if return_cpu else result
+
+        raw = X @ self.coef_
+        if self._effective_intercept:
+            raw += self.intercept_
+
+        # Apply link inverse for GLM losses
+        if self.loss == "logistic":
+            p = 1.0 / (1.0 + np.exp(-np.clip(raw, -_ETA_CLIP, _ETA_CLIP)))
+            return (p > 0.5).astype(float)
+        elif self.loss != "squared_error":
+            return self._family_for_loss().link.inverse(raw)
+        return raw
+
+    def score(self, X, y, sample_weight=None):
+        """
+        Return goodness-of-fit score (R² = 1 - SS_res/SS_tot).
+
+        For all loss types, computes the standard R² metric on the response
+        scale. For squared_error this is the classical R². For GLM losses
+        (logistic, Poisson, Gamma, etc.) this is R² on the original y scale,
+        not the deviance-based pseudo-R².
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_features)
+            Test data.
+        y : array-like of shape (n_samples,)
+            True values.
+        sample_weight : array-like of shape (n_samples,), optional
+            Sample weights. When provided, returns weighted R².
+
+        Returns
+        -------
+        score : float
+            R² or pseudo-R² score.
+        """
+        # Use predict(return_cpu=True) to avoid device mismatch between
+        # predict() and score() backend resolution logic.
+        y_pred_np = np.asarray(_to_numpy(self.predict(X, return_cpu=True)))
+        y = np.asarray(y)
+        sw = np.asarray(sample_weight, dtype=np.float64).ravel() if sample_weight is not None else None
+        resid_sq = (y - y_pred_np) ** 2
+        if sw is not None:
+            w_sum = float(np.sum(sw))
+            if w_sum <= 0:
+                return 0.0
+            ss_res = float(np.sum(sw * resid_sq))
+            ss_tot = float(np.sum(sw * (y - np.average(y, weights=sw)) ** 2))
+        else:
+            ss_res = float(np.sum(resid_sq))
+            ss_tot = float(np.sum((y - np.mean(y)) ** 2))
+        return 1 - ss_res / ss_tot if ss_tot > 0 else 0.0

statgpu/linear_model/wrappers/__init__.py

@@ -0,0 +1,31 @@
+"""Basic model wrappers (thin wrappers over PenalizedGLM / GLM base)."""
+
+from ._linear import LinearRegression
+from ._ridge import Ridge
+from ._lasso import Lasso
+from ._elasticnet import ElasticNet
+from ._adaptive_lasso import AdaptiveLasso
+from ._scad import SCADRegression
+from ._mcp import MCPRegression
+from ._logistic import LogisticRegression
+from ._gamma import GammaRegression
+from ._poisson import PoissonRegression
+from ._inverse_gaussian import InverseGaussianRegression
+from ._negative_binomial import NegativeBinomialRegression
+from ._tweedie import TweedieRegression
+
+__all__ = [
+    "LinearRegression",
+    "Ridge",
+    "Lasso",
+    "ElasticNet",
+    "AdaptiveLasso",
+    "SCADRegression",
+    "MCPRegression",
+    "LogisticRegression",
+    "GammaRegression",
+    "PoissonRegression",
+    "InverseGaussianRegression",
+    "NegativeBinomialRegression",
+    "TweedieRegression",
+]

statgpu/linear_model/wrappers/_adaptive_lasso.py

@@ -0,0 +1,63 @@
+"""Adaptive Lasso regression (Zou, JASA 2006)."""
+
+from __future__ import annotations
+
+from typing import Union
+
+from statgpu._config import Device
+from statgpu.linear_model.penalized._penalized_linear import PenalizedLinearRegression
+
+
+class AdaptiveLasso(PenalizedLinearRegression):
+    """Adaptive Lasso regression.
+
+    Uses data-driven per-coordinate weights: w_j = 1/(|init_coef_j| + eps)^nu.
+    Provides oracle property under regularity conditions (Zou 2006).
+
+    Parameters
+    ----------
+    alpha : float, default=1.0
+        Regularization strength.
+    nu : float, default=1.0
+        Exponent for weight computation.
+    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.
+    inference_method : str, default='debiased'
+        Inference method.
+    """
+
+    def __init__(
+        self,
+        alpha: float = 1.0,
+        nu: float = 1.0,
+        fit_intercept: bool = True,
+        max_iter: int = 1000,
+        tol: float = 1e-4,
+        device: Union[str, Device] = Device.AUTO,
+        compute_inference: bool = False,
+        inference_method: str = "debiased",
+        solver: str = "auto",
+        gpu_memory_cleanup: bool = False,
+    ):
+        self.nu = nu
+        super().__init__(
+            penalty="adaptive_l1",
+            alpha=alpha,
+            fit_intercept=fit_intercept,
+            max_iter=max_iter,
+            tol=tol,
+            device=device,
+            compute_inference=compute_inference,
+            inference_method=inference_method,
+            solver=solver,
+            gpu_memory_cleanup=gpu_memory_cleanup,
+            penalty_kwargs={"nu": nu},
+        )

statgpu/linear_model/wrappers/_elasticnet.py

@@ -0,0 +1,75 @@
+"""
+Elastic Net regression with GPU support.
+
+The V9 ElasticNet class is a thin wrapper over PenalizedLinearRegression
+with penalty="elasticnet" and solver="exact".
+
+The legacy standalone implementation has been moved to _elasticnet_legacy.py.
+"""
+
+from __future__ import annotations
+
+__all__ = ["ElasticNet"]
+
+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 ElasticNet(_PenalizedLinearRegression):
+    """Thin sklearn-style wrapper over ``PenalizedLinearRegression`` with Elastic Net penalty."""
+
+    def __init__(
+        self,
+        alpha: float = 1.0,
+        l1_ratio: float = 0.5,
+        fit_intercept: bool = True,
+        max_iter: int = 1000,
+        tol: float = 1e-4,
+        stopping: str = "coef_delta",
+        device: Union[str, Device] = Device.AUTO,
+        n_jobs: Optional[int] = None,
+        solver: str = "fista",
+        cpu_solver: str = "fista",
+        lipschitz_L: Optional[float] = None,
+        gpu_memory_cleanup: bool = False,
+    ):
+        if alpha < 0:
+            raise ValueError(f"alpha must be non-negative, got {alpha}")
+        self.stopping = str(stopping).lower()
+        super().__init__(
+            penalty="elasticnet",
+            alpha=alpha,
+            l1_ratio=l1_ratio,
+            fit_intercept=fit_intercept,
+            max_iter=max_iter,
+            tol=tol,
+            device=device,
+            n_jobs=n_jobs,
+            solver=solver,
+            cpu_solver=cpu_solver,
+            lipschitz_L=lipschitz_L,
+            gpu_memory_cleanup=gpu_memory_cleanup,
+            stopping=stopping,
+        )
+
+    def fit(self, X=None, y=None, sample_weight=None, initial_coef=None, **kwargs):
+        """Fit Elastic Net model.
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_features)
+            Training data.
+        y : array-like of shape (n_samples,)
+            Target values.
+        sample_weight : array-like of shape (n_samples,), optional
+            Sample weights.
+        initial_coef : array-like of shape (n_features,), optional
+            Warm-start coefficients. Passed to the underlying solver.
+        """
+        if initial_coef is not None:
+            self._init_coef = np.asarray(initial_coef, dtype=np.float64)
+        return super().fit(X=X, y=y, sample_weight=sample_weight, **kwargs)

statgpu/linear_model/wrappers/_gamma.py

@@ -0,0 +1,67 @@
+"""Gamma regression (GLM with Gamma family, log link)."""
+
+from typing import Optional
+
+from statgpu._config import Device
+from statgpu.glm_core._family import Gamma, LogLink, InversePowerLink
+from statgpu.linear_model._glm_base import GeneralizedLinearModel
+
+
+_LINK_MAP = {
+    "log": LogLink,
+    "inverse_power": InversePowerLink,
+}
+
+
+class GammaRegression(GeneralizedLinearModel):
+    """Gamma regression for positive continuous outcomes.
+
+    Uses log link by default for numerical stability. The canonical
+    inverse_power link is also supported.
+
+    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'
+    link : str, default='log'
+        Link function: 'log' or 'inverse_power'.
+    """
+
+    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,
+        link: str = "log",
+        solver: str = "auto",
+        gpu_memory_cleanup: bool = False,
+    ):
+        self._link_name = link
+        super().__init__(
+            family="gamma",
+            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):
+        if self._link_name not in _LINK_MAP:
+            valid = ", ".join(sorted(_LINK_MAP))
+            raise ValueError(f"GammaRegression link must be one of: {valid}")
+        link_cls = _LINK_MAP[self._link_name]
+        return Gamma(link=link_cls())
+
+    def _get_loss_kwargs(self):
+        return {"link": self._link_name}

statgpu/linear_model/wrappers/_inverse_gaussian.py

@@ -0,0 +1,47 @@
+"""Inverse Gaussian regression (GLM, log link)."""
+
+from typing import Optional
+
+from statgpu._config import Device
+from statgpu.glm_core._family import InverseGaussian
+from statgpu.linear_model._glm_base import GeneralizedLinearModel
+
+
+class InverseGaussianRegression(GeneralizedLinearModel):
+    """Inverse Gaussian regression for positive right-skewed outcomes.
+
+    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,
+        solver: str = "auto",
+        gpu_memory_cleanup: bool = False,
+    ):
+        super().__init__(
+            family="inverse_gaussian",
+            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 InverseGaussian()