separatix 0.1.0a1__py3-none-any.whl

separatix/__init__.py

@@ -0,0 +1,8 @@
+"""Public package exports for separatix."""
+
+from separatix.api import diagnose
+from separatix.config import ProfilerConfig
+from separatix.profiler import ComplexityProfiler
+from separatix.report import DiagnosticReport
+
+__all__ = ["ComplexityProfiler", "DiagnosticReport", "ProfilerConfig", "diagnose"]

separatix/api.py

@@ -0,0 +1,37 @@
+"""Functional API for separatix."""
+
+from __future__ import annotations
+
+from typing import Any, Literal
+
+from separatix.profiler import ComplexityProfiler
+from separatix.report import DiagnosticReport
+
+
+def diagnose(
+    X: Any,
+    y: Any,
+    *,
+    return_report: bool = False,
+    budget: Literal["fast", "standard", "extended"] = "standard",
+    topology: Literal["off", "auto", "graph", "persistent"] = "auto",
+    densify_policy: Literal["fail", "warn_and_sample", "skip"] = ("warn_and_sample"),
+    max_dense_mb: int = 512,
+    max_samples: int | None = None,
+    random_state: int | None = None,
+    warn_on_densify: bool = True,
+) -> str | DiagnosticReport:
+    """Diagnose apparent classification complexity from embeddings and labels."""
+    profiler = ComplexityProfiler(
+        budget=budget,
+        topology=topology,
+        densify_policy=densify_policy,
+        max_dense_mb=max_dense_mb,
+        max_samples=max_samples,
+        random_state=random_state,
+        warn_on_densify=warn_on_densify,
+    )
+    report = profiler.fit(X, y).report_
+    if report is None:
+        raise RuntimeError("Profiler did not produce a report.")
+    return report if return_report else report.recommendation_text

separatix/config.py

@@ -0,0 +1,42 @@
+"""Configuration objects for separatix."""
+
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass
+from typing import Literal
+
+from separatix.constants import BUDGETS
+
+
+@dataclass
+class ProfilerConfig:
+    """Configuration for the separatix diagnostic profiler."""
+
+    budget: Literal["fast", "standard", "extended"] = "standard"
+    topology: Literal["off", "auto", "graph", "persistent"] = "auto"
+    densify_policy: Literal["fail", "warn_and_sample", "skip"] = "warn_and_sample"
+    max_dense_mb: int = 512
+    max_samples: int | None = None
+    min_dense_samples: int = 200
+    random_state: int | None = None
+    warn_on_densify: bool = True
+    n_jobs: int | None = None
+
+    def __post_init__(self) -> None:
+        """Validate configuration values."""
+        if self.budget not in BUDGETS:
+            raise ValueError(f"Unsupported budget: {self.budget!r}")
+        if self.topology not in {"off", "auto", "graph", "persistent"}:
+            raise ValueError(f"Unsupported topology mode: {self.topology!r}")
+        if self.densify_policy not in {"fail", "warn_and_sample", "skip"}:
+            raise ValueError(f"Unsupported densify policy: {self.densify_policy!r}")
+        if self.max_dense_mb <= 0:
+            raise ValueError("max_dense_mb must be positive.")
+        if self.max_samples is not None and self.max_samples <= 0:
+            raise ValueError("max_samples must be positive when provided.")
+        if self.min_dense_samples <= 0:
+            raise ValueError("min_dense_samples must be positive.")
+
+    def to_dict(self) -> dict[str, object]:
+        """Return a JSON-serializable configuration dictionary."""
+        return asdict(self)

separatix/constants.py

@@ -0,0 +1,57 @@
+"""Constants used across the separatix package."""
+
+from __future__ import annotations
+
+LINEAR_LIKELY_SUFFICIENT = "linear_likely_sufficient"
+SMOOTH_NONLINEAR_RECOMMENDED = "smooth_nonlinear_recommended"
+KERNEL_OR_LOCAL_RECOMMENDED = "kernel_or_local_recommended"
+HIGH_CAPACITY_OR_PARTITIONING_RECOMMENDED = "high_capacity_or_partitioning_recommended"
+FEATURE_OR_LABEL_BOTTLENECK_LIKELY = "feature_or_label_bottleneck_likely"
+INSUFFICIENT_DATA_OR_UNRELIABLE_GEOMETRY = "insufficient_data_or_unreliable_geometry"
+INCONCLUSIVE = "inconclusive"
+
+RECOMMENDATION_LABELS = {
+    LINEAR_LIKELY_SUFFICIENT: "Linear model likely sufficient.",
+    SMOOTH_NONLINEAR_RECOMMENDED: "Smooth nonlinear model likely useful.",
+    KERNEL_OR_LOCAL_RECOMMENDED: "Kernel or local model likely useful.",
+    HIGH_CAPACITY_OR_PARTITIONING_RECOMMENDED: (
+        "Higher-capacity or partitioning model likely useful."
+    ),
+    FEATURE_OR_LABEL_BOTTLENECK_LIKELY: "Feature or label bottleneck likely.",
+    INSUFFICIENT_DATA_OR_UNRELIABLE_GEOMETRY: (
+        "Insufficient data or unreliable geometry."
+    ),
+    INCONCLUSIVE: "Diagnostic result is inconclusive.",
+}
+
+BUDGETS = {
+    "fast": {
+        "max_probe_samples": 5000,
+        "max_neighbor_samples": 5000,
+        "max_boundary_samples": 2000,
+        "cv_folds": 3,
+        "bootstrap_repeats": 0,
+        "run_kernel_probe": False,
+        "run_persistent_topology": False,
+    },
+    "standard": {
+        "max_probe_samples": 20000,
+        "max_neighbor_samples": 10000,
+        "max_boundary_samples": 3000,
+        "cv_folds": 5,
+        "bootstrap_repeats": 3,
+        "run_kernel_probe": True,
+        "run_persistent_topology": "auto",
+    },
+    "extended": {
+        "max_probe_samples": 50000,
+        "max_neighbor_samples": 20000,
+        "max_boundary_samples": 5000,
+        "cv_folds": 5,
+        "bootstrap_repeats": 10,
+        "run_kernel_probe": True,
+        "run_persistent_topology": "auto",
+    },
+}
+
+CONFIDENCE_LEVELS = ("low", "medium", "high")

separatix/densify.py

@@ -0,0 +1,106 @@
+"""Dense conversion helpers."""
+
+from __future__ import annotations
+
+from math import floor
+from typing import Any
+
+import numpy as np
+from scipy import sparse
+
+from separatix.config import ProfilerConfig
+from separatix.exceptions import DensificationError, DensificationWarning
+from separatix.sampling import stratified_subsample_indices
+from separatix.utils.warnings import record_warning
+
+
+def ensure_dense_or_sample(
+    X: Any,
+    y: np.ndarray,
+    *,
+    reason: str,
+    config: ProfilerConfig,
+    report_context: dict[str, Any],
+) -> dict[str, Any]:
+    """Return a dense matrix, optionally after stratified subsampling."""
+    densification_events = report_context.setdefault("densification_events", [])
+    warnings_list = report_context.setdefault("warnings", [])
+    skipped = report_context.setdefault("skipped_diagnostics", [])
+
+    if not sparse.issparse(X):
+        return {"X": np.asarray(X), "y": y, "performed": False, "skipped": False}
+
+    dtype = X.dtype if X.dtype is not None else np.dtype(float)
+    estimated_mb = X.shape[0] * X.shape[1] * np.dtype(dtype).itemsize / 1024**2
+    event = {
+        "operation": "densify",
+        "reason": reason,
+        "input_shape": [int(X.shape[0]), int(X.shape[1])],
+        "estimated_full_dense_mb": float(estimated_mb),
+        "max_dense_mb": config.max_dense_mb,
+        "policy": config.densify_policy,
+        "sampling_used": False,
+        "n_original": int(X.shape[0]),
+        "n_used": int(X.shape[0]),
+        "status": "performed",
+    }
+
+    if estimated_mb <= config.max_dense_mb:
+        dense = X.toarray()
+        densification_events.append(event)
+        if config.warn_on_densify:
+            record_warning(
+                f"Sparse input densified for {reason}.",
+                warnings_list,
+                DensificationWarning,
+            )
+        return {"X": dense, "y": y, "performed": True, "skipped": False}
+
+    if config.densify_policy == "fail":
+        message = (
+            f"Dense conversion for {reason} would exceed "
+            f"max_dense_mb={config.max_dense_mb}."
+        )
+        raise DensificationError(message)
+
+    if config.densify_policy == "skip":
+        event["status"] = "skipped"
+        densification_events.append(event)
+        skipped.append(
+            {
+                "name": reason,
+                "reason": "dense conversion exceeds configured memory budget",
+            }
+        )
+        return {"X": None, "y": y, "performed": False, "skipped": True}
+
+    max_rows = floor(
+        (config.max_dense_mb * 1024**2) / (X.shape[1] * np.dtype(dtype).itemsize)
+    )
+    n_used = min(X.shape[0], max_rows, config.max_samples or X.shape[0])
+    if n_used < min(config.min_dense_samples, X.shape[0]):
+        skipped.append({"name": reason, "reason": "dense subsample would be too small"})
+        event["status"] = "skipped_too_small"
+        event["n_used"] = int(max(n_used, 0))
+        densification_events.append(event)
+        if config.densify_policy == "warn_and_sample":
+            return {"X": None, "y": y, "performed": False, "skipped": True}
+        raise DensificationError(f"Unable to densify enough samples for {reason}.")
+
+    indices = stratified_subsample_indices(
+        y,
+        n_samples=n_used,
+        random_state=config.random_state,
+    )
+    dense = X[indices, :].toarray()
+    event["sampling_used"] = True
+    event["n_used"] = int(indices.shape[0])
+    event["status"] = "performed_on_subsample"
+    densification_events.append(event)
+    if config.warn_on_densify:
+        record_warning(
+            f"Sparse input was stratified-subsampled then densified for {reason}.",
+            warnings_list,
+            DensificationWarning,
+        )
+    return {"X": dense, "y": y[indices], "performed": True, "skipped": False}

separatix/exceptions.py

@@ -0,0 +1,13 @@
+"""Custom exceptions and warnings for separatix."""
+
+
+class SeparatixError(Exception):
+    """Base exception for separatix."""
+
+
+class DensificationError(SeparatixError):
+    """Raised when dense conversion is required but disallowed or impossible."""
+
+
+class DensificationWarning(UserWarning):
+    """Warning emitted when sparse data are densified or subsampled."""

separatix/metrics/__init__.py

@@ -0,0 +1 @@
+"""Diagnostic metric modules."""

separatix/metrics/audit.py

@@ -0,0 +1,61 @@
+"""Dataset audit metrics."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import numpy as np
+
+
+def compute_dataset_audit(
+    X: Any,
+    y: np.ndarray,
+    *,
+    classes: np.ndarray,
+    is_sparse: bool,
+) -> dict[str, Any]:
+    """Compute cheap dataset audit statistics."""
+    class_ids, counts = np.unique(y, return_counts=True)
+    proportions = counts / counts.sum()
+    imbalance_ratio = float(counts.max() / max(1, counts.min()))
+    result: dict[str, Any] = {
+        "n_samples": int(X.shape[0]),
+        "n_features": int(X.shape[1]),
+        "n_classes": int(classes.shape[0]),
+        "class_counts": {
+            str(classes[i]): int(counts[idx]) for idx, i in enumerate(class_ids)
+        },
+        "class_proportions": {
+            str(classes[i]): float(proportions[idx]) for idx, i in enumerate(class_ids)
+        },
+        "imbalance_ratio": imbalance_ratio,
+        "is_sparse": is_sparse,
+    }
+    if is_sparse:
+        density = (
+            float(X.nnz / (X.shape[0] * X.shape[1]))
+            if X.shape[0] and X.shape[1]
+            else 0.0
+        )
+        result.update(
+            {
+                "nnz": int(X.nnz),
+                "density": density,
+                "sparsity_fraction": float(1.0 - density),
+                "estimated_dense_memory_mb": float(
+                    X.shape[0] * X.shape[1] * X.dtype.itemsize / 1024**2
+                ),
+                "dtype": str(X.dtype),
+            }
+        )
+    else:
+        result.update(
+            {
+                "dtype": str(X.dtype),
+                "constant_feature_fraction": float(
+                    np.mean(np.nanstd(X, axis=0) == 0.0)
+                ),
+                "estimated_dense_memory_mb": float(X.nbytes / 1024**2),
+            }
+        )
+    return result

separatix/metrics/baseline.py

@@ -0,0 +1,21 @@
+"""Baseline metric helpers."""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+def summarize_probe_family(probes: dict[str, dict[str, Any]]) -> dict[str, Any]:
+    """Summarize high-level probe behavior."""
+    available = {
+        name: result["balanced_accuracy"]
+        for name, result in probes.items()
+        if "balanced_accuracy" in result
+    }
+    best_name = (
+        max(available.items(), key=lambda item: item[1])[0] if available else None
+    )
+    return {
+        "best_probe": best_name,
+        "best_probe_score": available.get(best_name) if best_name is not None else None,
+    }

separatix/metrics/boundary.py

@@ -0,0 +1,54 @@
+"""Boundary candidate diagnostics."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import numpy as np
+
+
+def compute_boundary_candidates(
+    y: np.ndarray,
+    neighborhood: dict[str, Any],
+    probes: dict[str, dict[str, Any]],
+) -> dict[str, Any]:
+    """Extract boundary candidate indices from ambiguity and disagreement."""
+    local_entropy = np.asarray(neighborhood.get("local_entropy", []), dtype=float)
+    local_ambiguity = np.asarray(neighborhood.get("local_ambiguity", []), dtype=float)
+    if local_entropy.size == 0 or local_ambiguity.size == 0:
+        return {
+            "candidate_indices": [],
+            "candidate_fraction": 0.0,
+            "boundary_sample_size": 0,
+            "class_composition": {},
+            "warning": "Boundary diagnostics unavailable.",
+        }
+    entropy_threshold = float(np.quantile(local_entropy, 0.75))
+    ambiguity_threshold = max(0.33, float(np.quantile(local_ambiguity, 0.75)))
+    candidate_mask = (local_entropy >= entropy_threshold) | (
+        local_ambiguity >= ambiguity_threshold
+    )
+    linear_preds = probes.get("linear", {}).get("predictions")
+    knn_preds = probes.get("knn", {}).get("predictions")
+    if (
+        linear_preds is not None
+        and knn_preds is not None
+        and len(linear_preds) == candidate_mask.shape[0]
+    ):
+        disagreement = np.asarray(linear_preds) != np.asarray(knn_preds)
+        candidate_mask = candidate_mask | disagreement
+    indices = np.flatnonzero(candidate_mask)
+    counts = {
+        str(cls): int(np.sum(y[indices] == cls))
+        for cls in np.unique(y[indices])
+        if indices.size
+    }
+    return {
+        "candidate_indices": indices.tolist(),
+        "candidate_fraction": float(indices.shape[0] / max(1, y.shape[0])),
+        "boundary_sample_size": int(indices.shape[0]),
+        "class_composition": counts,
+        "warning": "Boundary sample is very small."
+        if indices.shape[0] < max(10, len(np.unique(y)))
+        else None,
+    }

separatix/metrics/geometry.py

@@ -0,0 +1,80 @@
+"""Geometry reliability diagnostics."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import numpy as np
+from scipy import sparse
+from sklearn.decomposition import PCA, TruncatedSVD
+from sklearn.metrics import pairwise_distances
+
+from separatix.config import ProfilerConfig
+from separatix.densify import ensure_dense_or_sample
+from separatix.sampling import cap_samples_for_budget
+
+
+def compute_geometry_diagnostics(
+    X: Any,
+    y: np.ndarray,
+    *,
+    config: ProfilerConfig,
+    report_context: dict[str, Any],
+) -> dict[str, Any]:
+    """Compute cheap geometry reliability metrics."""
+    X_used, y_used, sample_info = cap_samples_for_budget(
+        X, y, config=config, reason="neighbors"
+    )
+    if sparse.issparse(X_used):
+        svd = TruncatedSVD(
+            n_components=min(10, max(2, X_used.shape[1] - 1)),
+            random_state=config.random_state,
+        )
+        embedding = svd.fit_transform(X_used)
+        explained = svd.explained_variance_ratio_
+        feature_scale_range = None
+    else:
+        centered = np.asarray(X_used)
+        pca = PCA(
+            n_components=min(10, centered.shape[1], max(1, centered.shape[0] - 1)),
+            random_state=config.random_state,
+        )
+        embedding = pca.fit_transform(centered)
+        explained = pca.explained_variance_ratio_
+        std = np.std(centered, axis=0)
+        feature_scale_range = float(
+            std.max() / max(std[std > 0].min() if np.any(std > 0) else 1.0, 1e-9)
+        )
+
+    dense_for_dist = ensure_dense_or_sample(
+        X_used,
+        y_used,
+        reason="geometry_distance_concentration",
+        config=config,
+        report_context=report_context,
+    )
+    if dense_for_dist["skipped"]:
+        concentration = None
+    else:
+        sample = dense_for_dist["X"]
+        if sample.shape[0] > 250:
+            sample = sample[:250]
+        dists = pairwise_distances(sample)
+        tri = dists[np.triu_indices_from(dists, k=1)]
+        concentration = (
+            float((tri.max() - tri.min()) / max(tri.mean(), 1e-9)) if tri.size else 0.0
+        )
+
+    intrinsic_dim = float(np.sum(explained > (1.0 / max(embedding.shape[1], 1))))
+    effective_rank = float(
+        np.exp(-np.sum(explained * np.log(np.clip(explained, 1e-12, None))))
+    )
+    return {
+        "feature_scale_range_estimate": feature_scale_range,
+        "effective_rank_estimate": effective_rank,
+        "intrinsic_dimension_proxy": intrinsic_dim,
+        "distance_concentration_proxy": concentration,
+        "high_dimensionality_flag": bool(X.shape[1] > max(100, X.shape[0] // 2)),
+        "sample_to_feature_ratio": float(X.shape[0] / max(1, X.shape[1])),
+        "sampling": sample_info,
+    }

separatix/metrics/graph.py

@@ -0,0 +1,72 @@
+"""Graph fragmentation diagnostics."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import numpy as np
+from scipy.sparse.csgraph import connected_components
+from sklearn.neighbors import NearestNeighbors
+
+from separatix.config import ProfilerConfig
+from separatix.sampling import cap_samples_for_budget
+
+
+def compute_graph_fragmentation(
+    X: Any,
+    y: np.ndarray,
+    boundary: dict[str, Any],
+    *,
+    config: ProfilerConfig,
+) -> dict[str, Any]:
+    """Compute fragmentation diagnostics over boundary candidates."""
+    indices = np.asarray(boundary.get("candidate_indices", []), dtype=int)
+    if indices.size < 3:
+        return {
+            "component_count": 0,
+            "largest_component_fraction": 1.0 if indices.size else 0.0,
+            "component_size_entropy": 0.0,
+            "small_component_count": 0,
+            "cross_class_edge_density": 0.0,
+            "graph_fragmentation_score": 0.0,
+            "warning": "Not enough boundary candidates for graph diagnostics.",
+        }
+
+    X_boundary = X[indices]
+    y_boundary = y[indices]
+    X_boundary, y_boundary, sample_info = cap_samples_for_budget(
+        X_boundary, y_boundary, config=config, reason="boundary"
+    )
+    k = min(len(y_boundary) - 1, 10)
+    nn = NearestNeighbors(n_neighbors=k + 1)
+    nn.fit(X_boundary)
+    graph = nn.kneighbors_graph(X_boundary, mode="connectivity")
+    graph = graph.maximum(graph.T)
+    n_components, labels = connected_components(graph, directed=False)
+    sizes = np.bincount(labels)
+    probs = sizes / max(1, sizes.sum())
+    entropy = float(
+        -np.sum(np.where(probs > 0, probs * np.log(probs), 0.0))
+        / max(np.log(max(2, len(sizes))), 1e-9)
+    )
+    rows, cols = graph.nonzero()
+    valid = rows < cols
+    cross_class = (
+        np.mean(y_boundary[rows[valid]] != y_boundary[cols[valid]])
+        if np.any(valid)
+        else 0.0
+    )
+    largest = float(sizes.max() / max(1, sizes.sum()))
+    component_count_scaled = min(1.0, n_components / max(3, len(y_boundary) / 20))
+    fragmentation = float(
+        np.clip(np.mean([1.0 - largest, component_count_scaled, entropy]), 0.0, 1.0)
+    )
+    return {
+        "component_count": int(n_components),
+        "largest_component_fraction": largest,
+        "component_size_entropy": entropy,
+        "small_component_count": int(np.sum(sizes <= 3)),
+        "cross_class_edge_density": float(cross_class),
+        "graph_fragmentation_score": fragmentation,
+        "sampling": sample_info,
+    }

separatix/metrics/neighborhood.py

@@ -0,0 +1,96 @@
+"""Neighborhood diagnostics."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import numpy as np
+from scipy import sparse
+from sklearn.neighbors import NearestNeighbors
+
+from separatix.config import ProfilerConfig
+from separatix.densify import ensure_dense_or_sample
+from separatix.sampling import cap_samples_for_budget
+
+
+def compute_neighborhood_diagnostics(
+    X: Any,
+    y: np.ndarray,
+    *,
+    config: ProfilerConfig,
+    report_context: dict[str, Any],
+) -> dict[str, Any]:
+    """Compute neighborhood overlap and ambiguity diagnostics."""
+    X_used, y_used, sample_info = cap_samples_for_budget(
+        X, y, config=config, reason="neighbors"
+    )
+    k = min(len(y_used) - 1, min(15, max(3, int(np.sqrt(len(y_used))))))
+    if k < 1:
+        return {
+            "mean_local_entropy": 0.0,
+            "high_entropy_fraction": 0.0,
+            "same_class_neighbor_fraction": 1.0,
+            "cross_class_neighbor_fraction": 0.0,
+            "mean_local_ambiguity": 0.0,
+            "sampling": sample_info,
+        }
+
+    X_fit = X_used
+    if sparse.issparse(X_used):
+        try:
+            nn = NearestNeighbors(n_neighbors=k)
+            nn.fit(X_fit)
+        except TypeError:
+            dense_info = ensure_dense_or_sample(
+                X_used,
+                y_used,
+                reason="neighborhood_diagnostics",
+                config=config,
+                report_context=report_context,
+            )
+            if dense_info["skipped"]:
+                return {
+                    "sampling": sample_info,
+                    "skipped_reason": "dense conversion unavailable",
+                }
+            X_fit = dense_info["X"]
+            y_used = dense_info["y"]
+            nn = NearestNeighbors(n_neighbors=min(k, len(y_used) - 1))
+            nn.fit(X_fit)
+    else:
+        nn = NearestNeighbors(n_neighbors=k)
+        nn.fit(X_fit)
+
+    indices = nn.kneighbors(X_fit, n_neighbors=k + 1, return_distance=False)[:, 1:]
+    entropies = []
+    ambiguities = []
+    same_class = []
+    enemy_distances = []
+    distances, idxs = nn.kneighbors(X_fit, n_neighbors=k + 1, return_distance=True)
+    for row_i, neigh in enumerate(indices):
+        neigh_labels = y_used[neigh]
+        counts = np.bincount(neigh_labels, minlength=len(np.unique(y_used)))
+        probs = counts / max(1, counts.sum())
+        positive_probs = probs[probs > 0]
+        ent = -np.sum(positive_probs * np.log(positive_probs))
+        entropies.append(float(ent / max(np.log(max(2, len(probs))), 1e-9)))
+        ambiguities.append(float(1.0 - probs.max()))
+        same_class.append(float(np.mean(neigh_labels == y_used[row_i])))
+        row_dist = distances[row_i, 1:]
+        enemy_mask = neigh_labels != y_used[row_i]
+        if np.any(enemy_mask):
+            enemy_distances.append(float(np.min(row_dist[enemy_mask])))
+    entropies_arr = np.array(entropies)
+    return {
+        "mean_local_entropy": float(entropies_arr.mean()),
+        "high_entropy_fraction": float(np.mean(entropies_arr >= 0.5)),
+        "same_class_neighbor_fraction": float(np.mean(same_class)),
+        "cross_class_neighbor_fraction": float(1.0 - np.mean(same_class)),
+        "nearest_enemy_distance_estimate": float(np.mean(enemy_distances))
+        if enemy_distances
+        else None,
+        "mean_local_ambiguity": float(np.mean(ambiguities)),
+        "local_entropy": entropies,
+        "local_ambiguity": ambiguities,
+        "sampling": sample_info,
+    }