gpu-glm 0.1.0__tar.gz

gpu_glm-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Greg McMahan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

gpu_glm-0.1.0/PKG-INFO

@@ -0,0 +1,72 @@
+Metadata-Version: 2.4
+Name: gpu-glm
+Version: 0.1.0
+Summary: Regularized GLM models running on a GPU.
+Author-email: Greg McMahan <gmcmacran@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/gmcmacran/gpu_glm
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=2.4.3
+Requires-Dist: scipy>=1.17.1
+Provides-Extra: gpu
+Requires-Dist: cupy>=14.0.1; extra == "gpu"
+Provides-Extra: dev
+Requires-Dist: numpy>=2.4.3; extra == "dev"
+Requires-Dist: scipy>=1.17.1; extra == "dev"
+Requires-Dist: scikit-learn>=1.8.0; extra == "dev"
+Requires-Dist: pytest>=9.0.2; extra == "dev"
+Requires-Dist: ruff>=0.15.1; extra == "dev"
+Requires-Dist: pre-commit>=4.5.1; extra == "dev"
+Requires-Dist: mkdocs>=1.6.1; extra == "dev"
+Requires-Dist: mkdocs-material>=9.7.1; extra == "dev"
+Requires-Dist: mkdocstrings[python]>=1.0.3; extra == "dev"
+Dynamic: license-file
+
+# gpu_glm
+
+A lightweight Python implementation of Generalized Linear Models (GLMs) that runs on a GPU. 
+
+This package provides:
+
+- Gaussian, Bernoulli, Poisson, Gamma, and Inverse Gaussian models.
+- Multiple link functions (identity, log, inverse, logit, probit, etc.)
+- A Cupy-based implementation that falls back to Numpy.
+- A sci-kit learn interface.
+- L2 regularization.
+
+---
+
+## Installation
+To use the GPU, cupy must be installed with a GPU dependancies already working. If cupy is unavailable, numpy is used.  
+
+```bash
+pip install gpu-glm
+```
+
+A conda package to handle GPU dependancies is under development.
+
+
+## Quick Example
+
+Below fits a linear regression model.
+
+```python
+import numpy as np
+from gpu_glm import gaussian_glm
+from sklearn.metrics import root_mean_squared_error
+
+# Simulated data
+X = np.column_stack([np.random.randn(100), np.ones(100)])
+y = 2 * X[:, 0] + 3 +  np.random.randn(100)
+
+# Fit model
+model = gaussian_glm()
+model.fit(X, y)
+print(f"coefficients: {model.coef()}")
+
+y_hat = model.predict(X)
+rmse = root_mean_squared_error(y, y_hat)
+print(f"RMSE: {np.round(rmse, 3)}")
+```

gpu_glm-0.1.0/README.md

@@ -0,0 +1,46 @@
+# gpu_glm
+
+A lightweight Python implementation of Generalized Linear Models (GLMs) that runs on a GPU. 
+
+This package provides:
+
+- Gaussian, Bernoulli, Poisson, Gamma, and Inverse Gaussian models.
+- Multiple link functions (identity, log, inverse, logit, probit, etc.)
+- A Cupy-based implementation that falls back to Numpy.
+- A sci-kit learn interface.
+- L2 regularization.
+
+---
+
+## Installation
+To use the GPU, cupy must be installed with a GPU dependancies already working. If cupy is unavailable, numpy is used.  
+
+```bash
+pip install gpu-glm
+```
+
+A conda package to handle GPU dependancies is under development.
+
+
+## Quick Example
+
+Below fits a linear regression model.
+
+```python
+import numpy as np
+from gpu_glm import gaussian_glm
+from sklearn.metrics import root_mean_squared_error
+
+# Simulated data
+X = np.column_stack([np.random.randn(100), np.ones(100)])
+y = 2 * X[:, 0] + 3 +  np.random.randn(100)
+
+# Fit model
+model = gaussian_glm()
+model.fit(X, y)
+print(f"coefficients: {model.coef()}")
+
+y_hat = model.predict(X)
+rmse = root_mean_squared_error(y, y_hat)
+print(f"RMSE: {np.round(rmse, 3)}")
+```

gpu_glm-0.1.0/pyproject.toml

@@ -0,0 +1,54 @@
+[build-system]
+requires = ["setuptools>=69.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "gpu-glm"
+version = "0.1.0"
+description = "Regularized GLM models running on a GPU."
+readme = "README.md"
+requires-python = ">=3.12"
+license = "MIT"
+
+authors = [
+    { name = "Greg McMahan", email = "gmcmacran@gmail.com" }
+]
+
+# IMPORTANT:
+# Do NOT list CuPy here if you want Conda to install it.
+# These dependencies must be CPU‑safe and pip‑installable everywhere.
+dependencies = [
+    "numpy>=2.4.3",
+    "scipy>=1.17.1"
+]
+
+[project.optional-dependencies]
+# Users who want GPU support can install this extra via pip,
+# but Conda users will ignore it and install CuPy themselves.
+gpu = [
+    "cupy>=14.0.1"
+]
+
+dev = [
+    "numpy>=2.4.3",
+    "scipy>=1.17.1",
+    "scikit-learn>=1.8.0",
+    "pytest>=9.0.2",
+    "ruff>=0.15.1",
+    "pre-commit>=4.5.1",
+    "mkdocs>=1.6.1",
+    "mkdocs-material>=9.7.1",
+    "mkdocstrings[python]>=1.0.3"
+]
+
+[project.urls]
+Homepage = "https://github.com/gmcmacran/gpu_glm"
+
+[tool.ruff]
+line-length = 88
+target-version = "py313"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "B", "UP", "SIM", "C4"]
+
+[tool.ruff.format]

gpu_glm-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

gpu_glm-0.1.0/src/gpu_glm/__init__.py

@@ -0,0 +1,15 @@
+from .models import (
+    bernoulli_glm,
+    gamma_glm,
+    gaussian_glm,
+    inverse_gaussian_glm,
+    poisson_glm,
+)
+
+__all__ = [
+    "gaussian_glm",
+    "bernoulli_glm",
+    "poisson_glm",
+    "gamma_glm",
+    "inverse_gaussian_glm",
+]

gpu_glm-0.1.0/src/gpu_glm/models.py

@@ -0,0 +1,480 @@
+from abc import ABC, ABCMeta, abstractmethod
+
+import numpy as _np
+
+try:
+    import cupy as _cp
+
+    CUPY_AVAILABLE = True
+except ImportError:
+    _cp = None
+    CUPY_AVAILABLE = False
+
+import scipy.stats as stats
+
+
+def xp():
+    """Return the active array module (CuPy if available, else NumPy)."""
+    return _cp if CUPY_AVAILABLE else _np
+
+
+def backend_info():
+    """
+    Return a human‑readable description of the active compute backend.
+
+    Returns
+    -------
+    str
+        A multi‑line string describing whether the package is using
+        NumPy (CPU) or CuPy (GPU), and GPU details if available.
+    """
+    if not CUPY_AVAILABLE:
+        return "Backend: NumPy (CPU)\nCuPy not installed. All computations run on CPU."
+
+    # CuPy is available → gather GPU info
+    try:
+        device_id = _cp.cuda.runtime.getDevice()
+        props = _cp.cuda.runtime.getDeviceProperties(device_id)
+
+        name = props["name"].decode("utf-8")
+        total_mem = props["totalGlobalMem"] / (1024**3)
+        mp_count = props["multiProcessorCount"]
+
+        cuda_rt = _cp.cuda.runtime.runtimeGetVersion()
+        cuda_drv = _cp.cuda.runtime.driverGetVersion()
+
+        return (
+            "Backend: CuPy (GPU)\n"
+            f"Device: {name}\n"
+            f"Total Memory: {total_mem:.2f} GB\n"
+            f"Multiprocessors: {mp_count}\n"
+            f"CUDA Runtime Version: {cuda_rt}\n"
+            f"CUDA Driver Version: {cuda_drv}"
+        )
+
+    except Exception as e:
+        # Fallback if GPU query fails
+        return (
+            "Backend: CuPy (GPU)\n"
+            "CuPy is installed, but GPU properties could not be retrieved.\n"
+            f"Error: {e}"
+        )
+
+
+class IRLS(ABC):
+    """
+    Base class implementing the Iteratively Reweighted Least Squares (IRLS)
+    algorithm for fitting Generalized Linear Models (GLMs).
+
+    Subclasses must implement:
+
+    - ``_var_mu(mu)``: variance function of the mean
+    - ``_a_of_phi(Y, mu, B)``: dispersion-related function
+
+    Parameters
+    ----------
+    link : str
+        Name of the link function. Supported values depend on the subclass.
+    alpha : float, default=0.0
+        L2 regularization strength. Matches scikit-learn's ``alpha``
+        parameter in ``PoissonRegressor``, ``GammaRegressor``, etc.
+        The penalty term is ``(alpha / 2) * ||coef||^2``. The intercept
+        is not regularized.
+    """
+
+    __metaclass__ = ABCMeta
+
+    def __init__(self, link, alpha=0.0):
+        """
+        Initialize the IRLS model.
+
+        Parameters
+        ----------
+        link : str
+            The link function to use (e.g., ``"identity"``, ``"log"``,
+            ``"logit"``, ``"inverse"``, ``"probit"``, ``"sqrt"``,
+            ``"1/mu^2"``).
+        alpha : float, default=0.0
+            L2 regularization strength. The penalty is
+            ``(alpha / 2) * ||coef||^2``. The intercept is excluded
+            from regularization.
+        """
+        if alpha >= 0.0:
+            self._alpha = alpha
+        else:
+            raise ValueError(f"Invalid alpha: {alpha}. Alpha must be non-negative.")
+        self._B = None
+        self._link = link
+        self._alpha = alpha
+        super().__init__()
+
+    # -----------------------------
+    # Backend helpers
+    # -----------------------------
+    def _to_backend(self, arr):
+        """Convert input to backend array (CuPy if available, else NumPy)."""
+        if CUPY_AVAILABLE:
+            return _cp.asarray(arr)
+        return _np.asarray(arr)
+
+    def _to_numpy(self, arr):
+        """Convert backend array to NumPy (for SciPy/stats)."""
+        if CUPY_AVAILABLE:
+            return _cp.asnumpy(arr)
+        return arr
+
+    # -----------------------------
+    # Public API
+    # -----------------------------
+    def coef(self):
+        """
+        Return the fitted coefficient vector.
+
+        Returns
+        -------
+        np.ndarray
+            The coefficient vector ``B`` of shape ``(n_features,)``.
+        """
+        return self._to_numpy(self._B)
+
+    def fit(self, X, Y):
+        """
+        Fit the GLM using the IRLS algorithm.
+
+        Parameters
+        ----------
+        X : np.ndarray, shape (n_samples, n_features)
+            Design matrix.
+        Y : np.ndarray, shape (n_samples,)
+            Response vector.
+        """
+        xp_backend = xp()
+
+        # Convert to backend (CuPy or NumPy)
+        X = self._to_backend(X)
+        Y = self._to_backend(Y)
+
+        # Add intercept column if missing
+        if not xp_backend.allclose(X[:, -1], 1):
+            ones = xp_backend.ones((X.shape[0], 1))
+            X = xp_backend.concatenate([X, ones], axis=1)
+
+        n_features = X.shape[1]
+
+        # Initialize coefficients
+        self._B = xp_backend.zeros(n_features)
+        self._B[-1] = Y.mean()
+
+        tol = 1e6
+        while tol > 1e-5:
+            eta = X.dot(self._B)
+            mu = self._inv_link(eta)
+
+            # Vectorized weights
+            w = (
+                1 / (self._var_mu(mu) * self._a_of_phi(Y, mu, self._B))
+            ) * xp_backend.power(self._del_eta_del_mu(mu), 2)
+
+            # Vectorized z
+            z = (Y - mu) * self._del_eta_del_mu(mu) + eta
+
+            # Weighted least squares without forming diag(W)
+            # X^T W X  ==  (X * w[:, None]).T @ X
+            Xw = X * w[:, None]
+            XtWX = Xw.T.dot(X)
+            XtWz = Xw.T.dot(z)
+
+            # L2 regularization: add alpha to diagonal (exclude intercept)
+            if self._alpha > 0:
+                n_coef = n_features - 1
+                XtWX[:n_coef, :n_coef] += self._alpha * xp_backend.eye(n_coef)
+
+            # Solve for update
+            B_new = xp_backend.linalg.solve(XtWX, XtWz)
+
+            tol = xp_backend.sum(xp_backend.abs(B_new - self._B))
+            self._B = B_new
+
+        return self
+
+    def predict(self, X):
+        """
+        Predict the mean response for new data.
+
+        Parameters
+        ----------
+        X : np.ndarray, shape (n_samples, n_features)
+            Design matrix.
+
+        Returns
+        -------
+        np.ndarray
+            Predicted mean response ``mu``.
+        """
+        xp_backend = xp()
+        Xb = self._to_backend(X)
+        # Add intercept column if missing
+        if not xp_backend.allclose(Xb[:, -1], 1):
+            ones = xp_backend.ones((Xb.shape[0], 1))
+            Xb = xp_backend.concatenate([Xb, ones], axis=1)
+        eta = Xb.dot(self._B)
+        mu = self._inv_link(eta)
+        return self._to_numpy(mu)
+
+    # -----------------------------
+    # Link functions
+    # -----------------------------
+    def _inv_link(self, eta):
+        """
+        Apply the inverse link function.
+
+        Parameters
+        ----------
+        eta : np.ndarray
+            Linear predictor.
+
+        Returns
+        -------
+        np.ndarray
+            Mean response ``mu``.
+        """
+        xp_backend = xp()
+
+        if self._link == "identity":
+            return eta
+        elif self._link == "log":
+            return xp_backend.exp(eta)
+        elif self._link == "inverse":
+            return 1 / eta
+        elif self._link == "logit":
+            e = xp_backend.exp(eta)
+            return e / (1 + e)
+        elif self._link == "probit":
+            eta_np = self._to_numpy(eta)
+            return self._to_backend(stats.norm.cdf(eta_np))
+        elif self._link == "sqrt":
+            return xp_backend.power(eta, 2)
+        elif self._link == "1/mu^2":
+            return 1 / xp_backend.power(eta, 0.5)
+
+    def _del_eta_del_mu(self, mu):
+        """
+        Compute derivative :math:`d\\eta/d\\mu` for the link function.
+
+        Parameters
+        ----------
+        mu : np.ndarray
+            Mean response.
+
+        Returns
+        -------
+        np.ndarray
+            Derivative ``dη/dμ`` evaluated at ``mu``.
+        """
+        xp_backend = xp()
+
+        if self._link == "identity":
+            return xp_backend.ones(mu.shape)
+        elif self._link == "log":
+            return 1 / mu
+        elif self._link == "inverse":
+            return -1 / xp_backend.power(mu, 2)
+        elif self._link == "logit":
+            return 1 / (mu * (1 - mu))
+        elif self._link == "probit":
+            mu_np = self._to_numpy(mu)
+            return self._to_backend(stats.norm.pdf(stats.norm.ppf(mu_np)))
+        elif self._link == "sqrt":
+            return 0.5 * xp_backend.power(mu, -0.5)
+        elif self._link == "1/mu^2":
+            return -2 / xp_backend.power(mu, 3)
+
+    # -----------------------------
+    # Abstract variance + dispersion
+    # -----------------------------
+    @abstractmethod
+    def _var_mu(self, mu):
+        """
+        Variance function :math:`\\mathrm{Var}(Y \\mid \\mu)`.
+
+        Parameters
+        ----------
+        mu : np.ndarray
+            Mean response.
+
+        Returns
+        -------
+        np.ndarray
+            Variance evaluated at ``mu``.
+        """
+        pass
+
+    @abstractmethod
+    def _a_of_phi(self, Y, mu, B):
+        """
+        Dispersion-related function :math:`a(\\phi)`.
+
+        Parameters
+        ----------
+        Y : np.ndarray
+            Observed response.
+        mu : np.ndarray
+            Mean response.
+        B : np.ndarray
+            Coefficient vector.
+
+        Returns
+        -------
+        np.ndarray or float
+            Dispersion-related quantity.
+        """
+        pass
+
+
+# -----------------------------
+# GLM Subclasses
+# -----------------------------
+class gaussian_glm(IRLS):
+    """
+    Gaussian GLM with identity, log, or inverse link.
+
+    Parameters
+    ----------
+    link : str, default="identity"
+        Link function. One of ``"identity"``, ``"log"``, ``"inverse"``.
+    alpha : float, default=0.0
+        L2 regularization strength.
+    """
+
+    def __init__(self, link="identity", alpha=0.0):
+        if link in ("identity", "log", "inverse"):
+            super().__init__(link, alpha=alpha)
+        else:
+            raise ValueError(f"Invalid link: {link}")
+
+    def _var_mu(self, mu):
+        return xp().ones(mu.shape)
+
+    def _a_of_phi(self, Y, mu, B):
+        xp_backend = xp()
+        return xp_backend.sum((Y - mu) ** 2) / (Y.shape[0] - B.shape[0])
+
+
+class bernoulli_glm(IRLS):
+    """
+    Bernoulli GLM with logit or probit link.
+
+    Parameters
+    ----------
+    link : str, default="logit"
+        Link function. One of ``"logit"``, ``"probit"``.
+    alpha : float, default=0.0
+        L2 regularization strength.
+    """
+
+    def __init__(self, link="logit", alpha=0.0):
+        if link in ("logit", "probit"):
+            super().__init__(link, alpha=alpha)
+        else:
+            raise ValueError(f"Invalid link: {link}")
+
+    def _var_mu(self, mu):
+        return mu * (1 - mu)
+
+    def _a_of_phi(self, Y, mu, B):
+        return xp().ones(Y.shape[0])
+
+    def predict_proba(self, X):
+        xp_backend = xp()
+        Xb = self._to_backend(X)
+        # Add intercept column if missing
+        if not xp_backend.allclose(Xb[:, -1], 1):
+            ones = xp_backend.ones((Xb.shape[0], 1))
+            Xb = xp_backend.concatenate([Xb, ones], axis=1)
+        props = self._inv_link(Xb.dot(self._B))
+        props = self._to_numpy(props)
+        return _np.column_stack([1 - props, props])
+
+    def predict(self, X):
+        probs = self.predict_proba(X)
+        return (probs[:, 1] > 0.5).astype(int)
+
+
+class poisson_glm(IRLS):
+    """
+    Poisson GLM with log, identity, or sqrt link.
+
+    Parameters
+    ----------
+    link : str, default="log"
+        Link function. One of ``"log"``, ``"identity"``, ``"sqrt"``.
+    alpha : float, default=0.0
+        L2 regularization strength.
+    """
+
+    def __init__(self, link="log", alpha=0.0):
+        if link in ("log", "identity", "sqrt"):
+            super().__init__(link, alpha=alpha)
+        else:
+            raise ValueError(f"Invalid link: {link}")
+
+    def _var_mu(self, mu):
+        return mu
+
+    def _a_of_phi(self, Y, mu, B):
+        return xp().ones(Y.shape[0])
+
+
+class gamma_glm(IRLS):
+    """
+    Gamma GLM with inverse, identity, or log link.
+
+    Parameters
+    ----------
+    link : str, default="inverse"
+        Link function. One of ``"inverse"``, ``"identity"``, ``"log"``.
+    alpha : float, default=0.0
+        L2 regularization strength.
+    """
+
+    def __init__(self, link="inverse", alpha=0.0):
+        if link in ("inverse", "identity", "log"):
+            super().__init__(link, alpha=alpha)
+        else:
+            raise ValueError(f"Invalid link: {link}")
+
+    def _var_mu(self, mu):
+        return mu**2
+
+    def _a_of_phi(self, Y, mu, B):
+        xp_backend = xp()
+        numerator = (Y - mu) ** 2
+        denominator = mu**2 * (Y.shape[0] - B.shape[0])
+        phi = xp_backend.sum(numerator / denominator)
+        return xp_backend.ones(Y.shape[0]) * phi
+
+
+class inverse_gaussian_glm(IRLS):
+    """
+    Inverse Gaussian GLM with 1/μ², inverse, identity, or log link.
+
+    Parameters
+    ----------
+    link : str, default="1/mu^2"
+        Link function. One of ``"1/mu^2"``, ``"inverse"``, ``"identity"``, ``"log"``.
+    alpha : float, default=0.0
+        L2 regularization strength.
+    """
+
+    def __init__(self, link="1/mu^2", alpha=0.0):
+        if link in ("1/mu^2", "inverse", "identity", "log"):
+            super().__init__(link, alpha=alpha)
+        else:
+            raise ValueError(f"Invalid link: {link}")
+
+    def _var_mu(self, mu):
+        return mu**3
+
+    def _a_of_phi(self, Y, mu, B):
+        xp_backend = xp()
+        return -xp_backend.sum((Y - mu) ** 2) / (Y.shape[0] - B.shape[0])