pbhc 0.1.0__tar.gz

pbhc-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Albert Alonso
+
+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.

pbhc-0.1.0/PKG-INFO

@@ -0,0 +1,94 @@
+Metadata-Version: 2.4
+Name: pbhc
+Version: 0.1.0
+Summary: Minimal parallel Bayesian hierarchical clustering on graphs in JAX.
+Author-email: Albert Alonso <alonfnt@pm.me>
+License: MIT License
+        
+        Copyright (c) 2026 Albert Alonso
+        
+        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.
+        
+Project-URL: Homepage, https://github.com/alonfnt/pbhc
+Project-URL: Documentation, https://github.com/alonfnt/pbhc
+Project-URL: Source, https://github.com/alonfnt/pbhc
+Project-URL: Bug Tracker, https://github.com/alonfnt/pbhc/issues
+Keywords: jax,clustering,bayesian,hierarchical-clustering,graph
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: jax
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: scipy; extra == "dev"
+Dynamic: license-file
+
+[![tests](https://github.com/alonfnt/pbhc/actions/workflows/pytest.yml/badge.svg)](https://github.com/alonfnt/pbhc/actions/workflows/pytest.yml)
+[![PyPI](https://img.shields.io/pypi/v/pbhc.svg)](https://pypi.org/project/pbhc/)
+
+`pbhc` is a minimal parallel Bayesian hierarchical clustering (BHC) implementation in [JAX](https://github.com/jax-ml/jax) that runs on GPU/TPU/CPU.
+Clustering is constrained to a graph: only clusters joined by an edge may merge, so on a pixel grid every cluster is spatially contiguous.
+Instead of BHC's one-merge-at-a-time greedy loop, every cluster merges with its most probable neighbour in the same round (Borůvka-style), so the number of rounds grows roughly with the log of the number of points.
+
+Each cluster follows a diagonal Normal-Normal model, `x ~ N(mu, sigma2)`, `mu ~ N(0, tau2)`, with a Dirichlet process prior of concentration `alpha` ([Heller & Ghahramani, 2005](https://doi.org/10.1145/1102351.1102389)).
+Merges of several children at once use the product over children of [Bayesian rose trees](https://arxiv.org/abs/1203.3468), and merging stops when no merge has posterior probability above `threshold` (0.5 by default).
+
+## Usage
+```python
+import jax
+import jax.numpy as jnp
+import pbhc
+
+jax.config.update("jax_enable_x64", True)  # recommended for large inputs
+
+# 100 points in a line: the first 50 around 0, the last 50 around 10
+X = jax.random.normal(jax.random.key(0), (100, 3)).at[50:].add(10)
+
+# edges between consecutive points (only connected clusters can merge)
+i, j = jnp.arange(99), jnp.arange(1, 100)
+
+# sigma2: spread inside a cluster, from differences between neighbours
+# tau2: spread between clusters, from the variance of the whole data
+sigma2 = 0.5 * jnp.mean((X[i] - X[j]) ** 2)
+tau2 = jnp.var(X)
+
+state = pbhc.fit(X, i, j, sigma2=sigma2, tau2=tau2)
+print(state.labels)  # [0 0 ... 0 1 1 ... 1]
+```
+
+## Installation
+`pbhc` can be installed from PyPI via `pip`
+```
+pip install pbhc
+```
+
+## Citation
+If you use `pbhc` in your research and need to reference it, please cite it as follows:
+```
+@software{alonso_pbhc,
+  author = {Alonso, Albert},
+  title = {pbhc: Minimal Parallel Bayesian Hierarchical Clustering in JAX},
+  url = {https://github.com/alonfnt/pbhc},
+  version = {0.1.0}
+}
+```

pbhc-0.1.0/README.md

@@ -0,0 +1,49 @@
+[![tests](https://github.com/alonfnt/pbhc/actions/workflows/pytest.yml/badge.svg)](https://github.com/alonfnt/pbhc/actions/workflows/pytest.yml)
+[![PyPI](https://img.shields.io/pypi/v/pbhc.svg)](https://pypi.org/project/pbhc/)
+
+`pbhc` is a minimal parallel Bayesian hierarchical clustering (BHC) implementation in [JAX](https://github.com/jax-ml/jax) that runs on GPU/TPU/CPU.
+Clustering is constrained to a graph: only clusters joined by an edge may merge, so on a pixel grid every cluster is spatially contiguous.
+Instead of BHC's one-merge-at-a-time greedy loop, every cluster merges with its most probable neighbour in the same round (Borůvka-style), so the number of rounds grows roughly with the log of the number of points.
+
+Each cluster follows a diagonal Normal-Normal model, `x ~ N(mu, sigma2)`, `mu ~ N(0, tau2)`, with a Dirichlet process prior of concentration `alpha` ([Heller & Ghahramani, 2005](https://doi.org/10.1145/1102351.1102389)).
+Merges of several children at once use the product over children of [Bayesian rose trees](https://arxiv.org/abs/1203.3468), and merging stops when no merge has posterior probability above `threshold` (0.5 by default).
+
+## Usage
+```python
+import jax
+import jax.numpy as jnp
+import pbhc
+
+jax.config.update("jax_enable_x64", True)  # recommended for large inputs
+
+# 100 points in a line: the first 50 around 0, the last 50 around 10
+X = jax.random.normal(jax.random.key(0), (100, 3)).at[50:].add(10)
+
+# edges between consecutive points (only connected clusters can merge)
+i, j = jnp.arange(99), jnp.arange(1, 100)
+
+# sigma2: spread inside a cluster, from differences between neighbours
+# tau2: spread between clusters, from the variance of the whole data
+sigma2 = 0.5 * jnp.mean((X[i] - X[j]) ** 2)
+tau2 = jnp.var(X)
+
+state = pbhc.fit(X, i, j, sigma2=sigma2, tau2=tau2)
+print(state.labels)  # [0 0 ... 0 1 1 ... 1]
+```
+
+## Installation
+`pbhc` can be installed from PyPI via `pip`
+```
+pip install pbhc
+```
+
+## Citation
+If you use `pbhc` in your research and need to reference it, please cite it as follows:
+```
+@software{alonso_pbhc,
+  author = {Alonso, Albert},
+  title = {pbhc: Minimal Parallel Bayesian Hierarchical Clustering in JAX},
+  url = {https://github.com/alonfnt/pbhc},
+  version = {0.1.0}
+}
+```

pbhc-0.1.0/pbhc/__init__.py

@@ -0,0 +1,3 @@
+from .bhc import fit, log_marginal, PBHCState
+
+__version__ = '0.1.0'

pbhc-0.1.0/pbhc/bhc.py

@@ -0,0 +1,129 @@
+from typing import NamedTuple
+
+import jax
+import jax.numpy as jnp
+from jax.scipy.special import gammaln
+
+
+class PBHCState(NamedTuple):
+    """Result of fit.
+
+    Attributes:
+        labels: Cluster of each point, 0..k-1.
+        size: Size of the point's cluster.
+        log_d: BHC's log d of the point's cluster.
+        log_p: Log evidence log p(D | T) of the point's cluster.
+        rounds: Number of merge rounds.
+    """
+
+    labels: jax.Array
+    size: jax.Array
+    log_d: jax.Array
+    log_p: jax.Array
+    rounds: jax.Array
+
+
+def log_marginal(n: jax.Array, s: jax.Array, ss: jax.Array, sigma2, tau2) -> jax.Array:
+    """
+    Log p(D | H1) of each cluster, with x ~ N(mu, sigma2) and mu ~ N(0, tau2).
+
+    Args:
+        n: Points per cluster, shape (k,).
+        s: Sum of the points, shape (k, n_features).
+        ss: Sum of squares of the points, shape (k, n_features).
+        sigma2: Variance of points around their cluster mean.
+        tau2: Variance of the cluster means.
+
+    Returns:
+        Log marginal likelihood per cluster, shape (k,).
+    """
+    n = n[:, None]
+    return jnp.sum(-0.5 * n * jnp.log(2 * jnp.pi * sigma2) - 0.5 * jnp.log1p(n * tau2 / sigma2)
+                   - (ss - tau2 * s**2 / (sigma2 + n * tau2)) / (2 * sigma2), axis=1)
+
+
+def _join(m, s, ss, log_d_children, log_p_children, sigma2, tau2, log_alpha, beta):
+    """Merge children into one node. Returns log d, log p(D | T) and the merge log-odds."""
+    log_d = jnp.logaddexp(log_alpha + gammaln(m), log_d_children)
+    log_pi = log_alpha + gammaln(m) - log_d
+    h1 = beta * log_marginal(m, s, ss, sigma2, tau2)
+    rest = log_d_children - log_d + log_p_children  # log(1 - pi) = log(prod d_children / d), exact
+    return log_d, jnp.logaddexp(log_pi + h1, rest), log_pi + h1 - rest
+
+
+def _step(state, sigma2, tau2, log_alpha, beta, min_log_odds):
+    """One round: each cluster merges with its best neighbour if r > threshold."""
+    size, S, SS, log_d, log_p, ei, ej, label = state
+    n, ids = len(size), jnp.arange(len(size))
+    hyper = (sigma2, tau2, log_alpha, beta)
+    _, _, lo = _join(size[ei] + size[ej], S[ei] + S[ej], SS[ei] + SS[ej],
+                     log_d[ei] + log_d[ej], log_p[ei] + log_p[ej], *hyper)
+    lo = jnp.where(ei != ej, lo, -jnp.inf)
+
+    # each cluster points to its best neighbour if r > threshold; 2-cycles keep the smaller id as root
+    ends, other = jnp.concatenate([ei, ej]), jnp.concatenate([ej, ei])
+    lo2 = jnp.concatenate([lo, lo])
+    best = jax.ops.segment_max(lo2, ends, n)
+    target = jax.ops.segment_min(jnp.where(lo2 == best[ends], other, n), ends, n)
+    target = jnp.where((best > min_log_odds) & (target < n), target, ids)
+    target = jnp.where((target[target] == ids) & (ids < target), ids, target)
+    root = jax.lax.fori_loop(0, n.bit_length(), lambda _, r: r[r], target)  # pointer jumping
+
+    # merge every group that shares a root: sums of statistics, product over children in _join()
+    seg = lambda v: jax.ops.segment_sum(v, root, n)  # noqa: E731
+    kids = seg(jnp.ones_like(size))
+    m, s, ss = seg(size), seg(S), seg(SS)
+    new_d, new_p, _ = _join(m, s, ss, seg(log_d), seg(log_p), *hyper)
+    grouped = kids > 1
+    size, S, SS = jnp.where(grouped, m, size), jnp.where(grouped[:, None], s, S), jnp.where(grouped[:, None], ss, SS)
+    log_d, log_p = jnp.where(grouped, new_d, log_d), jnp.where(grouped, new_p, log_p)
+    ei, ej, label = root[ei], root[ej], root[label]
+    return (size, S, SS, log_d, log_p, ei, ej, label), grouped.any()
+
+
+@jax.jit
+def fit(x: jax.Array, i: jax.Array, j: jax.Array, sigma2, tau2, alpha: float = 1.0,
+        beta: float = 1.0, threshold: float = 0.5) -> PBHCState:
+    """
+    Bayesian hierarchical clustering of the rows of x, where only clusters joined by an edge can merge.
+
+    Each round, every cluster merges with its best neighbour if the merge probability is above threshold.
+    Enable float64 for large inputs.
+
+    Args:
+        x: Data, shape (n_samples, n_features).
+        i: Edge sources, shape (n_edges,).
+        j: Edge targets, shape (n_edges,).
+        sigma2: Variance of points around their cluster mean.
+        tau2: Variance of the cluster means.
+        alpha: Dirichlet process concentration. Larger gives more clusters.
+        beta: Likelihood temperature. Smaller gives larger clusters.
+        threshold: Minimum merge probability.
+
+    Returns:
+        The fitted PBHCState.
+
+    Each new input size compiles again. To reuse one compile across sizes, pad x with extra rows and the
+    edges with self-loops (i == j), which never merge.
+    """
+    x = jnp.asarray(x, float)
+    n = len(x)
+    size = jnp.ones(n, x.dtype)
+    log_d = jnp.full(n, jnp.log(alpha), x.dtype)
+    log_p = beta * log_marginal(size, x, x**2, sigma2, tau2)
+    state = (size, x, x**2, log_d, log_p, jnp.asarray(i, int), jnp.asarray(j, int), jnp.arange(n))
+    hyper = (sigma2, tau2, jnp.log(alpha), beta, jnp.log(threshold) - jnp.log1p(-threshold))
+
+    def body(carry):
+        state, _, rounds = carry
+        state, merged = _step(state, *hyper)
+        return state, merged, rounds + 1
+
+    state, _, rounds = jax.lax.while_loop(lambda c: c[1], body, (state, True, 0))
+
+    root = state[7]
+    is_root = jnp.zeros(n, int).at[root].set(1)
+    labels = (jnp.cumsum(is_root) - 1)[root]
+    return PBHCState(labels=labels, size=state[0][root], log_d=state[3][root], log_p=state[4][root],
+                     rounds=rounds)
+

pbhc-0.1.0/pbhc/bhc_test.py

@@ -0,0 +1,90 @@
+import jax
+import jax.numpy as jnp
+import numpy as np
+import pytest
+
+jax.config.update("jax_enable_x64", True)
+
+from pbhc import fit, log_marginal  # noqa: E402
+
+KEY = jax.random.key(42)
+
+
+def path(n):
+    return jnp.arange(n - 1), jnp.arange(1, n)
+
+
+def blobs(n, d=3, gap=10.0):
+    x = jax.random.normal(KEY, (2 * n, d))
+    return x.at[n:].add(gap)
+
+
+def test_log_marginal_matches_scipy():
+    from scipy.stats import multivariate_normal
+    sigma2, tau2, n = 0.5, 2.0, 7
+    x = jax.random.normal(KEY, (n, 3))
+    lm = log_marginal(jnp.array([n]), x.sum(0)[None], (x**2).sum(0)[None], sigma2, tau2)[0]
+    cov = sigma2 * np.eye(n) + tau2 * np.ones((n, n))
+    ref = sum(multivariate_normal(np.zeros(n), cov).logpdf(np.asarray(x[:, k])) for k in range(3))
+    assert jnp.allclose(lm, ref, rtol=1e-10)
+
+
+def test_two_blobs_on_path():
+    x = blobs(50)
+    state = fit(x, *path(100), sigma2=1.0, tau2=100.0)
+    labels = np.asarray(state.labels)
+    assert len(np.unique(labels)) == 2
+    assert np.all(labels[:50] == labels[0]) and np.all(labels[50:] == labels[50])
+    assert np.all(np.asarray(state.size) == 50)
+
+
+def test_no_edges_no_merges():
+    x = jax.random.normal(KEY, (20, 2))
+    state = fit(x, jnp.zeros(0, int), jnp.zeros(0, int), sigma2=1.0, tau2=1.0)
+    assert len(np.unique(state.labels)) == 20
+    assert state.rounds == 1
+
+
+def test_disconnected_components_never_merge():
+    x = jnp.zeros((20, 2))
+    i, j = path(10)
+    state = fit(x, jnp.concatenate([i, i + 10]), jnp.concatenate([j, j + 10]), sigma2=1.0, tau2=1.0)
+    labels = np.asarray(state.labels)
+    assert len(np.unique(labels)) == 2
+    assert labels[0] != labels[10]
+
+
+@pytest.mark.parametrize("n", [5, 17, 100, 333])
+def test_labels_contiguous(n):
+    x = jax.random.normal(KEY, (n, 4)) * 3
+    state = fit(x, *path(n), sigma2=1.0, tau2=4.0)
+    labels = np.asarray(state.labels)
+    assert labels.shape == (n,)
+    assert set(np.unique(labels)) == set(range(labels.max() + 1))
+
+
+def test_edge_order_invariant():
+    x = blobs(30)
+    i, j = path(60)
+    a = fit(x, i, j, sigma2=1.0, tau2=100.0).labels
+    b = fit(x, j[::-1], i[::-1], sigma2=1.0, tau2=100.0).labels
+    assert jnp.array_equal(a, b)
+
+
+def test_alpha_controls_number_of_clusters():
+    x = jax.random.normal(KEY, (200, 2)) * 2
+    k = [len(np.unique(fit(x, *path(200), sigma2=1.0, tau2=4.0, alpha=a).labels)) for a in (1e-3, 1e3)]
+    assert k[0] <= k[1]
+
+
+def test_threshold_controls_number_of_clusters():
+    x = jax.random.normal(KEY, (200, 2)) * 2
+    k = [len(np.unique(fit(x, *path(200), sigma2=1.0, tau2=4.0, threshold=t).labels)) for t in (0.01, 0.99)]
+    assert k[0] <= k[1]
+
+
+def test_jit():
+    x = blobs(20)
+    a = fit(x, *path(40), sigma2=1.0, tau2=100.0)
+    b = jax.jit(fit)(x, *path(40), sigma2=1.0, tau2=100.0, alpha=1.0)
+    assert jnp.array_equal(a.labels, b.labels)

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

@@ -0,0 +1,94 @@
+Metadata-Version: 2.4
+Name: pbhc
+Version: 0.1.0
+Summary: Minimal parallel Bayesian hierarchical clustering on graphs in JAX.
+Author-email: Albert Alonso <alonfnt@pm.me>
+License: MIT License
+        
+        Copyright (c) 2026 Albert Alonso
+        
+        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.
+        
+Project-URL: Homepage, https://github.com/alonfnt/pbhc
+Project-URL: Documentation, https://github.com/alonfnt/pbhc
+Project-URL: Source, https://github.com/alonfnt/pbhc
+Project-URL: Bug Tracker, https://github.com/alonfnt/pbhc/issues
+Keywords: jax,clustering,bayesian,hierarchical-clustering,graph
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: jax
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: scipy; extra == "dev"
+Dynamic: license-file
+
+[![tests](https://github.com/alonfnt/pbhc/actions/workflows/pytest.yml/badge.svg)](https://github.com/alonfnt/pbhc/actions/workflows/pytest.yml)
+[![PyPI](https://img.shields.io/pypi/v/pbhc.svg)](https://pypi.org/project/pbhc/)
+
+`pbhc` is a minimal parallel Bayesian hierarchical clustering (BHC) implementation in [JAX](https://github.com/jax-ml/jax) that runs on GPU/TPU/CPU.
+Clustering is constrained to a graph: only clusters joined by an edge may merge, so on a pixel grid every cluster is spatially contiguous.
+Instead of BHC's one-merge-at-a-time greedy loop, every cluster merges with its most probable neighbour in the same round (Borůvka-style), so the number of rounds grows roughly with the log of the number of points.
+
+Each cluster follows a diagonal Normal-Normal model, `x ~ N(mu, sigma2)`, `mu ~ N(0, tau2)`, with a Dirichlet process prior of concentration `alpha` ([Heller & Ghahramani, 2005](https://doi.org/10.1145/1102351.1102389)).
+Merges of several children at once use the product over children of [Bayesian rose trees](https://arxiv.org/abs/1203.3468), and merging stops when no merge has posterior probability above `threshold` (0.5 by default).
+
+## Usage
+```python
+import jax
+import jax.numpy as jnp
+import pbhc
+
+jax.config.update("jax_enable_x64", True)  # recommended for large inputs
+
+# 100 points in a line: the first 50 around 0, the last 50 around 10
+X = jax.random.normal(jax.random.key(0), (100, 3)).at[50:].add(10)
+
+# edges between consecutive points (only connected clusters can merge)
+i, j = jnp.arange(99), jnp.arange(1, 100)
+
+# sigma2: spread inside a cluster, from differences between neighbours
+# tau2: spread between clusters, from the variance of the whole data
+sigma2 = 0.5 * jnp.mean((X[i] - X[j]) ** 2)
+tau2 = jnp.var(X)
+
+state = pbhc.fit(X, i, j, sigma2=sigma2, tau2=tau2)
+print(state.labels)  # [0 0 ... 0 1 1 ... 1]
+```
+
+## Installation
+`pbhc` can be installed from PyPI via `pip`
+```
+pip install pbhc
+```
+
+## Citation
+If you use `pbhc` in your research and need to reference it, please cite it as follows:
+```
+@software{alonso_pbhc,
+  author = {Alonso, Albert},
+  title = {pbhc: Minimal Parallel Bayesian Hierarchical Clustering in JAX},
+  url = {https://github.com/alonfnt/pbhc},
+  version = {0.1.0}
+}
+```

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

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+pyproject.toml
+pbhc/__init__.py
+pbhc/bhc.py
+pbhc/bhc_test.py
+pbhc.egg-info/PKG-INFO
+pbhc.egg-info/SOURCES.txt
+pbhc.egg-info/dependency_links.txt
+pbhc.egg-info/requires.txt
+pbhc.egg-info/top_level.txt

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,5 @@
+jax
+
+[dev]
+pytest
+scipy

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

@@ -0,0 +1 @@
+pbhc

pbhc-0.1.0/pyproject.toml

@@ -0,0 +1,34 @@
+[build-system]
+requires = ["setuptools", "wheel", "jax"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pbhc"
+dynamic = ["version"]
+description = "Minimal parallel Bayesian hierarchical clustering on graphs in JAX."
+readme = "README.md"
+requires-python = ">=3.10"
+authors = [
+    {name = "Albert Alonso", email = "alonfnt@pm.me"},
+]
+license = {file = "LICENSE"}
+keywords = ["jax", "clustering", "bayesian", "hierarchical-clustering", "graph"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+]
+dependencies = ["jax",]
+
+[project.optional-dependencies]
+dev = ["pytest", "scipy"]
+
+[tool.setuptools.dynamic]
+version = {attr = "pbhc.__version__"}
+
+[project.urls]
+"Homepage" = "https://github.com/alonfnt/pbhc"
+"Documentation" = "https://github.com/alonfnt/pbhc"
+"Source" = "https://github.com/alonfnt/pbhc"
+"Bug Tracker" = "https://github.com/alonfnt/pbhc/issues"

pbhc-0.1.0/setup.cfg

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