space-graph 0.1.0__tar.gz

space_graph-0.1.0/LICENSE

@@ -0,0 +1,16 @@
+GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007
+
+Copyright (C) 2025 space_graph authors
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <https://www.gnu.org/licenses/>.

space_graph-0.1.0/PKG-INFO

@@ -0,0 +1,81 @@
+Metadata-Version: 2.4
+Name: space-graph
+Version: 0.1.0
+Summary: Pure Python SPACE: sparse partial correlation estimation
+License: GPL-3.0-or-later
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.20
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+Provides-Extra: numba
+Requires-Dist: numba>=0.57; extra == "numba"
+Dynamic: license-file
+
+# space-graph
+
+[![PyPI version](https://img.shields.io/pypi/v/space-graph)](https://pypi.org/project/space-graph/)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10%2B-blue.svg)](https://www.python.org/downloads/)
+[![License: GPL-3.0-or-later](https://img.shields.io/badge/license-GPL--3.0--or--later-blue.svg)](LICENSE)
+
+Pure Python implementation of **SPACE** (Sparse Partial Correlation Estimation) from Peng et al. (2009), with no R or C dependencies.
+
+Paper: [Sparse Partial Correlation Estimation for High-Dimensional Data](https://www.tandfonline.com/doi/abs/10.1198/jasa.2009.0126)
+
+## Install
+
+```bash
+pip install space-graph
+```
+
+Optional Numba (faster inner `jsrm` loop):
+
+```bash
+pip install 'space-graph[numba]'
+```
+
+From GitHub:
+
+```bash
+pip install git+https://github.com/shahrozeabbas/space-graph.git
+```
+
+## Usage
+
+```python
+import numpy as np
+from space_graph import SPACE
+
+X = np.random.randn(20, 5)
+model = SPACE(
+    alpha=0.7,
+    max_outer_iter=2,
+    max_inner_iter=500,
+    tol=1e-6,
+    weight='uniform',
+)
+model.fit(X)
+print(model.partial_correlation_)
+```
+
+## Penalty
+
+The public parameter `alpha` in `[0, 1]` maps to inner penalties as `lam1 = alpha` and `lam2 = 1 - alpha`, matching the reference elastic-net-style JSRM solver.
+
+## Options
+
+- **`tol`** (default `1e-6`): inner coordinate-descent stopping tolerance (and active-set threshold), same scale as the reference C code.
+- **`weight`**: default **`uniform`** (unit weights). Use **`equal`** as an alias. Other modes: **`sig`**, **`degree`**, or a custom positive vector of length `p`.
+
+## Tests
+
+```bash
+pytest
+```
+
+Optional: build `libjsrm_test.so` from `../space/src/JSRM.c` to run the ctypes cross-check in `tests/test_space.py`.
+
+## License
+
+GPL-3.0-or-later (same family as the original `space` R package).

space_graph-0.1.0/README.md

@@ -0,0 +1,66 @@
+# space-graph
+
+[![PyPI version](https://img.shields.io/pypi/v/space-graph)](https://pypi.org/project/space-graph/)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10%2B-blue.svg)](https://www.python.org/downloads/)
+[![License: GPL-3.0-or-later](https://img.shields.io/badge/license-GPL--3.0--or--later-blue.svg)](LICENSE)
+
+Pure Python implementation of **SPACE** (Sparse Partial Correlation Estimation) from Peng et al. (2009), with no R or C dependencies.
+
+Paper: [Sparse Partial Correlation Estimation for High-Dimensional Data](https://www.tandfonline.com/doi/abs/10.1198/jasa.2009.0126)
+
+## Install
+
+```bash
+pip install space-graph
+```
+
+Optional Numba (faster inner `jsrm` loop):
+
+```bash
+pip install 'space-graph[numba]'
+```
+
+From GitHub:
+
+```bash
+pip install git+https://github.com/shahrozeabbas/space-graph.git
+```
+
+## Usage
+
+```python
+import numpy as np
+from space_graph import SPACE
+
+X = np.random.randn(20, 5)
+model = SPACE(
+    alpha=0.7,
+    max_outer_iter=2,
+    max_inner_iter=500,
+    tol=1e-6,
+    weight='uniform',
+)
+model.fit(X)
+print(model.partial_correlation_)
+```
+
+## Penalty
+
+The public parameter `alpha` in `[0, 1]` maps to inner penalties as `lam1 = alpha` and `lam2 = 1 - alpha`, matching the reference elastic-net-style JSRM solver.
+
+## Options
+
+- **`tol`** (default `1e-6`): inner coordinate-descent stopping tolerance (and active-set threshold), same scale as the reference C code.
+- **`weight`**: default **`uniform`** (unit weights). Use **`equal`** as an alias. Other modes: **`sig`**, **`degree`**, or a custom positive vector of length `p`.
+
+## Tests
+
+```bash
+pytest
+```
+
+Optional: build `libjsrm_test.so` from `../space/src/JSRM.c` to run the ctypes cross-check in `tests/test_space.py`.
+
+## License
+
+GPL-3.0-or-later (same family as the original `space` R package).

space_graph-0.1.0/pyproject.toml

@@ -0,0 +1,25 @@
+[build-system]
+requires = ['setuptools>=61', 'wheel']
+build-backend = 'setuptools.build_meta'
+
+[project]
+name = 'space-graph'
+version = '0.1.0'
+description = 'Pure Python SPACE: sparse partial correlation estimation'
+readme = 'README.md'
+requires-python = '>=3.10'
+license = { text = 'GPL-3.0-or-later' }
+dependencies = [
+    'numpy>=1.20',
+]
+
+[project.optional-dependencies]
+dev = ['pytest>=7']
+numba = ['numba>=0.57']
+
+[tool.setuptools]
+packages = ['space_graph']
+
+[tool.pytest.ini_options]
+testpaths = ['tests']
+pythonpath = ['.']

space_graph-0.1.0/setup.cfg

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

space_graph-0.1.0/space_graph/__init__.py

@@ -0,0 +1,4 @@
+from .model import SPACE
+
+__all__ = ['SPACE', '__version__']
+__version__ = '0.1.0'

space_graph-0.1.0/space_graph/kernels.py

@@ -0,0 +1,183 @@
+"""
+Numba-compiled JSRM shooting loop (optional).
+
+Install with ``pip install 'space-graph[numba]'`` or ``pip install numba``.
+If Numba is not installed, ``jsrm_shooting_loop`` is ``None`` and ``solver.jsrm``
+uses the pure NumPy loop.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+
+
+def _try_build_shooting_loop():
+    try:
+        from numba import njit
+    except ImportError:
+        return None
+
+    @njit(cache=True)
+    def jsrm_shooting_loop(
+        Y_m: np.ndarray,
+        E_m: np.ndarray,
+        beta_new: np.ndarray,
+        beta_old: np.ndarray,
+        beta_last: np.ndarray,
+        B: np.ndarray,
+        B_s: np.ndarray,
+        lambda1: float,
+        lambda2: float,
+        n: int,
+        p: int,
+        n_iter: int,
+        change_i: int,
+        change_j: int,
+        beta_change: float,
+        tol: float,
+    ) -> None:
+        """In-place shooting iterations (matches ``solver`` Python loop)."""
+        eps1 = tol
+        maxdif_tol = tol
+        for _ in range(n_iter):
+            for ii in range(p):
+                for jj in range(p):
+                    beta_last[ii, jj] = beta_new[ii, jj]
+
+            nrow_pick = 0
+            for j in range(p - 1, 0, -1):
+                for i in range(j - 1, -1, -1):
+                    b = beta_new[i, j]
+                    if b > eps1 or b < -eps1:
+                        nrow_pick += 1
+
+            maxdif = -100.0
+
+            if nrow_pick > 0:
+                for j in range(p - 1, 0, -1):
+                    for i in range(j - 1, -1, -1):
+                        cur_i = i
+                        cur_j = j
+                        b = beta_new[cur_i, cur_j]
+                        if not (b > eps1 or b < -eps1):
+                            continue
+
+                        beta_old[change_i, change_j] = beta_new[
+                            change_i, change_j
+                        ]
+                        beta_old[change_j, change_i] = beta_new[
+                            change_j, change_i
+                        ]
+
+                        c1 = beta_change * B[change_j, change_i]
+                        c2 = beta_change * B[change_i, change_j]
+                        for kk in range(n):
+                            E_m[kk, change_i] += Y_m[kk, change_j] * c1
+                            E_m[kk, change_j] += Y_m[kk, change_i] * c2
+
+                        aij = 0.0
+                        aji = 0.0
+                        for kk in range(n):
+                            aij += E_m[kk, cur_j] * Y_m[kk, cur_i]
+                            aji += E_m[kk, cur_i] * Y_m[kk, cur_j]
+                        aij *= B[cur_i, cur_j]
+                        aji *= B[cur_j, cur_i]
+
+                        b_s = B_s[cur_i, cur_j]
+                        beta_next = (aij + aji) / b_s + beta_old[cur_i, cur_j]
+                        temp1 = beta_next
+                        if beta_next > 0.0:
+                            temp = beta_next - lambda1 / b_s
+                        else:
+                            temp = -beta_next - lambda1 / b_s
+                        if temp < 0.0:
+                            temp = 0.0
+                        else:
+                            temp = temp / (1.0 + lambda2)
+                            if temp1 < 0.0:
+                                temp = -temp
+
+                        beta_new[cur_i, cur_j] = temp
+                        beta_new[cur_j, cur_i] = temp
+
+                        beta_change = beta_old[cur_i, cur_j] - temp
+                        change_i = cur_i
+                        change_j = cur_j
+
+                maxdif = -100.0
+                for ii in range(p):
+                    for jj in range(p):
+                        d = beta_last[ii, jj] - beta_new[ii, jj]
+                        if d < 0.0:
+                            d = -d
+                        if d > maxdif:
+                            maxdif = d
+
+            if maxdif < maxdif_tol or nrow_pick < 1:
+                for ii in range(p):
+                    for jj in range(p):
+                        beta_last[ii, jj] = beta_new[ii, jj]
+
+                for cur_i in range(p - 1):
+                    for cur_j in range(cur_i + 1, p):
+                        beta_old[change_i, change_j] = beta_new[
+                            change_i, change_j
+                        ]
+                        beta_old[change_j, change_i] = beta_new[
+                            change_j, change_i
+                        ]
+
+                        if beta_change < -eps1 or beta_change > eps1:
+                            c1 = beta_change * B[change_j, change_i]
+                            c2 = beta_change * B[change_i, change_j]
+                            for kk in range(n):
+                                E_m[kk, change_i] += Y_m[kk, change_j] * c1
+                                E_m[kk, change_j] += Y_m[kk, change_i] * c2
+
+                        aij = 0.0
+                        aji = 0.0
+                        for kk in range(n):
+                            aij += E_m[kk, cur_j] * Y_m[kk, cur_i]
+                            aji += E_m[kk, cur_i] * Y_m[kk, cur_j]
+                        aij *= B[cur_i, cur_j]
+                        aji *= B[cur_j, cur_i]
+
+                        b_s = B_s[cur_i, cur_j]
+                        beta_next = (aij + aji) / b_s + beta_old[
+                            cur_i, cur_j
+                        ]
+                        temp1 = beta_next
+                        if beta_next > 0.0:
+                            temp = beta_next - lambda1 / b_s
+                        else:
+                            temp = -beta_next - lambda1 / b_s
+                        if temp < 0.0:
+                            temp = 0.0
+                        else:
+                            temp = temp / (1.0 + lambda2)
+                            if temp1 < 0.0:
+                                temp = -temp
+
+                        beta_new[cur_i, cur_j] = temp
+                        beta_new[cur_j, cur_i] = temp
+
+                        beta_change = beta_old[cur_i, cur_j] - temp
+                        change_i = cur_i
+                        change_j = cur_j
+
+                maxdif = -100.0
+                for ii in range(p):
+                    for jj in range(p):
+                        d = beta_last[ii, jj] - beta_new[ii, jj]
+                        if d < 0.0:
+                            d = -d
+                        if d > maxdif:
+                            maxdif = d
+
+                if maxdif < maxdif_tol:
+                    return
+
+    return jsrm_shooting_loop
+
+
+jsrm_shooting_loop = _try_build_shooting_loop()

space_graph-0.1.0/space_graph/model.py

@@ -0,0 +1,132 @@
+"""Public SPACE estimator."""
+
+from __future__ import annotations
+
+from typing import Optional, Union
+
+import numpy as np
+
+from .penalties import alpha_to_penalties
+from .solver import jsrm
+from .utils import (
+    beta_coef_from_rho_upper,
+    inv_sig_diag_new,
+    partial_corr_to_precision,
+    standardize_columns_l2,
+)
+from .weights import WeightInput, rescale_degree_weights, resolve_weight
+
+
+class SPACE:
+    """
+    Sparse partial correlation estimation (SPACE), joint sparse regression.
+
+    Parameters
+    ----------
+    alpha : float in [0, 1]
+        Mix parameter: inner penalties are ``lam1 = alpha``, ``lam2 = 1 - alpha``.
+    weight : {'uniform', 'equal', 'sig', 'degree'} or ndarray of shape (p,)
+        Node weights for the joint loss (see Peng et al. and R package).
+        ``uniform`` and ``equal`` both mean unit weights (no reweighting).
+    max_outer_iter : int
+        Outer alternations for ``sig`` / weights (R ``iter``).
+    max_inner_iter : int
+        Max iterations for the inner JSRM solver.
+    tol : float
+        Inner solver tolerance: convergence and active-set threshold (default
+        ``1e-6``, same scale as the reference C implementation).
+    standardize : bool
+        If True, center columns and scale to unit L2 norm before fitting.
+    fit_sig : bool
+        If True, estimate diagonal ``sig^{ii}`` each outer step (when not fixed).
+    sig : ndarray of shape (p,) or None
+        Initial or fixed ``sig^{ii}``. If provided and ``fit_sig`` is False, held fixed.
+    """
+
+    def __init__(
+        self,
+        alpha: float = 1.0,
+        weight: WeightInput = 'uniform',
+        max_outer_iter: int = 5,
+        max_inner_iter: int = 1000,
+        tol: float = 1e-6,
+        standardize: bool = True,
+        fit_sig: bool = True,
+        sig: Optional[np.ndarray] = None,
+    ):
+        self.alpha = float(alpha)
+        self.weight = weight
+        self.max_outer_iter = int(max_outer_iter)
+        self.max_inner_iter = int(max_inner_iter)
+        self.tol = float(tol)
+        self.standardize = standardize
+        self.fit_sig = fit_sig
+        self.sig_init = None if sig is None else np.asarray(sig, dtype=np.float64)
+        if self.tol <= 0.0:
+            raise ValueError('tol must be positive')
+
+        self.partial_correlation_: Optional[np.ndarray] = None
+        self.precision_: Optional[np.ndarray] = None
+        self.sig_: Optional[np.ndarray] = None
+        self.weight_: Optional[np.ndarray] = None
+        self._mean_: Optional[np.ndarray] = None
+        self._scale_: Optional[np.ndarray] = None
+
+    def fit(self, X: np.ndarray) -> 'SPACE':
+        X = np.asarray(X, dtype=np.float64)
+        n, p = X.shape
+        lam1, lam2 = alpha_to_penalties(self.alpha)
+
+        if self.standardize:
+            Xw, self._mean_, self._scale_ = standardize_columns_l2(X)
+        else:
+            Xw = X.copy()
+            self._mean_ = np.zeros(p)
+            self._scale_ = np.ones(p)
+
+        w_vec, w_update, w_tag = resolve_weight(self.weight, p)
+
+        if self.sig_init is not None:
+            sig = np.asarray(self.sig_init, dtype=np.float64).ravel()
+            if sig.shape[0] != p:
+                raise ValueError('sig must have length p')
+            sig_update = self.fit_sig
+        else:
+            sig = np.ones(p, dtype=np.float64)
+            sig_update = self.fit_sig
+
+        for _ in range(self.max_outer_iter):
+            if w_tag == 1:
+                w_vec = sig.copy()
+            Y_u = Xw * np.sqrt(w_vec)[None, :]
+            sig_u = sig / w_vec
+
+            sigma_sr = np.sqrt(np.maximum(sig_u, 1e-15))
+            par_cor = jsrm(
+                Y_u,
+                sigma_sr,
+                lam1,
+                lam2,
+                self.max_inner_iter,
+                tol=self.tol,
+            )
+            np.fill_diagonal(par_cor, 1.0)
+
+            coef = par_cor[np.triu_indices(p, k=1)]
+            beta_cur = beta_coef_from_rho_upper(coef, sig)
+
+            if not w_update and not sig_update:
+                break
+
+            if sig_update:
+                sig = inv_sig_diag_new(Xw, beta_cur)
+
+            if w_update:
+                if w_tag == 2:
+                    w_vec = rescale_degree_weights(par_cor)
+
+        self.partial_correlation_ = par_cor
+        self.sig_ = sig
+        self.weight_ = w_vec
+        self.precision_ = partial_corr_to_precision(par_cor, sig)
+        return self

space_graph-0.1.0/space_graph/penalties.py

@@ -0,0 +1,17 @@
+"""Map public `alpha` to JSRM lam1, lam2."""
+
+from __future__ import annotations
+
+from typing import Tuple
+
+
+def alpha_to_penalties(alpha: float) -> Tuple[float, float]:
+    """
+    User contract: alpha in [0, 1] gives lam1 = alpha, lam2 = 1 - alpha.
+
+    This matches the reference elastic-net-style solver where both penalties appear.
+    """
+    a = float(alpha)
+    if a < 0.0 or a > 1.0:
+        raise ValueError('alpha must be in [0, 1]')
+    return a, 1.0 - a

space_graph-0.1.0/space_graph/solver.py

@@ -0,0 +1,272 @@
+"""
+JSRM inner solver: faithful port of `space/src/JSRM.c` active-shooting logic.
+
+Y layout: `Y[k, j]` = sample k, variable j (same as C row-major `Y_m[k*p+j]`).
+
+Performance: vectorized BLAS-friendly ops (``Y @ W`` for fitted values, column
+dot products for ``Aij``/``Aji``, in-place column updates for residuals).
+"""
+
+from __future__ import annotations
+
+import numpy as np
+
+from .kernels import jsrm_shooting_loop
+
+_DEFAULT_TOL = 1e-6
+
+
+def _elastic_net_shrink(
+    beta_next: float,
+    b_s: float,
+    lambda1: float,
+    lambda2: float,
+) -> float:
+    """One coordinate elastic-net shrink (matches JSRM.c)."""
+    temp1 = beta_next
+    if beta_next > 0.0:
+        temp = beta_next - lambda1 / b_s
+    else:
+        temp = -beta_next - lambda1 / b_s
+    if temp < 0.0:
+        return 0.0
+    temp = temp / (1.0 + lambda2)
+    if temp1 < 0.0:
+        temp = -temp
+    return temp
+
+
+def _aij_aji(
+    E_m: np.ndarray,
+    Y_m: np.ndarray,
+    cur_i: int,
+    cur_j: int,
+    B: np.ndarray,
+) -> tuple[float, float]:
+    """``Aij``, ``Aji`` as in JSRM (BLAS dot on columns)."""
+    aij = B[cur_i, cur_j] * float(np.dot(E_m[:, cur_j], Y_m[:, cur_i]))
+    aji = B[cur_j, cur_i] * float(np.dot(E_m[:, cur_i], Y_m[:, cur_j]))
+    return aij, aji
+
+
+def _update_e_pair(
+    E_m: np.ndarray,
+    Y_m: np.ndarray,
+    change_i: int,
+    change_j: int,
+    beta_change: float,
+    B: np.ndarray,
+) -> None:
+    """Residual update equation (11) in-place."""
+    c1 = beta_change * B[change_j, change_i]
+    c2 = beta_change * B[change_i, change_j]
+    if c1 != 0.0:
+        E_m[:, change_i] += Y_m[:, change_j] * c1
+    if c2 != 0.0:
+        E_m[:, change_j] += Y_m[:, change_i] * c2
+
+
+def jsrm(
+    Y_data: np.ndarray,
+    sigma_sr: np.ndarray,
+    lam1: float,
+    lam2: float,
+    n_iter: int = 500,
+    tol: float = _DEFAULT_TOL,
+) -> np.ndarray:
+    """
+    Joint sparse regression model (SPACE inner problem).
+
+    Parameters
+    ----------
+    Y_data : ndarray, shape (n, p)
+        Data; columns centered to mean 0 inside (C behavior).
+    sigma_sr : ndarray, shape (p,)
+        sqrt(sig^{ii}) per variable (R `sig.use^0.5`).
+    lam1, lam2 : float
+        L1 and elastic-net L2 penalties.
+    n_iter : int
+        Max inner iterations (R `jsrm` uses 500).
+    tol : float
+        Convergence tolerance: stop when max coordinate change between sweeps
+        is below ``tol`` (also used as the active-set threshold for nonzero
+        ``beta``, matching the reference ``1e-6`` scale).
+
+    Returns
+    -------
+    beta_new : ndarray, shape (p, p)
+        Symmetric estimates; diagonal 0.
+    """
+    Y_data = np.asarray(Y_data, dtype=np.float64, order='C')
+    sigma_sr = np.asarray(sigma_sr, dtype=np.float64).ravel()
+    n, p = Y_data.shape
+    if sigma_sr.shape[0] != p:
+        raise ValueError('sigma_sr must have length p')
+
+    lambda1 = float(lam1)
+    lambda2 = float(lam2)
+    tol = float(tol)
+    if tol <= 0.0:
+        raise ValueError('tol must be positive')
+    eps1 = tol
+    maxdif_tol = tol
+
+    Y_m = Y_data.copy()
+    Y_m -= Y_m.mean(axis=0)
+    normx = np.sum(Y_m * Y_m, axis=0)
+
+    B = sigma_sr[:, None] / sigma_sr[None, :]
+    B_sq = B * B
+    B_s = B_sq * normx[:, None] + B_sq.T * normx[None, :]
+
+    G = Y_m.T @ Y_m
+    ui, uj = np.triu_indices(p, k=1)
+    temp1_vec = G[ui, uj] * (B[uj, ui] + B[ui, uj])
+    tt = np.abs(temp1_vec) - lambda1
+    b_s_ij = B_s[ui, uj] * (1.0 + lambda2)
+    bet = np.zeros(ui.shape[0], dtype=np.float64)
+    m = tt >= 0.0
+    bet[m] = tt[m] / b_s_ij[m]
+    bet[m] *= np.sign(temp1_vec[m])
+
+    beta_new = np.zeros((p, p), dtype=np.float64)
+    beta_new[ui, uj] = bet
+    beta_new[uj, ui] = bet
+    np.fill_diagonal(beta_new, 0.0)
+
+    W = beta_new * B
+    E_m = Y_m - (Y_m @ W)
+
+    beta_old = beta_new.copy()
+    beta_last = np.empty((p, p), dtype=np.float64)
+
+    found = False
+    pick_i = pick_j = 0
+    for j in range(p - 1, 0, -1):
+        for i in range(j - 1, -1, -1):
+            b = beta_new[i, j]
+            if b > eps1 or b < -eps1:
+                pick_i, pick_j = i, j
+                found = True
+                break
+        if found:
+            break
+
+    if not found:
+        return beta_new
+
+    cur_i, cur_j = pick_i, pick_j
+
+    aij, aji = _aij_aji(E_m, Y_m, cur_i, cur_j, B)
+    b_s = B_s[cur_i, cur_j]
+    beta_next = (aij + aji) / b_s + beta_old[cur_i, cur_j]
+    temp = _elastic_net_shrink(beta_next, b_s, lambda1, lambda2)
+
+    beta_change = beta_old[cur_i, cur_j] - temp
+    beta_new[cur_i, cur_j] = temp
+    beta_new[cur_j, cur_i] = temp
+
+    change_i = cur_i
+    change_j = cur_j
+
+    if jsrm_shooting_loop is not None:
+        jsrm_shooting_loop(
+            Y_m,
+            E_m,
+            beta_new,
+            beta_old,
+            beta_last,
+            B,
+            B_s,
+            lambda1,
+            lambda2,
+            n,
+            p,
+            n_iter,
+            change_i,
+            change_j,
+            beta_change,
+            tol,
+        )
+        return beta_new
+
+    nbeta = p * (p - 1) // 2
+    pair_buf = np.empty((nbeta, 2), dtype=np.int32)
+
+    for _ in range(n_iter):
+        beta_last[:] = beta_new
+
+        k = 0
+        for j in range(p - 1, 0, -1):
+            for i in range(j - 1, -1, -1):
+                b = beta_new[i, j]
+                if b > eps1 or b < -eps1:
+                    pair_buf[k, 0] = i
+                    pair_buf[k, 1] = j
+                    k += 1
+        nrow_pick = k
+        maxdif = -100.0
+
+        if nrow_pick > 0:
+            for t in range(nrow_pick):
+                cur_i = int(pair_buf[t, 0])
+                cur_j = int(pair_buf[t, 1])
+                beta_old[change_i, change_j] = beta_new[change_i, change_j]
+                beta_old[change_j, change_i] = beta_new[change_j, change_i]
+
+                _update_e_pair(E_m, Y_m, change_i, change_j, beta_change, B)
+
+                aij, aji = _aij_aji(E_m, Y_m, cur_i, cur_j, B)
+                b_s = B_s[cur_i, cur_j]
+                beta_next = (aij + aji) / b_s + beta_old[cur_i, cur_j]
+                temp = _elastic_net_shrink(beta_next, b_s, lambda1, lambda2)
+
+                beta_new[cur_i, cur_j] = temp
+                beta_new[cur_j, cur_i] = temp
+
+                beta_change = beta_old[cur_i, cur_j] - temp
+                change_i = cur_i
+                change_j = cur_j
+
+            maxdif = float(np.max(np.abs(beta_last - beta_new)))
+
+        if maxdif < maxdif_tol or nrow_pick < 1:
+            beta_last[:] = beta_new
+
+            for cur_i in range(p - 1):
+                for cur_j in range(cur_i + 1, p):
+                    beta_old[change_i, change_j] = beta_new[
+                        change_i, change_j
+                    ]
+                    beta_old[change_j, change_i] = beta_new[
+                        change_j, change_i
+                    ]
+
+                    if beta_change < -eps1 or beta_change > eps1:
+                        _update_e_pair(
+                            E_m,
+                            Y_m,
+                            change_i,
+                            change_j,
+                            beta_change,
+                            B,
+                        )
+
+                    aij, aji = _aij_aji(E_m, Y_m, cur_i, cur_j, B)
+                    b_s = B_s[cur_i, cur_j]
+                    beta_next = (aij + aji) / b_s + beta_old[cur_i, cur_j]
+                    temp = _elastic_net_shrink(beta_next, b_s, lambda1, lambda2)
+
+                    beta_new[cur_i, cur_j] = temp
+                    beta_new[cur_j, cur_i] = temp
+
+                    beta_change = beta_old[cur_i, cur_j] - temp
+                    change_i = cur_i
+                    change_j = cur_j
+
+            maxdif = float(np.max(np.abs(beta_last - beta_new)))
+
+            if maxdif < maxdif_tol:
+                break
+
+    return beta_new

space_graph-0.1.0/space_graph/state.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import numpy as np
+
+
+@dataclass
+class SpaceState:
+    """Internal state for one SPACE fit."""
+
+    partial_correlation: np.ndarray
+    sig: np.ndarray
+    weight: np.ndarray
+    outer_iter: int

space_graph-0.1.0/space_graph/utils.py

@@ -0,0 +1,62 @@
+"""Standardization and matrix transforms matching `space` R code."""
+
+from __future__ import annotations
+
+import numpy as np
+
+
+def standardize_columns_l2(X: np.ndarray) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+    """
+    Center each column to mean 0 and scale to L2 norm 1 (per column).
+    Returns (X_std, mean, scale) where X_std = (X - mean) / scale.
+    """
+    X = np.asarray(X, dtype=np.float64)
+    mean = X.mean(axis=0)
+    Xc = X - mean
+    scale = np.sqrt(np.sum(Xc**2, axis=0))
+    scale = np.where(scale < 1e-15, 1.0, scale)
+    return Xc / scale, mean, scale
+
+
+def beta_coef_from_rho_upper(coef: np.ndarray, sig_fit: np.ndarray) -> np.ndarray:
+    """
+    `Beta.coef` from space/R/space.R: coef is upper-triangle rho^{ij}, sig_fit is sigma^{ii}.
+    """
+    p = sig_fit.shape[0]
+    result = np.zeros((p, p), dtype=np.float64)
+    result[np.triu_indices(p, k=1)] = coef
+    result = result + result.T
+    inv_sqrt = 1.0 / np.sqrt(sig_fit)
+    sqrt_sig = np.sqrt(sig_fit)
+    result = (inv_sqrt[:, None] * result) @ np.diag(sqrt_sig)
+    return result.T
+
+
+def inv_sig_diag_new(Y: np.ndarray, beta: np.ndarray) -> np.ndarray:
+    """
+    `InvSig.diag.new`: 1 / colMeans((Y - Y @ Beta0)^2) with diag(Beta)=0.
+    """
+    b = beta.copy()
+    np.fill_diagonal(b, 0.0)
+    esti = Y @ b
+    residue = Y - esti
+    return 1.0 / np.mean(residue**2, axis=0)
+
+
+def partial_corr_to_precision(
+    parcor: np.ndarray, sig: np.ndarray
+) -> np.ndarray:
+    """
+    Reconstruct a precision-like matrix from partial correlations and sig^{ii},
+    following NITK/R style: Theta_ij related to rho_ij via scaling by sig.
+    """
+    p = parcor.shape[0]
+    ind = np.triu_indices(p, k=1)
+    coef = parcor[ind]
+    result = np.zeros((p, p), dtype=np.float64)
+    result[ind] = coef
+    result = result + result.T
+    inv_sqrt = 1.0 / np.sqrt(sig)
+    sqrt_sig = np.sqrt(sig)
+    result = inv_sqrt[:, None] * result * sqrt_sig[None, :]
+    return result.T

space_graph-0.1.0/space_graph/weights.py

@@ -0,0 +1,50 @@
+"""Weight modes for SPACE outer loop (R `space.joint` semantics)."""
+
+from __future__ import annotations
+
+from typing import Literal, Union
+
+import numpy as np
+
+WeightInput = Union[
+    Literal['uniform'],
+    Literal['equal'],
+    Literal['sig'],
+    Literal['degree'],
+    np.ndarray,
+]
+
+
+def resolve_weight(
+    weight: WeightInput,
+    p: int,
+) -> tuple[np.ndarray, bool, int]:
+    """
+    Returns (weight_vector, update_each_outer_iter, tag).
+
+    tag: 0 uniform, 1 sig-based, 2 degree-based, 3 custom.
+    """
+    if isinstance(weight, str):
+        if weight in ('uniform', 'equal'):
+            return np.ones(p, dtype=np.float64), False, 0
+        if weight == 'sig':
+            return np.ones(p, dtype=np.float64), True, 1
+        if weight == 'degree':
+            return np.ones(p, dtype=np.float64), True, 2
+        raise ValueError(f'unknown weight mode: {weight}')
+
+    w = np.asarray(weight, dtype=np.float64).ravel()
+    if w.shape[0] != p:
+        raise ValueError('custom weight must have length p')
+    if np.any(w <= 0):
+        raise ValueError('custom weight must be positive')
+    w = w / w.mean()
+    return w, False, 3
+
+
+def rescale_degree_weights(par_cor: np.ndarray) -> np.ndarray:
+    """R: temp.w <- row sums of |rho|>1e-6; +max; normalize to mean 1."""
+    p = par_cor.shape[0]
+    temp_w = np.sum(np.abs(par_cor) > 1e-6, axis=1).astype(np.float64)
+    temp_w = temp_w + np.max(temp_w)
+    return temp_w / np.sum(temp_w) * p

space_graph-0.1.0/space_graph.egg-info/PKG-INFO

@@ -0,0 +1,81 @@
+Metadata-Version: 2.4
+Name: space-graph
+Version: 0.1.0
+Summary: Pure Python SPACE: sparse partial correlation estimation
+License: GPL-3.0-or-later
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.20
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+Provides-Extra: numba
+Requires-Dist: numba>=0.57; extra == "numba"
+Dynamic: license-file
+
+# space-graph
+
+[![PyPI version](https://img.shields.io/pypi/v/space-graph)](https://pypi.org/project/space-graph/)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10%2B-blue.svg)](https://www.python.org/downloads/)
+[![License: GPL-3.0-or-later](https://img.shields.io/badge/license-GPL--3.0--or--later-blue.svg)](LICENSE)
+
+Pure Python implementation of **SPACE** (Sparse Partial Correlation Estimation) from Peng et al. (2009), with no R or C dependencies.
+
+Paper: [Sparse Partial Correlation Estimation for High-Dimensional Data](https://www.tandfonline.com/doi/abs/10.1198/jasa.2009.0126)
+
+## Install
+
+```bash
+pip install space-graph
+```
+
+Optional Numba (faster inner `jsrm` loop):
+
+```bash
+pip install 'space-graph[numba]'
+```
+
+From GitHub:
+
+```bash
+pip install git+https://github.com/shahrozeabbas/space-graph.git
+```
+
+## Usage
+
+```python
+import numpy as np
+from space_graph import SPACE
+
+X = np.random.randn(20, 5)
+model = SPACE(
+    alpha=0.7,
+    max_outer_iter=2,
+    max_inner_iter=500,
+    tol=1e-6,
+    weight='uniform',
+)
+model.fit(X)
+print(model.partial_correlation_)
+```
+
+## Penalty
+
+The public parameter `alpha` in `[0, 1]` maps to inner penalties as `lam1 = alpha` and `lam2 = 1 - alpha`, matching the reference elastic-net-style JSRM solver.
+
+## Options
+
+- **`tol`** (default `1e-6`): inner coordinate-descent stopping tolerance (and active-set threshold), same scale as the reference C code.
+- **`weight`**: default **`uniform`** (unit weights). Use **`equal`** as an alias. Other modes: **`sig`**, **`degree`**, or a custom positive vector of length `p`.
+
+## Tests
+
+```bash
+pytest
+```
+
+Optional: build `libjsrm_test.so` from `../space/src/JSRM.c` to run the ctypes cross-check in `tests/test_space.py`.
+
+## License
+
+GPL-3.0-or-later (same family as the original `space` R package).

space_graph-0.1.0/space_graph.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+LICENSE
+README.md
+pyproject.toml
+space_graph/__init__.py
+space_graph/kernels.py
+space_graph/model.py
+space_graph/penalties.py
+space_graph/solver.py
+space_graph/state.py
+space_graph/utils.py
+space_graph/weights.py
+space_graph.egg-info/PKG-INFO
+space_graph.egg-info/SOURCES.txt
+space_graph.egg-info/dependency_links.txt
+space_graph.egg-info/requires.txt
+space_graph.egg-info/top_level.txt
+tests/test_space.py
+tests/test_utils.py

space_graph-0.1.0/space_graph.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

space_graph-0.1.0/space_graph.egg-info/requires.txt

@@ -0,0 +1,7 @@
+numpy>=1.20
+
+[dev]
+pytest>=7
+
+[numba]
+numba>=0.57

space_graph-0.1.0/space_graph.egg-info/top_level.txt

@@ -0,0 +1 @@
+space_graph

space_graph-0.1.0/tests/test_space.py

@@ -0,0 +1,125 @@
+"""Tests for SPACE / JSRM."""
+
+from __future__ import annotations
+
+import os
+
+import numpy as np
+import pytest
+
+from space_graph.model import SPACE
+from space_graph.solver import jsrm
+
+
+def _spd_cov(p: int, rng: np.random.Generator) -> np.ndarray:
+    a = rng.standard_normal((p, p))
+    return a @ a.T + p * np.eye(p)
+
+
+def test_jsrm_matches_c_when_available():
+    lib = '/Users/abba5hahroze/Desktop/space-lasso/space/src/libjsrm_test.so'
+    if not os.path.isfile(lib):
+        pytest.skip('compiled JSRM test library not present')
+    import ctypes
+    from numpy.ctypeslib import ndpointer
+
+    cdll = ctypes.CDLL(lib)
+    fun = cdll.JSRM
+    fun.restype = None
+    fun.argtypes = [
+        ctypes.POINTER(ctypes.c_int),
+        ctypes.POINTER(ctypes.c_int),
+        ctypes.POINTER(ctypes.c_float),
+        ctypes.POINTER(ctypes.c_float),
+        ndpointer(ctypes.c_float, flags='C_CONTIGUOUS'),
+        ndpointer(ctypes.c_float, flags='C_CONTIGUOUS'),
+        ctypes.POINTER(ctypes.c_int),
+        ctypes.POINTER(ctypes.c_int),
+        ndpointer(ctypes.c_float, flags='C_CONTIGUOUS'),
+    ]
+
+    rng = np.random.default_rng(42)
+    n, p = 12, 6
+    X = rng.standard_normal((n, p)).astype(np.float32)
+    sig = np.ones(p, dtype=np.float32)
+    lam1, lam2 = 0.35, 0.0
+
+    n_in = ctypes.c_int(n)
+    p_in = ctypes.c_int(p)
+    l1 = ctypes.c_float(lam1)
+    l2 = ctypes.c_float(lam2)
+    sigma_sr = np.sqrt(sig).astype(np.float32)
+    n_iter = ctypes.c_int(500)
+    iter_out = ctypes.c_int(0)
+    beta = np.zeros(p * p, dtype=np.float32)
+    y_flat = np.ascontiguousarray(X.ravel(order='C'))
+    fun(
+        ctypes.byref(n_in),
+        ctypes.byref(p_in),
+        ctypes.byref(l1),
+        ctypes.byref(l2),
+        y_flat,
+        sigma_sr,
+        ctypes.byref(n_iter),
+        ctypes.byref(iter_out),
+        beta,
+    )
+    beta_c = beta.reshape(p, p, order='C')
+
+    beta_py = jsrm(
+        X.astype(np.float64),
+        sigma_sr.astype(np.float64),
+        lam1,
+        lam2,
+        500,
+        tol=1e-6,
+    )
+    np.testing.assert_allclose(beta_c, beta_py, atol=1e-4, rtol=1e-4)
+
+
+def test_space_fit_symmetric_unit_diagonal():
+    rng = np.random.default_rng(0)
+    p, n = 8, 25
+    cov = _spd_cov(p, rng)
+    X = rng.multivariate_normal(np.zeros(p), cov, size=n)
+
+    m = SPACE(alpha=1.0, max_outer_iter=2, max_inner_iter=500)
+    m.fit(X)
+
+    r = m.partial_correlation_
+    assert r.shape == (p, p)
+    assert np.allclose(r, r.T)
+    assert np.allclose(np.diag(r), 1.0)
+    assert m.sig_ is not None
+    assert m.precision_ is not None
+
+
+def test_alpha_mix_penalty_runs():
+    rng = np.random.default_rng(1)
+    X = rng.standard_normal((30, 5))
+    m = SPACE(alpha=0.6, max_outer_iter=2)
+    m.fit(X)
+    assert m.partial_correlation_.shape == (5, 5)
+
+
+def test_weight_uniform_vs_sig():
+    rng = np.random.default_rng(2)
+    p, n = 6, 40
+    X = rng.multivariate_normal(np.zeros(p), _spd_cov(p, rng), size=n)
+
+    a = SPACE(alpha=0.9, weight='uniform', max_outer_iter=2)
+    a.fit(X)
+    b = SPACE(alpha=0.9, weight='sig', max_outer_iter=2)
+    b.fit(X)
+    assert a.partial_correlation_.shape == b.partial_correlation_.shape
+
+
+def test_weight_equal_alias_matches_uniform():
+    rng = np.random.default_rng(3)
+    p, n = 5, 30
+    X = rng.multivariate_normal(np.zeros(p), _spd_cov(p, rng), size=n)
+    u = SPACE(alpha=0.95, weight='uniform', max_outer_iter=2, tol=1e-6)
+    e = SPACE(alpha=0.95, weight='equal', max_outer_iter=2, tol=1e-6)
+    u.fit(X)
+    e.fit(X)
+    np.testing.assert_allclose(u.partial_correlation_, e.partial_correlation_)

space_graph-0.1.0/tests/test_utils.py

@@ -0,0 +1,15 @@
+"""Unit tests for utilities."""
+
+import numpy as np
+
+from space_graph.utils import beta_coef_from_rho_upper
+
+
+def test_beta_coef_shape():
+    p = 4
+    rho = np.eye(p)
+    rho[0, 1] = rho[1, 0] = 0.3
+    coef = rho[np.triu_indices(p, k=1)]
+    sig = np.ones(p)
+    b = beta_coef_from_rho_upper(coef, sig)
+    assert b.shape == (p, p)