| """Stable persistence-diagram summary vectorisation (18 scalars). |
| |
| Used by LGAP, RSCD, OWPS, GCLP, EAPT — every Phase-0..4 feature that |
| turns a small distance matrix into a Ripser persistence diagram and |
| needs a fixed-length, learnable summary. |
| |
| Output (18 scalars, in order): |
| H0: count, sum_persistence, max_persistence, mean_persistence, |
| std_persistence, entropy_of_persistence |
| H1: count, sum_persistence, max_persistence, mean_persistence, |
| std_persistence, entropy_of_persistence |
| cross: betti0_at_q25, betti0_at_q50, betti0_at_q75, |
| betti1_at_q25, betti1_at_q50, betti1_at_q75 |
| """ |
| from __future__ import annotations |
|
|
| from typing import List, Tuple |
|
|
| import numpy as np |
|
|
|
|
| def _safe_entropy(persistences: np.ndarray) -> float: |
| if persistences.size == 0: |
| return 0.0 |
| p = persistences / (persistences.sum() + 1e-12) |
| p = np.clip(p, 1e-12, 1.0) |
| return float(-(p * np.log(p)).sum()) |
|
|
|
|
| def _persistence_stats(intervals: np.ndarray) -> List[float]: |
| """intervals: (n, 2) array of [birth, death]. Returns 6 scalars.""" |
| if intervals.shape[0] == 0: |
| return [0.0] * 6 |
| pers = intervals[:, 1] - intervals[:, 0] |
| finite = pers[np.isfinite(pers)] |
| if finite.size == 0: |
| return [0.0] * 6 |
| return [ |
| float(finite.size), |
| float(finite.sum()), |
| float(finite.max()), |
| float(finite.mean()), |
| float(finite.std()), |
| _safe_entropy(finite), |
| ] |
|
|
|
|
| def _betti_counts(intervals: np.ndarray, thresholds: List[float]) -> List[float]: |
| if intervals.shape[0] == 0: |
| return [0.0] * len(thresholds) |
| out = [] |
| for t in thresholds: |
| born_before = intervals[:, 0] <= t |
| die_after = intervals[:, 1] > t |
| out.append(float((born_before & die_after).sum())) |
| return out |
|
|
|
|
| def summarize_persistence(h0: np.ndarray, h1: np.ndarray, |
| quantiles=(0.25, 0.5, 0.75)) -> List[float]: |
| """Return 18-dim summary of (H0, H1) persistence intervals.""" |
| feats = [] |
| feats.extend(_persistence_stats(h0)) |
| feats.extend(_persistence_stats(h1)) |
|
|
| |
| pooled = np.concatenate([h0, h1], axis=0) if (h0.size and h1.size) else (h0 if h0.size else h1) |
| if pooled.shape[0] == 0: |
| return feats + [0.0] * (2 * len(quantiles)) |
| finite_mask = np.isfinite(pooled).all(axis=1) |
| pooled = pooled[finite_mask] |
| if pooled.shape[0] == 0: |
| return feats + [0.0] * (2 * len(quantiles)) |
| thresholds = list(np.quantile(pooled[:, 0], list(quantiles))) |
| feats.extend(_betti_counts(h0, thresholds)) |
| feats.extend(_betti_counts(h1, thresholds)) |
| return feats |
|
|
|
|
| def column_names(prefix: str) -> List[str]: |
| return [ |
| f"{prefix}_H0_count", f"{prefix}_H0_sum", f"{prefix}_H0_max", |
| f"{prefix}_H0_mean", f"{prefix}_H0_std", f"{prefix}_H0_ent", |
| f"{prefix}_H1_count", f"{prefix}_H1_sum", f"{prefix}_H1_max", |
| f"{prefix}_H1_mean", f"{prefix}_H1_std", f"{prefix}_H1_ent", |
| f"{prefix}_B0_q25", f"{prefix}_B0_q50", f"{prefix}_B0_q75", |
| f"{prefix}_B1_q25", f"{prefix}_B1_q50", f"{prefix}_B1_q75", |
| ] |
|
|
|
|
| def ripser_summary_from_distance(D: np.ndarray, maxdim: int = 1, |
| prefix: str = "p") -> Tuple[List[float], List[str]]: |
| """Run Ripser on a square distance matrix D and return an 18-scalar summary. |
| |
| Falls back to an all-zero feature vector if Ripser is unavailable or D is |
| degenerate (one point, all-NaN, etc.). |
| """ |
| try: |
| from ripser import ripser |
| except ImportError: |
| return [0.0] * 18, column_names(prefix) |
|
|
| if D.shape[0] < 2: |
| return [0.0] * 18, column_names(prefix) |
| D = np.nan_to_num(D, nan=0.0, posinf=1.0, neginf=0.0) |
| |
| D = 0.5 * (D + D.T) |
| np.fill_diagonal(D, 0.0) |
| try: |
| res = ripser(D, distance_matrix=True, maxdim=maxdim) |
| dgms = res["dgms"] |
| h0 = dgms[0] if len(dgms) > 0 else np.zeros((0, 2)) |
| h1 = dgms[1] if len(dgms) > 1 else np.zeros((0, 2)) |
| except Exception: |
| return [0.0] * 18, column_names(prefix) |
| return summarize_persistence(h0, h1), column_names(prefix) |
|
|
