statgpu 0.1.0__py3-none-any.whl

statgpu/glm_core/_negative_binomial.py

@@ -0,0 +1,68 @@
+"""
+Negative Binomial loss: negative log-likelihood with log link.
+
+For overdispersed count data:
+    Var(Y) = mu + alpha * mu^2
+where mu = exp(X @ coef), alpha is the dispersion parameter.
+
+Supports numpy / cupy / torch backends via _array_ops helpers.
+"""
+import numpy as np
+
+from statgpu.backends._array_ops import _clip, _exp, _log, _sum, _max_eigval_power
+from statgpu.glm_core._base import GLMLoss, register_glm_loss
+
+
+@register_glm_loss('negative_binomial')
+class NegativeBinomialLoss(GLMLoss):
+    name = "negative_binomial"
+    y_type = "count"
+    smooth_gradient = True
+    has_hessian = True
+
+    _MU_LO = 1e-300
+
+    def __init__(self, alpha=1.0):
+        if not np.isfinite(alpha) or alpha <= 0.0:
+            raise ValueError("alpha must be a finite positive scalar for negative binomial loss")
+        self.alpha = alpha
+
+    def _mu_from_eta(self, eta):
+        return _clip(_exp(_clip(eta, -30, 30)), self._MU_LO, None)
+
+    # ── Per-sample formulas (single source of truth) ──────────────────
+
+    def per_sample_value(self, eta, y):
+        mu = self._mu_from_eta(eta)
+        a = self.alpha
+        one_plus_a_mu = 1.0 + a * mu
+        return -y * _log(mu / one_plus_a_mu) + (1.0 / a) * _log(one_plus_a_mu)
+
+    def per_sample_gradient(self, eta, y):
+        mu = self._mu_from_eta(eta)
+        return (mu - y) / (1.0 + self.alpha * mu)
+
+    def hessian(self, X, y, coef, sample_weight=None):
+        z = _clip(X @ coef, -30, 30)
+        mu = _exp(z)
+        W = _clip(mu, 1e-10, None) / (1.0 + self.alpha * _clip(mu, 1e-10, None))
+        if sample_weight is not None:
+            W = W * sample_weight
+        n_eff = float(sample_weight.sum()) if sample_weight is not None else X.shape[0]
+        return X.T @ (X * W[:, None]) / n_eff
+
+    _lipschitz_safety = 2.0  # NB Hessian varies moderately with mu
+
+    def lipschitz(self, X, coef, y=None, sample_weight=None):
+        z = _clip(X @ coef, -30, 30)
+        mu = _exp(z)
+        W = _clip(mu, 1e-10, 1e6) / (1.0 + self.alpha * _clip(mu, 1e-10, 1e6))
+        if sample_weight is not None:
+            W = W * sample_weight
+        n_eff = float(sample_weight.sum()) if sample_weight is not None else X.shape[0]
+        XtWX = X.T @ (X * W[:, None])
+        L = _max_eigval_power(XtWX) / n_eff
+        return max(L, 1e-8)  # Safety factor applied by solver via _lipschitz_safety
+
+    def predict(self, X, coef):
+        return _exp(X @ coef)

statgpu/glm_core/_poisson.py

@@ -0,0 +1,60 @@
+"""
+Poisson loss: negative Poisson log-likelihood.
+
+For count data:
+    loss = (1/n) * sum(mu - y*log(mu))
+where mu = exp(X @ coef).
+
+Supports numpy / cupy / torch backends via _backend helpers.
+"""
+from statgpu.backends._array_ops import _clip, _exp, _log, _sum, _max_eigval_power
+from statgpu.glm_core._base import GLMLoss, register_glm_loss
+
+
+@register_glm_loss('poisson')
+class PoissonLoss(GLMLoss):
+    name = "poisson"
+    y_type = "count"
+    smooth_gradient = True
+    has_hessian = True
+    _momentum_beta_cap = 0.5
+    _poisson_like = True
+
+    _MU_LO = 1e-10
+    _MU_HI = 1e6  # must exceed typical max(y); clip prevents extreme weights
+    _ETA_LO = -30
+    _ETA_HI = 30
+
+    # ── Per-sample formulas (single source of truth) ──────────────────
+
+    def _mu_from_eta(self, eta):
+        return _clip(_exp(_clip(eta, self._ETA_LO, self._ETA_HI)), self._MU_LO, self._MU_HI)
+
+    def per_sample_value(self, eta, y):
+        mu = self._mu_from_eta(eta)
+        return mu - y * _log(mu)
+
+    def per_sample_gradient(self, eta, y):
+        mu = self._mu_from_eta(eta)
+        return mu - y
+
+    # ── Hessian / Lipschitz ───────────────────────────────────────────
+
+    def hessian(self, X, y, coef, sample_weight=None):
+        z = _clip(X @ coef, -30, 30)
+        mu = _clip(_exp(z), self._MU_LO, self._MU_HI)
+        W = mu if sample_weight is None else mu * sample_weight
+        n_eff = float(sample_weight.sum()) if sample_weight is not None else X.shape[0]
+        return X.T @ (X * W[:, None]) / n_eff
+
+    def lipschitz(self, X, coef, y=None, sample_weight=None):
+        z = _clip(X @ coef, -30, 30)
+        mu = _clip(_exp(z), self._MU_LO, self._MU_HI)
+        W = mu if sample_weight is None else mu * sample_weight
+        n_eff = float(sample_weight.sum()) if sample_weight is not None else X.shape[0]
+        XtWX = X.T @ (X * W[:, None])
+        L = _max_eigval_power(XtWX) / n_eff
+        return max(L, 1e-8)
+
+    def predict(self, X, coef):
+        return _exp(X @ coef)

statgpu/glm_core/_solver_legacy.py

@@ -0,0 +1,100 @@
+"""Legacy solver methods from _solver.py.
+
+DO NOT import in production code."""
+
+from __future__ import annotations
+
+import numpy as np
+
+def fista_sqerr_adaptive_l1_fused(
+    X, y, penalty_weights, alpha,
+    XtX, Xty, yty, n_samples,
+    L_init, max_iter, tol,
+    backend, no_momentum=False,
+):
+    """Fused FISTA for squared_error + AdaptiveL1 with pre-computed XtX/Xty.
+
+    Eliminates:
+    - Redundant X@coef matmul (uses XtX instead)
+    - GPU→CPU syncs (convergence check deferred)
+    - Element-wise kernel overhead (fused update+proximal+momentum)
+
+    Parameters
+    ----------
+    X, y : array (centered)
+    penalty_weights : array (p,) — LLA weights
+    alpha : float — penalty alpha
+    XtX, Xty, yty : pre-computed
+    n_samples : int
+    L_init : float — initial Lipschitz
+    max_iter, tol : FISTA params
+    backend : 'torch' or 'cupy'
+    no_momentum : bool
+
+    Returns
+    -------
+    coef : array (p,)
+    n_iter : int
+    """
+    p = XtX.shape[0]
+    step = 1.0 / L_init
+    L = L_init
+
+    if backend == "torch":
+        import torch
+        thresh = torch.tensor(
+            alpha * penalty_weights * step,
+            device=XtX.device, dtype=XtX.dtype,
+        )
+        coef = torch.zeros(p, device=XtX.device, dtype=XtX.dtype)
+        coef_old = coef.clone()
+        y_k = coef.clone()
+        _fused = _get_sqerr_proximal_torch()
+        # Pre-allocate for momentum-free case
+        _zero_beta = 0.0
+    else:
+        import cupy as cp
+        thresh = cp.asarray(alpha * penalty_weights * step, dtype=cp.float64)
+        coef = cp.zeros(p, dtype=cp.float64)
+        coef_old = coef.copy()
+        y_k = coef.copy()
+        _fused = _get_sqerr_proximal_cupy()
+        _zero_beta = 0.0
+
+    t_k = 1.0
+    _sync_interval = 10  # Only check convergence every N iterations
+
+    iteration = -1  # default if max_iter=0
+    for iteration in range(max_iter):
+        # Gradient: grad = (XtX @ y_k - Xty) / n
+        grad = (XtX @ y_k - Xty) / n_samples
+
+        # Clip gradients (avoid sync — do it on GPU)
+        if iteration % 10 == 0:
+            grad = _clip_grad_on_device(grad, coef_old, backend)
+
+        # Proximal gradient step (no backtracking — Lipschitz is exact for squared_error)
+        # Pre-compute momentum coefficient so the fused kernel can apply it in one pass.
+        if no_momentum:
+            beta_mom = 0.0
+        else:
+            t_new = (1.0 + np.sqrt(1.0 + 4.0 * t_k * t_k)) / 2.0
+            beta_mom = (t_k - 1.0) / t_new
+        coef_new, y_k = _fused(y_k, grad, step, thresh, coef_old, beta_mom)
+        coef = coef_new
+
+        # Momentum state update
+        if not no_momentum:
+            t_k = t_new
+
+        # Convergence check (device-side, minimal sync)
+        if iteration < 20 or iteration % _sync_interval == 0:
+            coef_diff_dev = _abs_sum_dev(coef - coef_old)
+            if _to_float_scalar(coef_diff_dev) < tol:
+                break
+
+        coef_old = _copy_arr(coef)
+
+    return _to_numpy(coef), iteration + 1
+
+

statgpu/glm_core/_squared.py

@@ -0,0 +1,53 @@
+"""
+Squared error loss: (1/(2n)) * ||y - Xw||^2
+
+Convention: loss = (1/(2n)) * sum(resid^2).
+All penalties use alpha*n in the normal equations / CD updates,
+matching the PenalizedGeneralizedLinearModel convention and sklearn.
+
+sklearn compatibility mapping:
+  - Ridge:   sklearn alpha = statgpu alpha * n  (statgpu alpha = sklearn alpha / n)
+  - Lasso:   statgpu alpha = sklearn alpha
+  - ElasticNet: statgpu alpha = sklearn alpha
+
+Internal consistency: Ridge(alpha=a) == PGLM(alpha=a, penalty='l2')
+for all alpha values (verified to machine precision).
+
+Supports numpy / cupy / torch backends via _backend helpers.
+"""
+from statgpu.backends._array_ops import _max_eigval_power
+from statgpu.glm_core._base import GLMLoss, register_glm_loss
+
+
+@register_glm_loss('squared_error')
+class SquaredErrorLoss(GLMLoss):
+    name = "squared_error"
+    y_type = "continuous"
+    smooth_gradient = True
+    has_hessian = True
+    _is_quadratic = True
+    _supports_cholesky = True
+
+    # ── Per-sample formulas (single source of truth) ──────────────────
+
+    def per_sample_value(self, eta, y):
+        resid = y - eta
+        return 0.5 * resid * resid
+
+    def per_sample_gradient(self, eta, y):
+        return eta - y
+
+    # ── Hessian / Lipschitz (override for weighted support) ───────────
+
+    def hessian(self, X, y, coef, sample_weight=None):
+        if sample_weight is not None:
+            return X.T @ (X * sample_weight[:, None]) / sample_weight.sum()
+        return X.T @ X / X.shape[0]
+
+    def lipschitz(self, X, coef, y=None, sample_weight=None):
+        if sample_weight is not None:
+            sw = sample_weight[:, None] if hasattr(sample_weight, '__len__') else sample_weight
+            XtWX = X.T @ (X * sw)
+            return _max_eigval_power(XtWX) / sample_weight.sum()
+        XtX = X.T @ X
+        return _max_eigval_power(XtX) / X.shape[0]

statgpu/glm_core/_tweedie.py

@@ -0,0 +1,74 @@
+"""
+Tweedie loss: negative Tweedie log-likelihood with log link.
+
+For compound Poisson-Gamma (1 < p < 2) outcomes:
+    loss = (1/n) * sum(-y * mu^(1-p)/(1-p) + mu^(2-p)/(2-p))
+where mu = exp(X @ coef), p is the Tweedie power parameter.
+
+Supports numpy / cupy / torch backends via _array_ops helpers.
+"""
+from statgpu.backends._array_ops import _clip, _exp, _sum, _max_eigval_power
+from statgpu.glm_core._base import GLMLoss, register_glm_loss
+
+
+@register_glm_loss('tweedie')
+class TweedieLoss(GLMLoss):
+    name = "tweedie"
+    y_type = "nonnegative"
+    smooth_gradient = True
+    has_hessian = True
+    _lipschitz_uses_y = True
+    _lipschitz_safety = 5.0
+    _tweedie = True  # Tweedie variance function requires large safety
+
+    # Clip z to [-50, 50] instead of [-500, 500] to prevent
+    # mu^(-0.5) explosion: mu >= exp(-50) ~ 1.9e-22 -> mu^(-0.5) <= 2.3e10.
+    _Z_CLIP = 50.0
+
+    _MU_LO = 1e-3
+    _MU_HI = 1e4
+
+    def __init__(self, power=1.5):
+        if not 1.0 < power < 2.0:
+            raise ValueError(f"Tweedie power must be in (1, 2), got {power}")
+        self.power = power
+
+    def _mu_from_eta(self, eta):
+        return _clip(_exp(_clip(eta, -self._Z_CLIP, self._Z_CLIP)), self._MU_LO, self._MU_HI)
+
+    # ── Per-sample formulas (single source of truth) ──────────────────
+
+    def per_sample_value(self, eta, y):
+        mu = self._mu_from_eta(eta)
+        p = self.power
+        return -y * mu ** (1.0 - p) / (1.0 - p) + mu ** (2.0 - p) / (2.0 - p)
+
+    def per_sample_gradient(self, eta, y):
+        mu = self._mu_from_eta(eta)
+        p = self.power
+        return mu ** (1.0 - p) * (mu - y)
+
+    def hessian(self, X, y, coef, sample_weight=None):
+        z = _clip(X @ coef, -self._Z_CLIP, self._Z_CLIP)
+        mu = _clip(_exp(z), self._MU_LO, self._MU_HI)
+        p = self.power
+        W = mu ** (2.0 - p)
+        if sample_weight is not None:
+            W = W * sample_weight
+        n_eff = float(sample_weight.sum()) if sample_weight is not None else X.shape[0]
+        return X.T @ (X * W[:, None]) / n_eff
+
+    def lipschitz(self, X, coef, y=None, sample_weight=None):
+        z = _clip(X @ coef, -self._Z_CLIP, self._Z_CLIP)
+        mu = _clip(_exp(z), self._MU_LO, self._MU_HI)
+        p = self.power
+        W = mu ** (2.0 - p)
+        if sample_weight is not None:
+            W = W * sample_weight
+        n_eff = float(sample_weight.sum()) if sample_weight is not None else X.shape[0]
+        XtWX = X.T @ (X * W[:, None])
+        L = _max_eigval_power(XtWX) / n_eff
+        return max(L, 1e-8)
+
+    def predict(self, X, coef):
+        return _exp(X @ coef)

statgpu/inference/__init__.py

@@ -0,0 +1,239 @@
+"""Inference helper utilities shared across models."""
+
+from ._distributions_backend import (
+    BetaDistributionBase,
+    BinomDistributionBase,
+    CauchyDistributionBase,
+    Chi2DistributionBase,
+    ExponDistributionBase,
+    FDistributionBase,
+    GammaDistributionBase,
+    LaplaceDistributionBase,
+    LogisticDistributionBase,
+    LognormDistributionBase,
+    NormDistributionBase,
+    PoissonDistributionBase,
+    ScipyFallbackDistribution,
+    TDistributionBase,
+    UniformDistributionBase,
+    WeibullMinDistributionBase,
+    # Backward-compatible aliases
+    BetaDistributionBase as BetaDistributionGPU,
+    BinomDistributionBase as BinomDistributionGPU,
+    CauchyDistributionBase as CauchyDistributionGPU,
+    Chi2DistributionBase as Chi2DistributionGPU,
+    ExponDistributionBase as ExponDistributionGPU,
+    FDistributionBase as FDistributionGPU,
+    GammaDistributionBase as GammaDistributionGPU,
+    LaplaceDistributionBase as LaplaceDistributionGPU,
+    LogisticDistributionBase as LogisticDistributionGPU,
+    LognormDistributionBase as LognormDistributionGPU,
+    NormDistributionBase as NormDistributionGPU,
+    PoissonDistributionBase as PoissonDistributionGPU,
+    TDistributionBase as TDistributionGPU,
+    UniformDistributionBase as UniformDistributionGPU,
+    WeibullMinDistributionBase as WeibullMinDistributionGPU,
+    beta,
+    binom,
+    cauchy,
+    chi2,
+    expon,
+    f,
+    gamma,
+    get_distribution,
+    get_distribution_gpu,
+    laplace,
+    list_available_distributions,
+    list_available_distributions_gpu,
+    logistic,
+    lognorm,
+    norm,
+    poisson,
+    t,
+    uniform,
+    weibull_min,
+)
+from statgpu.linear_model.legacy._distributions_legacy_gpu import (
+    dbeta_gpu,
+    dbinom_gpu,
+    dchisq_gpu,
+    df_gpu,
+    dgamma_gpu,
+    dnorm_gpu,
+    dpois_gpu,
+    dt_gpu,
+    norm_cdf_gpu,
+    norm_isf_gpu,
+    norm_ppf_gpu,
+    norm_sf_gpu,
+    norm_two_sided_critical_value_gpu,
+    norm_two_sided_pvalue_gpu,
+    pbeta_gpu,
+    pbinom_gpu,
+    pchisq_gpu,
+    pf_gpu,
+    pgamma_gpu,
+    pnorm_gpu,
+    ppois_gpu,
+    pt_gpu,
+    qbeta_gpu,
+    qbinom_gpu,
+    qchisq_gpu,
+    qf_gpu,
+    qgamma_gpu,
+    qnorm_gpu,
+    qpois_gpu,
+    qt_gpu,
+    rbeta_gpu,
+    rbinom_gpu,
+    rchisq_gpu,
+    rf_gpu,
+    rgamma_gpu,
+    rnorm_gpu,
+    rpois_gpu,
+    rt_gpu,
+    t_cdf_gpu,
+    t_ppf_gpu,
+    t_sf_gpu,
+    t_two_sided_critical_value_gpu,
+    t_two_sided_pvalue_gpu,
+)
+from ._multiple_testing import adjust_pvalues, combine_pvalues, multipletests
+from ._results import (
+    BaseInferenceResult,
+    DebiasedInferenceResult,
+    GaussianInferenceResult,
+    OracleActiveSetInferenceResult,
+    ParameterInferenceResult,
+    ResamplingInferenceResult,
+)
+from ._resampling import (
+    BootstrapResult,
+    PermutationTestResult,
+    bootstrap_statistic,
+    permutation_test,
+)
+try:
+    from statgpu.nonparametric.kernel_smoothing._kde import (
+        KDE,
+        KDEBootstrapResult,
+        fit_kde,
+        kde_pdf,
+        kde_bootstrap_confidence_interval,
+    )
+except ImportError:
+    KDE = None
+    KDEBootstrapResult = None
+    fit_kde = None
+    kde_pdf = None
+    kde_bootstrap_confidence_interval = None
+
+__all__ = [
+    "adjust_pvalues",
+    "combine_pvalues",
+    "multipletests",
+    # Inference results
+    "BaseInferenceResult",
+    "ParameterInferenceResult",
+    "GaussianInferenceResult",
+    "DebiasedInferenceResult",
+    "OracleActiveSetInferenceResult",
+    "ResamplingInferenceResult",
+    # Distribution base classes
+    "NormDistributionBase",
+    "TDistributionBase",
+    "UniformDistributionBase",
+    "ExponDistributionBase",
+    "CauchyDistributionBase",
+    "LaplaceDistributionBase",
+    "LogisticDistributionBase",
+    "Chi2DistributionBase",
+    "GammaDistributionBase",
+    "BetaDistributionBase",
+    "FDistributionBase",
+    "WeibullMinDistributionBase",
+    "LognormDistributionBase",
+    "PoissonDistributionBase",
+    "BinomDistributionBase",
+    "ScipyFallbackDistribution",
+    # Factory
+    "get_distribution",
+    "get_distribution_gpu",
+    "list_available_distributions",
+    "list_available_distributions_gpu",
+    # Module-level proxies
+    "norm", "t", "uniform", "expon", "cauchy", "laplace",
+    "logistic", "chi2", "gamma", "beta", "f",
+    "weibull_min", "lognorm", "poisson", "binom",
+    # Legacy GPU names (backward compat)
+    "NormDistributionGPU",
+    "TDistributionGPU",
+    "UniformDistributionGPU",
+    "ExponDistributionGPU",
+    "CauchyDistributionGPU",
+    "LaplaceDistributionGPU",
+    "LogisticDistributionGPU",
+    "Chi2DistributionGPU",
+    "GammaDistributionGPU",
+    "BetaDistributionGPU",
+    "FDistributionGPU",
+    "WeibullMinDistributionGPU",
+    "LognormDistributionGPU",
+    "PoissonDistributionGPU",
+    "BinomDistributionGPU",
+    # Legacy function names
+    "norm_cdf_gpu",
+    "norm_isf_gpu",
+    "norm_ppf_gpu",
+    "norm_sf_gpu",
+    "norm_two_sided_critical_value_gpu",
+    "norm_two_sided_pvalue_gpu",
+    "t_cdf_gpu",
+    "t_ppf_gpu",
+    "t_sf_gpu",
+    "t_two_sided_critical_value_gpu",
+    "t_two_sided_pvalue_gpu",
+    "dnorm_gpu",
+    "pnorm_gpu",
+    "qnorm_gpu",
+    "rnorm_gpu",
+    "dt_gpu",
+    "pt_gpu",
+    "qt_gpu",
+    "rt_gpu",
+    "dchisq_gpu",
+    "pchisq_gpu",
+    "qchisq_gpu",
+    "rchisq_gpu",
+    "dgamma_gpu",
+    "pgamma_gpu",
+    "qgamma_gpu",
+    "rgamma_gpu",
+    "dbeta_gpu",
+    "pbeta_gpu",
+    "qbeta_gpu",
+    "rbeta_gpu",
+    "df_gpu",
+    "pf_gpu",
+    "qf_gpu",
+    "rf_gpu",
+    "dpois_gpu",
+    "ppois_gpu",
+    "qpois_gpu",
+    "rpois_gpu",
+    "dbinom_gpu",
+    "pbinom_gpu",
+    "qbinom_gpu",
+    "rbinom_gpu",
+    # Resampling
+    "BootstrapResult",
+    "PermutationTestResult",
+    "bootstrap_statistic",
+    "permutation_test",
+    # KDE
+    "KDE",
+    "KDEBootstrapResult",
+    "fit_kde",
+    "kde_pdf",
+    "kde_bootstrap_confidence_interval",
+]