cp-pde 1.0.0__tar.gz

cp_pde-1.0.0/LICENSE

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

cp_pde-1.0.0/PKG-INFO

@@ -0,0 +1,102 @@
+Metadata-Version: 2.4
+Name: cp-pde
+Version: 1.0.0
+Summary: Pattern Discovery Engine: A unified library for pattern discovery, anomaly detection, and conformal calibration.
+License: MIT
+License-File: LICENSE
+Author: cpadlab
+Author-email: cpadlab@gmail.com
+Requires-Python: >=3.12,!=3.14.1
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
+Requires-Dist: hdbscan (>=0.8.44,<0.9.0)
+Requires-Dist: mlxtend (>=0.25.0,<0.26.0)
+Requires-Dist: networkx (>=3.7,<4.0)
+Requires-Dist: numpy (>=2.5.4,<3.0.0)
+Requires-Dist: pandas (>=3.1.1,<4.0.0)
+Requires-Dist: scikit-learn (>=1.9.1,<2.0.0)
+Requires-Dist: scipy (>=1.18.1,<2.0.0)
+Description-Content-Type: text/markdown
+
+# Pattern Discovery Engine
+
+A production-ready Python library for classical machine learning, pattern discovery, and statistical anomaly detection with distribution-free false positive rate control.
+
+---
+
+## Overview
+
+**Pattern Discovery Engine (`cp-pde`)** discovers underlying patterns and detects anomalies across diverse data modalities without relying on arbitrary heuristic score thresholds. 
+
+By integrating **inductive conformal prediction**, `cp-pde` provides rigorous statistical Type I error bounds (False Positive Rate $\le \alpha$) and delivers a structured tripartite decision framework (`anomaly`, `review`, and `no_alert`) to safely manage borderline cases.
+
+---
+
+## Core Capabilities
+
+- **Continuous Tabular Data**: Geometric ensemble combining HDBSCAN, Isolation Forest, Local Outlier Factor (LOF), and One-Class SVM with Bonferroni-corrected conformal bounds.
+- **Heterogeneous / Mixed-Type Data**: Leakage-free Gower distance computation paired with robust k-Medoids++ clustering and automated elbow detection (`KneeLocator`).
+- **Sequential & Temporal Dynamics**: Semi-Markovian modeling coupling Laplace-smoothed transition matrices with state-conditional log-normal holding time distributions.
+- **Symbolic Association & Rule Mining**: Quantile-based feature discretization, Apriori rule extraction, contextual violation scoring, and dependency graphs.
+- **Conformal Calibration**: Distribution-free, non-parametric p-value inference with mathematically bounded false positive rates.
+- **Distribution Drift Monitoring**: Real-time Kolmogorov-Smirnov goodness-of-fit testing tracking shifts from uniform p-value distributions.
+- **Lossless Persistence**: Native JSON serialization and restoration preserving exact numerical state across save/load cycles.
+
+---
+
+## Installation
+
+Install the package via `pip`:
+
+```bash
+pip install cp-pde
+
+```
+
+### Requirements
+
+* Python `>= 3.12` (excluding `3.14.1`)
+
+---
+
+## Package Structure
+
+| Module | Core Responsibility |
+| --- | --- |
+| `pde.geometry` | Continuous geometric anomaly detection suites and Bonferroni ensembles |
+| `pde.clustering` | Gower distance metrics, robust k-Medoids++, and optimal $k$ selection |
+| `pde.sequential` | Semi-Markovian trajectory modeling (state transitions and holding times) |
+| `pde.association` | Discretization, association rule mining, and contextual violation scoring |
+| `pde.calibration` | Non-parametric conformal calibration and selective tripartite classification |
+| `pde.drift` | Streaming Kolmogorov-Smirnov distribution drift monitoring |
+| `pde.persistence` | Full engine serialization and deserialization via JSON |
+
+---
+
+## Development
+
+Clone the repository and install development dependencies using [Poetry](https://python-poetry.org/):
+
+```bash
+git clone [https://github.com/cpadlab/pde.git](https://github.com/cpadlab/pde.git)
+cd pde
+poetry install
+
+```
+
+Run test suite and coverage reports:
+
+```bash
+poetry run pytest
+
+```
+
+---
+
+## License
+
+This project is licensed under the MIT License. See the [LICENSE](https://www.google.com/search?q=LICENSE) file for details.

cp_pde-1.0.0/README.md

@@ -0,0 +1,78 @@
+# Pattern Discovery Engine
+
+A production-ready Python library for classical machine learning, pattern discovery, and statistical anomaly detection with distribution-free false positive rate control.
+
+---
+
+## Overview
+
+**Pattern Discovery Engine (`cp-pde`)** discovers underlying patterns and detects anomalies across diverse data modalities without relying on arbitrary heuristic score thresholds. 
+
+By integrating **inductive conformal prediction**, `cp-pde` provides rigorous statistical Type I error bounds (False Positive Rate $\le \alpha$) and delivers a structured tripartite decision framework (`anomaly`, `review`, and `no_alert`) to safely manage borderline cases.
+
+---
+
+## Core Capabilities
+
+- **Continuous Tabular Data**: Geometric ensemble combining HDBSCAN, Isolation Forest, Local Outlier Factor (LOF), and One-Class SVM with Bonferroni-corrected conformal bounds.
+- **Heterogeneous / Mixed-Type Data**: Leakage-free Gower distance computation paired with robust k-Medoids++ clustering and automated elbow detection (`KneeLocator`).
+- **Sequential & Temporal Dynamics**: Semi-Markovian modeling coupling Laplace-smoothed transition matrices with state-conditional log-normal holding time distributions.
+- **Symbolic Association & Rule Mining**: Quantile-based feature discretization, Apriori rule extraction, contextual violation scoring, and dependency graphs.
+- **Conformal Calibration**: Distribution-free, non-parametric p-value inference with mathematically bounded false positive rates.
+- **Distribution Drift Monitoring**: Real-time Kolmogorov-Smirnov goodness-of-fit testing tracking shifts from uniform p-value distributions.
+- **Lossless Persistence**: Native JSON serialization and restoration preserving exact numerical state across save/load cycles.
+
+---
+
+## Installation
+
+Install the package via `pip`:
+
+```bash
+pip install cp-pde
+
+```
+
+### Requirements
+
+* Python `>= 3.12` (excluding `3.14.1`)
+
+---
+
+## Package Structure
+
+| Module | Core Responsibility |
+| --- | --- |
+| `pde.geometry` | Continuous geometric anomaly detection suites and Bonferroni ensembles |
+| `pde.clustering` | Gower distance metrics, robust k-Medoids++, and optimal $k$ selection |
+| `pde.sequential` | Semi-Markovian trajectory modeling (state transitions and holding times) |
+| `pde.association` | Discretization, association rule mining, and contextual violation scoring |
+| `pde.calibration` | Non-parametric conformal calibration and selective tripartite classification |
+| `pde.drift` | Streaming Kolmogorov-Smirnov distribution drift monitoring |
+| `pde.persistence` | Full engine serialization and deserialization via JSON |
+
+---
+
+## Development
+
+Clone the repository and install development dependencies using [Poetry](https://python-poetry.org/):
+
+```bash
+git clone [https://github.com/cpadlab/pde.git](https://github.com/cpadlab/pde.git)
+cd pde
+poetry install
+
+```
+
+Run test suite and coverage reports:
+
+```bash
+poetry run pytest
+
+```
+
+---
+
+## License
+
+This project is licensed under the MIT License. See the [LICENSE](https://www.google.com/search?q=LICENSE) file for details.

cp_pde-1.0.0/pyproject.toml

@@ -0,0 +1,53 @@
+[project]
+name = "cp-pde"
+version = "1.0.0"
+description = "Pattern Discovery Engine: A unified library for pattern discovery, anomaly detection, and conformal calibration."
+authors = [
+    {name = "cpadlab", email = "cpadlab@gmail.com"}
+]
+license = {text = "MIT"}
+readme = "README.md"
+requires-python = ">=3.12,!=3.14.1"
+dependencies = [
+    "numpy (>=2.5.4,<3.0.0)",
+    "scipy (>=1.18.1,<2.0.0)",
+    "pandas (>=3.1.1,<4.0.0)",
+    "scikit-learn (>=1.9.1,<2.0.0)",
+    "hdbscan (>=0.8.44,<0.9.0)",
+    "mlxtend (>=0.25.0,<0.26.0)",
+    "networkx (>=3.7,<4.0)"
+]
+
+[build-system]
+requires = ["poetry-core>=2.0.0,<3.0.0"]
+build-backend = "poetry.core.masonry.api"
+
+[dependency-groups]
+dev = [
+    "pytest (>=9.2.0,<10.0.0)",
+    "pytest-cov (>=7.1.0,<8.0.0)",
+    "pysonar (>=1.11.0.6012,<2.0.0.0)"
+]
+
+[tool.poetry]
+packages = [{ include = "pde", from = "src" }]
+
+[tool.pytest.ini_options]
+minversion = "9.2.0"
+testpaths = ["tests"]
+python_files = ["test_*.py"]
+python_classes = ["Test*"]
+python_functions = ["test_*"]
+addopts = "-v --strict-markers --cov=pde --cov-report=term-missing --cov-report=xml --junitxml=test-results.xml"
+
+[tool.coverage.run]
+source = ["src/pde"]
+branch = true
+
+[tool.coverage.report]
+show_missing = true
+skip_covered = false
+fail_under = 90
+
+[tool.coverage.xml]
+output = "coverage.xml"

cp_pde-1.0.0/src/pde/__init__.py

@@ -0,0 +1,7 @@
+
+from pde.engine import PatternDiscoveryEngine
+
+__version__ = "1.0.0"
+__all__ = [
+    "PatternDiscoveryEngine"
+]

cp_pde-1.0.0/src/pde/association/__init__.py

@@ -0,0 +1,10 @@
+
+from pde.association.discretizer import QuantileDiscretizer
+from pde.association.rules import AssociationRuleScorer
+from pde.association.graph import DependencyGraphEngine
+
+__all__ = [
+    "QuantileDiscretizer", 
+    "AssociationRuleScorer", 
+    "DependencyGraphEngine"
+]

cp_pde-1.0.0/src/pde/association/discretizer.py

@@ -0,0 +1,157 @@
+
+from typing import Dict, List, Optional, Sequence
+import numpy as np
+import pandas as pd
+
+
+class QuantileDiscretizer:
+    """
+    Discretizer for numerical features fitted on the training dataset.
+
+    Bins continuous variables into discrete intervals using empirical
+    quantiles computed from training data, and transforms inputs into
+    one-hot encoded boolean indicator features.
+
+    Attributes:
+        n_bins (int): Number of quantile bins to partition the feature space into.
+        labels (List[str]): Ordered categorical labels assigned to the bins.
+        bin_edges_ (Dict[str, np.ndarray]): Mapping from feature names to their
+            calculated bin boundary arrays, bounded by [-inf, inf].
+        feature_names_ (List[str]): List of column names selected and fitted
+            for discretization.
+        is_fitted_ (bool): Flag indicating whether the discretizer has been
+            fitted with training data.
+    """
+
+
+    def __init__(self, n_bins: int = 3, labels: Optional[Sequence[str]] = None):
+        """
+        Initializes the QuantileDiscretizer instance.
+
+        Args:
+            n_bins (int, optional): Number of quantile intervals to form.
+                Defaults to 3.
+            labels (Optional[Sequence[str]], optional): Category names for each
+                bin ordered from lowest to highest value. If None, defaults to
+                `["Low", "Medium", "High"]`. Length must match `n_bins`.
+
+        Raises:
+            ValueError: If the number of provided labels does not match `n_bins`.
+        """
+        self.n_bins = int(n_bins)
+        self.labels = list(labels) if labels else ["Low", "Medium", "High"]
+        
+        if len(self.labels) != self.n_bins:
+            raise ValueError(f"The number of labels ({len(self.labels)}) must match n_bins ({self.n_bins}).")
+
+        self.bin_edges_: Dict[str, np.ndarray] = {}
+        self.feature_names_: List[str] = []
+        self.is_fitted_: bool = False
+
+
+    def fit(self, df: pd.DataFrame, features: Optional[Sequence[str]] = None) -> "QuantileDiscretizer":
+        """
+        Computes bin cutoffs using empirical quantiles strictly from training data.
+
+        If quantile boundaries collapse due to heavily concentrated data, falls
+        back to linearly spaced thresholds between the column's minimum and
+        maximum values. The outer edges are extended to `-inf` and `inf` to
+        accommodate out-of-distribution values at inference time.
+
+        Args:
+            df (pd.DataFrame): Training DataFrame used to compute feature
+                quantiles.
+            features (Optional[Sequence[str]], optional): Specific numeric column
+                names to discretize. If None, automatically selects all numeric
+                columns in `df`. Defaults to None.
+
+        Returns:
+            QuantileDiscretizer: The fitted discretizer instance (`self`).
+        """
+        self.feature_names_ = list(features) if features else [c for c in df.columns if pd.api.types.is_numeric_dtype(df[c])]
+        self.bin_edges_ = {}
+
+        quantiles = np.linspace(0, 1, self.n_bins + 1)
+
+        for col in self.feature_names_:
+            edges = np.quantile(df[col].to_numpy(), quantiles)
+            edges = np.unique(edges)
+            
+            if len(edges) < self.n_bins + 1:
+                edges = np.linspace(df[col].min(), df[col].max(), self.n_bins + 1)
+
+            edges[0] = -np.inf
+            edges[-1] = np.inf
+            self.bin_edges_[col] = edges
+
+        self.is_fitted_ = True
+
+        return self
+
+
+    def transform(self, df: pd.DataFrame) -> pd.DataFrame:
+        """
+        Transforms continuous features into one-hot encoded boolean indicators.
+
+        Applies learned bin intervals to partition continuous variables and
+        generates binary dummy variables for each bin category.
+
+        Args:
+            df (pd.DataFrame): DataFrame containing the columns to discretize.
+
+        Returns:
+            pd.DataFrame: Concatenated DataFrame composed of boolean one-hot
+                indicator columns with names formatted as `{column}_{label}`.
+
+        Raises:
+            RuntimeError: If called before fitting the discretizer with `fit`.
+        """
+        if not self.is_fitted_:
+            raise RuntimeError("You must call .fit() before transforming the data.")
+
+        one_hot_parts = []
+        for col in self.feature_names_:
+            binned = pd.cut(df[col], bins=self.bin_edges_[col], labels=self.labels, include_lowest=True)
+            dummies = pd.get_dummies(binned, prefix=col, dtype=bool)
+            one_hot_parts.append(dummies)
+
+        return pd.concat(one_hot_parts, axis=1)
+
+
+    def to_dict(self) -> dict:
+        """
+        Serializes the discretizer configuration and learned bin edges.
+
+        Returns:
+            dict: Dictionary containing `n_bins`, `labels`, `feature_names`,
+                `bin_edges` (with values serialized to lists of floats), and
+                `is_fitted`.
+        """
+        return {
+            "n_bins": self.n_bins,
+            "labels": self.labels,
+            "feature_names": self.feature_names_,
+            "bin_edges": {k: v.tolist() for k, v in self.bin_edges_.items()},
+            "is_fitted": self.is_fitted_,
+        }
+
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "QuantileDiscretizer":
+        """
+        Reconstructs a QuantileDiscretizer instance from a serialized dictionary.
+
+        Args:
+            data (dict): Dictionary with keys `'n_bins'`, `'labels'`,
+                `'feature_names'`, `'bin_edges'`, and `'is_fitted'`.
+
+        Returns:
+            QuantileDiscretizer: A restored discretizer instance with loaded
+                features and bin boundary thresholds.
+        """
+        inst = cls(n_bins=data["n_bins"], labels=data["labels"])
+        inst.feature_names_ = data["feature_names"]
+        inst.bin_edges_ = {k: np.array(v) for k, v in data["bin_edges"].items()}
+        inst.is_fitted_ = bool(data["is_fitted"])
+        
+        return inst

cp_pde-1.0.0/src/pde/association/graph.py

@@ -0,0 +1,200 @@
+
+from typing import Any, Dict, List, Optional, Tuple
+import networkx as nx
+import numpy as np
+import pandas as pd
+from scipy.stats import spearmanr
+from sklearn.feature_selection import mutual_info_regression
+
+
+class DependencyGraphEngine:
+    """
+    Maps variable relationship networks and computes topological centrality metrics.
+
+    Provides static utilities to construct weighted directed association graphs
+    from mining rules, derive structural graph centrality measures, and compute
+    pairwise continuous dependency metrics including Spearman's rank correlation
+    and mutual information.
+    """
+
+
+    @staticmethod
+    def _upsert_edge(graph: nx.DiGraph, u: Any, v: Any, lift: float, conf: float, supp: float) -> None:
+        """
+        Inserts a directed edge or updates its attributes if a higher lift is observed.
+
+        Checks whether an edge from node `u` to node `v` already exists in `graph`.
+        If present, updates its `'lift'`, `'confidence'`, and `'support'` attributes
+        only when the incoming `lift` exceeds the existing edge's lift. If the edge
+        does not exist, adds it with the specified metrics.
+
+        Args:
+            graph (nx.DiGraph): Target directed graph to modify in place.
+            u (Any): Source node identifier representing the rule antecedent.
+            v (Any): Target node identifier representing the rule consequent.
+            lift (float): Association rule lift value.
+            conf (float): Association rule confidence value.
+            supp (float): Association rule support value.
+        """
+        if graph.has_edge(u, v):
+            if lift > graph[u][v]["lift"]:
+                graph[u][v]["lift"] = lift
+                graph[u][v]["confidence"] = conf
+                graph[u][v]["support"] = supp
+        else:
+            graph.add_edge(u, v, lift=lift, confidence=conf, support=supp)
+
+
+    @classmethod
+    def _process_rule_edges(
+        cls,
+        graph: nx.DiGraph,
+        edge_rows: List[Dict[str, Any]],
+        rule_series: pd.Series,
+    ) -> None:
+        """
+        Processes antecedent-consequent pairs for a single association rule.
+
+        Iterates through the Cartesian product of antecedents and consequents
+        for a given rule, discarding self-loops (`u == v`), updating the graph
+        via `_upsert_edge`, and appending an edge attribute dictionary to
+        `edge_rows`.
+
+        Args:
+            graph (nx.DiGraph): Target directed association graph modified in place.
+            edge_rows (List[Dict[str, Any]]): Accumulator list of edge dictionary records
+                to which each valid directed connection is appended.
+            rule_series (pd.Series): Pandas Series containing rule attributes with expected
+                keys `'antecedents'`, `'consequents'`, `'lift'`, `'confidence'`, and
+                `'support'`.
+        """
+        lift = float(rule_series["lift"])
+        conf = float(rule_series["confidence"])
+        supp = float(rule_series["support"])
+
+        for u in rule_series["antecedents"]:
+            for v in rule_series["consequents"]:
+                if u == v:
+                    continue
+                cls._upsert_edge(graph, u, v, lift, conf, supp)
+                edge_rows.append({"source": u, "target": v, "lift": lift, "confidence": conf, "support": supp})
+
+
+    @classmethod
+    def build_association_graph(cls, rules_df: pd.DataFrame) -> Tuple[nx.DiGraph, pd.DataFrame]:
+        """
+        Constructs a directed graph weighted by lift from association rules.
+
+        Iterates over antecedent-consequent pairs extracted from association rules,
+        adding directed edges weighted by lift, confidence, and support. If an edge
+        already exists, its attributes are updated if a higher lift value is found.
+
+        Args:
+            rules_df (pd.DataFrame): DataFrame containing association rules. Expected
+                columns are `'antecedents'`, `'consequents'`, `'lift'`,
+                `'confidence'`, and `'support'`.
+
+        Returns:
+            Tuple[nx.DiGraph, pd.DataFrame]: A tuple containing:
+                - **graph** (`nx.DiGraph`): Directed network graph where nodes represent
+                  items and edges store association metric attributes.
+                - **edges_df** (`pd.DataFrame`): DataFrame containing deduplicated edge
+                  records with columns `'source'`, `'target'`, `'lift'`,
+                  `'confidence'`, and `'support'`.
+        """
+        graph = nx.DiGraph()
+        edge_rows: List[Dict[str, Any]] = []
+
+        if rules_df.empty:
+            return graph, pd.DataFrame()
+
+        for _, r in rules_df.iterrows():
+            cls._process_rule_edges(graph, edge_rows, r)
+
+        edges_df = pd.DataFrame(edge_rows).drop_duplicates(subset=["source", "target"])
+
+        return graph, edges_df
+
+
+    @staticmethod
+    def compute_centrality_metrics(graph: nx.DiGraph) -> pd.DataFrame:
+        """
+        Computes network centrality metrics for nodes in a directed graph.
+
+        Evaluates weighted in-degree, weighted out-degree, betweenness centrality,
+        and closeness centrality for each node in the network.
+
+        Args:
+            graph (nx.DiGraph): Directed association graph with weighted edges.
+
+        Returns:
+            pd.DataFrame: DataFrame sorted by `'betweenness_centrality'` in
+                descending order, containing the following columns:
+                - `'node'`: Identifier of the node.
+                - `'in_degree_weighted'`: Sum of incoming edge lift weights.
+                - `'out_degree_weighted'`: Sum of outgoing edge lift weights.
+                - `'betweenness_centrality'`: Normalized betweenness centrality score.
+                - `'closeness_centrality'`: Closeness centrality score.
+                Returns an empty DataFrame if `graph` has no nodes.
+        """
+        if graph.number_of_nodes() == 0:
+            return pd.DataFrame()
+
+        in_deg = dict(graph.in_degree(weight="lift"))
+        out_deg = dict(graph.out_degree(weight="lift"))
+        betweenness = nx.betweenness_centrality(graph, weight="lift", normalized=True)
+        closeness = nx.closeness_centrality(graph)
+
+        rows = []
+
+        for node in graph.nodes():
+            rows.append({
+                "node": node,
+                "in_degree_weighted": float(in_deg.get(node, 0.0)),
+                "out_degree_weighted": float(out_deg.get(node, 0.0)),
+                "betweenness_centrality": float(betweenness.get(node, 0.0)),
+                "closeness_centrality": float(closeness.get(node, 0.0)),
+            })
+
+        return pd.DataFrame(rows).sort_values(by="betweenness_centrality", ascending=False)
+
+
+    @staticmethod
+    def compute_continuous_dependencies(df: pd.DataFrame, features: List[str], seed: int = 42) -> pd.DataFrame:
+        """
+        Computes pairwise continuous multivariate dependencies between features.
+
+        Calculates Spearman's rank correlation coefficient (rho) and non-linear
+        mutual information for all unique feature pairs.
+
+        Args:
+            df (pd.DataFrame): Dataset containing continuous numerical variables.
+            features (List[str]): List of column names to evaluate pairwise.
+            seed (int, optional): Random seed used for mutual information
+                regression estimation. Defaults to 42.
+
+        Returns:
+            pd.DataFrame: DataFrame containing pairwise dependency measures with columns:
+                - `'var_x'`: First variable name.
+                - `'var_y'`: Second variable name.
+                - `'spearman_rho'`: Monotonic correlation coefficient in [-1.0, 1.0].
+                - `'mutual_information'`: Estimated non-negative mutual information score.
+        """
+        rows = []
+
+        for i, col1 in enumerate(features):
+            for j, col2 in enumerate(features):
+                if i >= j:
+                    continue
+
+                rho, _ = spearmanr(df[col1], df[col2])
+                mi = mutual_info_regression(df[[col1]], df[col2], random_state=seed, n_neighbors=5)[0]
+
+                rows.append({
+                    "var_x": col1,
+                    "var_y": col2,
+                    "spearman_rho": float(rho),
+                    "mutual_information": float(mi),
+                })
+
+        return pd.DataFrame(rows)