bayesian-sparse-gmm 0.1.0__py3-none-any.whl

bayesian_sparse_gmm/__init__.py

@@ -0,0 +1,5 @@
+from .model import BayesianSparseGMM
+
+__version__ = "0.1.0"
+
+__all__ = ["BayesianSparseGMM"]

bayesian_sparse_gmm/backends/__init__.py

@@ -0,0 +1,52 @@
+import warnings
+
+from ._base import ComputeBackend
+from ._numpy import NumpyBackend
+
+try:
+    from ._numba import NumbaBackend
+
+    NUMBA_AVAILABLE = True
+except ImportError:
+    NUMBA_AVAILABLE = False
+
+from ._cuda import CUPY_AVAILABLE, CUDABackend
+
+
+def select_backend(preference: str = "auto", use_cuda: bool = False) -> ComputeBackend:
+    """Select the best available compute backend based on preference."""
+    preference = preference.lower()
+
+    if preference == "numpy":
+        return NumpyBackend()
+
+    if preference == "cuda":
+        if CUPY_AVAILABLE:
+            return CUDABackend()
+        if NUMBA_AVAILABLE:
+            return NumbaBackend(use_cuda=True)
+        warnings.warn(
+            "CUDA backend requested but neither CuPy nor Numba CUDA is available. Falling back to NumPy."
+        )
+        return NumpyBackend()
+
+    if preference in ("numba", "auto"):
+        if preference == "numba":
+            if NUMBA_AVAILABLE:
+                return NumbaBackend(use_cuda=use_cuda)
+            warnings.warn(
+                "Numba backend requested but Numba is not available. Falling back to NumPy."
+            )
+            return NumpyBackend()
+
+        # preference == "auto"
+        if use_cuda:
+            if CUPY_AVAILABLE:
+                return CUDABackend()
+            if NUMBA_AVAILABLE:
+                return NumbaBackend(use_cuda=True)
+        if NUMBA_AVAILABLE:
+            return NumbaBackend(use_cuda=False)
+        return NumpyBackend()
+
+    raise ValueError(f"Unknown backend preference: {preference}")

bayesian_sparse_gmm/backends/_base.py

@@ -0,0 +1,46 @@
+from abc import ABC, abstractmethod
+
+import numpy as np
+
+
+class ComputeBackend(ABC):
+    """Abstract base class for all compute backends."""
+
+    @abstractmethod
+    def compute_cluster_log_probs(
+        self, X: np.ndarray, mu: np.ndarray, log_w: np.ndarray, sigma2: np.ndarray
+    ) -> np.ndarray:
+        """Step 2: Compute log probability of cluster assignment for all samples and clusters.
+
+        Returns shape (n, K_max)
+        """
+        pass
+
+    @abstractmethod
+    def compute_sufficient_stats(
+        self, X: np.ndarray, z: np.ndarray, K_max: int
+    ) -> tuple[np.ndarray, np.ndarray]:
+        """Step 4: Compute cluster sizes and feature sums per cluster.
+
+        Returns (n_k, sum_x)
+        """
+        pass
+
+    @abstractmethod
+    def sample_cluster_means(
+        self,
+        sum_x: np.ndarray,
+        n_k: np.ndarray,
+        tau2: np.ndarray,
+        sigma2: np.ndarray,
+        rng: np.random.Generator,
+    ) -> np.ndarray:
+        """Step 4b: Sample cluster means mu[k,j] ~ Normal."""
+        pass
+
+    @abstractmethod
+    def sample_inverse_gaussian(
+        self, mu_abs: np.ndarray, lam: np.ndarray, rng: np.random.Generator
+    ) -> np.ndarray:
+        """Step 4a: Sample tau^2 via Inverse Gaussian."""
+        pass

bayesian_sparse_gmm/backends/_cuda.py

@@ -0,0 +1,106 @@
+import numpy as np
+
+from ._base import ComputeBackend
+
+try:
+    import cupy as cp
+
+    CUPY_AVAILABLE = True
+except ImportError:
+    CUPY_AVAILABLE = False
+    cp = None
+
+
+class CUDABackend(ComputeBackend):
+    """CuPy-based GPU accelerated compute backend."""
+
+    def __init__(self):
+        if not CUPY_AVAILABLE:
+            raise ImportError(
+                "CuPy is not installed. Please install cupy to use CUDABackend."
+            )
+
+    def compute_cluster_log_probs(
+        self, X: np.ndarray, mu: np.ndarray, log_w: np.ndarray
+    ) -> np.ndarray:
+        """Step 2: Compute log probability of cluster assignment for all samples and clusters on GPU."""
+        X_gpu = cp.asarray(X)
+        mu_gpu = cp.asarray(mu)
+        log_w_gpu = cp.asarray(log_w)
+
+        x_sq = cp.sum(X_gpu**2, axis=1, keepdims=True)
+        mu_sq = cp.sum(mu_gpu**2, axis=1, keepdims=True).T
+        dist = x_sq - 2.0 * cp.dot(X_gpu, mu_gpu.T) + mu_sq
+        dist = cp.maximum(dist, 0.0)
+
+        log_probs = log_w_gpu - 0.5 * dist
+        return cp.asnumpy(log_probs)
+
+    def compute_sufficient_stats(
+        self, X: np.ndarray, z: np.ndarray, K_max: int
+    ) -> tuple[np.ndarray, np.ndarray]:
+        """Step 4: Compute cluster sizes and feature sums per cluster on GPU."""
+        X_gpu = cp.asarray(X)
+        z_gpu = cp.asarray(z)
+
+        n_k = cp.bincount(z_gpu, minlength=K_max)
+        sum_x = cp.zeros((K_max, X.shape[1]), dtype=X_gpu.dtype)
+        cp.scatter_add(sum_x, z_gpu, X_gpu)
+
+        return cp.asnumpy(n_k), cp.asnumpy(sum_x)
+
+    def sample_cluster_means(
+        self,
+        sum_x: np.ndarray,
+        n_k: np.ndarray,
+        tau2: np.ndarray,
+        rng: np.random.Generator,
+    ) -> np.ndarray:
+        """Step 4b: Sample cluster means mu[k,j] ~ Normal on GPU."""
+        sum_x_gpu = cp.asarray(sum_x)
+        n_k_gpu = cp.asarray(n_k)
+        tau2_gpu = cp.asarray(tau2)
+
+        noise = rng.normal(size=sum_x.shape)
+        noise_gpu = cp.asarray(noise)
+
+        post_var = 1.0 / (n_k_gpu[:, cp.newaxis] + 1.0 / tau2_gpu)
+        post_mean = post_var * sum_x_gpu
+        mu_gpu = post_mean + cp.sqrt(post_var) * noise_gpu
+
+        return cp.asnumpy(mu_gpu)
+
+    def sample_inverse_gaussian(
+        self, mu_abs: np.ndarray, lam: np.ndarray, rng: np.random.Generator
+    ) -> np.ndarray:
+        """Step 4a: Sample tau^2 via Inverse Gaussian on GPU using stable formula."""
+        mu_abs_gpu = cp.asarray(mu_abs)
+        lam_gpu = cp.asarray(lam)
+
+        y_noise = rng.normal(size=mu_abs.shape) ** 2
+        u_noise = rng.uniform(size=mu_abs.shape)
+
+        y_gpu = cp.asarray(y_noise)
+        u_gpu = cp.asarray(u_noise)
+
+        inv_mean = lam_gpu / (mu_abs_gpu + 1e-10)
+        inv_mean = cp.minimum(inv_mean, 1e5)
+        shape = lam_gpu**2
+        inv_mean2 = inv_mean**2
+
+        term = cp.sqrt(
+            cp.maximum(0.0, 4.0 * inv_mean * shape * y_gpu + inv_mean2 * (y_gpu**2))
+        )
+        x1 = inv_mean / (
+            1.0 + (inv_mean * y_gpu) / (2.0 * shape) + term / (2.0 * shape)
+        )
+
+        cond = inv_mean / (inv_mean + x1 + 1e-15)
+        mask = u_gpu <= cond
+
+        res = cp.empty_like(inv_mean)
+        res[mask] = x1[mask]
+        res[~mask] = inv_mean2[~mask] / (x1[~mask] + 1e-15)
+
+        tau2_gpu = 1.0 / res
+        return cp.asnumpy(tau2_gpu)

bayesian_sparse_gmm/backends/_numba.py

@@ -0,0 +1,274 @@
+import warnings
+
+import numpy as np
+from numba import cuda, njit, prange
+
+from ._base import ComputeBackend
+
+# =====================================================================
+# Numba CPU parallel kernels
+# =====================================================================
+
+
+@njit(parallel=True, fastmath=True, cache=True)
+def _compute_cluster_log_probs_numba(X, mu, log_w, sigma2):
+    n, p = X.shape
+    K_max = mu.shape[0]
+    log_probs = np.empty((n, K_max), dtype=X.dtype)
+    for i in prange(n):
+        for k in range(K_max):
+            dist = 0.0
+            for j in range(p):
+                diff = X[i, j] - mu[k, j]
+                dist += diff * diff / sigma2[j]
+            log_probs[i, k] = log_w[k] - 0.5 * dist
+    return log_probs
+
+
+@njit(parallel=True, fastmath=True, cache=True)
+def _compute_sufficient_stats_numba(X, z, K_max):
+    n, p = X.shape
+    n_k = np.zeros(K_max, dtype=np.int64)
+    for i in range(n):
+        n_k[z[i]] += 1
+
+    sum_x = np.zeros((K_max, p), dtype=X.dtype)
+    for j in prange(p):
+        for i in range(n):
+            k = z[i]
+            sum_x[k, j] += X[i, j]
+
+    return n_k, sum_x
+
+
+@njit(parallel=True, fastmath=True, cache=True)
+def _sample_cluster_means_numba(sum_x, n_k, tau2, sigma2, noise):
+    K_max, p = sum_x.shape
+    mu = np.empty((K_max, p), dtype=sum_x.dtype)
+    for k in prange(K_max):
+        nk = n_k[k]
+        for j in range(p):
+            post_var = 1.0 / (nk / sigma2[j] + 1.0 / tau2[k, j])
+            post_mean = post_var * (sum_x[k, j] / sigma2[j])
+            mu[k, j] = post_mean + np.sqrt(post_var) * noise[k, j]
+    return mu
+
+
+@njit(parallel=True, fastmath=True, cache=True)
+def _sample_inverse_gaussian_numba(mu_abs, lam, y_noise, u_noise):
+    K_max, p = mu_abs.shape
+    tau2 = np.empty((K_max, p), dtype=mu_abs.dtype)
+    for k in prange(K_max):
+        for j in range(p):
+            mean = lam[0, j] / (mu_abs[k, j] + 1e-10)
+            if mean > 1e5:
+                mean = 1e5
+            sh = lam[0, j] ** 2
+            mean2 = mean**2
+            y = y_noise[k, j]
+            term = np.sqrt(np.maximum(0.0, 4.0 * mean * sh * y + mean2 * (y**2)))
+            x1 = mean / (1.0 + (mean * y) / (2.0 * sh) + term / (2.0 * sh))
+            u = u_noise[k, j]
+
+            cond = mean / (mean + x1 + 1e-15)
+            if u <= cond:
+                inv_tau2 = x1
+            else:
+                inv_tau2 = mean2 / (x1 + 1e-15)
+            tau2[k, j] = 1.0 / inv_tau2
+    return tau2
+
+
+# =====================================================================
+# Numba CUDA GPU kernels
+# =====================================================================
+
+
+@cuda.jit
+def _compute_cluster_log_probs_cuda(X, mu, log_w, sigma2, out):
+    i = cuda.grid(1)
+    n = X.shape[0]
+    K_max = mu.shape[0]
+    p = X.shape[1]
+    if i < n:
+        for k in range(K_max):
+            dist = 0.0
+            for j in range(p):
+                diff = X[i, j] - mu[k, j]
+                dist += diff * diff / sigma2[j]
+            out[i, k] = log_w[k] - 0.5 * dist
+
+
+@cuda.jit
+def _compute_sufficient_stats_cuda(X, z, n_k, sum_x):
+    i = cuda.grid(1)
+    n = X.shape[0]
+    p = X.shape[1]
+    if i < n:
+        k = z[i]
+        cuda.atomic.add(n_k, k, 1)
+        for j in range(p):
+            cuda.atomic.add(sum_x, (k, j), X[i, j])
+
+
+@cuda.jit
+def _sample_cluster_means_cuda(sum_x, n_k, tau2, sigma2, noise, out):
+    k = cuda.grid(1)
+    K_max = sum_x.shape[0]
+    p = sum_x.shape[1]
+    if k < K_max:
+        nk = n_k[k]
+        for j in range(p):
+            post_var = 1.0 / (nk / sigma2[j] + 1.0 / tau2[k, j])
+            post_mean = post_var * (sum_x[k, j] / sigma2[j])
+            out[k, j] = post_mean + np.sqrt(post_var) * noise[k, j]
+
+
+@cuda.jit
+def _sample_inverse_gaussian_cuda(mu_abs, lam, y_noise, u_noise, out_tau2):
+    k = cuda.grid(1)
+    K_max = mu_abs.shape[0]
+    p = mu_abs.shape[1]
+    if k < K_max:
+        for j in range(p):
+            mean = lam[0, j] / (mu_abs[k, j] + 1e-10)
+            if mean > 1e5:
+                mean = 1e5
+            sh = lam[0, j] ** 2
+            mean2 = mean**2
+            y = y_noise[k, j]
+            term = np.sqrt(np.maximum(0.0, 4.0 * mean * sh * y + mean2 * (y**2)))
+            x1 = mean / (1.0 + (mean * y) / (2.0 * sh) + term / (2.0 * sh))
+            u = u_noise[k, j]
+
+            cond = mean / (mean + x1 + 1e-15)
+            if u <= cond:
+                inv_tau2 = x1
+            else:
+                inv_tau2 = mean2 / (x1 + 1e-15)
+            out_tau2[k, j] = 1.0 / inv_tau2
+
+
+# =====================================================================
+# Numba backend class wrapper
+# =====================================================================
+
+
+class NumbaBackend(ComputeBackend):
+    """Numba-accelerated compute backend supporting CPU parallel and GPU CUDA."""
+
+    def __init__(self, use_cuda: bool = False):
+        self.use_cuda = use_cuda
+        if use_cuda:
+            if not cuda.is_available():
+                warnings.warn(
+                    "CUDA is requested but Numba CUDA is not available. Falling back to CPU multi-core."
+                )
+                self.use_cuda = False
+
+    def compute_cluster_log_probs(
+        self, X: np.ndarray, mu: np.ndarray, log_w: np.ndarray, sigma2: np.ndarray
+    ) -> np.ndarray:
+        if self.use_cuda:
+            n, p = X.shape
+            K_max = mu.shape[0]
+            out = np.empty((n, K_max), dtype=X.dtype)
+
+            d_X = cuda.to_device(X)
+            d_mu = cuda.to_device(mu)
+            d_log_w = cuda.to_device(log_w)
+            d_sigma2 = cuda.to_device(sigma2)
+            d_out = cuda.to_device(out)
+
+            threads_per_block = 256
+            blocks_per_grid = (n + threads_per_block - 1) // threads_per_block
+            _compute_cluster_log_probs_cuda[blocks_per_grid, threads_per_block](
+                d_X, d_mu, d_log_w, d_sigma2, d_out
+            )
+
+            d_out.copy_to_host(out)
+            return out
+        else:
+            return _compute_cluster_log_probs_numba(X, mu, log_w, sigma2)
+
+    def compute_sufficient_stats(
+        self, X: np.ndarray, z: np.ndarray, K_max: int
+    ) -> tuple[np.ndarray, np.ndarray]:
+        if self.use_cuda:
+            n, p = X.shape
+            n_k = np.zeros(K_max, dtype=np.int64)
+            sum_x = np.zeros((K_max, p), dtype=X.dtype)
+
+            d_X = cuda.to_device(X)
+            d_z = cuda.to_device(z)
+            d_n_k = cuda.to_device(n_k)
+            d_sum_x = cuda.to_device(sum_x)
+
+            threads_per_block = 256
+            blocks_per_grid = (n + threads_per_block - 1) // threads_per_block
+            _compute_sufficient_stats_cuda[blocks_per_grid, threads_per_block](
+                d_X, d_z, d_n_k, d_sum_x
+            )
+
+            d_n_k.copy_to_host(n_k)
+            d_sum_x.copy_to_host(sum_x)
+            return n_k, sum_x
+        else:
+            return _compute_sufficient_stats_numba(X, z, K_max)
+
+    def sample_cluster_means(
+        self,
+        sum_x: np.ndarray,
+        n_k: np.ndarray,
+        tau2: np.ndarray,
+        sigma2: np.ndarray,
+        rng: np.random.Generator,
+    ) -> np.ndarray:
+        noise = rng.normal(size=sum_x.shape)
+        if self.use_cuda:
+            K_max, p = sum_x.shape
+            out = np.empty((K_max, p), dtype=sum_x.dtype)
+
+            d_sum_x = cuda.to_device(sum_x)
+            d_n_k = cuda.to_device(n_k)
+            d_tau2 = cuda.to_device(tau2)
+            d_sigma2 = cuda.to_device(sigma2)
+            d_noise = cuda.to_device(noise)
+            d_out = cuda.to_device(out)
+
+            threads_per_block = 64
+            blocks_per_grid = (K_max + threads_per_block - 1) // threads_per_block
+            _sample_cluster_means_cuda[blocks_per_grid, threads_per_block](
+                d_sum_x, d_n_k, d_tau2, d_sigma2, d_noise, d_out
+            )
+
+            d_out.copy_to_host(out)
+            return out
+        else:
+            return _sample_cluster_means_numba(sum_x, n_k, tau2, sigma2, noise)
+
+    def sample_inverse_gaussian(
+        self, mu_abs: np.ndarray, lam: np.ndarray, rng: np.random.Generator
+    ) -> np.ndarray:
+        y_noise = rng.normal(size=mu_abs.shape) ** 2
+        u_noise = rng.uniform(size=mu_abs.shape)
+        if self.use_cuda:
+            K_max, p = mu_abs.shape
+            out_tau2 = np.empty((K_max, p), dtype=mu_abs.dtype)
+
+            d_mu_abs = cuda.to_device(mu_abs)
+            d_lam = cuda.to_device(lam)
+            d_y_noise = cuda.to_device(y_noise)
+            d_u_noise = cuda.to_device(u_noise)
+            d_out_tau2 = cuda.to_device(out_tau2)
+
+            threads_per_block = 64
+            blocks_per_grid = (K_max + threads_per_block - 1) // threads_per_block
+            _sample_inverse_gaussian_cuda[blocks_per_grid, threads_per_block](
+                d_mu_abs, d_lam, d_y_noise, d_u_noise, d_out_tau2
+            )
+
+            d_out_tau2.copy_to_host(out_tau2)
+            return out_tau2
+        else:
+            return _sample_inverse_gaussian_numba(mu_abs, lam, y_noise, u_noise)

bayesian_sparse_gmm/backends/_numpy.py

@@ -0,0 +1,53 @@
+import numpy as np
+
+from ..utils import sample_inverse_gaussian as utils_sample_inverse_gaussian
+from ._base import ComputeBackend
+
+
+class NumpyBackend(ComputeBackend):
+    """NumPy-based compute backend for the Bayesian Sparse GMM."""
+
+    def compute_cluster_log_probs(
+        self, X: np.ndarray, mu: np.ndarray, log_w: np.ndarray, sigma2: np.ndarray
+    ) -> np.ndarray:
+        """Step 2: Compute log probability of cluster assignment for all samples and clusters."""
+        # Scale X and mu by sqrt(sigma2) to compute diagonal Mahalanobis distance efficiently via GEMM trick
+        std = np.sqrt(sigma2)
+        X_scaled = X / std
+        mu_scaled = mu / std
+        x_sq = np.sum(X_scaled**2, axis=1, keepdims=True)
+        mu_sq = np.sum(mu_scaled**2, axis=1, keepdims=True).T
+        dist = x_sq - 2.0 * np.dot(X_scaled, mu_scaled.T) + mu_sq
+        dist = np.maximum(dist, 0.0)
+        return log_w - 0.5 * dist
+
+    def compute_sufficient_stats(
+        self, X: np.ndarray, z: np.ndarray, K_max: int
+    ) -> tuple[np.ndarray, np.ndarray]:
+        """Step 4: Compute cluster sizes and feature sums per cluster."""
+        n_k = np.bincount(z, minlength=K_max)
+        sum_x = np.zeros((K_max, X.shape[1]), dtype=X.dtype)
+        np.add.at(sum_x, z, X)
+        return n_k, sum_x
+
+    def sample_cluster_means(
+        self,
+        sum_x: np.ndarray,
+        n_k: np.ndarray,
+        tau2: np.ndarray,
+        sigma2: np.ndarray,
+        rng: np.random.Generator,
+    ) -> np.ndarray:
+        """Step 4b: Sample cluster means mu[k,j] ~ Normal."""
+        post_var = 1.0 / (n_k[:, np.newaxis] / sigma2[np.newaxis, :] + 1.0 / tau2)
+        post_mean = post_var * (sum_x / sigma2[np.newaxis, :])
+        return rng.normal(loc=post_mean, scale=np.sqrt(post_var))
+
+    def sample_inverse_gaussian(
+        self, mu_abs: np.ndarray, lam: np.ndarray, rng: np.random.Generator
+    ) -> np.ndarray:
+        """Step 4a: Sample tau^2 via Inverse Gaussian."""
+        inv_mean = lam / (mu_abs + 1e-10)
+        shape = lam**2
+        inv_tau2 = utils_sample_inverse_gaussian(inv_mean, shape, rng)
+        return 1.0 / inv_tau2

bayesian_sparse_gmm/config.py

@@ -0,0 +1,29 @@
+from dataclasses import dataclass
+from typing import Optional
+
+
+@dataclass(frozen=True)
+class HyperParams:
+    """Hyperparameters for the Bayesian GMM."""
+
+    lambda_0: float = 1000.0
+    lambda_1: float = 0.1
+    alpha: float = 0.01
+    theta: float = 0.1
+    a_sigma: float = 1.0
+    b_sigma: float = 1.0
+
+
+@dataclass(frozen=True)
+class SamplerConfig:
+    """Configuration options for the Gibbs sampler."""
+
+    K_max: int = 15
+    n_iter: int = 2000
+    burn_in: int = 500
+    thinning: int = 1
+    warm_up_iters: int = 50
+    backend: str = "auto"
+    n_jobs: int = -1
+    random_state: Optional[int] = None
+    verbose: int = 0

bayesian_sparse_gmm/diagnostics.py

@@ -0,0 +1,111 @@
+import numpy as np
+
+
+def _prepare_chains(trace: np.ndarray) -> tuple[np.ndarray, tuple]:
+    """Prepare input trace array to be of shape (M, N, D) and return original shape."""
+    orig_shape = trace.shape
+
+    # 1D: (samples,) -> (1, samples, 1)
+    if trace.ndim == 1:
+        return trace[np.newaxis, :, np.newaxis], ()
+
+    # 2D: (samples, D) -> (1, samples, D)
+    if trace.ndim == 2:
+        return trace[np.newaxis, :, :], (orig_shape[1],)
+
+    # 3D: (samples, K, P) -> (1, samples, K*P)
+    if trace.ndim == 3:
+        samples, k, p = trace.shape
+        return trace.reshape(1, samples, k * p), (k, p)
+
+    # 4D: (chains, samples, K, P) -> (chains, samples, K*P)
+    if trace.ndim == 4:
+        chains, samples, k, p = trace.shape
+        return trace.reshape(chains, samples, k * p), (k, p)
+
+    raise ValueError(f"Unsupported trace dimensions: {trace.ndim}")
+
+
+def gelman_rubin(trace: np.ndarray) -> np.ndarray:
+    """Compute Gelman-Rubin R-hat statistic for trace variables.
+
+    Supports single or multiple chains. For single chain inputs, split-R-hat is computed.
+    """
+    chains, param_shape = _prepare_chains(trace)
+    M, N, D = chains.shape
+
+    if N < 4:
+        # Too few samples to split/estimate
+        rhat_flat = np.ones(D)
+        return rhat_flat.reshape(param_shape) if param_shape else rhat_flat[0]
+
+    if M < 2:
+        # Split-R-hat: split each chain in half
+        N_half = N // 2
+        chains_split = np.empty((2 * M, N_half, D), dtype=chains.dtype)
+        for m in range(M):
+            chains_split[2 * m] = chains[m, :N_half]
+            chains_split[2 * m + 1] = chains[m, N_half : 2 * N_half]
+        chains = chains_split
+        M, N, D = chains.shape
+
+    # Means per chain
+    chain_means = np.mean(chains, axis=1)
+    overall_mean = np.mean(chain_means, axis=0)
+
+    # Within-chain variance
+    chain_vars = np.var(chains, axis=1, ddof=1)
+    W = np.mean(chain_vars, axis=0)
+
+    # Between-chain variance
+    B = (N / (M - 1.0)) * np.sum((chain_means - overall_mean) ** 2, axis=0)
+
+    # Estimated marginal variance
+    var_theta = ((N - 1.0) / N) * W + (1.0 / N) * B
+
+    rhat_flat = np.empty_like(var_theta)
+    zero_w = W == 0.0
+    rhat_flat[zero_w] = 1.0
+    rhat_flat[~zero_w] = np.sqrt(var_theta[~zero_w] / W[~zero_w])
+
+    if param_shape:
+        return rhat_flat.reshape(param_shape)
+    return rhat_flat[0]
+
+
+def effective_sample_size(trace: np.ndarray) -> np.ndarray:
+    """Compute Effective Sample Size (ESS) for MCMC chains."""
+    chains, param_shape = _prepare_chains(trace)
+    M, N, D = chains.shape
+
+    ess_flat = np.empty(D)
+
+    for d in range(D):
+        rhos = []
+        for m in range(M):
+            x = chains[m, :, d]
+            mean = np.mean(x)
+            var = np.var(x)
+            if var == 0.0:
+                rhos.append(np.zeros(N))
+                continue
+
+            xp = x - mean
+            corr = np.correlate(xp, xp, mode="full")
+            autocorr = corr[N - 1 :] / (N * var)
+            rhos.append(autocorr)
+
+        avg_rho = np.mean(rhos, axis=0)
+
+        sum_rho = 0.0
+        for t in range(1, N - 1, 2):
+            val = avg_rho[t] + avg_rho[t + 1]
+            if val < 0:
+                break
+            sum_rho += avg_rho[t] + avg_rho[t + 1]
+
+        ess_flat[d] = (M * N) / (1.0 + 2.0 * sum_rho)
+
+    if param_shape:
+        return ess_flat.reshape(param_shape)
+    return ess_flat[0]

bayesian_sparse_gmm/model.py

@@ -0,0 +1,203 @@
+from typing import Any, Dict, Optional
+
+import numpy as np
+from sklearn.base import BaseEstimator, ClusterMixin
+from sklearn.utils.validation import check_array, check_is_fitted
+
+from .backends import select_backend
+from .config import HyperParams, SamplerConfig
+from .sampler import GibbsSampler
+from .utils import log_sum_exp
+
+
+class BayesianSparseGMM(BaseEstimator, ClusterMixin):
+    """Bayesian Sparse Gaussian Mixture Model for high-dimensional clustering.
+
+    Parameters
+    ----------
+    K_max : int, default=15
+        Maximum number of clusters.
+    n_iter : int, default=2000
+        Number of Gibbs sampler iterations.
+    burn_in : int, default=500
+        Number of burn-in iterations to discard.
+    thinning : int, default=1
+        Thinning interval for MCMC samples.
+    lambda_0 : float, default=1000.0
+        Spike prior parameter (large value for sparse features).
+    lambda_1 : float, default=0.1
+        Slab prior parameter (small value for active features).
+    alpha : float, default=0.01
+        Dirichlet prior parameter for mixing weights.
+    theta : float, default=0.1
+        Prior probability of a feature being informative (Slab).
+    backend : str, default='auto'
+        Computation backend: 'numpy', 'numba', or 'auto'.
+    n_jobs : int, default=-1
+        Number of parallel jobs (for Numba backend).
+    random_state : int, optional
+        Seed for the random number generator.
+    verbose : int, default=0
+        Progress reporting interval.
+    """
+
+    def __init__(
+        self,
+        K_max: int = 15,
+        n_iter: int = 2000,
+        burn_in: int = 500,
+        thinning: int = 1,
+        warm_up_iters: int = 50,
+        lambda_0: float = 1000.0,
+        lambda_1: float = 0.1,
+        alpha: float = 0.01,
+        theta: float = 0.1,
+        a_sigma: float = 1.0,
+        b_sigma: float = 1.0,
+        backend: str = "auto",
+        n_jobs: int = -1,
+        random_state: Optional[int] = None,
+        verbose: int = 0,
+    ):
+        self.K_max = K_max
+        self.n_iter = n_iter
+        self.burn_in = burn_in
+        self.thinning = thinning
+        self.warm_up_iters = warm_up_iters
+        self.lambda_0 = lambda_0
+        self.lambda_1 = lambda_1
+        self.alpha = alpha
+        self.theta = theta
+        self.a_sigma = a_sigma
+        self.b_sigma = b_sigma
+        self.backend = backend
+        self.n_jobs = n_jobs
+        self.random_state = random_state
+        self.verbose = verbose
+
+    def fit(self, X: np.ndarray, y: Any = None) -> "BayesianSparseGMM":
+        """Fit the GMM model using Gibbs sampling."""
+        X = check_array(X, dtype=[np.float64, np.float32])
+
+        config = SamplerConfig(
+            K_max=self.K_max,
+            n_iter=self.n_iter,
+            burn_in=self.burn_in,
+            thinning=self.thinning,
+            warm_up_iters=self.warm_up_iters,
+            backend=self.backend,
+            n_jobs=self.n_jobs,
+            random_state=self.random_state,
+            verbose=self.verbose,
+        )
+        hyperparams = HyperParams(
+            lambda_0=self.lambda_0,
+            lambda_1=self.lambda_1,
+            alpha=self.alpha,
+            theta=self.theta,
+            a_sigma=self.a_sigma,
+            b_sigma=self.b_sigma,
+        )
+
+        self.backend_ = select_backend(config.backend)
+        sampler = GibbsSampler(config, hyperparams, self.backend_)
+
+        self.states_ = sampler.run(X, seed=self.random_state)
+
+        from .postprocessing import align_labels
+
+        self.states_ = align_labels(self.states_)
+
+        self.w_ = np.mean([state.w for state in self.states_], axis=0)
+        self.means_ = np.mean([state.mu for state in self.states_], axis=0)
+
+        # Consolidate local gamma states
+        self.feature_probabilities_2d_ = np.mean(
+            [state.gamma for state in self.states_], axis=0
+        )
+
+        # Final label assignment based on mode over samples
+        z_samples = np.array([state.z for state in self.states_])
+        labels = np.empty(X.shape[0], dtype=int)
+        for i in range(X.shape[0]):
+            labels[i] = np.argmax(np.bincount(z_samples[:, i]))
+        self.labels_ = labels
+
+        # Compute 1D feature probabilities for backward compatibility based on active clusters
+        active_clusters = np.unique(self.labels_)
+        if len(active_clusters) > 0:
+            self.feature_probabilities_ = np.max(
+                self.feature_probabilities_2d_[active_clusters], axis=0
+            )
+        else:
+            self.feature_probabilities_ = np.max(self.feature_probabilities_2d_, axis=0)
+        self.selected_features_ = np.where(self.feature_probabilities_ > 0.5)[0]
+
+        return self
+
+    def predict_proba(self, X: np.ndarray) -> np.ndarray:
+        """Predict posterior probability of each cluster for each sample."""
+        X = check_array(X, dtype=[np.float64, np.float32])
+        check_is_fitted(self, "states_")
+
+        n = X.shape[0]
+        threshold = 1.0 / (2.0 * n)
+        all_probs = []
+        for state in self.states_:
+            w_safe = np.where(state.w < threshold, 1e-300, state.w)
+            log_w = np.log(w_safe)
+            log_probs = self.backend_.compute_cluster_log_probs(
+                X, state.mu, log_w, state.sigma2
+            )
+
+            max_log = np.max(log_probs, axis=1, keepdims=True)
+            probs = np.exp(log_probs - max_log)
+            probs /= np.sum(probs, axis=1, keepdims=True)
+            all_probs.append(probs)
+
+        return np.mean(all_probs, axis=0)
+
+    def predict(self, X: np.ndarray) -> np.ndarray:
+        """Predict cluster index for each sample."""
+        return np.argmax(self.predict_proba(X), axis=1)
+
+    def score(self, X: np.ndarray, y: Any = None) -> float:
+        """Compute the average GMM log-likelihood of the dataset."""
+        X = check_array(X, dtype=[np.float64, np.float32])
+        check_is_fitted(self, "states_")
+
+        n, p = X.shape
+        threshold = 1.0 / (2.0 * n)
+
+        log_liks = []
+        for state in self.states_:
+            w_safe = np.where(state.w < threshold, 1e-300, state.w)
+            log_w = np.log(w_safe)
+            log_probs = self.backend_.compute_cluster_log_probs(
+                X, state.mu, log_w, state.sigma2
+            )
+
+            const = -0.5 * p * np.log(2.0 * np.pi) - 0.5 * np.sum(np.log(state.sigma2))
+            sample_log_lik = log_sum_exp(log_probs, axis=1) + const
+            log_liks.append(np.mean(sample_log_lik))
+
+        return float(np.mean(log_liks))
+
+    @property
+    def n_clusters_(self) -> int:
+        """Number of active clusters."""
+        check_is_fitted(self, "labels_")
+        return len(np.unique(self.labels_))
+
+    @property
+    def trace_(self) -> Dict[str, np.ndarray]:
+        """Full trace of MCMC samples."""
+        check_is_fitted(self, "states_")
+        return {
+            "z": np.array([state.z for state in self.states_]),
+            "w": np.array([state.w for state in self.states_]),
+            "mu": np.array([state.mu for state in self.states_]),
+            "gamma": np.array([state.gamma for state in self.states_]),
+            "theta": np.array([state.theta for state in self.states_]),
+            "sigma2": np.array([state.sigma2 for state in self.states_]),
+        }

bayesian_sparse_gmm/postprocessing.py

@@ -0,0 +1,46 @@
+from typing import List
+
+import numpy as np
+from scipy.optimize import linear_sum_assignment
+
+from .state import SamplerState
+
+
+def align_labels(states: List[SamplerState]) -> List[SamplerState]:
+    """Align cluster labels across MCMC iterations to solve label switching.
+
+    Uses the final state as the reference and applies the Hungarian algorithm
+    (linear sum assignment) to match clusters in each state to the reference based
+    on the Euclidean distance of their cluster means.
+    """
+    if not states:
+        return states
+
+    ref_idx = int(np.argmax([np.std(s.w) for s in states]))
+    ref_mu = states[ref_idx].mu
+
+    for state in states:
+        diff = state.mu[:, np.newaxis, :] - ref_mu[np.newaxis, :, :]
+        cost_matrix = np.sum(diff**2, axis=2)
+        row_ind, col_ind = linear_sum_assignment(cost_matrix)
+
+        new_mu = np.empty_like(state.mu)
+        new_w = np.empty_like(state.w)
+        new_tau2 = np.empty_like(state.tau2)
+        new_gamma = np.empty_like(state.gamma)
+        new_z = np.empty_like(state.z)
+
+        for r, c in zip(row_ind, col_ind):
+            new_mu[c] = state.mu[r]
+            new_w[c] = state.w[r]
+            new_tau2[c] = state.tau2[r]
+            new_gamma[c] = state.gamma[r]
+            new_z[state.z == r] = c
+
+        state.mu = new_mu
+        state.w = new_w
+        state.tau2 = new_tau2
+        state.gamma = new_gamma
+        state.z = new_z
+
+    return states

bayesian_sparse_gmm/sampler.py

@@ -0,0 +1,167 @@
+from typing import List, Optional
+
+import numpy as np
+from tqdm import tqdm
+
+from .backends._base import ComputeBackend
+from .config import HyperParams, SamplerConfig
+from .state import SamplerState
+
+
+class GibbsSampler:
+    """Gibbs Sampler orchestrator for Bayesian Sparse GMM."""
+
+    def __init__(
+        self, config: SamplerConfig, hyperparams: HyperParams, backend: ComputeBackend
+    ):
+        self.config = config
+        self.hyperparams = hyperparams
+        self.backend = backend
+
+    def initialize(self, X: np.ndarray, rng: np.random.Generator) -> SamplerState:
+        """Initialize the sampler state using K-Means++ or random assignment."""
+        n, p = X.shape
+        K_max = self.config.K_max
+
+        try:
+            from sklearn.cluster import KMeans
+
+            kmeans = KMeans(
+                n_clusters=K_max,
+                init="k-means++",
+                n_init=1,
+                random_state=rng.integers(0, 2**31 - 1),
+            )
+            kmeans.fit(X)
+            z = kmeans.labels_
+            mu = kmeans.cluster_centers_.copy()
+
+        except Exception:
+            z = rng.choice(K_max, size=n)
+            mu = rng.normal(size=(K_max, p))
+
+        w = np.ones(K_max) / K_max
+        gamma = np.ones((K_max, p), dtype=np.int32)
+        theta = self.hyperparams.theta
+        tau2 = np.ones((K_max, p))
+        sigma2 = np.ones(p)
+
+        return SamplerState(
+            z=z,
+            w=w,
+            mu=mu,
+            gamma=gamma,
+            theta=theta,
+            tau2=tau2,
+            sigma2=sigma2,
+            iteration=0,
+        )
+
+    def sample_step(
+        self, X: np.ndarray, state: SamplerState, rng: np.random.Generator
+    ) -> SamplerState:
+        """Execute one complete Gibbs sampling iteration."""
+        K_max = self.config.K_max
+        n, p = X.shape
+        hp = self.hyperparams
+
+        # STEP 1: Update cluster assignments (z) using the previous mixing weights
+        threshold = 1.0 / (2.0 * n)
+        w_safe = np.where(state.w < threshold, 1e-300, state.w)
+        log_w = np.log(w_safe)
+        log_probs = self.backend.compute_cluster_log_probs(
+            X, state.mu, log_w, state.sigma2
+        )
+        max_log = np.max(log_probs, axis=1, keepdims=True)
+        probs = np.exp(log_probs - max_log)
+        probs /= np.sum(probs, axis=1, keepdims=True)
+
+        cumsum = np.cumsum(probs, axis=1)
+        u = rng.uniform(size=(n, 1))
+        z = np.sum(cumsum < u, axis=1)
+        z = np.clip(z, 0, K_max - 1)
+
+        # STEP 2: Update cluster mixing weights (w) using the new cluster assignments
+        n_k = np.bincount(z, minlength=K_max)
+        w = rng.dirichlet(hp.alpha + n_k)
+
+        # STEP 3: Update feature inclusion indicators (gamma) using active cluster mask
+        active_mask = n_k > 0
+        active_K = int(np.sum(active_mask))
+        if active_K == 0:
+            active_K = K_max
+            active_mask = np.ones(K_max, dtype=bool)
+
+        gamma = np.zeros((K_max, p), dtype=np.int32)
+        if state.iteration < self.config.warm_up_iters:
+            # During warm-up, force gamma to 1 for all active clusters to allow means to migrate
+            gamma[active_mask] = 1
+        else:
+            # Local feature selection: sample gamma_kj independently for active clusters
+            active_mu = state.mu[active_mask]
+            log_laplace_slab = (
+                np.log(hp.lambda_1) - np.log(2.0)
+            ) - hp.lambda_1 * np.abs(active_mu)
+            log_laplace_spike = (
+                np.log(hp.lambda_0) - np.log(2.0)
+            ) - hp.lambda_0 * np.abs(active_mu)
+
+            safe_theta = np.clip(state.theta, 1e-15, 1.0 - 1e-15)
+            log_P_slab = np.log(safe_theta) + log_laplace_slab
+            log_P_spike = np.log(1.0 - safe_theta) + log_laplace_spike
+
+            max_log = np.maximum(log_P_slab, log_P_spike)
+            prob_slab = np.exp(log_P_slab - max_log)
+            prob_spike = np.exp(log_P_spike - max_log)
+            p_slab = prob_slab / (prob_slab + prob_spike)
+
+            gamma[active_mask] = rng.binomial(1, p_slab)
+
+        # STEP 3b: Update feature-specific variances (sigma2)
+        # sigma2_j ~ Inverse-Gamma(a_sigma + N / 2, b_sigma + 0.5 * sum_i (X_ij - mu_{Z_i, j})^2)
+        residuals_sq = (X - state.mu[z]) ** 2
+        sum_residuals_sq = np.sum(residuals_sq, axis=0)
+
+        shape_sig = hp.a_sigma + 0.5 * n
+        scale_sig = 1.0 / (hp.b_sigma + 0.5 * sum_residuals_sq)
+
+        gamma_sig_sample = rng.gamma(shape_sig, scale_sig)
+        sigma2 = 1.0 / np.maximum(gamma_sig_sample, 1e-15)
+
+        # STEP 4: Update cluster means (mu) and auxiliary variables (tau2)
+        lam = np.where(gamma == 1, hp.lambda_1, hp.lambda_0)
+        tau2 = self.backend.sample_inverse_gaussian(np.abs(state.mu), lam, rng)
+
+        n_k_new, sum_x = self.backend.compute_sufficient_stats(X, z, K_max)
+        mu = self.backend.sample_cluster_means(sum_x, n_k_new, tau2, sigma2, rng)
+
+        return SamplerState(
+            z=z,
+            w=w,
+            mu=mu,
+            gamma=gamma,
+            theta=state.theta,
+            tau2=tau2,
+            sigma2=sigma2,
+            iteration=state.iteration + 1,
+        )
+
+    def run(self, X: np.ndarray, seed: Optional[int] = None) -> List[SamplerState]:
+        """Run the Gibbs sampler chain and return thinned post-burn-in states."""
+        rng = np.random.default_rng(seed)
+        state = self.initialize(X, rng)
+
+        n_iter = self.config.n_iter
+        burn_in = self.config.burn_in
+        thinning = self.config.thinning
+        verbose = self.config.verbose
+
+        states = []
+        iterator = tqdm(range(1, n_iter + 1), disable=not verbose, desc="Gibbs Sampler")
+        for i in iterator:
+            state = self.sample_step(X, state, rng)
+
+            if i > burn_in and (i - burn_in) % thinning == 0:
+                states.append(state)
+
+        return states

bayesian_sparse_gmm/state.py

@@ -0,0 +1,17 @@
+from dataclasses import dataclass
+
+import numpy as np
+
+
+@dataclass
+class SamplerState:
+    """MCMC sampler state at a single iteration."""
+
+    z: np.ndarray
+    w: np.ndarray
+    mu: np.ndarray
+    gamma: np.ndarray
+    theta: float
+    tau2: np.ndarray
+    sigma2: np.ndarray
+    iteration: int

bayesian_sparse_gmm/utils.py

@@ -0,0 +1,30 @@
+import numpy as np
+
+
+def log_sum_exp(x: np.ndarray, axis: int = -1, keepdims: bool = False) -> np.ndarray:
+    """Compute log of sum of exponentials in a numerically stable way."""
+    x_max = np.max(x, axis=axis, keepdims=True)
+    res = x_max + np.log(np.sum(np.exp(x - x_max), axis=axis, keepdims=True))
+    if not keepdims:
+        res = np.squeeze(res, axis=axis)
+    return res
+
+
+def sample_inverse_gaussian(
+    mean: np.ndarray, shape: np.ndarray, rng: np.random.Generator
+) -> np.ndarray:
+    """Sample from Inverse Gaussian distribution using Michael et al. (1976)."""
+    mean = np.minimum(mean, 1e5)
+    y = rng.normal(size=mean.shape) ** 2
+    mean2 = mean**2
+    term = np.sqrt(np.maximum(0.0, 4.0 * mean * shape * y + mean2 * (y**2)))
+    x1 = mean / (1.0 + (mean * y) / (2.0 * shape) + term / (2.0 * shape))
+    u = rng.uniform(size=mean.shape)
+
+    cond = mean / (mean + x1 + 1e-15)
+    mask = u <= cond
+
+    res = np.empty_like(mean)
+    res[mask] = x1[mask]
+    res[~mask] = mean2[~mask] / (x1[~mask] + 1e-15)
+    return res

bayesian_sparse_gmm-0.1.0.dist-info/METADATA

@@ -0,0 +1,108 @@
+Metadata-Version: 2.4
+Name: bayesian-sparse-gmm
+Version: 0.1.0
+Summary: Bayesian Sparse Gaussian Mixture Model implementation in Python
+Author-email: Nam Nam <nampvh4436@gmail.com>
+License: MIT
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9
+Requires-Dist: numpy>=1.20.0
+Requires-Dist: scikit-learn>=1.0.0
+Requires-Dist: scipy>=1.7.0
+Requires-Dist: tqdm>=4.60.0
+Provides-Extra: dev
+Requires-Dist: black>=22.0.0; extra == 'dev'
+Requires-Dist: flake8>=4.0.0; extra == 'dev'
+Requires-Dist: isort>=5.10.0; extra == 'dev'
+Requires-Dist: matplotlib>=3.5.0; extra == 'dev'
+Requires-Dist: pytest>=7.0.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# Bayesian Sparse GMM
+
+Bayesian Sparse Gaussian Mixture Model (GMM) implementation in Python.
+
+This model employs a sparsity-inducing prior (e.g., a Dirichlet distribution with parameter $\alpha_0 < 1$) over mixture component weights to automatically determine/prune the number of active components.
+
+## Installation
+
+To install the latest release:
+
+```bash
+pip install bayesian-sparse-gmm
+```
+
+Or for development (editable mode):
+
+```bash
+git clone https://github.com/Coalyx/bayesian-sparse-gmm.git
+cd bayesian-sparse-gmm
+pip install -e .
+```
+
+## Quick Start
+
+```python
+import numpy as np
+from sklearn.datasets import make_blobs
+from sklearn.preprocessing import StandardScaler
+from bayesian_sparse_gmm import BayesianSparseGMM
+
+# Append noise dimensions to true clusters to verify that the model successfully performs feature selection.
+rng = np.random.default_rng(42)
+X_clean, _ = make_blobs(n_samples=200, centers=3, n_features=2, cluster_std=0.5, random_state=42)
+X_noise = rng.normal(loc=0.0, scale=1.0, size=(200, 8))
+X = np.hstack([X_clean, X_noise])
+
+# Standardize features to satisfy the zero-mean assumptions in the prior structure.
+X = StandardScaler().fit_transform(X)
+
+model = BayesianSparseGMM(
+    K_max=5,
+    n_iter=300,
+    burn_in=100,
+    lambda_0=10.0,
+    lambda_1=0.05,
+    random_state=42,
+    verbose=0
+)
+model.fit(X)
+
+print(f"Number of active clusters: {model.n_clusters_}")
+print(f"Selected informative features: {model.selected_features_}")
+print(f"Feature inclusion probabilities: {model.feature_probabilities_.round(3)}")
+
+labels = model.predict(X)
+```
+
+## Development and Testing
+
+Install development dependencies:
+
+```bash
+pip install -e ".[dev]"
+```
+
+Run tests using `pytest`:
+
+```bash
+pytest
+```
+
+## Reference
+
+```bib
+@article{JMLR:v26:23-0142,
+  author  = {Dapeng Yao and Fangzheng Xie and Yanxun Xu},
+  title   = {Bayesian Sparse Gaussian Mixture Model for Clustering in High Dimensions},
+  journal = {Journal of Machine Learning Research},
+  year    = {2025},
+  volume  = {26},
+  number  = {21},
+  pages   = {1--50},
+  url     = {http://jmlr.org/papers/v26/23-0142.html}
+}
+```

bayesian_sparse_gmm-0.1.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+bayesian_sparse_gmm/__init__.py,sha256=zp-sMET8SlJ0Yief18xABg6ZhKk5sJklPidSeDTmVBM,93
+bayesian_sparse_gmm/config.py,sha256=fotJjoKIOLjyhaUfBU4aNVv6xpUjDGsKJLjbgXweOhY,634
+bayesian_sparse_gmm/diagnostics.py,sha256=Sq0RfGaNxMPD_53myuCWSqdtbz26XaHiUHJAcEj_yYU,3401
+bayesian_sparse_gmm/model.py,sha256=i_skapVvvAE4TLNPb41noNi3OrZ_x2RymV8DTY_krL0,7271
+bayesian_sparse_gmm/postprocessing.py,sha256=ZBAP-70nk2BHUXQ7LNJ-I0O3rGfvdq0ByFhcehrBUc8,1434
+bayesian_sparse_gmm/sampler.py,sha256=wWakTN8Ju_SA13s5ievtmzTmDopApuEBLjuQ-Il3gr0,5915
+bayesian_sparse_gmm/state.py,sha256=qV-s174UGYH-1kUt6wnidd7MP54pBthqfPfqQTfEQ5s,297
+bayesian_sparse_gmm/utils.py,sha256=pL-0ZdV29a5DxqkvaBbPyry3MmanqHNMfYUn_jiZmck,1044
+bayesian_sparse_gmm/backends/__init__.py,sha256=VUsyddYY88DyAPJOI0mS7GiHjIfzVbnQmLAf0sj7JRI,1552
+bayesian_sparse_gmm/backends/_base.py,sha256=E7InzD5jQcYzVl-AJ9IW2337U_D3TN82VtunTn81H1Y,1254
+bayesian_sparse_gmm/backends/_cuda.py,sha256=FHPO9seyFVIDHt7pcM3xGmMeYiOI18i8UsBwS-Jh55U,3313
+bayesian_sparse_gmm/backends/_numba.py,sha256=jACpeg3YNK4feDlkF0OfJ_EAOYiaWIRckeXr--lwnsc,9037
+bayesian_sparse_gmm/backends/_numpy.py,sha256=tztz3TESWDQWZinGa6qcj4hsoCz6PpFHiEMaLiLEz-0,2129
+bayesian_sparse_gmm-0.1.0.dist-info/METADATA,sha256=xjh1Z0UPVYQEom3ylQdo7jVfzuiFrm4E46M_m1tjHGA,2958
+bayesian_sparse_gmm-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+bayesian_sparse_gmm-0.1.0.dist-info/RECORD,,

bayesian_sparse_gmm-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any