From a86879ce71a76e5451df49f38c8f7b048eb6ab74 Mon Sep 17 00:00:00 2001 From: jaydu1 <413075930@qq.com> Date: Wed, 18 Feb 2026 08:58:42 +0800 Subject: [PATCH 1/2] Update 0.0.2 --- .gitignore | 1 + CHANGELOG.md | 16 +- README.md | 35 + docs/README.md | 10 + docs/api/explainers.rst | 22 + docs/api/utils.rst | 7 + docs/conf.py | 9 +- docs/getting_started.md | 33 +- docs/index.rst | 9 +- docs/tutorials/confidence_intervals.ipynb | 213 +++--- docs/tutorials/eot_explainer.ipynb | 764 +++++++++++++--------- docs/tutorials/flow_explainer.ipynb | 361 ++++++---- docs/tutorials/index.rst | 9 +- docs/tutorials/ot_explainer.ipynb | 171 +++-- docs/tutorials/quickstart.ipynb | 145 ++-- docs/user_guide/choosing_explainer.rst | 22 + docs/user_guide/concepts.rst | 11 + fdfi/__init__.py | 39 +- fdfi/explainers.py | 458 ++++++++++++- fdfi/models.py | 12 +- fdfi/utils.py | 134 ++++ pyproject.toml | 2 +- tests/test_explainers.py | 137 ++++ tests/test_utils.py | 73 ++- 24 files changed, 2013 insertions(+), 680 deletions(-) diff --git a/.gitignore b/.gitignore index cf3d02a..f76c3b5 100644 --- a/.gitignore +++ b/.gitignore @@ -207,3 +207,4 @@ marimo/_lsp/ __marimo__/ .DS_Store .vscode/settings.json +.DS_Store diff --git a/CHANGELOG.md b/CHANGELOG.md index 2fd7f05..0fa9bb4 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,19 @@ # Changelog +## [0.0.2] - 2026-02-17 +### Added +- Shared diagnostics now emit qualitative labels (GOOD/MODERATE/POOR) with unified `[FDFI][DIAG]` logging for OT/EOT/Flow explainers. +- Utility functions `compute_latent_independence` and `compute_mmd` are promoted and documented in the public API. +- Notebook investigations now include SE calibration checks (formula vs bootstrap) and reconstruction-fidelity checks for FlowExplainer. + +### Changed +- `conf_int()` now defaults to mixture-based variance floor and mixture-based margin for all explainers. +- Diagnostics implementation is generalized in the base explainer API (`diagnose` / `diagnostics`) for OT/EOT/Flow, and Flow-specific legacy diagnostics are removed. +- Flow diagnostics reconstruction now uses high-precision ODE tolerances to measure model fidelity instead of solver drift. +- Flow solver tolerances are configurable (`flow_solver_rtol/atol`, `diagnostics_solver_rtol/atol`) and flow training can be seeded via `flow_training_seed`. +- `compute_latent_independence` and `compute_mmd` are optimized for better computational efficiency. +- Package version is synchronized to `0.0.2` across package metadata, docs configuration, and tutorial notebook outputs. + ## [0.0.1] - 2026-01-31 ### Added - OTExplainer (Gaussian optimal-transport DFI without cross-fitting). @@ -14,7 +28,5 @@ - Exp3 example now uses `conf_int` for CI bands and supports `FDFI_USE_EOT` toggle. - `environment.yml` now includes plotting + sklearn deps for running examples. - Removed legacy `setup.py` and `requirements*.txt` in favor of `pyproject.toml` extras. - -### Changed - DFIExplainer is renamed to OTExplainer (DFIExplainer remains as an alias). - Explainer can skip flow training via `fit_flow=False`. diff --git a/README.md b/README.md index 09f4aa4..00c352d 100644 --- a/README.md +++ b/README.md @@ -5,6 +5,8 @@ A Python library for computing feature importance using disentangled methods, inspired by SHAP. +Current release: `0.0.2` + ## Overview FDFI (Flow-Disentangled Feature Importance) is a Python module that provides interpretable machine learning explanations through disentangled feature importance methods. This package implements both DFI (Disentangled Feature Importance) and FDFI (Flow-DFI) methods. Similar to SHAP, FDFI helps you understand which features are driving your model's predictions. @@ -62,6 +64,16 @@ results = explainer(X_test) ci = explainer.conf_int(alpha=0.05, target="X", alternative="two-sided") ``` +### CI Defaults in v0.0.2 + +By default, `conf_int()` now uses: + +- `var_floor_method="mixture"` +- `margin_method="mixture"` + +This improves stability for weak effects and avoids ad hoc thresholding in many use cases. +You can still override both methods explicitly if needed. + ## EOT Options (Entropic OT) `EOTExplainer` supports adaptive epsilon, stochastic transport sampling, and @@ -110,6 +122,29 @@ results = explainer(X_test) ci = explainer.conf_int(alpha=0.05, target="Z", alternative="two-sided") ``` +### Explainer diagnostics (new in v0.0.2) + +Disentangled explainers (`OTExplainer`, `EOTExplainer`, and `FlowExplainer`) report two diagnostics with qualitative labels (GOOD / MODERATE / POOR) using consistent `[FDFI][DIAG]` logging: + +- **Latent independence (median dCor)** — lower is better (thresholds: <0.10 good, <0.25 moderate). +- **Distribution fidelity (MMD)** — lower is better (thresholds: <0.05 good, <0.15 moderate). + +Example log: + +``` +[FDFI][DIAG] Flow Model Diagnostics +[FDFI][DIAG] Latent independence (median dCor): 0.0421 [GOOD] → lower is better +[FDFI][DIAG] Distribution fidelity (MMD): 0.0187 [GOOD] → lower is better +``` + +Access diagnostics directly: + +```python +diag = explainer.diagnostics +print(diag["latent_independence_median"], diag["latent_independence_label"]) +print(diag["distribution_fidelity_mmd"], diag["distribution_fidelity_label"]) +``` + For advanced users, flow models can be trained separately: ```python diff --git a/docs/README.md b/docs/README.md index a812f23..eb0462f 100644 --- a/docs/README.md +++ b/docs/README.md @@ -5,6 +5,7 @@ orphan: true # DFI Documentation This is the documentation source for DFI (Disentangled Feature Importance). +Current documented release: `0.0.2`. For the full documentation, see the main README in the project root or build the docs: @@ -25,3 +26,12 @@ open _build/html/index.html - [Concepts](user_guide/concepts.rst): Theory behind DFI and Flow-DFI - [Choosing an Explainer](user_guide/choosing_explainer.rst): Which explainer to use - [Tutorials](tutorials/index.rst): Hands-on notebooks + +## Diagnostics + +All disentangled explainers (`OTExplainer`, `EOTExplainer`, and `FlowExplainer`) +expose a shared `diagnostics` dictionary with latent independence (dCor) and +distribution fidelity (MMD) metrics plus qualitative labels. + +Confidence intervals (`conf_int`) use mixture defaults in v0.0.2 for both +variance floor and practical margin. diff --git a/docs/api/explainers.rst b/docs/api/explainers.rst index 025d59f..fceaa9d 100644 --- a/docs/api/explainers.rst +++ b/docs/api/explainers.rst @@ -100,6 +100,28 @@ and empirical transport targets. ) results = explainer(X_test) +Shared Disentanglement Diagnostics +---------------------------------- + +``OTExplainer``, ``EOTExplainer``, and ``FlowExplainer`` expose a shared +diagnostics interface via: + +- ``explainer.diagnostics`` (computed at setup by default) +- ``explainer.diagnose(...)`` (recompute manually) + +The diagnostics dictionary contains: + +- ``latent_independence_dcor`` (pairwise dCor matrix) +- ``latent_independence_median`` and ``latent_independence_label`` +- ``distribution_fidelity_mmd`` and ``distribution_fidelity_label`` + +.. code-block:: python + + diag = explainer.diagnostics + # or: diag = explainer.diagnose() + print(diag["latent_independence_median"], diag["latent_independence_label"]) + print(diag["distribution_fidelity_mmd"], diag["distribution_fidelity_label"]) + Flow-Based DFI (FlowExplainer) ------------------------------ diff --git a/docs/api/utils.rst b/docs/api/utils.rst index 6fbbbbc..d883a49 100644 --- a/docs/api/utils.rst +++ b/docs/api/utils.rst @@ -63,6 +63,13 @@ Computes the Gower distance matrix for mixed-type data (continuous, binary, and categorical features). Used by ``EOTExplainer`` when ``cost_metric="gower"`` or ``cost_metric="auto"``. +Diagnostics Utilities +--------------------- + +.. autofunction:: fdfi.utils.compute_latent_independence + +.. autofunction:: fdfi.utils.compute_mmd + Statistical Utilities --------------------- diff --git a/docs/conf.py b/docs/conf.py index 9c5fa86..b87371a 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -10,10 +10,10 @@ sys.path.insert(0, os.path.abspath("..")) # -- Project information ----------------------------------------------------- -project = "DFI" -copyright = "2024, DFI Team" -author = "DFI Team" -release = "0.0.1" +project = "FDFI" +copyright = "2025, FDFI Team" +author = "FDFI Team" +release = "0.0.2" # -- General configuration --------------------------------------------------- extensions = [ @@ -91,6 +91,7 @@ # -- Options for HTML output ------------------------------------------------- html_theme = "sphinx_rtd_theme" html_static_path = ["_static"] +html_title = "FDFI Documentation" html_theme_options = { "logo_only": False, diff --git a/docs/getting_started.md b/docs/getting_started.md index 49df998..42b704b 100644 --- a/docs/getting_started.md +++ b/docs/getting_started.md @@ -94,12 +94,23 @@ results = explainer(X_test) ### EOTExplainer (Entropic OT) -Entropic OT DFI using a learned transport kernel: +Entropic OT DFI using a learned transport kernel (useful for non-Gaussian and mixed-type tabular data): ```python +import numpy as np from fdfi.explainers import EOTExplainer -explainer = EOTExplainer(model.predict, X_background, epsilon=0.1, nsamples=50) +feature_types = np.array(["continuous", "binary", "categorical", "continuous"]) + +explainer = EOTExplainer( + model.predict, + X_background, + nsamples=50, + cost_metric="gower", + feature_types=feature_types, + auto_epsilon=True, + target="empirical", +) results = explainer(X_test) ``` @@ -116,15 +127,29 @@ explainer = EOTExplainer( ) ``` -### Confidence Intervals +### Attribution Inference (Confidence Intervals) -All explainers support post-hoc CIs via `conf_int`: +All explainers support post-hoc attribution inference via `conf_int`: ```python results = explainer(X_test) ci = explainer.conf_int(alpha=0.05, target="X", alternative="two-sided") ``` +In v0.0.2, `conf_int` defaults to mixture-based methods for both variance floor +and practical margin. You can still pass explicit methods/quantiles to override. + +### Disentanglement Diagnostics + +`OTExplainer`, `EOTExplainer`, and `FlowExplainer` expose a shared +`diagnostics` dictionary: + +```python +diag = explainer.diagnostics +print(diag["latent_independence_median"], diag["latent_independence_label"]) +print(diag["distribution_fidelity_mmd"], diag["distribution_fidelity_label"]) +``` + ## Next Steps - See `examples/` directory for complete examples diff --git a/docs/index.rst b/docs/index.rst index 62fbe18..a4241b9 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -1,5 +1,5 @@ -DFI Documentation -================= +FDFI Documentation +================== .. image:: https://img.shields.io/badge/License-MIT-yellow.svg :target: https://opensource.org/licenses/MIT @@ -9,15 +9,16 @@ DFI Documentation :target: https://www.python.org/downloads/ :alt: Python 3.8+ -**DFI** (Disentangled Feature Importance) is a Python library for computing +**FDFI** (Flow-Disentangled Feature Importance) is a Python library for computing feature importance using disentangled methods, inspired by SHAP. This package -implements both DFI and FDFI (Flow-DFI) methods. +implements both OT-based DFI and flow-based FDFI methods. Key Features ------------ - 🎯 **Multiple Explainer Types**: Tree, Linear, Kernel, and Optimal Transport explainers - 🧭 **OT-Based DFI**: Gaussian OT (OTExplainer) and Entropic OT (EOTExplainer) +- 🔍 **Shared Diagnostics**: Latent independence and fidelity checks for OT/EOT/Flow - 📊 **Statistical Inference**: Confidence intervals and hypothesis testing - 🔧 **Easy to Use**: Simple API similar to SHAP - 🚀 **Extensible**: Built with modularity for future enhancements diff --git a/docs/tutorials/confidence_intervals.ipynb b/docs/tutorials/confidence_intervals.ipynb index 2c03095..a179e3d 100644 --- a/docs/tutorials/confidence_intervals.ipynb +++ b/docs/tutorials/confidence_intervals.ipynb @@ -1,5 +1,31 @@ { "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "646d6207", + "metadata": { + "execution": { + "iopub.execute_input": "2026-02-17T15:57:02.181392Z", + "iopub.status.busy": "2026-02-17T15:57:02.181247Z", + "iopub.status.idle": "2026-02-17T15:57:02.187893Z", + "shell.execute_reply": "2026-02-17T15:57:02.187355Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "FDFI version: 0.0.2\n" + ] + } + ], + "source": [ + "import fdfi\n", + "print('FDFI version:', fdfi.__version__)" + ] + }, { "cell_type": "markdown", "id": "495b1ae3", @@ -20,14 +46,14 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "id": "4b311614", "metadata": { "execution": { - "iopub.execute_input": "2026-02-12T06:44:56.163967Z", - "iopub.status.busy": "2026-02-12T06:44:56.163708Z", - "iopub.status.idle": "2026-02-12T06:44:56.802090Z", - "shell.execute_reply": "2026-02-12T06:44:56.801783Z" + "iopub.execute_input": "2026-02-17T15:57:02.190083Z", + "iopub.status.busy": "2026-02-17T15:57:02.189929Z", + "iopub.status.idle": "2026-02-17T15:57:02.970029Z", + "shell.execute_reply": "2026-02-17T15:57:02.969193Z" } }, "outputs": [], @@ -51,14 +77,14 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "id": "b49a0457", "metadata": { "execution": { - "iopub.execute_input": "2026-02-12T06:44:56.804054Z", - "iopub.status.busy": "2026-02-12T06:44:56.803923Z", - "iopub.status.idle": "2026-02-12T06:44:56.845073Z", - "shell.execute_reply": "2026-02-12T06:44:56.842455Z" + "iopub.execute_input": "2026-02-17T15:57:02.971961Z", + "iopub.status.busy": "2026-02-17T15:57:02.971789Z", + "iopub.status.idle": "2026-02-17T15:57:03.007826Z", + "shell.execute_reply": "2026-02-17T15:57:03.007364Z" } }, "outputs": [ @@ -106,14 +132,14 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "id": "b8ee9553", "metadata": { "execution": { - "iopub.execute_input": "2026-02-12T06:44:56.850351Z", - "iopub.status.busy": "2026-02-12T06:44:56.850018Z", - "iopub.status.idle": "2026-02-12T06:44:56.857393Z", - "shell.execute_reply": "2026-02-12T06:44:56.855617Z" + "iopub.execute_input": "2026-02-17T15:57:03.009874Z", + "iopub.status.busy": "2026-02-17T15:57:03.009751Z", + "iopub.status.idle": "2026-02-17T15:57:03.800817Z", + "shell.execute_reply": "2026-02-17T15:57:03.800040Z" } }, "outputs": [ @@ -125,16 +151,16 @@ "----------------------------------------------------------------------\n", " Feature Estimate SE CI Lower CI Upper P-value\n", "----------------------------------------------------------------------\n", - " 0 3.6412 0.5218 2.6185 4.6638 0.0000 *\n", - " 1 2.6736 0.3968 1.8958 3.4513 0.0000 *\n", - " 2 0.2268 0.0353 0.1575 0.2960 0.0000 *\n", - " 3 0.0073 0.0100 -0.0124 0.0269 0.4676 \n", - " 4 0.0116 0.0101 -0.0082 0.0313 0.2509 \n", - " 5 0.0067 0.0100 -0.0129 0.0264 0.5012 \n", - " 6 0.0037 0.0100 -0.0159 0.0233 0.7141 \n", - " 7 0.0008 0.0100 -0.0188 0.0204 0.9337 \n", - " 8 0.0090 0.0100 -0.0107 0.0287 0.3692 \n", - " 9 0.0151 0.0101 -0.0046 0.0349 0.1337 \n" + " 0 3.6412 0.5222 2.6177 4.6646 0.0000 *\n", + " 1 2.6736 0.3974 1.8947 3.4524 0.0000 *\n", + " 2 0.2268 0.0410 0.1465 0.3071 0.0776 \n", + " 3 0.0073 0.0230 -0.0378 0.0524 0.0000 *\n", + " 4 0.0116 0.0230 -0.0336 0.0567 0.0000 *\n", + " 5 0.0067 0.0230 -0.0384 0.0519 0.0000 *\n", + " 6 0.0037 0.0230 -0.0414 0.0488 0.0000 *\n", + " 7 0.0008 0.0230 -0.0443 0.0459 0.0000 *\n", + " 8 0.0090 0.0230 -0.0361 0.0542 0.0000 *\n", + " 9 0.0151 0.0230 -0.0300 0.0603 0.0000 *\n" ] } ], @@ -162,20 +188,20 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "id": "a31af857", "metadata": { "execution": { - "iopub.execute_input": "2026-02-12T06:44:56.867150Z", - "iopub.status.busy": "2026-02-12T06:44:56.866929Z", - "iopub.status.idle": "2026-02-12T06:44:56.986079Z", - "shell.execute_reply": "2026-02-12T06:44:56.982301Z" + "iopub.execute_input": "2026-02-17T15:57:03.803324Z", + "iopub.status.busy": "2026-02-17T15:57:03.803065Z", + "iopub.status.idle": "2026-02-17T15:57:03.925537Z", + "shell.execute_reply": "2026-02-17T15:57:03.924572Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -216,14 +242,14 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "id": "7377545b", "metadata": { "execution": { - "iopub.execute_input": "2026-02-12T06:44:56.992972Z", - "iopub.status.busy": "2026-02-12T06:44:56.992604Z", - "iopub.status.idle": "2026-02-12T06:44:56.999934Z", - "shell.execute_reply": "2026-02-12T06:44:56.998898Z" + "iopub.execute_input": "2026-02-17T15:57:03.928335Z", + "iopub.status.busy": "2026-02-17T15:57:03.928142Z", + "iopub.status.idle": "2026-02-17T15:57:03.935594Z", + "shell.execute_reply": "2026-02-17T15:57:03.935161Z" } }, "outputs": [ @@ -235,16 +261,16 @@ "------------------------------------------------------------\n", " Feature Estimate CI Lower P-value Significant\n", "------------------------------------------------------------\n", - " 0 3.6412 2.7829 0.0000 Yes\n", - " 1 2.6736 2.0208 0.0000 Yes\n", - " 2 0.2268 0.1686 0.0000 Yes\n", - " 3 0.0073 -0.0092 0.2338 No\n", - " 4 0.0116 -0.0050 0.1254 No\n", - " 5 0.0067 -0.0097 0.2506 No\n", - " 6 0.0037 -0.0128 0.3571 No\n", - " 7 0.0008 -0.0156 0.4668 No\n", - " 8 0.0090 -0.0075 0.1846 No\n", - " 9 0.0151 -0.0015 0.0669 No\n" + " 0 3.6412 2.7822 0.0000 Yes\n", + " 1 2.6736 2.0199 0.0000 Yes\n", + " 2 0.2268 0.1594 0.0388 Yes\n", + " 3 0.0073 -0.0306 1.0000 No\n", + " 4 0.0116 -0.0263 1.0000 No\n", + " 5 0.0067 -0.0311 1.0000 No\n", + " 6 0.0037 -0.0342 1.0000 No\n", + " 7 0.0008 -0.0370 1.0000 No\n", + " 8 0.0090 -0.0289 1.0000 No\n", + " 9 0.0151 -0.0228 1.0000 No\n" ] } ], @@ -278,14 +304,14 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "id": "50f51917", "metadata": { "execution": { - "iopub.execute_input": "2026-02-12T06:44:57.005567Z", - "iopub.status.busy": "2026-02-12T06:44:57.005310Z", - "iopub.status.idle": "2026-02-12T06:45:05.629234Z", - "shell.execute_reply": "2026-02-12T06:45:05.628372Z" + "iopub.execute_input": "2026-02-17T15:57:03.937919Z", + "iopub.status.busy": "2026-02-17T15:57:03.937721Z", + "iopub.status.idle": "2026-02-17T15:57:03.950213Z", + "shell.execute_reply": "2026-02-17T15:57:03.949589Z" } }, "outputs": [ @@ -297,16 +323,16 @@ "-------------------------------------------------------\n", " Feature No Floor Fixed Mixture\n", "-------------------------------------------------------\n", - " 0 0.5217 0.5218 0.5222\n", - " 1 0.3967 0.3968 0.3974\n", - " 2 0.0339 0.0353 0.0410\n", - " 3 0.0007 0.0100 0.0230\n", - " 4 0.0012 0.0101 0.0230\n", - " 5 0.0006 0.0100 0.0230\n", - " 6 0.0004 0.0100 0.0230\n", - " 7 0.0001 0.0100 0.0230\n", - " 8 0.0009 0.0100 0.0230\n", - " 9 0.0013 0.0101 0.0230\n" + " 0 0.5222 0.5218 0.5222\n", + " 1 0.3974 0.3968 0.3974\n", + " 2 0.0410 0.0353 0.0410\n", + " 3 0.0230 0.0100 0.0230\n", + " 4 0.0230 0.0101 0.0230\n", + " 5 0.0230 0.0100 0.0230\n", + " 6 0.0230 0.0100 0.0230\n", + " 7 0.0230 0.0100 0.0230\n", + " 8 0.0230 0.0100 0.0230\n", + " 9 0.0230 0.0101 0.0230\n" ] } ], @@ -344,14 +370,14 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "id": "a6839f90", "metadata": { "execution": { - "iopub.execute_input": "2026-02-12T06:45:05.639896Z", - "iopub.status.busy": "2026-02-12T06:45:05.637558Z", - "iopub.status.idle": "2026-02-12T06:45:05.648749Z", - "shell.execute_reply": "2026-02-12T06:45:05.647966Z" + "iopub.execute_input": "2026-02-17T15:57:03.952062Z", + "iopub.status.busy": "2026-02-17T15:57:03.951922Z", + "iopub.status.idle": "2026-02-17T15:57:03.959663Z", + "shell.execute_reply": "2026-02-17T15:57:03.959071Z" } }, "outputs": [ @@ -365,7 +391,7 @@ "--------------------------------------------------\n", " 0 3.6412 0.0000 Yes\n", " 1 2.6736 0.0000 Yes\n", - " 2 0.2268 1.0000 No\n", + " 2 0.2268 0.0388 Yes\n", " 3 0.0073 1.0000 No\n", " 4 0.0116 1.0000 No\n", " 5 0.0067 1.0000 No\n", @@ -406,14 +432,14 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "id": "c949b1f4", "metadata": { "execution": { - "iopub.execute_input": "2026-02-12T06:45:05.653145Z", - "iopub.status.busy": "2026-02-12T06:45:05.652881Z", - "iopub.status.idle": "2026-02-12T06:45:05.662713Z", - "shell.execute_reply": "2026-02-12T06:45:05.661819Z" + "iopub.execute_input": "2026-02-17T15:57:03.961710Z", + "iopub.status.busy": "2026-02-17T15:57:03.961569Z", + "iopub.status.idle": "2026-02-17T15:57:03.968353Z", + "shell.execute_reply": "2026-02-17T15:57:03.967789Z" } }, "outputs": [ @@ -450,14 +476,14 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 10, "id": "139638b5", "metadata": { "execution": { - "iopub.execute_input": "2026-02-12T06:45:05.666469Z", - "iopub.status.busy": "2026-02-12T06:45:05.666166Z", - "iopub.status.idle": "2026-02-12T06:45:05.723029Z", - "shell.execute_reply": "2026-02-12T06:45:05.722068Z" + "iopub.execute_input": "2026-02-17T15:57:03.969932Z", + "iopub.status.busy": "2026-02-17T15:57:03.969821Z", + "iopub.status.idle": "2026-02-17T15:57:03.984574Z", + "shell.execute_reply": "2026-02-17T15:57:03.983834Z" } }, "outputs": [ @@ -524,14 +550,14 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 11, "id": "42d7fc37", "metadata": { "execution": { - "iopub.execute_input": "2026-02-12T06:45:05.728052Z", - "iopub.status.busy": "2026-02-12T06:45:05.727240Z", - "iopub.status.idle": "2026-02-12T06:45:05.738658Z", - "shell.execute_reply": "2026-02-12T06:45:05.737840Z" + "iopub.execute_input": "2026-02-17T15:57:03.987040Z", + "iopub.status.busy": "2026-02-17T15:57:03.986880Z", + "iopub.status.idle": "2026-02-17T15:57:03.994439Z", + "shell.execute_reply": "2026-02-17T15:57:03.993724Z" } }, "outputs": [ @@ -546,19 +572,20 @@ "Number of features: 10\n", "Significance level: 0.05\n", "Alternative: greater\n", + "Practical margin: 0.1545\n", "------------------------------------------------------------------------------\n", " Feature Estimate Std Err CI Lower CI Upper P-value Sig\n", "------------------------------------------------------------------------------\n", " 0 3.6412 0.5222 2.7822 inf 0.0000 ***\n", " 1 2.6736 0.3974 2.0199 inf 0.0000 ***\n", - " 2 0.2268 0.0410 0.1594 inf 0.0000 ***\n", - " 3 0.0073 0.0230 -0.0306 inf 0.3759 \n", - " 4 0.0116 0.0230 -0.0263 inf 0.3079 \n", - " 5 0.0067 0.0230 -0.0311 inf 0.3848 \n", - " 6 0.0037 0.0230 -0.0342 inf 0.4367 \n", - " 7 0.0008 0.0230 -0.0370 inf 0.4856 \n", - " 8 0.0090 0.0230 -0.0289 inf 0.3477 \n", - " 9 0.0151 0.0230 -0.0228 inf 0.2559 \n", + " 2 0.2268 0.0410 0.1594 inf 0.0388 **\n", + " 3 0.0073 0.0230 -0.0306 inf 1.0000 \n", + " 4 0.0116 0.0230 -0.0263 inf 1.0000 \n", + " 5 0.0067 0.0230 -0.0311 inf 1.0000 \n", + " 6 0.0037 0.0230 -0.0342 inf 1.0000 \n", + " 7 0.0008 0.0230 -0.0370 inf 1.0000 \n", + " 8 0.0090 0.0230 -0.0289 inf 1.0000 \n", + " 9 0.0151 0.0230 -0.0228 inf 1.0000 \n", "==============================================================================\n", "Significant features: 3 / 10\n", "---\n", @@ -569,10 +596,10 @@ { "data": { "text/plain": [ - "\"==============================================================================\\nFeature Importance Results\\n==============================================================================\\nMethod: OTExplainer\\nNumber of features: 10\\nSignificance level: 0.05\\nAlternative: greater\\n------------------------------------------------------------------------------\\n Feature Estimate Std Err CI Lower CI Upper P-value Sig\\n------------------------------------------------------------------------------\\n 0 3.6412 0.5222 2.7822 inf 0.0000 ***\\n 1 2.6736 0.3974 2.0199 inf 0.0000 ***\\n 2 0.2268 0.0410 0.1594 inf 0.0000 ***\\n 3 0.0073 0.0230 -0.0306 inf 0.3759 \\n 4 0.0116 0.0230 -0.0263 inf 0.3079 \\n 5 0.0067 0.0230 -0.0311 inf 0.3848 \\n 6 0.0037 0.0230 -0.0342 inf 0.4367 \\n 7 0.0008 0.0230 -0.0370 inf 0.4856 \\n 8 0.0090 0.0230 -0.0289 inf 0.3477 \\n 9 0.0151 0.0230 -0.0228 inf 0.2559 \\n==============================================================================\\nSignificant features: 3 / 10\\n---\\nSignif. codes: 0 '***' 0.01 '**' 0.05 '*' 0.1 ' ' 1\\n==============================================================================\"" + "\"==============================================================================\\nFeature Importance Results\\n==============================================================================\\nMethod: OTExplainer\\nNumber of features: 10\\nSignificance level: 0.05\\nAlternative: greater\\nPractical margin: 0.1545\\n------------------------------------------------------------------------------\\n Feature Estimate Std Err CI Lower CI Upper P-value Sig\\n------------------------------------------------------------------------------\\n 0 3.6412 0.5222 2.7822 inf 0.0000 ***\\n 1 2.6736 0.3974 2.0199 inf 0.0000 ***\\n 2 0.2268 0.0410 0.1594 inf 0.0388 **\\n 3 0.0073 0.0230 -0.0306 inf 1.0000 \\n 4 0.0116 0.0230 -0.0263 inf 1.0000 \\n 5 0.0067 0.0230 -0.0311 inf 1.0000 \\n 6 0.0037 0.0230 -0.0342 inf 1.0000 \\n 7 0.0008 0.0230 -0.0370 inf 1.0000 \\n 8 0.0090 0.0230 -0.0289 inf 1.0000 \\n 9 0.0151 0.0230 -0.0228 inf 1.0000 \\n==============================================================================\\nSignificant features: 3 / 10\\n---\\nSignif. codes: 0 '***' 0.01 '**' 0.05 '*' 0.1 ' ' 1\\n==============================================================================\"" ] }, - "execution_count": 10, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" } @@ -614,7 +641,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.12" + "version": "3.10.19" } }, "nbformat": 4, diff --git a/docs/tutorials/eot_explainer.ipynb b/docs/tutorials/eot_explainer.ipynb index 82329c0..b9e9c1c 100644 --- a/docs/tutorials/eot_explainer.ipynb +++ b/docs/tutorials/eot_explainer.ipynb @@ -1,5 +1,31 @@ { "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "c149bc65", + "metadata": { + "execution": { + "iopub.execute_input": "2026-02-18T00:54:45.578461Z", + "iopub.status.busy": "2026-02-18T00:54:45.578136Z", + "iopub.status.idle": "2026-02-18T00:54:45.588565Z", + "shell.execute_reply": "2026-02-18T00:54:45.587727Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "FDFI version: 0.0.2\n" + ] + } + ], + "source": [ + "import fdfi\n", + "print('FDFI version:', fdfi.__version__)" + ] + }, { "cell_type": "markdown", "id": "c02efd2d", @@ -16,26 +42,26 @@ "source": [ "# EOTExplainer: Entropic Optimal Transport\n", "\n", - "This tutorial covers the `EOTExplainer`, which uses entropic optimal transport for more flexible feature importance computation.\n", + "This tutorial covers the `EOTExplainer`, with a **mixed-type feature-importance** example as the primary workflow.\n", "\n", "## What You'll Learn\n", "\n", - "1. When to use EOTExplainer over OTExplainer\n", - "2. Adaptive epsilon selection\n", - "3. Stochastic transport sampling\n", - "4. Handling mixed-type data with Gower distance" + "1. Why EOT is useful for mixed-type data\n", + "2. How to use Gower cost with explicit feature types\n", + "3. How to run one-sided attribution inference with practical margins\n", + "4. How stochastic transport and target choice change attribution\n" ] }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "id": "22022569", "metadata": { "execution": { - "iopub.execute_input": "2026-02-12T06:44:41.174177Z", - "iopub.status.busy": "2026-02-12T06:44:41.173971Z", - "iopub.status.idle": "2026-02-12T06:44:41.796677Z", - "shell.execute_reply": "2026-02-12T06:44:41.796341Z" + "iopub.execute_input": "2026-02-18T00:54:45.591026Z", + "iopub.status.busy": "2026-02-18T00:54:45.590822Z", + "iopub.status.idle": "2026-02-18T00:54:47.756268Z", + "shell.execute_reply": "2026-02-18T00:54:47.755594Z" }, "papermill": { "duration": 0.788061, @@ -49,10 +75,9 @@ "outputs": [], "source": [ "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "from fdfi.explainers import EOTExplainer, OTExplainer\n", + "from fdfi.explainers import EOTExplainer\n", "\n", - "np.random.seed(42)" + "np.random.seed(42)\n" ] }, { @@ -71,13 +96,13 @@ "source": [ "## Why Entropic OT?\n", "\n", - "Gaussian OT assumes your data follows a Gaussian distribution. When this assumption is violated (e.g., multimodal data, heavy tails), **Entropic OT** provides a more flexible alternative.\n", + "Gaussian OT assumes continuous, approximately Gaussian structure. For mixed-type data (continuous + binary + categorical), **Entropic OT** with a flexible cost matrix is often more appropriate.\n", "\n", "EOTExplainer uses the **Sinkhorn algorithm** to solve:\n", "\n", "$$P^* = \\arg\\min_P \\langle C, P \\rangle + \\epsilon H(P)$$\n", "\n", - "where $C$ is the cost matrix, $P$ is the transport plan, and $H$ is entropy regularization." + "where $C$ is the cost matrix, $P$ is the transport plan, and $H$ is entropy regularization.\n" ] }, { @@ -94,21 +119,22 @@ "tags": [] }, "source": [ - "## Example: Non-Gaussian Data\n", + "## Primary Example: Mixed-Type Data with Known Active Features\n", "\n", - "Let's create bimodal data where Gaussian OT may struggle:" + "We build a dataset with continuous, binary, and categorical variables.\n", + "Only two features are truly active in the model, so we can check whether EOT attribution inference highlights them.\n" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "id": "89ec974f", "metadata": { "execution": { - "iopub.execute_input": "2026-02-12T06:44:41.798635Z", - "iopub.status.busy": "2026-02-12T06:44:41.798481Z", - "iopub.status.idle": "2026-02-12T06:44:41.912899Z", - "shell.execute_reply": "2026-02-12T06:44:41.912601Z" + "iopub.execute_input": "2026-02-18T00:54:47.758283Z", + "iopub.status.busy": "2026-02-18T00:54:47.758129Z", + "iopub.status.idle": "2026-02-18T00:54:47.763121Z", + "shell.execute_reply": "2026-02-18T00:54:47.762544Z" }, "papermill": { "duration": 0.142511, @@ -121,55 +147,73 @@ }, "outputs": [ { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" + "name": "stdout", + "output_type": "stream", + "text": [ + "Train shape: (400, 8)\n", + "Test shape: (120, 8)\n", + "Active feature indices: [0, 7]\n", + "Active feature names: ['cont_0', 'cat_2']\n" + ] } ], "source": [ - "# Create bimodal data\n", - "n_samples = 300\n", - "n_features = 5\n", - "\n", - "# Mix of two Gaussian clusters\n", - "cluster1 = np.random.randn(n_samples // 2, n_features) - 2\n", - "cluster2 = np.random.randn(n_samples // 2, n_features) + 2\n", - "X_train = np.vstack([cluster1, cluster2])\n", - "\n", - "# Shuffle\n", - "np.random.shuffle(X_train)\n", - "\n", - "# Visualize\n", - "plt.figure(figsize=(8, 3))\n", - "plt.subplot(1, 2, 1)\n", - "plt.hist(X_train[:, 0], bins=30, edgecolor='black')\n", - "plt.title(\"Feature 0 Distribution (Bimodal)\")\n", - "plt.xlabel(\"Value\")\n", - "\n", - "plt.subplot(1, 2, 2)\n", - "plt.scatter(X_train[:, 0], X_train[:, 1], alpha=0.5, s=10)\n", - "plt.xlabel(\"X₀\")\n", - "plt.ylabel(\"X₁\")\n", - "plt.title(\"First Two Features\")\n", - "plt.tight_layout()\n", - "plt.show()" + "# Mixed-type synthetic data\n", + "n_train = 400\n", + "n_test = 120\n", + "\n", + "feature_names = [\n", + " \"cont_0\", \"cont_1\", \"cont_2\",\n", + " \"bin_0\", \"bin_1\",\n", + " \"cat_0\", \"cat_1\", \"cat_2\",\n", + "]\n", + "feature_types = np.array([\n", + " \"continuous\", \"continuous\", \"continuous\",\n", + " \"binary\", \"binary\",\n", + " \"categorical\", \"categorical\", \"categorical\",\n", + "])\n", + "active_idx = np.array([0, 7])\n", + "\n", + "rng = np.random.default_rng(42)\n", + "\n", + "X_train = np.column_stack([\n", + " rng.normal(size=n_train),\n", + " rng.normal(size=n_train),\n", + " rng.normal(size=n_train),\n", + " rng.integers(0, 2, size=n_train),\n", + " rng.integers(0, 2, size=n_train),\n", + " rng.integers(0, 3, size=n_train),\n", + " rng.integers(0, 4, size=n_train),\n", + " rng.integers(0, 5, size=n_train),\n", + "]).astype(float)\n", + "\n", + "X_test = np.column_stack([\n", + " rng.normal(size=n_test),\n", + " rng.normal(size=n_test),\n", + " rng.normal(size=n_test),\n", + " rng.integers(0, 2, size=n_test),\n", + " rng.integers(0, 2, size=n_test),\n", + " rng.integers(0, 3, size=n_test),\n", + " rng.integers(0, 4, size=n_test),\n", + " rng.integers(0, 5, size=n_test),\n", + "]).astype(float)\n", + "\n", + "print(\"Train shape:\", X_train.shape)\n", + "print(\"Test shape:\", X_test.shape)\n", + "print(\"Active feature indices:\", active_idx.tolist())\n", + "print(\"Active feature names:\", [feature_names[i] for i in active_idx])\n" ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "id": "37bd4e00", "metadata": { "execution": { - "iopub.execute_input": "2026-02-12T06:44:41.914537Z", - "iopub.status.busy": "2026-02-12T06:44:41.914423Z", - "iopub.status.idle": "2026-02-12T06:44:41.916525Z", - "shell.execute_reply": "2026-02-12T06:44:41.916261Z" + "iopub.execute_input": "2026-02-18T00:54:47.764502Z", + "iopub.status.busy": "2026-02-18T00:54:47.764390Z", + "iopub.status.idle": "2026-02-18T00:54:47.767196Z", + "shell.execute_reply": "2026-02-18T00:54:47.766639Z" }, "papermill": { "duration": 0.006289, @@ -180,16 +224,25 @@ }, "tags": [] }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Preview predictions: [-0.341 -1.312 8.831 1.537 2.033]\n" + ] + } + ], "source": [ - "# Model: feature 0 is most important\n", - "def model(X):\n", - " return X[:, 0] ** 2 + 0.5 * X[:, 1]\n", - "\n", - "X_test = np.vstack([\n", - " np.random.randn(25, n_features) - 2,\n", - " np.random.randn(25, n_features) + 2,\n", - "])" + "# Model with only two active features: cont_0 and cat_2\n", + "def mixed_model(X):\n", + " y = 2.8 * X[:, 0]\n", + " y += 3.2 * (X[:, 7] >= 3).astype(float)\n", + " return y\n", + "\n", + "# Quick sanity check\n", + "y_preview = mixed_model(X_test[:5])\n", + "print(\"Preview predictions:\", np.round(y_preview, 3))\n" ] }, { @@ -206,19 +259,21 @@ "tags": [] }, "source": [ - "## Compare OT vs EOT" + "## EOT with Gower Cost (Mixed-Type Aware)\n", + "\n", + "Use Gower distance with explicit feature types. This is the recommended baseline for mixed-type tabular data.\n" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "id": "c869c63a", "metadata": { "execution": { - "iopub.execute_input": "2026-02-12T06:44:41.918390Z", - "iopub.status.busy": "2026-02-12T06:44:41.918270Z", - "iopub.status.idle": "2026-02-12T06:44:41.949384Z", - "shell.execute_reply": "2026-02-12T06:44:41.948219Z" + "iopub.execute_input": "2026-02-18T00:54:47.768878Z", + "iopub.status.busy": "2026-02-18T00:54:47.768750Z", + "iopub.status.idle": "2026-02-18T00:54:49.848341Z", + "shell.execute_reply": "2026-02-18T00:54:49.847839Z" }, "papermill": { "duration": 0.02748, @@ -234,122 +289,116 @@ "name": "stdout", "output_type": "stream", "text": [ - "Feature importance comparison:\n", - "----------------------------------------\n", - " Feature OT EOT\n", - "----------------------------------------\n", - " 0 79.6976 85.2524\n", - " 1 48.0271 52.4058\n", - " 2 48.8011 50.7724\n", - " 3 46.5330 50.7336\n", - " 4 59.7025 59.8619\n", + "Feature importance (phi_X):\n", + "---------------------------------------------------------------------------\n", + "Idx Feature Type phi_X Active\n", + "---------------------------------------------------------------------------\n", + " 0 cont_0 continuous 7.9944 Yes\n", + " 1 cont_1 continuous 0.5579 No\n", + " 2 cont_2 continuous 0.6004 No\n", + " 3 bin_0 binary 0.1236 No\n", + " 4 bin_1 binary 0.1128 No\n", + " 5 cat_0 categorical 0.2845 No\n", + " 6 cat_1 categorical 0.5244 No\n", + " 7 cat_2 categorical 4.0868 Yes\n", "\n", - "Auto-selected epsilon: 7.1670\n" + "Top-2 features by phi_X: ['cont_0', 'cat_2']\n", + "Active/null mean ratio: 16.45x\n", + "Auto epsilon: 0.4781\n", + "Decoder: knn\n" ] } ], "source": [ - "# Gaussian OT\n", - "ot_explainer = OTExplainer(model, data=X_train, nsamples=50)\n", - "ot_results = ot_explainer(X_test)\n", - "\n", - "# Entropic OT with auto epsilon\n", - "eot_explainer = EOTExplainer(\n", - " model, \n", - " data=X_train, \n", - " nsamples=50,\n", + "explainer_gower = EOTExplainer(\n", + " mixed_model,\n", + " data=X_train,\n", + " nsamples=60,\n", + " cost_metric=\"gower\",\n", + " feature_types=feature_types,\n", " auto_epsilon=True,\n", + " target=\"empirical\",\n", + " stochastic_transport=True,\n", + " n_transport_samples=8,\n", + " random_state=0,\n", ")\n", - "eot_results = eot_explainer(X_test)\n", "\n", - "# Compare\n", - "print(\"Feature importance comparison:\")\n", - "print(\"-\" * 40)\n", - "print(f\"{'Feature':>8} {'OT':>12} {'EOT':>12}\")\n", - "print(\"-\" * 40)\n", - "for i in range(n_features):\n", - " print(f\"{i:>8} {ot_results['phi_X'][i]:>12.4f} {eot_results['phi_X'][i]:>12.4f}\")\n", - "\n", - "print(f\"\\nAuto-selected epsilon: {eot_explainer.epsilon:.4f}\")" + "results_gower = explainer_gower(X_test)\n", + "phi = results_gower[\"phi_X\"]\n", + "active_mask = np.isin(np.arange(len(feature_names)), active_idx)\n", + "\n", + "print(\"Feature importance (phi_X):\")\n", + "print(\"-\" * 75)\n", + "print(f\"{'Idx':>3} {'Feature':>10} {'Type':>12} {'phi_X':>10} {'Active':>8}\")\n", + "print(\"-\" * 75)\n", + "for i, (name, ftype) in enumerate(zip(feature_names, feature_types)):\n", + " active_tag = \"Yes\" if i in active_idx else \"No\"\n", + " print(f\"{i:>3} {name:>10} {ftype:>12} {phi[i]:>10.4f} {active_tag:>8}\")\n", + "\n", + "top2 = np.argsort(phi)[::-1][:2]\n", + "ratio = phi[active_mask].mean() / phi[~active_mask].mean()\n", + "print(\"\\nTop-2 features by phi_X:\", [feature_names[i] for i in top2])\n", + "print(f\"Active/null mean ratio: {ratio:.2f}x\")\n", + "print(f\"Auto epsilon: {explainer_gower.epsilon:.4f}\")\n", + "print(\"Decoder:\", getattr(explainer_gower, \"decode_method_effective_\", explainer_gower.decode_method))\n" ] }, { "cell_type": "markdown", - "id": "003a7223", - "metadata": { - "papermill": { - "duration": 0.002088, - "end_time": "2026-02-12T05:43:38.590092", - "exception": false, - "start_time": "2026-02-12T05:43:38.588004", - "status": "completed" - }, - "tags": [] - }, + "id": "692d413d", + "metadata": {}, "source": [ - "## Epsilon Selection\n", - "\n", - "The `epsilon` parameter controls the entropy regularization:\n", - "- **Small epsilon**: Sharp transport (closer to true OT), may be unstable\n", - "- **Large epsilon**: Smooth transport, loses structure\n", + "## Active-Feature Attribution Inference (One-Sided Test)\n", "\n", - "Use `auto_epsilon=True` to automatically select based on median pairwise distance." + "We use one-sided testing with a fixed practical margin to encourage sparse attribution calls.\n", + "This setup should highlight mostly the truly active features in this synthetic example.\n" ] }, { "cell_type": "code", - "execution_count": 5, - "id": "050ab946", + "execution_count": 6, + "id": "7c7a6e95", "metadata": { "execution": { - "iopub.execute_input": "2026-02-12T06:44:41.957050Z", - "iopub.status.busy": "2026-02-12T06:44:41.956795Z", - "iopub.status.idle": "2026-02-12T06:44:42.298939Z", - "shell.execute_reply": "2026-02-12T06:44:42.298031Z" - }, - "papermill": { - "duration": 0.34833, - "end_time": "2026-02-12T05:43:38.940349", - "exception": false, - "start_time": "2026-02-12T05:43:38.592019", - "status": "completed" - }, - "tags": [] + "iopub.execute_input": "2026-02-18T00:54:49.849917Z", + "iopub.status.busy": "2026-02-18T00:54:49.849760Z", + "iopub.status.idle": "2026-02-18T00:54:49.853047Z", + "shell.execute_reply": "2026-02-18T00:54:49.852607Z" + } }, "outputs": [ { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" + "name": "stdout", + "output_type": "stream", + "text": [ + "Attribution-positive feature indices: [0, 7]\n", + "Attribution-positive feature names: ['cont_0', 'cat_2']\n", + "Expected active names: ['cont_0', 'cat_2']\n", + "True positives: [0, 7]\n", + "False positives: []\n" + ] } ], "source": [ - "# Compare different epsilon values\n", - "epsilon_values = [0.01, 0.1, 1.0, 10.0]\n", - "results_by_eps = {}\n", - "\n", - "for eps in epsilon_values:\n", - " explainer = EOTExplainer(\n", - " model, data=X_train, nsamples=50,\n", - " epsilon=eps, auto_epsilon=False\n", - " )\n", - " results_by_eps[eps] = explainer(X_test)\n", - "\n", - "# Plot\n", - "fig, axes = plt.subplots(1, len(epsilon_values), figsize=(14, 3))\n", - "for ax, eps in zip(axes, epsilon_values):\n", - " phi = results_by_eps[eps][\"phi_X\"]\n", - " ax.bar(range(n_features), phi)\n", - " ax.set_xlabel(\"Feature\")\n", - " ax.set_ylabel(\"Importance\")\n", - " ax.set_title(f\"ε = {eps}\")\n", - "plt.tight_layout()\n", - "plt.show()" + "ci = explainer_gower.conf_int(\n", + " alpha=0.05,\n", + " target=\"X\",\n", + " alternative=\"greater\",\n", + " margin_method=\"fixed\",\n", + " margin=1.2,\n", + " var_floor_method=\"fixed\",\n", + " var_floor_c=0.0,\n", + ")\n", + "\n", + "attribution_idx = np.where(ci[\"reject_null\"])[0]\n", + "expected_active = set(active_idx.tolist())\n", + "attribution_set = set(attribution_idx.tolist())\n", + "\n", + "print(\"Attribution-positive feature indices:\", attribution_idx.tolist())\n", + "print(\"Attribution-positive feature names:\", [feature_names[i] for i in attribution_idx])\n", + "print(\"Expected active names:\", [feature_names[i] for i in active_idx])\n", + "print(\"True positives:\", sorted(expected_active & attribution_set))\n", + "print(\"False positives:\", sorted(attribution_set - expected_active))\n" ] }, { @@ -366,21 +415,21 @@ "tags": [] }, "source": [ - "## Stochastic Transport Sampling\n", + "## Compare Cost Metrics: Gower vs Squared Euclidean\n", "\n", - "Instead of using the barycentric map (average transport), you can sample from the transport kernel for variance reduction:" + "For mixed-type data, Gower typically provides more appropriate geometry than squared Euclidean cost.\n" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "id": "e2241247", "metadata": { "execution": { - "iopub.execute_input": "2026-02-12T06:44:42.317187Z", - "iopub.status.busy": "2026-02-12T06:44:42.316844Z", - "iopub.status.idle": "2026-02-12T06:44:42.532043Z", - "shell.execute_reply": "2026-02-12T06:44:42.531392Z" + "iopub.execute_input": "2026-02-18T00:54:49.854629Z", + "iopub.status.busy": "2026-02-18T00:54:49.854531Z", + "iopub.status.idle": "2026-02-18T00:54:50.246801Z", + "shell.execute_reply": "2026-02-18T00:54:50.246319Z" }, "papermill": { "duration": 0.274662, @@ -396,42 +445,45 @@ "name": "stdout", "output_type": "stream", "text": [ - "Feature importance with stochastic transport:\n", - "--------------------------------------------------\n", - " Feature Deterministic Stochastic\n", - "--------------------------------------------------\n", - " 0 85.2524 75.1587\n", - " 1 52.4058 48.4361\n", - " 2 50.7724 47.8746\n", - " 3 50.7336 47.8951\n", - " 4 59.8619 59.4248\n" + " Feature Gower SqEuclid\n", + "--------------------------------------\n", + " cont_0 7.9944 8.0813\n", + " cont_1 0.5579 0.5402\n", + " cont_2 0.6004 0.6008\n", + " bin_0 0.1236 0.1333\n", + " bin_1 0.1128 0.1146\n", + " cat_0 0.2845 0.2880\n", + " cat_1 0.5244 0.5352\n", + " cat_2 4.0868 4.1496\n", + "\n", + "Top-2 (Gower): ['cont_0', 'cat_2']\n", + "Top-2 (SqEuclid): ['cont_0', 'cat_2']\n" ] } ], "source": [ - "# Without stochastic transport\n", - "explainer_det = EOTExplainer(\n", - " model, data=X_train, nsamples=50,\n", - " auto_epsilon=True,\n", - " stochastic_transport=False,\n", - ")\n", - "results_det = explainer_det(X_test)\n", - "\n", - "# With stochastic transport\n", - "explainer_stoch = EOTExplainer(\n", - " model, data=X_train, nsamples=50,\n", + "explainer_sq = EOTExplainer(\n", + " mixed_model,\n", + " data=X_train,\n", + " nsamples=60,\n", + " cost_metric=\"sqeuclidean\",\n", " auto_epsilon=True,\n", + " target=\"empirical\",\n", " stochastic_transport=True,\n", - " n_transport_samples=10,\n", + " n_transport_samples=8,\n", + " random_state=0,\n", ")\n", - "results_stoch = explainer_stoch(X_test)\n", "\n", - "print(\"Feature importance with stochastic transport:\")\n", - "print(\"-\" * 50)\n", - "print(f\"{'Feature':>8} {'Deterministic':>14} {'Stochastic':>14}\")\n", - "print(\"-\" * 50)\n", - "for i in range(n_features):\n", - " print(f\"{i:>8} {results_det['phi_X'][i]:>14.4f} {results_stoch['phi_X'][i]:>14.4f}\")" + "results_sq = explainer_sq(X_test)\n", + "phi_sq = results_sq[\"phi_X\"]\n", + "\n", + "print(f\"{'Feature':>10} {'Gower':>12} {'SqEuclid':>12}\")\n", + "print(\"-\" * 38)\n", + "for i, name in enumerate(feature_names):\n", + " print(f\"{name:>10} {phi[i]:>12.4f} {phi_sq[i]:>12.4f}\")\n", + "\n", + "print(\"\\nTop-2 (Gower):\", [feature_names[i] for i in np.argsort(phi)[::-1][:2]])\n", + "print(\"Top-2 (SqEuclid):\", [feature_names[i] for i in np.argsort(phi_sq)[::-1][:2]])\n" ] }, { @@ -448,21 +500,21 @@ "tags": [] }, "source": [ - "## Mixed Data Types with Gower Distance\n", + "## Stochastic vs Deterministic Transport\n", "\n", - "EOTExplainer supports categorical features using Gower distance:" + "Stochastic transport samples from the transport kernel instead of using only barycentric averages.\n" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "id": "26149aff", "metadata": { "execution": { - "iopub.execute_input": "2026-02-12T06:44:42.537789Z", - "iopub.status.busy": "2026-02-12T06:44:42.537317Z", - "iopub.status.idle": "2026-02-12T06:44:42.557245Z", - "shell.execute_reply": "2026-02-12T06:44:42.554894Z" + "iopub.execute_input": "2026-02-18T00:54:50.248619Z", + "iopub.status.busy": "2026-02-18T00:54:50.248492Z", + "iopub.status.idle": "2026-02-18T00:54:50.659800Z", + "shell.execute_reply": "2026-02-18T00:54:50.659347Z" }, "papermill": { "duration": 0.011575, @@ -478,40 +530,73 @@ "name": "stdout", "output_type": "stream", "text": [ - "Mixed data shape: (200, 5)\n", - "Feature types: [continuous, continuous, continuous, binary, categorical]\n" + " Feature Deterministic Stochastic\n", + "------------------------------------------\n", + " cont_0 8.0457 7.9944\n", + " cont_1 1.0420 0.5579\n", + " cont_2 0.7713 0.6004\n", + " bin_0 0.2159 0.1236\n", + " bin_1 0.1992 0.1128\n", + " cat_0 0.3964 0.2845\n", + " cat_1 0.8258 0.5244\n", + " cat_2 5.7677 4.0868\n", + "\n", + "Active/null ratio (deterministic): 12.01x\n", + "Active/null ratio (stochastic): 16.45x\n" ] } ], "source": [ - "# Create mixed-type data\n", - "n_samples = 200\n", - "\n", - "# Continuous features\n", - "X_cont = np.random.randn(n_samples, 3)\n", + "explainer_det = EOTExplainer(\n", + " mixed_model,\n", + " data=X_train,\n", + " nsamples=60,\n", + " cost_metric=\"gower\",\n", + " feature_types=feature_types,\n", + " auto_epsilon=True,\n", + " target=\"empirical\",\n", + " stochastic_transport=False,\n", + " random_state=0,\n", + ")\n", + "results_det = explainer_det(X_test)\n", + "phi_det = results_det[\"phi_X\"]\n", "\n", - "# Binary feature\n", - "X_binary = np.random.choice([0, 1], size=(n_samples, 1))\n", + "explainer_stoch = EOTExplainer(\n", + " mixed_model,\n", + " data=X_train,\n", + " nsamples=60,\n", + " cost_metric=\"gower\",\n", + " feature_types=feature_types,\n", + " auto_epsilon=True,\n", + " target=\"empirical\",\n", + " stochastic_transport=True,\n", + " n_transport_samples=8,\n", + " random_state=0,\n", + ")\n", + "results_stoch = explainer_stoch(X_test)\n", + "phi_stoch = results_stoch[\"phi_X\"]\n", "\n", - "# Categorical feature (encoded as integers)\n", - "X_cat = np.random.choice([0, 1, 2], size=(n_samples, 1))\n", + "print(f\"{'Feature':>10} {'Deterministic':>14} {'Stochastic':>14}\")\n", + "print(\"-\" * 42)\n", + "for i, name in enumerate(feature_names):\n", + " print(f\"{name:>10} {phi_det[i]:>14.4f} {phi_stoch[i]:>14.4f}\")\n", "\n", - "# Combine\n", - "X_mixed = np.hstack([X_cont, X_binary, X_cat])\n", - "print(f\"Mixed data shape: {X_mixed.shape}\")\n", - "print(f\"Feature types: [continuous, continuous, continuous, binary, categorical]\")" + "active_mask = np.isin(np.arange(len(feature_names)), active_idx)\n", + "ratio_det = phi_det[active_mask].mean() / phi_det[~active_mask].mean()\n", + "ratio_stoch = phi_stoch[active_mask].mean() / phi_stoch[~active_mask].mean()\n", + "print(f\"\\nActive/null ratio (deterministic): {ratio_det:.2f}x\")\n", + "print(f\"Active/null ratio (stochastic): {ratio_stoch:.2f}x\")\n" ] }, { - "cell_type": "code", - "execution_count": 8, + "cell_type": "markdown", "id": "13007a36", "metadata": { "execution": { - "iopub.execute_input": "2026-02-12T06:44:42.566312Z", - "iopub.status.busy": "2026-02-12T06:44:42.565815Z", - "iopub.status.idle": "2026-02-12T06:44:42.598252Z", - "shell.execute_reply": "2026-02-12T06:44:42.577817Z" + "iopub.execute_input": "2026-02-17T16:26:13.234601Z", + "iopub.status.busy": "2026-02-17T16:26:13.234489Z", + "iopub.status.idle": "2026-02-17T16:26:13.237114Z", + "shell.execute_reply": "2026-02-17T16:26:13.236656Z" }, "papermill": { "duration": 0.008126, @@ -522,23 +607,10 @@ }, "tags": [] }, - "outputs": [], "source": [ - "# Model that uses all features\n", - "def mixed_model(X):\n", - " # Continuous contribution\n", - " y = X[:, 0] + 0.5 * X[:, 1]\n", - " # Binary feature effect\n", - " y += 2 * X[:, 3]\n", - " # Categorical feature effect\n", - " y += X[:, 4] * 0.3\n", - " return y\n", + "## Target Distribution: Gaussian vs Empirical\n", "\n", - "X_test_mixed = np.hstack([\n", - " np.random.randn(30, 3),\n", - " np.random.choice([0, 1], size=(30, 1)),\n", - " np.random.choice([0, 1, 2], size=(30, 1)),\n", - "])" + "EOT can transport toward either a Gaussian latent target or a permuted empirical target.\n" ] }, { @@ -547,10 +619,10 @@ "id": "2af05493", "metadata": { "execution": { - "iopub.execute_input": "2026-02-12T06:44:42.606846Z", - "iopub.status.busy": "2026-02-12T06:44:42.606710Z", - "iopub.status.idle": "2026-02-12T06:44:42.631476Z", - "shell.execute_reply": "2026-02-12T06:44:42.630469Z" + "iopub.execute_input": "2026-02-18T00:54:50.661842Z", + "iopub.status.busy": "2026-02-18T00:54:50.661701Z", + "iopub.status.idle": "2026-02-18T00:54:51.429749Z", + "shell.execute_reply": "2026-02-18T00:54:51.429304Z" }, "papermill": { "duration": 0.016598, @@ -566,39 +638,61 @@ "name": "stdout", "output_type": "stream", "text": [ - "Feature importance for mixed-type data:\n", - " cont_0: 0.9021\n", - " cont_1: 0.1426\n", - " cont_2: 0.0004\n", - " binary: 0.2224\n", - " categorical: 0.0882\n", + " Feature Gaussian Empirical\n", + "--------------------------------------\n", + " cont_0 8.0781 7.9944\n", + " cont_1 0.5678 0.5579\n", + " cont_2 0.5628 0.6004\n", + " bin_0 0.1550 0.1236\n", + " bin_1 0.1415 0.1128\n", + " cat_0 0.3663 0.2845\n", + " cat_1 0.5932 0.5244\n", + " cat_2 4.1552 4.0868\n", "\n", - "Detected types: ['continuous' 'continuous' 'continuous' 'binary' 'categorical']\n" + "Top-2 (Gaussian): ['cont_0', 'cat_2']\n", + "Top-2 (Empirical): ['cont_0', 'cat_2']\n" ] } ], "source": [ - "# Use Gower distance for mixed types\n", - "import numpy as np\n", - "feature_types = np.array([\"continuous\", \"continuous\", \"continuous\", \"binary\", \"categorical\"])\n", + "explainer_gaussian = EOTExplainer(\n", + " mixed_model,\n", + " data=X_train,\n", + " nsamples=60,\n", + " cost_metric=\"gower\",\n", + " feature_types=feature_types,\n", + " auto_epsilon=True,\n", + " target=\"gaussian\",\n", + " stochastic_transport=True,\n", + " n_transport_samples=8,\n", + " random_state=0,\n", + ")\n", "\n", - "explainer_gower = EOTExplainer(\n", + "explainer_empirical = EOTExplainer(\n", " mixed_model,\n", - " data=X_mixed,\n", - " nsamples=50,\n", + " data=X_train,\n", + " nsamples=60,\n", " cost_metric=\"gower\",\n", " feature_types=feature_types,\n", " auto_epsilon=True,\n", + " target=\"empirical\",\n", + " stochastic_transport=True,\n", + " n_transport_samples=8,\n", + " random_state=0,\n", ")\n", "\n", - "results_mixed = explainer_gower(X_test_mixed)\n", + "results_g = explainer_gaussian(X_test)\n", + "results_e = explainer_empirical(X_test)\n", + "phi_g = results_g[\"phi_X\"]\n", + "phi_e = results_e[\"phi_X\"]\n", "\n", - "print(\"Feature importance for mixed-type data:\")\n", - "feature_names = [\"cont_0\", \"cont_1\", \"cont_2\", \"binary\", \"categorical\"]\n", + "print(f\"{'Feature':>10} {'Gaussian':>12} {'Empirical':>12}\")\n", + "print(\"-\" * 38)\n", "for i, name in enumerate(feature_names):\n", - " print(f\" {name}: {results_mixed['phi_X'][i]:.4f}\")\n", + " print(f\"{name:>10} {phi_g[i]:>12.4f} {phi_e[i]:>12.4f}\")\n", "\n", - "print(f\"\\nDetected types: {explainer_gower.detected_types_['types']}\")" + "print(\"\\nTop-2 (Gaussian):\", [feature_names[i] for i in np.argsort(phi_g)[::-1][:2]])\n", + "print(\"Top-2 (Empirical):\", [feature_names[i] for i in np.argsort(phi_e)[::-1][:2]])\n" ] }, { @@ -615,9 +709,9 @@ "tags": [] }, "source": [ - "## Target Distribution: Gaussian vs Empirical\n", + "## Diagnostics and Standardized Summary\n", "\n", - "EOTExplainer can use either a Gaussian target or an empirical (permuted) target:" + "Use shared diagnostics and `summary()` to inspect transport quality and feature-level inference.\n" ] }, { @@ -626,10 +720,10 @@ "id": "6d8207d4", "metadata": { "execution": { - "iopub.execute_input": "2026-02-12T06:44:42.636058Z", - "iopub.status.busy": "2026-02-12T06:44:42.635481Z", - "iopub.status.idle": "2026-02-12T06:44:42.668428Z", - "shell.execute_reply": "2026-02-12T06:44:42.667592Z" + "iopub.execute_input": "2026-02-18T00:54:51.431808Z", + "iopub.status.busy": "2026-02-18T00:54:51.431642Z", + "iopub.status.idle": "2026-02-18T00:54:51.435454Z", + "shell.execute_reply": "2026-02-18T00:54:51.434858Z" }, "papermill": { "duration": 0.035844, @@ -645,42 +739,60 @@ "name": "stdout", "output_type": "stream", "text": [ - "Target distribution comparison:\n", - "---------------------------------------------\n", - " Feature Gaussian Empirical\n", - "---------------------------------------------\n", - " 0 85.2524 82.9647\n", - " 1 52.4058 51.3192\n", - " 2 50.7724 50.3143\n", - " 3 50.7336 50.0130\n", - " 4 59.8619 60.4786\n" + "Diagnostics comparison\n", + "--------------------------------------------------------------------------------\n", + " Gower-stoch: dCor=0.348636 [POOR], MMD=0.409461 [POOR]\n", + " Gower-det: dCor=0.348636 [POOR], MMD=0.409461 [POOR]\n", + "SqEuclid-stoch: dCor=0.073760 [GOOD], MMD=0.007061 [GOOD]\n", + "\n", + "Gower-stochastic summary (one-sided attribution inference)\n", + "==============================================================================\n", + "Feature Importance Results\n", + "==============================================================================\n", + "Method: EOTExplainer\n", + "Number of features: 8\n", + "Significance level: 0.05\n", + "Alternative: greater\n", + "Practical margin: 1.3631\n", + "------------------------------------------------------------------------------\n", + " Feature Estimate Std Err CI Lower CI Upper P-value Sig\n", + "------------------------------------------------------------------------------\n", + " 0 7.9944 1.1047 6.1773 inf 0.0000 ***\n", + " 1 0.5579 0.3790 -0.0656 inf 0.9832 \n", + " 2 0.6004 0.3926 -0.0454 inf 0.9740 \n", + " 3 0.1236 0.3496 -0.4514 inf 0.9998 \n", + " 4 0.1128 0.3494 -0.4619 inf 0.9998 \n", + " 5 0.2845 0.3597 -0.3071 inf 0.9986 \n", + " 6 0.5244 0.3757 -0.0936 inf 0.9872 \n", + " 7 4.0868 0.5085 3.2505 inf 0.0000 ***\n", + "==============================================================================\n", + "Significant features: 2 / 8\n", + "---\n", + "Signif. codes: 0 '***' 0.01 '**' 0.05 '*' 0.1 ' ' 1\n", + "==============================================================================\n" ] } ], "source": [ - "# Gaussian target\n", - "explainer_gaussian = EOTExplainer(\n", - " model, data=X_train, nsamples=50,\n", - " target=\"gaussian\",\n", - " auto_epsilon=True,\n", - ")\n", - "\n", - "# Empirical target\n", - "explainer_empirical = EOTExplainer(\n", - " model, data=X_train, nsamples=50,\n", - " target=\"empirical\",\n", - " auto_epsilon=True,\n", - ")\n", - "\n", - "results_g = explainer_gaussian(X_test)\n", - "results_e = explainer_empirical(X_test)\n", + "print(\"Diagnostics comparison\")\n", + "print(\"-\" * 80)\n", + "for name, exp in [\n", + " (\"Gower-stoch\", explainer_gower),\n", + " (\"Gower-det\", explainer_det),\n", + " (\"SqEuclid-stoch\", explainer_sq),\n", + "]:\n", + " d = exp.diagnostics\n", + " print(\n", + " f\"{name:>14}: dCor={d['latent_independence_median']:.6f} [{d['latent_independence_label']}], \"\n", + " f\"MMD={d['distribution_fidelity_mmd']:.6f} [{d['distribution_fidelity_label']}]\"\n", + " )\n", "\n", - "print(\"Target distribution comparison:\")\n", - "print(\"-\" * 45)\n", - "print(f\"{'Feature':>8} {'Gaussian':>14} {'Empirical':>14}\")\n", - "print(\"-\" * 45)\n", - "for i in range(n_features):\n", - " print(f\"{i:>8} {results_g['phi_X'][i]:>14.4f} {results_e['phi_X'][i]:>14.4f}\")" + "print(\"\\nGower-stochastic summary (one-sided attribution inference)\")\n", + "_ = explainer_gower.summary(\n", + " alpha=0.05,\n", + " target=\"X\",\n", + " alternative=\"greater\"\n", + ")\n" ] }, { @@ -700,24 +812,29 @@ "## Best Practices for EOTExplainer\n", "\n", "```python\n", - "# Recommended settings for most cases\n", + "from fdfi.explainers import EOTExplainer\n", + "\n", "explainer = EOTExplainer(\n", " model,\n", " data=X_train,\n", - " nsamples=50,\n", - " auto_epsilon=True, # Let the algorithm choose\n", - " target=\"gaussian\", # Standard choice\n", - " stochastic_transport=False, # Enable for variance reduction\n", + " nsamples=60,\n", + " cost_metric=\"gower\", # mixed-type data\n", + " feature_types=feature_types,\n", + " auto_epsilon=True, # start here\n", + " target=\"empirical\", # often stable for tabular data\n", + " stochastic_transport=True, # sample transport kernel\n", + " n_transport_samples=8,\n", ")\n", "\n", - "# For mixed-type data\n", - "explainer = EOTExplainer(\n", - " model,\n", - " data=X_train,\n", - " cost_metric=\"gower\", # or \"auto\"\n", - " categorical_threshold=10, # Unique values ≤ 10 = categorical\n", + "results = explainer(X_test)\n", + "\n", + "ci = explainer.conf_int(\n", + " alpha=0.05,\n", + " target=\"X\",\n", + " alternative=\"greater\"\n", ")\n", - "```" + "attribution_idx = np.where(ci[\"reject_null\"])[0]\n", + "```\n" ] }, { @@ -738,15 +855,20 @@ "\n", "Key takeaways:\n", "\n", - "1. **EOTExplainer** is more flexible than OTExplainer for non-Gaussian data\n", - "2. Use `auto_epsilon=True` for automatic regularization tuning\n", - "3. Enable `stochastic_transport=True` for variance reduction\n", - "4. Use `cost_metric=\"gower\"` for mixed continuous/categorical features\n", - "5. Choose `target=\"empirical\"` if you want to stay close to the data distribution" + "1. Mixed-type data is a natural use case for `EOTExplainer` with Gower cost.\n", + "2. Defining known active features in synthetic data helps validate attribution behavior.\n", + "3. One-sided testing with a practical margin can make attribution-positive features much sparser.\n", + "4. Stochastic transport and target choice can change attribution magnitudes.\n", + "5. Use shared diagnostics and `summary()` to validate transport quality before interpretation.\n" ] } ], "metadata": { + "kernelspec": { + "display_name": "fdfi", + "language": "python", + "name": "python3" + }, "language_info": { "codemirror_mode": { "name": "ipython", @@ -757,7 +879,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.12" + "version": "3.10.19" }, "papermill": { "default_parameters": {}, diff --git a/docs/tutorials/flow_explainer.ipynb b/docs/tutorials/flow_explainer.ipynb index dc37e21..0feee2e 100644 --- a/docs/tutorials/flow_explainer.ipynb +++ b/docs/tutorials/flow_explainer.ipynb @@ -1,5 +1,31 @@ { "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "a3208230", + "metadata": { + "execution": { + "iopub.execute_input": "2026-02-17T16:01:03.941070Z", + "iopub.status.busy": "2026-02-17T16:01:03.940931Z", + "iopub.status.idle": "2026-02-17T16:01:03.948147Z", + "shell.execute_reply": "2026-02-17T16:01:03.947431Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "FDFI version: 0.0.2\n" + ] + } + ], + "source": [ + "import fdfi\n", + "print('FDFI version:', fdfi.__version__)" + ] + }, { "cell_type": "markdown", "id": "a6923e4a", @@ -45,14 +71,14 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "id": "7c6820dd", "metadata": { "execution": { - "iopub.execute_input": "2026-02-12T06:44:43.573602Z", - "iopub.status.busy": "2026-02-12T06:44:43.573362Z", - "iopub.status.idle": "2026-02-12T06:44:44.064693Z", - "shell.execute_reply": "2026-02-12T06:44:44.064357Z" + "iopub.execute_input": "2026-02-17T16:01:03.950075Z", + "iopub.status.busy": "2026-02-17T16:01:03.949917Z", + "iopub.status.idle": "2026-02-17T16:01:04.379302Z", + "shell.execute_reply": "2026-02-17T16:01:04.378711Z" }, "papermill": { "duration": 0.525849, @@ -75,7 +101,8 @@ "from fdfi.explainers import FlowExplainer, OTExplainer\n", "\n", "# Set random seed for reproducibility\n", - "np.random.seed(42)" + "np.random.seed(42)\n", + "\n" ] }, { @@ -126,14 +153,14 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "id": "3993bd28", "metadata": { "execution": { - "iopub.execute_input": "2026-02-12T06:44:44.066645Z", - "iopub.status.busy": "2026-02-12T06:44:44.066503Z", - "iopub.status.idle": "2026-02-12T06:44:44.069516Z", - "shell.execute_reply": "2026-02-12T06:44:44.069245Z" + "iopub.execute_input": "2026-02-17T16:01:04.382108Z", + "iopub.status.busy": "2026-02-17T16:01:04.381911Z", + "iopub.status.idle": "2026-02-17T16:01:04.386185Z", + "shell.execute_reply": "2026-02-17T16:01:04.385629Z" }, "papermill": { "duration": 0.007333, @@ -203,14 +230,14 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "id": "3b3caa62", "metadata": { "execution": { - "iopub.execute_input": "2026-02-12T06:44:44.071046Z", - "iopub.status.busy": "2026-02-12T06:44:44.070960Z", - "iopub.status.idle": "2026-02-12T06:44:46.670801Z", - "shell.execute_reply": "2026-02-12T06:44:46.670465Z" + "iopub.execute_input": "2026-02-17T16:01:04.388238Z", + "iopub.status.busy": "2026-02-17T16:01:04.388121Z", + "iopub.status.idle": "2026-02-17T16:01:08.018901Z", + "shell.execute_reply": "2026-02-17T16:01:08.017922Z" }, "papermill": { "duration": 5.229684, @@ -226,7 +253,17 @@ "name": "stdout", "output_type": "stream", "text": [ - "Training complete: 200 steps, final loss=1.7683\n" + "[FDFI][INFO] Training flow model...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Training complete: 200 steps, final loss=1.7161\n", + "[FDFI][DIAG] Flow Model Diagnostics\n", + "[FDFI][DIAG] Latent independence (median dCor): 0.083235 [GOOD] -> lower is better\n", + "[FDFI][DIAG] Distribution fidelity (MMD): 0.000000 [GOOD] -> lower is better\n" ] }, { @@ -236,14 +273,14 @@ "\n", "CPI Feature Importance:\n", "----------------------------------------\n", - " Feature 0: 7.0929 *\n", - " Feature 1: 10.7967 *\n", - " Feature 2: 0.3819 *\n", - " Feature 3: 0.1437 \n", - " Feature 4: 0.0559 \n", - " Feature 5: 0.0583 \n", - " Feature 6: 0.0103 \n", - " Feature 7: 0.0334 \n", + " Feature 0: 8.0275 *\n", + " Feature 1: 11.1829 *\n", + " Feature 2: 0.4036 *\n", + " Feature 3: 0.0956 \n", + " Feature 4: 0.0383 \n", + " Feature 5: 0.0099 \n", + " Feature 6: 0.0354 \n", + " Feature 7: 0.0120 \n", "\n", "* = active feature\n" ] @@ -311,14 +348,14 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "id": "f9d94ca0", "metadata": { "execution": { - "iopub.execute_input": "2026-02-12T06:44:46.672398Z", - "iopub.status.busy": "2026-02-12T06:44:46.672258Z", - "iopub.status.idle": "2026-02-12T06:44:47.929207Z", - "shell.execute_reply": "2026-02-12T06:44:47.928863Z" + "iopub.execute_input": "2026-02-17T16:01:08.020566Z", + "iopub.status.busy": "2026-02-17T16:01:08.020396Z", + "iopub.status.idle": "2026-02-17T16:01:09.817724Z", + "shell.execute_reply": "2026-02-17T16:01:09.816908Z" }, "papermill": { "duration": 3.495416, @@ -334,7 +371,17 @@ "name": "stdout", "output_type": "stream", "text": [ - "Training complete: 200 steps, final loss=1.7733\n" + "[FDFI][INFO] Training flow model...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Training complete: 200 steps, final loss=1.7161\n", + "[FDFI][DIAG] Flow Model Diagnostics\n", + "[FDFI][DIAG] Latent independence (median dCor): 0.083235 [GOOD] -> lower is better\n", + "[FDFI][DIAG] Distribution fidelity (MMD): 0.000000 [GOOD] -> lower is better\n" ] }, { @@ -345,14 +392,14 @@ "--------------------------------------------------\n", " Feature CPI SCPI Active\n", "--------------------------------------------------\n", - " 0 7.0929 6.8508 Yes\n", - " 1 10.7967 9.8425 Yes\n", - " 2 0.3819 0.3062 Yes\n", - " 3 0.1437 0.0840 No\n", - " 4 0.0559 0.0236 No\n", - " 5 0.0583 0.0111 No\n", - " 6 0.0103 0.0050 No\n", - " 7 0.0334 0.0438 No\n" + " 0 8.0275 7.3967 Yes\n", + " 1 11.1829 9.9715 Yes\n", + " 2 0.4036 0.3063 Yes\n", + " 3 0.0956 0.0727 No\n", + " 4 0.0383 0.0263 No\n", + " 5 0.0099 0.0092 No\n", + " 6 0.0354 0.0327 No\n", + " 7 0.0120 0.0108 No\n" ] } ], @@ -400,14 +447,14 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "id": "4735221c", "metadata": { "execution": { - "iopub.execute_input": "2026-02-12T06:44:47.930772Z", - "iopub.status.busy": "2026-02-12T06:44:47.930652Z", - "iopub.status.idle": "2026-02-12T06:44:49.179623Z", - "shell.execute_reply": "2026-02-12T06:44:49.179303Z" + "iopub.execute_input": "2026-02-17T16:01:09.819661Z", + "iopub.status.busy": "2026-02-17T16:01:09.819515Z", + "iopub.status.idle": "2026-02-17T16:01:11.699991Z", + "shell.execute_reply": "2026-02-17T16:01:11.699264Z" }, "papermill": { "duration": 3.633958, @@ -423,7 +470,17 @@ "name": "stdout", "output_type": "stream", "text": [ - "Training complete: 200 steps, final loss=1.7355\n" + "[FDFI][INFO] Training flow model...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Training complete: 200 steps, final loss=1.7161\n", + "[FDFI][DIAG] Flow Model Diagnostics\n", + "[FDFI][DIAG] Latent independence (median dCor): 0.083235 [GOOD] -> lower is better\n", + "[FDFI][DIAG] Distribution fidelity (MMD): 0.000000 [GOOD] -> lower is better\n" ] }, { @@ -432,8 +489,8 @@ "text": [ "Result keys: ['phi_Z', 'std_Z', 'se_Z', 'phi_X', 'std_X', 'se_X', 'phi_Z_scpi', 'std_Z_scpi', 'se_Z_scpi', 'phi_X_scpi', 'std_X_scpi', 'se_X_scpi']\n", "\n", - "CPI importance (phi_Z): [4.7299 7.6382 0.3533]\n", - "SCPI importance (phi_Z_scpi): [4.4189 6.87 0.2783]\n" + "CPI importance (phi_Z): [5.2 7.8715 0.329 ]\n", + "SCPI importance (phi_Z_scpi): [4.8899 6.9501 0.248 ]\n" ] } ], @@ -469,21 +526,23 @@ "tags": [] }, "source": [ - "## Confidence Intervals\n", + "## Confidence Intervals and Summary\n", "\n", - "FlowExplainer supports the same `conf_int()` method as other explainers:" + "Use the built-in `conf_int()` and `summary()` methods for quick, reproducible inference.\n", + "This avoids custom ad hoc diagnostics code and keeps reporting consistent across explainers.\n", + "\n" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "id": "edd0887e", "metadata": { "execution": { - "iopub.execute_input": "2026-02-12T06:44:49.181233Z", - "iopub.status.busy": "2026-02-12T06:44:49.181124Z", - "iopub.status.idle": "2026-02-12T06:44:49.183748Z", - "shell.execute_reply": "2026-02-12T06:44:49.183505Z" + "iopub.execute_input": "2026-02-17T16:01:11.702265Z", + "iopub.status.busy": "2026-02-17T16:01:11.702076Z", + "iopub.status.idle": "2026-02-17T16:01:11.705753Z", + "shell.execute_reply": "2026-02-17T16:01:11.705104Z" }, "papermill": { "duration": 0.033446, @@ -499,34 +558,50 @@ "name": "stdout", "output_type": "stream", "text": [ + "Flow diagnostics\n", + "------------------------------------------------------------------------\n", + "Latent independence (median dCor): 0.083235 [GOOD]\n", + "Distribution fidelity (MMD): 0.000000 [GOOD]\n", "\n", - "Confidence Intervals (95%, one-sided):\n", - "----------------------------------------------------------------------\n", - " Feature Estimate SE CI Lower Significant\n", - "----------------------------------------------------------------------\n", - " 0 7.0929 0.7590 5.8445 Yes *\n", - " 1 10.7967 1.2248 8.7822 Yes *\n", - " 2 0.3819 0.0527 0.2951 Yes *\n", - " 3 0.1437 0.0173 0.1153 Yes *\n", - " 4 0.0559 0.0156 0.0302 Yes *\n", - " 5 0.0583 0.0119 0.0386 Yes *\n", - " 6 0.0103 0.0101 -0.0062 No\n", - " 7 0.0334 0.0106 0.0160 Yes *\n" + "X-space summary\n", + "==============================================================================\n", + "Feature Importance Results\n", + "==============================================================================\n", + "Method: FlowExplainer\n", + "Number of features: 8\n", + "Significance level: 0.05\n", + "Alternative: greater\n", + "Practical margin: 0.2034\n", + "------------------------------------------------------------------------------\n", + " Feature Estimate Std Err CI Lower CI Upper P-value Sig\n", + "------------------------------------------------------------------------------\n", + " 0 8.0275 0.8855 6.5710 inf 0.0000 ***\n", + " 1 11.1829 1.2737 9.0879 inf 0.0000 ***\n", + " 2 0.4036 0.0580 0.3081 inf 0.0003 ***\n", + " 3 0.0956 0.0244 0.0555 inf 1.0000 \n", + " 4 0.0383 0.0231 0.0003 inf 1.0000 \n", + " 5 0.0099 0.0225 -0.0270 inf 1.0000 \n", + " 6 0.0354 0.0228 -0.0020 inf 1.0000 \n", + " 7 0.0120 0.0225 -0.0250 inf 1.0000 \n", + "==============================================================================\n", + "Significant features: 3 / 8\n", + "---\n", + "Signif. codes: 0 '***' 0.01 '**' 0.05 '*' 0.1 ' ' 1\n", + "==============================================================================\n" ] } ], "source": [ - "# Compute confidence intervals\n", - "ci = explainer_cpi.conf_int(alpha=0.05, target='X', alternative='greater')\n", + "# Shared diagnostics (computed automatically)\n", + "flow_diag = explainer_cpi.diagnostics\n", + "print(\"Flow diagnostics\")\n", + "print(\"-\" * 72)\n", + "print(f\"Latent independence (median dCor): {flow_diag['latent_independence_median']:.6f} [{flow_diag['latent_independence_label']}]\")\n", + "print(f\"Distribution fidelity (MMD): {flow_diag['distribution_fidelity_mmd']:.6f} [{flow_diag['distribution_fidelity_label']}]\")\n", "\n", - "print(\"\\nConfidence Intervals (95%, one-sided):\")\n", - "print(\"-\" * 70)\n", - "print(f\"{'Feature':>8} {'Estimate':>10} {'SE':>10} {'CI Lower':>10} {'Significant':>12}\")\n", - "print(\"-\" * 70)\n", - "for i in range(n_features):\n", - " sig = \"Yes *\" if ci['reject_null'][i] else \"No\"\n", - " print(f\"{i:>8} {ci['phi_hat'][i]:>10.4f} {ci['se'][i]:>10.4f} \"\n", - " f\"{ci['ci_lower'][i]:>10.4f} {sig:>12}\")" + "# Standardized inference summary (v0.0.2 defaults use mixture methods)\n", + "print(\"\\nX-space summary\")\n", + "_ = explainer_cpi.summary(alpha=0.05, target='X', alternative='greater')\n" ] }, { @@ -555,14 +630,14 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "id": "1b281856", "metadata": { "execution": { - "iopub.execute_input": "2026-02-12T06:44:49.185186Z", - "iopub.status.busy": "2026-02-12T06:44:49.185061Z", - "iopub.status.idle": "2026-02-12T06:44:53.039633Z", - "shell.execute_reply": "2026-02-12T06:44:53.039305Z" + "iopub.execute_input": "2026-02-17T16:01:11.707276Z", + "iopub.status.busy": "2026-02-17T16:01:11.707157Z", + "iopub.status.idle": "2026-02-17T16:01:17.164457Z", + "shell.execute_reply": "2026-02-17T16:01:17.163760Z" }, "papermill": { "duration": 10.791123, @@ -578,21 +653,51 @@ "name": "stdout", "output_type": "stream", "text": [ - "Training complete: 200 steps, final loss=1.6822\n" + "[FDFI][INFO] Training flow model...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Training complete: 200 steps, final loss=1.7161\n", + "[FDFI][DIAG] Flow Model Diagnostics\n", + "[FDFI][DIAG] Latent independence (median dCor): 0.083235 [GOOD] -> lower is better\n", + "[FDFI][DIAG] Distribution fidelity (MMD): 0.000000 [GOOD] -> lower is better\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[FDFI][INFO] Training flow model...\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Training complete: 200 steps, final loss=1.6810\n" + "Training complete: 200 steps, final loss=1.7161\n", + "[FDFI][DIAG] Flow Model Diagnostics\n", + "[FDFI][DIAG] Latent independence (median dCor): 0.083235 [GOOD] -> lower is better\n", + "[FDFI][DIAG] Distribution fidelity (MMD): 0.000000 [GOOD] -> lower is better\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Training complete: 200 steps, final loss=1.7802\n" + "[FDFI][INFO] Training flow model...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Training complete: 200 steps, final loss=1.7161\n", + "[FDFI][DIAG] Flow Model Diagnostics\n", + "[FDFI][DIAG] Latent independence (median dCor): 0.083235 [GOOD] -> lower is better\n", + "[FDFI][DIAG] Distribution fidelity (MMD): 0.000000 [GOOD] -> lower is better\n" ] }, { @@ -603,14 +708,14 @@ "-------------------------------------------------------\n", " Feature resample permutation normal\n", "-------------------------------------------------------\n", - " 0 7.5032 7.1106 6.2776\n", - " 1 10.8725 10.2875 9.8244\n", - " 2 0.4309 0.6010 0.3521\n", - " 3 0.1071 0.1664 0.1567\n", - " 4 0.0119 0.0145 0.0160\n", - " 5 0.0260 0.0174 0.0110\n", - " 6 0.0142 0.0224 0.0157\n", - " 7 0.0371 0.0259 0.0307\n" + " 0 8.0275 7.6684 7.6812\n", + " 1 11.1829 10.7789 10.9221\n", + " 2 0.4036 0.3880 0.4060\n", + " 3 0.0956 0.0909 0.0978\n", + " 4 0.0383 0.0364 0.0365\n", + " 5 0.0099 0.0087 0.0093\n", + " 6 0.0354 0.0334 0.0337\n", + " 7 0.0120 0.0112 0.0118\n" ] } ], @@ -664,14 +769,14 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "id": "55db939e", "metadata": { "execution": { - "iopub.execute_input": "2026-02-12T06:44:53.041261Z", - "iopub.status.busy": "2026-02-12T06:44:53.041141Z", - "iopub.status.idle": "2026-02-12T06:44:55.097180Z", - "shell.execute_reply": "2026-02-12T06:44:55.096881Z" + "iopub.execute_input": "2026-02-17T16:01:17.166820Z", + "iopub.status.busy": "2026-02-17T16:01:17.166670Z", + "iopub.status.idle": "2026-02-17T16:01:20.114388Z", + "shell.execute_reply": "2026-02-17T16:01:20.113774Z" }, "papermill": { "duration": 7.247732, @@ -687,7 +792,10 @@ "name": "stdout", "output_type": "stream", "text": [ - "Training complete: 300 steps, final loss=1.5154\n" + "Training complete: 300 steps, final loss=1.5140\n", + "[FDFI][DIAG] Flow Model Diagnostics\n", + "[FDFI][DIAG] Latent independence (median dCor): 0.083218 [GOOD] -> lower is better\n", + "[FDFI][DIAG] Distribution fidelity (MMD): 0.000000 [GOOD] -> lower is better\n" ] }, { @@ -695,7 +803,7 @@ "output_type": "stream", "text": [ "\n", - "Importance with custom flow: [4.0551 6.3796 0.3789 0.1194]\n" + "Importance with custom flow: [3.936 6.1696 0.4598 0.0759]\n" ] } ], @@ -746,14 +854,14 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 10, "id": "e3ca716d", "metadata": { "execution": { - "iopub.execute_input": "2026-02-12T06:44:55.098701Z", - "iopub.status.busy": "2026-02-12T06:44:55.098618Z", - "iopub.status.idle": "2026-02-12T06:44:55.103162Z", - "shell.execute_reply": "2026-02-12T06:44:55.102768Z" + "iopub.execute_input": "2026-02-17T16:01:20.116360Z", + "iopub.status.busy": "2026-02-17T16:01:20.116216Z", + "iopub.status.idle": "2026-02-17T16:01:20.132518Z", + "shell.execute_reply": "2026-02-17T16:01:20.131852Z" }, "papermill": { "duration": 0.056569, @@ -773,20 +881,20 @@ "-------------------------------------------------------\n", " Feature Flow (CPI) Flow (SCPI) OT\n", "-------------------------------------------------------\n", - " 0 7.0929 6.8508 3.0570\n", - " 1 10.7967 9.8425 5.3006\n", - " 2 0.3819 0.3062 0.3043\n", - " 3 0.1437 0.0840 0.0372\n", - " 4 0.0559 0.0236 0.0015\n", - " 5 0.0583 0.0111 0.0036\n", - " 6 0.0103 0.0050 0.0007\n", - " 7 0.0334 0.0438 0.0049\n", + " 0 8.0275 7.3967 3.0570\n", + " 1 11.1829 9.9715 5.3006\n", + " 2 0.4036 0.3063 0.3043\n", + " 3 0.0956 0.0727 0.0372\n", + " 4 0.0383 0.0263 0.0015\n", + " 5 0.0099 0.0092 0.0036\n", + " 6 0.0354 0.0327 0.0007\n", + " 7 0.0120 0.0108 0.0049\n", "\n", "=======================================================\n", "Summary: Active vs Null Feature Importance\n", "=======================================================\n", - " Flow CPI: active=6.0905, null=0.0603, ratio=100.97x\n", - " Flow SCPI: active=5.6665, null=0.0335, ratio=169.11x\n", + " Flow CPI: active=6.5380, null=0.0382, ratio=170.99x\n", + " Flow SCPI: active=5.8915, null=0.0303, ratio=194.30x\n", " OT: active=2.8873, null=0.0096, ratio=301.79x\n" ] } @@ -874,25 +982,26 @@ "\n", "In this tutorial, you learned:\n", "\n", - "1. **FlowExplainer** uses normalizing flows for flexible, data-driven feature importance\n", - "2. **CPI** averages predictions first, **SCPI** averages squared differences (Sobol-style)\n", - "3. Use `method='both'` to compute CPI and SCPI simultaneously\n", - "4. Different **sampling methods** offer different tradeoffs\n", - "5. You can use **custom flow models** for more control\n", - "6. FlowExplainer is best for **non-Gaussian data** with complex dependencies\n", + "1. **FlowExplainer** uses normalizing flows for flexible, data-driven feature importance.\n", + "2. **CPI** averages predictions first, **SCPI** averages squared differences (Sobol-style).\n", + "3. Use `method='both'` to compute CPI and SCPI simultaneously.\n", + "4. Different **sampling methods** offer different tradeoffs.\n", + "5. You can use **custom flow models** for more control.\n", + "6. Shared diagnostics and `conf_int`/`summary` provide a consistent inference workflow.\n", + "7. Strict one-sided testing (`alternative='greater'`) is useful for feature screening.\n", "\n", "## Next Steps\n", "\n", - "- Try FlowExplainer on your own data\n", - "- Experiment with different `num_steps` values for flow training\n", - "- Compare results across different sampling methods\n", - "- Read the API documentation for advanced options" + "- Try FlowExplainer on your own data.\n", + "- Compare X-space and Z-space significance.\n", + "- Cross-check with OT/EOT for consistency.\n", + "\n" ] } ], "metadata": { "kernelspec": { - "display_name": "dfi", + "display_name": "fdfi", "language": "python", "name": "python3" }, @@ -906,7 +1015,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.12" + "version": "3.10.19" }, "papermill": { "default_parameters": {}, diff --git a/docs/tutorials/index.rst b/docs/tutorials/index.rst index cd9d0f0..95d6281 100644 --- a/docs/tutorials/index.rst +++ b/docs/tutorials/index.rst @@ -28,15 +28,16 @@ Tutorial Overview :doc:`ot_explainer` Deep dive into the Gaussian OT explainer. Learn about the mathematical - foundation, hyperparameters, and when to use it. + foundation, hyperparameters, shared diagnostics, and when to use it. :doc:`eot_explainer` - Master entropic optimal transport for non-Gaussian data. Covers adaptive - epsilon, stochastic transport, and mixed data types. + Mixed-type-first EOT tutorial. Starts with active-feature screening using + Gower cost, then covers epsilon, stochastic transport, target choice, and + shared diagnostics. :doc:`flow_explainer` Master Flow-DFI with normalizing flows. Learn about CPI vs SCPI methods, - custom flow models, and when to choose FlowExplainer over OT methods. + custom flow models, shared diagnostics, and when to choose FlowExplainer. :doc:`confidence_intervals` Statistical inference with FDFI. Learn to compute confidence intervals, diff --git a/docs/tutorials/ot_explainer.ipynb b/docs/tutorials/ot_explainer.ipynb index 60cc3c3..9d23a69 100644 --- a/docs/tutorials/ot_explainer.ipynb +++ b/docs/tutorials/ot_explainer.ipynb @@ -1,5 +1,31 @@ { "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "f2756f07", + "metadata": { + "execution": { + "iopub.execute_input": "2026-02-17T16:04:25.925744Z", + "iopub.status.busy": "2026-02-17T16:04:25.925540Z", + "iopub.status.idle": "2026-02-17T16:04:25.935665Z", + "shell.execute_reply": "2026-02-17T16:04:25.934948Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "FDFI version: 0.0.2\n" + ] + } + ], + "source": [ + "import fdfi\n", + "print('FDFI version:', fdfi.__version__)" + ] + }, { "cell_type": "markdown", "id": "64771235", @@ -28,14 +54,14 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "id": "1b6990e4", "metadata": { "execution": { - "iopub.execute_input": "2026-02-12T06:44:39.230204Z", - "iopub.status.busy": "2026-02-12T06:44:39.229857Z", - "iopub.status.idle": "2026-02-12T06:44:39.816563Z", - "shell.execute_reply": "2026-02-12T06:44:39.816224Z" + "iopub.execute_input": "2026-02-17T16:04:25.937703Z", + "iopub.status.busy": "2026-02-17T16:04:25.937531Z", + "iopub.status.idle": "2026-02-17T16:04:26.635835Z", + "shell.execute_reply": "2026-02-17T16:04:26.635204Z" }, "papermill": { "duration": 0.785167, @@ -106,14 +132,14 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "id": "04031dcd", "metadata": { "execution": { - "iopub.execute_input": "2026-02-12T06:44:39.818846Z", - "iopub.status.busy": "2026-02-12T06:44:39.818696Z", - "iopub.status.idle": "2026-02-12T06:44:39.821864Z", - "shell.execute_reply": "2026-02-12T06:44:39.821560Z" + "iopub.execute_input": "2026-02-17T16:04:26.637906Z", + "iopub.status.busy": "2026-02-17T16:04:26.637729Z", + "iopub.status.idle": "2026-02-17T16:04:26.641280Z", + "shell.execute_reply": "2026-02-17T16:04:26.640822Z" }, "papermill": { "duration": 0.007164, @@ -161,14 +187,14 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "id": "d88e79e9", "metadata": { "execution": { - "iopub.execute_input": "2026-02-12T06:44:39.823369Z", - "iopub.status.busy": "2026-02-12T06:44:39.823288Z", - "iopub.status.idle": "2026-02-12T06:44:39.825279Z", - "shell.execute_reply": "2026-02-12T06:44:39.825020Z" + "iopub.execute_input": "2026-02-17T16:04:26.642661Z", + "iopub.status.busy": "2026-02-17T16:04:26.642555Z", + "iopub.status.idle": "2026-02-17T16:04:26.645110Z", + "shell.execute_reply": "2026-02-17T16:04:26.644601Z" }, "papermill": { "duration": 0.005076, @@ -214,14 +240,14 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "id": "cb0dc14d", "metadata": { "execution": { - "iopub.execute_input": "2026-02-12T06:44:39.826715Z", - "iopub.status.busy": "2026-02-12T06:44:39.826644Z", - "iopub.status.idle": "2026-02-12T06:44:40.322304Z", - "shell.execute_reply": "2026-02-12T06:44:40.321988Z" + "iopub.execute_input": "2026-02-17T16:04:26.646855Z", + "iopub.status.busy": "2026-02-17T16:04:26.646744Z", + "iopub.status.idle": "2026-02-17T16:04:26.857687Z", + "shell.execute_reply": "2026-02-17T16:04:26.857196Z" }, "papermill": { "duration": 0.180749, @@ -235,7 +261,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABKUAAAGGCAYAAACqvTJ0AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAPZlJREFUeJzt/QmYVOWZMO4/zY4oIMhmxC244IqCiai4xBkMGJfEJM6MXzQuTBi3KCHGLUE00Yxh/Igbxhjlr46OmcH1E1EzgrtJEBxc0OiEACEgEpVN2et3vcd/V2joRmirT3dX3fd1Ha2z1Klzqqrr4Tzned+3qlAoFAIAAAAActQizxcDAAAAgERSCgAAAIDcSUoBAAAAkDtJKQAAAAByJykFAAAAQO4kpQAAAADInaQUAAAAALmTlAIAAAAgd5JSAAAAAOROUgqagKqqqrjiiiuiKVm6dGlcdNFFMXjw4OjWrdunHuO0adPi7/7u72LrrbeOzp07x9e+9rX44x//mOsxA5SzphgrpkyZkh1XbdNLL7200fZiBUD5xoSnnnoqzjjjjNhzzz2jQ4cO8bnPfS5OOOGEePnll2vdfktiwg033JDtt23btrHLLrvE6NGjY/Xq1Q18RuRBUgqo1V//+te49dZbY+XKlXHiiSdu8l16880348gjj4xVq1bFr3/967j99tvjD3/4QwwaNCjee+897zBAmbv66qvjxRdfrDHts88+NbYRKwDK27hx4+JPf/pTfPe7342JEyfGz3/+81i4cGEcfPDBWcKqvjHhJz/5SbbPlLR6/PHH4+yzz87izjnnnJPzGdIQWjXIXoFmb6eddooPPvgguwuzaNGiuO222+rc9kc/+lF21+L//b//Fx07dsyW9e/fP3bbbbcYM2ZM/Ou//muORw5A3tLvfbro2BSxAqC83XTTTdG9e/cay7785S9Hnz59siTSl770pS2OCelG+Y9//OMYNmxYto8kJbNSldTll18eF1xwQey11165nielpVKKZiGVpqbkyOuvvx7/+I//GJ06dYoePXpk5aGLFy8ubvef//mf8cUvfjFbv9VWW8Wuu+6abVNtxYoV8b3vfS/69euXbdOlS5cYOHBgPPTQQxu9Znq9c889N+64447YY489on379jFgwICsOUKhUIif/exnWeloKjdNP7DvvPNOjeenH8t0l/jZZ5/N/qGenp9KWH/4wx/G2rVrP/WcFyxYEN/5zndihx12iDZt2hTLVNesWbPRHYn9998/O45tttkmK2u99NJL6/lO1zz/NH2adDwpmJx00knFgFKd1DrqqKPigQce+MzHArA5xIr8Y8XmEiuAvIkJ+ceEDRNSSXqNlDSaO3duvWLCpEmTsmu4008/vcZ+03y6JnvwwQc/83HTuFRK0aykH66TTz45zjzzzHj11VfjkksuyZancs/UVCCtS1MKQu3atYvZs2fXKBVNTdHef//9GDlyZJYgSuWiv/nNb7JS0JR8OvXUU2u8XvqxnD59evz0pz/NEjQ/+MEP4thjj43TTjsta+984403ZkmxESNGZMf2yiuv1EjkpMTSP/zDP8TFF18cV155ZTz66KNZpj9VIKXn1iU97wtf+EK0aNEiu4vw+c9/Pju/9NxUEpuONfmP//iPrHz1vPPOy+4opO1TcuyNN96osb8NA1FdWrZsuVmJqPX97//+b3z88cex3377bbQuLXvyySezQJI+D4A8iBX5x4rUhCLFu3RDKN3sSTdgDjvssOJ6sQJoLGJC414/pGul1HfU+lVSWxITXnvttWz5vvvuW2O7Xr16xXbbbVdcTzNWgGZg1KhRhfR1vfbaa2ssP/vsswvt2rUrrFu3rjBmzJhsmw8//HCz97tmzZrC6tWrC2eeeWbhgAMOqLEu7atnz56FZcuWFZc9+OCD2fJ+/fplr1lt7Nix2fIZM2YUlx1xxBHZsoceeqjGfocNG1Zo0aJFYfbs2TVeK51jte985zuFrbfeusY2SfU5vv7669n8ueeeW+jcufMmz3HWrFnZczZnmjx5cq37eO+99zY6xmrPP/98tu7ee+/daN3VV1+drfvLX/6yyWMEKAWxIv9YMW3atMJ3v/vdwgMPPFB45plnCrfffnuhb9++hZYtWxYmTZpU3E6sAPImJjTu9UO1U045pdCqVavC1KlT6xUT0rVT27Zta9337rvvXhg8ePCnfhdo2jTfo1k5/vjjN8qkpyx66kDvoIMOypZ985vfzDrLmzdvXq37SE38Dj300KyUtFWrVtG6dev41a9+FTNnztxo21Q+mkaOqNa3b9/s/0OGDKlxR6B6earMWl8qh93wmP/pn/4p1q1bF88880yd55kqtNJrb7/99tldiuopvW7y9NNPZ/9P1VQffvhh1qQxNUFMfT9tKO3j97///WZNqR13fW3qDsmWVl8BfBZiRX6x4oADDoixY8dmA2KkzmlTc4oXXnghu4OdRnDdkFgB5E1MaLzrh1Q1++///u/xf//v/611u82NCWJHedN8j2ala9euNeZT53hJKv88/PDDszbF119/fdYMLzXV23vvveOyyy7LfnST+++/P0tafeMb34jvf//70bNnzywxldpVpyaAG0p9Tq0v9e20qeUpQba+1O/VhtJrVnfaV5d33303HnnkkSxhVpvq4PGtb30rS1b98pe/zEqTU7IrJedSM7+///u/Lx5b6kNrc8tv6/uZ1HY+qalkCiJpiFeAvIgVjRsr0m/+V77ylbjllluy+Jz6VBQrgMYiJjROTEh9WaV9ppHzUj+99b1+SNuma6yPPvooayK+4baf5aY6TYOkFGXlhBNOyKaUkEodkl9zzTVZZdLOO++c9XFx9913Zx3+3XfffTUy7mn7hpCSS7X1F1VbgFxfah+dqsDSj3ht0t2LaumudJqWL1+eVV+NGjUquxhIQ6qmzgJTG/J0zptj8uTJWQftWyL1d5UuOFIfXxtKy9JoG/qTApoSsaLhY8UnLdP/dndbrACaKjGh9DEhJaRSH79pqq0D9S2JCdV9SaXlaUCr9a+pUqItDSxF8yYpRVlKFVRHHHFElmF//PHHs87KU1Iq/eM4Zf437Iy8ttH3SmHp0qXx8MMP1ygbvueee7IOBVNlV11SUJg4cWL2g73ttttu1mulZoapeV/qvD01o0gjFaagUl1+uznSKINbKlWaHXfccVkV2rXXXps1WUzmzJmTBakLL7xwi/cJkAexomFiRRrMIzVDT3fZqy8qxAqgqRMTShMTrrrqqiwZdfnll2fJrtpsSUz48pe/nMWS8ePH10hKpfl0TZeue2jeJKUoG2mUuj//+c9x9NFHxw477JC1lf75z3+eNYFLCarqZE/68UsjTnz961/PhiZNP5yp74u333675MeUqqH+5V/+JfuB3X333bNEUyqVTct23HHHOp+XRupLo04ccsghcf7552c/9qlsNd21SPtITSLSOQ4bNiy7y5D6yErnkBJsqTqsU6dOxT62UhJuwIAB9Tr+xx57LKvASsm1JI3K8V//9V/Z46FDhxZLaNPdkPR66f1NIw2mY02fR6r4+t73vlev1wZoCGJFaWNFqkZO8Sw9N/3mp1j6b//2b1mlcLpgWJ9YATQ1YkJpY0L6/U/vaUokpRHLU8uV9R188MFbHBNStykpwZX6p0qPBw8enCXMUuLrrLPOir322uszfQdofJJSlI2UOZ86dWr84Ac/iPfeey+rkko/pk899VTWt1SSmrmlTtFTUif1IbXrrrtmP4IpmZV+GEst9R910003xciRI7OS0/RDmkpYP+21UoIpnUtKmP3sZz/Lji/dQUhltOlHvrp6KnUqm/7Rnzp2T3em0494GoL7zjvvjG7dun3m40/Js/U7b0+dxKcpmTVrVtYsMtlzzz1jypQp2Xufkn3p7kca9jUNM1uK4wAoFbGitLEiNTVPTeJTXF22bFkW59K+77rrruLFTTWxAmhqxITSxoTUJ24yadKkbKqrafeWxoTUR3C6FkrXVWl9usZK13BpOc1fVRqCr7EPAspRalud2jm/9tprjX0oADRRYgUAYgKVrEVjHwAAAAAAlUdSCgAAAIDcab4HAAAAQO5USgEAAACQO0kpAAAAAHInKQUAADRr11xzTRx00EHZsPHdu3ePE088Md56661NPicNR19VVbXR9Oabb+Z23ACVrlVUmHXr1sVf/vKXLGCloAPA3xQKhVi6dGlsv/320aJF5d63ECsAmlesePrpp+Occ87JElNr1qyJyy67LAYPHhxvvPFGdOjQYZPPTcmrjh07Fue7deu2Wa8pVgB89lhRcR2d//nPf47evXs39mEANGlz586NHXbYISqVWAHQvGPFe++9l1VMpWTV4YcfXmel1FFHHRUffPBBdO7ceYtfQ6wA+OyxouIqpVKFVPUbs/4dEQAilixZkiXuq38rK5VYAdC8Y8XixYuz/3fp0uVTtz3ggANixYoVsddee8Xll1+eJapqs3LlymyqVn1v33UFQP1jRcUlpaqb7KWElKQUwKZ/KyuVWAGw+b+VTU1KFo0YMSIOO+yw2GeffercrlevXnHrrbdG//79s2TTXXfdFUcffXRWQVVbdVXqt2r06NEbLXddAVD/WFFxzfdStq5Tp07Z3RNJKQC/kWIFQHn9ezr1LfXoo4/Gc889t8XNC4877rjsAurhhx/+1Eqp6iqApvo+ADSHWNE0eiYEAAD4jM4777wsoTR58uR69Xd18MEHx9tvv13rurZt2xarolRHAZRGxTXfAwAAyktq/JESUg888EDW/G6XXXap136mT5+eNesDIB+SUgAAQLOWmuzdc8898dBDD2Wd6i5YsCBbnpqOtG/fPnt8ySWXxLx58+LOO+/M5seOHRs777xz7L333rFq1aq4++67Y8KECdkEQD4kpQAAgGZt3Lhx2f+PPPLIGsvvuOOO+Pa3v509nj9/fsyZM6e4LiWiRo4cmSWqUuIqJadSX1RDhw7N+egBKpekFAAA0KxtzthN48ePrzF/0UUXZRMAjUdH5wAAAADkTlIKAAAAgNxJSgEAAACQO0kpAAAAAHInKQUAAABA7oy+1wSk4WnTVJdevXplEwCVS6wAQKwAyo2kVBPwi1/8IkaPHl3n+lGjRsUVV1yR6zEB0LSIFQCIFUC5kZRqAr7zne/E8ccfHx9//HEcdthh2bLnnnsu2rdvnz1WJQWAWAGA6wqg3EhKNQHVzfOWL19eXNavX7/o0KFDox4XAE2HWAGAWAGUGx2dAwAAAJA7SSkAAAAAcicpBQAAAEDuJKUAAAAAyJ2kFAAAAAC5k5QCAAAAIHeSUgAAAADkTlIKAAAAgNxJSgEAAACQO0kpAAAAAHInKQUAAABA7iSlAAAAAMidpBQAAAAAuZOUAgAAACB3klIAAAAA5E5SCgAAAIDcSUoBAAAAkDtJKQAAAAByJykFAAAAQO4kpQAAAADInaQUAAAAALmTlAIAAAAgd5JSAAAAAOROUgoAAACA3ElKAQAAAJA7SSkAAAAAcicpBQAAAEDuJKUAAAAAyJ2kFAAAAAC5k5QCAAAAIHeSUgAAAADkTlIKAAAAgMpKSl1zzTVx0EEHxTbbbBPdu3ePE088Md56661Pfd7TTz8d/fv3j3bt2sWuu+4at9xySy7HCwAAAEAZJKVScumcc86Jl156KZ588slYs2ZNDB48OJYvX17nc2bNmhVDhw6NQYMGxfTp0+PSSy+N888/PyZMmJDrsQMAAABQf62iEU2aNKnG/B133JFVTL388stx+OGH1/qcVBW14447xtixY7P5vn37xtSpU2PMmDFx0kkn5XLcAAAAAJRRn1KLFy/O/t+lS5c6t3nxxRezaqr1HXPMMVliavXq1Q1+jAAAAAA080qp9RUKhRgxYkQcdthhsc8++9S53YIFC6JHjx41lqX51PRv0aJF0atXrxrrVq5cmU3VlixZ0gBHDwAAAECzrJQ699xzY8aMGXHvvfd+6rZVVVUbJbRqW17dmXqnTp2KU+/evUt41AAAAAA026TUeeedFw8//HBMnjw5dthhh01u27Nnz6xaan0LFy6MVq1aRdeuXTfa/pJLLsmaBVZPc+fOLfnxAwAAANCMklKpwilVSN1///3x1FNPxS677PKpzxk4cGA2Ut/6nnjiiRgwYEC0bt16o+3btm0bHTt2rDEB0HykiteDDjoottlmm2wwjBNPPDHeeuutzRrhtX///tGuXbvYdddds4EyAACApqNRk1LnnHNO3H333XHPPfdkFxupAipNH3/8cY1Kp1NPPbU4P3z48Jg9e3bW/9TMmTPj9ttvj1/96lcxcuTIRjoLABpSSi6lePHSSy9lNyVSH4JpwIvly5fX+ZxZs2bF0KFDY9CgQTF9+vS49NJL4/zzz48JEyb4sAAAoIlo1KTUuHHjsiZ1Rx55ZNZBefV03333FbeZP39+zJkzpzifqqkmTpwYU6ZMiX79+sVVV10V119/fZx00kmNdBYANKRJkybFt7/97dh7771j//33jzvuuCOLCy+//HKdz0lVUTvuuGOMHTs2+vbtG2eddVacccYZMWbMGB8WQBlSVQvQPDXq6HvVHZRvyvjx4zdadsQRR8S0adMa6KgAaMrSzYykS5cudW7z4osvZtVU6zvmmGOyytrVq1dv1NzbSK0A5VFVm5p7p4rayy67LIsDb7zxRnTo0GGTVbXDhg3LWm88//zzcfbZZ0e3bt3c8AaohKQUAGzpzYzUfPuwww6LffbZp87tUlPwHj161FiW5tOFyqJFi7Kq3A3vsI8ePdqHAdCMq2rXl6pqUz+Eqar28MMP/9Sq2iRV1k6dOjWrqtUKA6CCRt8DgM2RBseYMWNG3HvvvZ+6bVVVVa3VuRsuT4zUClBePktVbUpMparaDaWq2iVLltSYAPhsJKUAaBbOO++8ePjhh2Py5Mmxww47bHLbnj17ZtVS61u4cGG0atUqunbtutH2RmoFKB+lqqrdUKqq7dSpU3Hq3bt3gxw/QCWRlAKgyV9cpAqp+++/P5566qlswItPM3DgwGykvvU98cQTMWDAgI36kwKgvKiqBWg+JKUAaNJSx7WpA9p77rknttlmm+zOdpo+/vjjGs3vTj311OL88OHDY/bs2dmd8pkzZ8btt9+edXI+cuTIRjoLAPKgqhageZGUAqBJGzduXNY3yJFHHpl1UF493XfffcVt5s+fH3PmzCnOp2qqiRMnxpQpU6Jfv35x1VVXxfXXX6/jWoAypaoWoHky+h4ATVp1B+WbMn78+I2WHXHEETFt2rQGOioAmlpVbaqofeihh4pVtUnq+6l9+/bFqtp58+bFnXfeWayqvfHGG7Oq2mHDhmUdn6eq2s0ZTAOA0lApBQAANGuqagGaJ5VSAABAs6aqFqB5UikFAAAAQO4kpQAAAADInaQUAAAAALmTlAIAAAAgd5JSAAAAAOROUgoAAACA3ElKAQAAAJA7SSkAAAAAcicpBQAAAEDuJKUAAAAAyJ2kFAAAAAC5k5QCAAAAIHeSUgAAAADkTlIKAAAAgNxJSgEAAACQO0kpAAAAAHInKQUAAABA7iSlAAAAAMidpBQAAAAAuZOUAgAAACB3klIAAAAA5E5SCgAAAIDcSUoBAAAAkDtJKQAAAAByJykFAAAAQO4kpQAAAADInaQUAAAAALmTlAIAAAAgd5JSAAAAAOROUgoAAACA3ElKAQAAAJA7SSkAAAAAcicpBQAAAEDuJKUAAAAAyJ2kFAAAAAC5k5QCAAAAIHeSUgAAAADkTlIKAAAAgNxJSgEAAACQO0kpAAAAAHInKQUAAABA7iSlAAAAAMidpBQAAAAAlZWUeuaZZ+K4446L7bffPqqqquLBBx/c5PZTpkzJtttwevPNN3M7ZgAAAAA+u1bRiJYvXx77779/nH766XHSSSdt9vPeeuut6NixY3G+W7duDXSEAAAAAJRdUmrIkCHZtKW6d+8enTt3bpBjAgAAAKDhNcs+pQ444IDo1atXHH300TF58uTGPhwAAAAA8kpK3XXXXXHooYdm/UHNnj07WzZ27Nh46KGHoqGkRNStt94aEyZMiPvvvz/22GOPLDGV+qaqy8qVK2PJkiU1JgDy0RixAoDmRawAqFz1SkqNGzcuRowYEUOHDo0PP/ww1q5dmy1PTerSxUZDSUmoYcOGxYEHHhgDBw6Mm2++OY499tgYM2ZMnc+55pprolOnTsWpd+/eDXZ8AJQ+VhgUA6B8NdZ1BQDNOCl1ww03xC9/+cu47LLLomXLlsXlAwYMiFdffTXydPDBB8fbb79d5/pLLrkkFi9eXJzmzp2b6/EBVKpSxYrqQTFuvPHGLXr9NCjG/Pnzi9Nuu+22Rc8HoPnECjcwACqoo/NZs2Zl/TptqG3bttnFQ56mT5+eNeurSzqmNAGQr1LFCoNiAJSvUsUKo3oDVFBSapdddolXXnkldtpppxrLH3vssdhrr702ez/Lli2Ld955p0ZQSvvt0qVL7LjjjlmV07x58+LOO+/M1qcS3p133jn23nvvWLVqVdx9991Z/1JpAqBpKVWsqK90kbNixYrstS6//PI46qijGvw1AWicWOEGBkAFJaW+//3vxznnnJP9Y79QKMTvfve7uPfee7P+m2677bbN3s/UqVNrXCSk9uTJaaedFuPHj8+aW8yZM6e4PiWiRo4cmSWq2rdvnyWnHn300awNOgBNS6liRX0Hxejfv3822EXqQDcNijFlypQ4/PDDa31O2i5N1QyKAVDesaKaGxgAzTApdfrpp8eaNWvioosuio8++ij+6Z/+KT73uc/Fz3/+8/iHf/iHzd7PkUcemQWfuqTE1PrS66UJgKavVLGiPoNipKlaGhgj9SeYBsWoKymVLn5Gjx7dYMcEQNOKFW5gADQNVYVNZYU2w6JFi2LdunXRvXv3aA7S3e80Cl/q9Lxjx47RlKS28FtvvXWxaWOHDh0a+5CACtNQv5GlihVVVVXxwAMPxIknnrhFz/vJT36SNfmeOXPmZldKpdFaxQqAyokVxx13XPbchx9+uNb1V1xxRa03MMQKgPrHinqNvpf6fqoe8W677bYrBo607E9/+lN9dglAmWlKsWJzBsVIwXL9CYDKihVG9QbIX72SUt/+9rfjhRde2Gj5b3/722wdAJQqVqTK0dQJbprWHxSjus/BNCjGqaeeWtw+DYrx4IMPZhc0r7/+erY+DYhx7rnn+lAAmpimdF3hBgZAM+lTKv1gH3roobXeXfCPfgBKGSsMigFQvkoVK4zqDVBBSanU1nrp0qUbLU9tBdeuXVuK4wKgmStVrDAoBkD5KlWscAMDoII6Ov/KV74SW221VTZca8uWLbNlKWicfPLJWWfdjz32WDRVOjoHyOc3UqxoGAbFABqbWFH696HUxAqgufxG1qtS6tprr82G1U5Dbg8aNChb9uyzz2Yv+tRTT9X/qAEoG2IFAGIFACXv6HyvvfaKGTNmxDe/+c1YuHBhVnKbOpl98803Y5999qnPLgEoM2IFAGIFAJtSr0qpZPvtt4+rr766vk8HoAKIFQCIFQCUPCn14Ycfxu9+97usUmrdunU11q0/NHe52fniRxts3+tWrSg+7vvDSdGiTbsGe60//fTYBts3QKXHCgA2n1gBULnqlZR65JFH4pRTTsk60Ntmm22yUTOqpccuNAAQKwBwXQFAyfuU+t73vhdnnHFG1pdUurPxwQcfFKf333+/PrsEoMyIFQCIFQCUPCk1b968OP/882Orrbaqz9MBqABiBQBiBQAlb753zDHHxNSpU2PXXXetz9MBqACVHCv0PwiweSo5VgBQz6TUscceG9///vfjjTfeiH333Tdat25dY/3xxx/vvQWocGIFAGJF3dzAAKhnUmrYsGHZ/6+88sqN1qWOzteuXeu9BahwYgUAYgUAJU9KbTisNwCIFQC4rgCgwTs6BwAAAIDcK6WS5cuXx9NPPx1z5syJVatW1ViXRuYDALECANcVAJQ0KTV9+vQYOnRofPTRR9kFR5cuXWLRokWx1VZbRffu3SWlABArAHBdAUDpm+9deOGFcdxxx8X7778f7du3j5deeilmz54d/fv3jzFjxtRnlwCUGbECALECgJInpV555ZX43ve+Fy1btsymlStXRu/evePaa6+NSy+9tD67BKDMiBUAiBUAlDwp1bp166iqqsoe9+jRI+tXKunUqVPxMQCVTawAQKwAoOR9Sh1wwAExderU2H333eOoo46KH/3oR1mfUnfddVfsu+++9dklAGVGrABArACg5JVSV199dfTq1St7fNVVV0XXrl3jX/7lX2LhwoXxi1/8oj67BKDMiBUAiBUAlLxSasCAAcXH3bp1i4kTJ9ZnNwCUMbECALECgJJXSn3pS1+KDz/8cKPlS5YsydYBgFgBgOsKAEqelJoyZUqsWrVqo+UrVqyIZ599tj67BKDMiBUAiBUAlKz53owZM4qP33jjjViwYEFxfu3atTFp0qT43Oc+tyW7BKDMiBUAiBUAlDwp1a9fv6iqqsqm2prptW/fPm644YYt2SUAZUasAECsAKDkSalZs2ZFoVCIXXfdNX73u99lnZxXa9OmTXTv3j1atmy5JbsEoMyIFQCIFQCUPCm10047xerVq+PUU0+NLl26ZPMAIFYA4LoCgAbv6Lx169bx0EMPbfELAVA5xAoAxAoAGmT0vRNPPDEefPDB+jwVgAohVgAgVgBQsuZ71fr06RNXXXVVvPDCC9G/f//o0KFDjfXnn39+fXYLQBkRKwAQKwAoeVLqtttui86dO8fLL7+cTetLI/NJSgEgVgDgugKAkiel0shKACBWAPBZuK4AqGz16lNqfYVCIZsAQKwAwHUFAA2elLrzzjtj3333jfbt22fTfvvtF3fddVd9dwdAGRIrABArAChp873rrrsufvjDH8a5554bhx56aFYp9fzzz8fw4cNj0aJFceGFF9ZntwCUEbECALECgJInpW644YYYN25cnHrqqcVlJ5xwQuy9995xxRVXSEoBIFYA4LoCgNI335s/f34ccsghGy1Py9I6ABArAHBdAUDJk1J9+vSJX//61xstv++++2K33Xarzy4BKDNiBQBiBQAlb743evToOPnkk+OZZ57J+pSqqqqK5557Lv77v/+71mQVAJVHrABArACg5JVSJ510Uvz2t7+N7bbbLh588MG4//77s8e/+93v4qtf/Wp9dglAmRErABArACh5pVTSv3//uPvuu+v7dAAqgFgBgFgBQMmTUmvXro0HHnggZs6cmTXf69u3bzYCX6tW9d4lAGVGrABArACgLvXKIL322mtZAmrBggWxxx57ZMv+8Ic/RLdu3eLhhx+Offfdtz67BaCMiBUAiBUAlLxPqbPOOiv23nvv+POf/xzTpk3Lprlz58Z+++0X//zP/1yfXQJQZsQKAMQKAEpeKfU///M/MXXq1Nh2222Ly9Ljn/zkJ3HQQQfVZ5cAlBmxAgCxAoCSV0qlJnvvvvvuRssXLlwYffr0qc8uASgzYgUAYgUAJU9KXX311XH++efHf/3Xf2VN+NKUHl9wwQXxr//6r7FkyZLiBEBlEisAECsAKHnzva985SvZ/7/5zW9mI+8lhUIh+/9xxx1XnE/r0shLdXnmmWfiZz/7Wbz88ssxf/78bDS/E088cZOv/fTTT8eIESPi9ddfj+233z4uuuiiGD58eH1OA4AGVKpYAUD5EisAKlu9klKTJ08uyYsvX7489t9//zj99NPjpJNO+tTtZ82aFUOHDo1hw4bF3XffHc8//3ycffbZ2ah/m/N8APJTqlgBQPkSKwAqW72SUkcccURJXnzIkCHZtLluueWW2HHHHWPs2LHZfN++fbMO18eMGSMpBdDElCpWAFC+xAqAylavpFSyYsWKmDFjRta5+bp162qsO/7446MhvPjiizF48OAay4455pj41a9+FatXr47WrVs3yOsC0HixQlNvgPLWGNcVADTjpNSkSZPi1FNPjUWLFm20riH7BlmwYEH06NGjxrI0v2bNmuxYevXqtdFzVq5cmU3VdL4OkI9SxQpNvQHKV6lihRsYABU0+t65554b3/jGN7LOydPdjPWnhu6strqz3GrVneZuuLzaNddcE506dSpOvXv3btDjA6C0sSI18/7xj38cX/va17a4qXdq5n3WWWfFGWeckTX1BqA8Y0X1DYwbb7xxs7av7qt20KBBMX369Lj00kuz0cUnTJjwGc4GgFwqpVJpbRoBb8OqpYbWs2fPrFpqw2Np1apVdO3atdbnXHLJJdmxrl8pJTEF0PAaK1Zo6g1QebFCX7UAFVQp9fWvfz2mTJkSeRs4cGA8+eSTNZY98cQTMWDAgDr7k2rbtm107NixxgRAw2usWPFpTb1rk5p5p5sW608AlG+sqOsGRhpEKfVVC0ATrpRKZbGpzPbZZ5+Nfffdd6OEUCp93RzLli2Ld955p0YZ7SuvvBJdunTJml6kKqd58+bFnXfema0fPnx49trpbsqwYcOyYJI6Ob/33nvrcxoANKBSxYq8mnqPHj26wY4HgKYVK/RVC9CMk1L33HNPPP7449G+ffvszsb6/8hPjzc3eKQ7EUcddVRxvrqZ3WmnnRbjx4/P2pbPmTOnuH6XXXaJiRMnxoUXXhg33XRTbL/99nH99dfHSSedVJ/TAKABlSpWbClNvQGaj8aKFdX7X58bGADNJCl1+eWXx5VXXhkXX3xxtGhRrxaAmSOPPLL441+blJja0BFHHBHTpk2r92sCkI9SxYr6NPV+5JFHtripd5oAqIxY4QYGQNNQr1/+VatWxcknn5xr4ACgeSlVrEhNvVPT7jSt39S7upI2NfVOw4lXS029Z8+enVXfzpw5M26//fasqffIkSM/4xkBUGqNdV2hr1qApqFev/6ped19991X+qMBoGyUKlakpt4HHHBANiUp2ZQe/+hHP8rm62rqnZqB9OvXL6666ipNvQHKPFa4gQFQQc331q5dG9dee23W/nu//fbbqDnEddddV6rjA6CZKlWs0NQboHyVKlboqxaggpJSr776avGO9WuvvVbqYwKgDIgVAOQVK9zAAKigpNTkyZNLfyQAlBWxAgCxAoCSJaW+9rWvbdbQqhMmTNiS3QJQRsQKAMQKAEqelOrUqdOWbA5ABRIrABArACh5UuqOO+7Yks0BqEBiBQBiBQCbo8VmbQUAAAAAJSQpBQAAAEDuJKUAAAAAyJ2kFAAAAAC5k5QCAAAAIHeSUgAAAADkTlIKAAAAgNxJSgEAAACQO0kpAAAAAHInKQUAAABA7lrl/5Lwifnz52dTXXr16pVNAAAAQPmRlKLR/OIXv4jRo0fXuX7UqFFxxRVX5HpMAAAAQD4kpWg03/nOd+L444+Pjz/+OA477LBs2XPPPRft27fPHquSAgAAgPIlKUWjqW6et3z58uKyfv36RYcOHXwqAAAAUOYkpQCAJkv/gwCIFVC+JKUAgCZL/4MAiBVQviSlAIAmS/+DAIgVUL4kpQCAJkv/gwCIFVC+WjT2AQAAAABQeSSlAAAAAMidpBQAAAAAuZOUAgAAACB3klIAAAAA5E5SCgAAAIDcSUoBAAAAkDtJKQAAAAByJykFAAAAQO4kpQAAAADInaQUAAAAALmTlAIAAAAgd5JSAAAAAOROUgoAAACA3ElKAQAAAJA7SSkAAAAAcicpBQAAAEDuJKUAAAAAyJ2kFAAAAAC5k5QCAAAAIHeSUgAAAADkTlIKAAAAgNxJSgEAAACQO0kpAAAAAHInKQUAAABA7iSlAAAAAMhdq2hkN998c/zsZz+L+fPnx9577x1jx46NQYMG1brtlClT4qijjtpo+cyZM2PPPffM4Wgr284XP9og+123akXxcd8fTooWbdpFQ/nTT49tsH0DAAAAzaRS6r777osLLrggLrvsspg+fXqWjBoyZEjMmTNnk8976623siRW9bTbbrvldswAAAAANPNKqeuuuy7OPPPMOOuss7L5VCX1+OOPx7hx4+Kaa66p83ndu3ePzp0753ikADQmVbXNh6paoLGIFQDNT6NVSq1atSpefvnlGDx4cI3laf6FF17Y5HMPOOCA6NWrVxx99NExefLkBj5SABqTqloAxAqA8tRolVKLFi2KtWvXRo8ePWosT/MLFiyo9TkpEXXrrbdG//79Y+XKlXHXXXdlianU19Thhx9e63PSdmmqtmTJkhKfCQANSVUtAGJFeVFVCzSZ0feqqqpqzBcKhY2WVdtjjz1i2LBhceCBB8bAgQOzEt1jjz02xowZU+f+UzPATp06FafevXuX/BwAaN5VtenmRbppsf4EQPOgBQZA89VoSantttsuWrZsuVFV1MKFCzeqntqUgw8+ON5+++06119yySWxePHi4jR37tzPdNwANI+q2gkTJsT999+f3dBIialnnnmmztdxAwOg+corVriBAVBGzffatGmTNcN78skn46tf/WpxeZo/4YQTNns/adS+FFTq0rZt22wCoPna0qraNFVLlbXphkSqqq2rqXe6gTFixIjifKqUUlkL0Lw0dKxINzBGjx5d4qMGqGyNOvpeugD41re+FQMGDMgCQbpbMWfOnBg+fHjxImHevHlx5513Fkfn23nnnWPvvffOynTvvvvu7O5GmgAoP6Wsqk0xoy5uYAA0X3nFCjcwAMosKXXyySfHX//617jyyitj/vz5sc8++8TEiRNjp512ytanZSlJVS0lokaOHJklqtq3b58lpx599NEYOnRoI54FAM29qhaA5ksLDIDmq1GTUsnZZ5+dTbUZP358jfmLLroomwCoHKpqARArAMpToyelAGBTVNUC8GnECoDmSVKqCViz7P1Yu+z9KKxeVVy26t0/RlXrNtnjllt3iVZbd2nEIwRoXKpqARArAMqPpFQTsOyVx2Lx8/fWWPbuPX9rptjp0H+Mzoed0ghHBgAAANAwJKWagK37DYn2fb5Y5/pUKQUAAABQTiSlmoDUNE/zPAAAAKCStGjsAwAAAACg8khKAQAAAJA7SSkAAAAAcqdPKQBoBtYsez/WLns/CqtXFZetevePUdW6TXFQDP0TAgDQnEhKAUAzsOyVx2Lx8/fWWPbuPRcVH3c69B+j82GnNMKRAdBUuIEBNDeSUgDQDGzdb0i07/PFOtenSikAKpsbGEBzIykFAM1AapqneR4Am+IGBtDcSEoBAACUATcwgObG6HsAAAAA5E5SCgAAAIDcSUoBAAAAkDtJKQAAAAByJykFAAAAQO4kpQAAAADInaQUAAAAALmTlAIAAAAgd63yf0n4xJpl78faZe9HYfWq4luy6t0/RlXrNtnjllt3iVZbd/F2AQAAQBmSlKLRLHvlsVj8/L01lr17z0XFx50O/cfofNgpjXBkADQVbmAAAJQvSSkazdb9hkT7Pl+sc32qlAKgsrmBAQBQviSlaLwvn+Z5AHwKNzAA+DSqaqH5kpQCAJosNzAA+DSqaqH5kpQCAACg2VJVC82XpBQAAADNlqpaaL5aNPYBAAAAAFB5JKUAAAAAyJ2kFAAAAAC5k5QCAAAAIHeSUgAAAADkTlIKAAAAgNxJSgEAAACQO0kpAAAAAHInKQUAAABA7iSlAAAAAMidpBQAAAAAuZOUAgAAACB3klIAAAAA5E5SCgAAAIDcSUoBAAAAkDtJKQAAAAByJykFAAAAQO4kpQAAAADInaQUAAAAALmTlAIAAAAgd5JSAAAAAOROUgoAAACA3ElKAQAAAJA7SSkAAAAAKi8pdfPNN8cuu+wS7dq1i/79+8ezzz67ye2ffvrpbLu0/a677hq33HJLbscKQOMQKwAQKwDKT6Mmpe6777644IIL4rLLLovp06fHoEGDYsiQITFnzpxat581a1YMHTo02y5tf+mll8b5558fEyZMyP3YAciHWAGAWAFQnho1KXXdddfFmWeeGWeddVb07ds3xo4dG717945x48bVun2qitpxxx2z7dL26XlnnHFGjBkzJvdjByAfYgUAYgVAeWrVWC+8atWqePnll+Piiy+usXzw4MHxwgsv1PqcF198MVu/vmOOOSZ+9atfxerVq6N169ab/fpr167Npg1VVVVFixZ/y9VtuE2LWFd8XMimFrWu29CG21bFuqjKedtk3Xrb1nb+62vZsuXfnrdu3SbPb/39VkUhm+reNh1hVaNsW33O6TNOn3X1uRUKde+3IbadP39+vPvuu8Vt03brb9uzZ8/o1atXrftN26V912X977Btt/x9+LS/jS3Ztvrv6JVXXonXX3+9zu/DXnvtFfvvv3+Nv7kt+fss5bZNjVghViRihVjR1GJbQ8SK9G+DNNV1DNX/NhArNiZWiBXZ353riuJvmesKsaJlM7quaLSk1KJFi7KT6NGjR43laX7BggW1Pictr237NWvWZPtb/yK+2sqVK7Op2uLFi7P//+Y3v4mtttpqo+233Xbb2GeffYrzzz//fI1/HPRd+8fi4+WFtvHHtV2L83u0WhCt6kjcfFxoE++s3e5v27ZcGG2q1tS67cpC6/jD2m7F+d1bvhdtq1bXuu2qQqt4a2334nyflouifdWqWrddEy1i5pqe2eMlS5bEjBkziu/HhtI/pA499NDi/GuvvVbj3Df06prti493bPlBdKr6uM5tX1/Ts5jE2qHFh7Fti4/q3Hbmmh6xJj754m/f4sPouolt31zTPVb//7/SPVssjm4tlm+0zaRJk7L/H3jggdGhQ4fs8ezZs+tsMpqM+M2H8XG0yR53a7E0erZYWue26fuQvhdJ16plsX3LJbVut2L2jJj+mwfigw8+yOa7d+8eu+++e3F9m167R7ud9ivOz1m7bSwutM8ep/c2vcd1+fPazvFB4ZPv9jZVK2Lnlu9nj88+ss9G237+85+P7bf/5LP78MMP49VXX61zvzvvvHNWyVj9/fmf//mfOrdNFY077bRT9nj58uUxbdq07HFKxKW/1fWl/uHat//k3Pr06RMffVT3Z5z+xtM21f8A/e1vf1vntum3ofo9Tb81dSW7k+222y6rvkz2GfV47NvqL3Vuu7TQLv60tktxfu9W86NFHcnS6t+Id/9zVKyaNzO++MUv1po8b7lNt2ix19+X9Dei+vNO7+9BBx1UXJ6aPi9btqzW/aZjSwmyZFPJ1zyJFWJFIlaIFZUQKz545v8Xy6Y9WmesSP82KOw4QKyohVghViRihVghVkTzjBWFRjJv3rysyOeFF16osfzHP/5xYY899qj1Obvttlvh6quvrrHsueeey/Yzf/78Wp8zatSoT4qJTN4D3wHfAd+Bzf4OzJ07t9AUiBX+bv3d+g74DjTd74BY0fifgcl74DvgOxDNPFY0WqVUutuUSr82rIpauHDhRtVQ65ct17Z9q1atomvXv1Usre+SSy6JESNGFOdT1dP777+fbV/dHKopSRUoqRpl7ty50bFjx6gUlXrelXzuzrtpft7pTsbSpUuLFXSNTayonb+fpvn305B85pX1mTf1z1us+ITriqapqf/9NKRKPXfnPbdZx4pGS0q1adMm+vfvH08++WR89atfLS5P8yeccEKtzxk4cGA88sgjNZY98cQTMWDAgDr7k2rbtm02ra9z587R1KUvVVP8YjW0Sj3vSj535930dOrUKZoKsWLT/P1UHp95ZWnKn7dY8QnXFU1XU/77aWiVeu7Ou3nGikYdfS9VMN12221x++23x8yZM+PCCy/M+vYZPnx4scrp1FNPLW6flqf+f9Lz0vbpeamT85EjRzbiWQDQkMQKAMQKgPLUaJVSycknnxx//etf48orr8xGG0kdjE+cOLHYQXJatn4H1Lvssku2PiWvbrrppqwM7Prrr4+TTjqpEc8CgIYkVgAgVgCUp0ZNSiVnn312NtVm/PjxGy074ogjiiN5laPU1HDUqFEbNTksd5V63pV87s67sj7vz0qsqMnfT+X9/fjMK+szr9TP+7MSK2qq1O9RpZ53JZ+7824bzVlV6u28sQ8CAAAAgMrSqH1KAQAAAFCZJKUAAAAAyJ2kFAAAAAC5k5RqYm6++eZslMF27dpF//7949lnn41y98wzz8Rxxx2XjaZYVVUVDz74YJS7a665Jg466KDYZpttonv37nHiiSfGW2+9FZVg3Lhxsd9++0XHjh2zaeDAgfHYY49FJUmff/quX3DBBY19KDRTYoVYUe7ECrGCz06sECvKnVgRZXFdISnVhNx3333Zl+myyy6L6dOnx6BBg2LIkCExZ86cKGfLly+P/fffP2688caoFE8//XScc8458dJLL8WTTz4Za9asicGDB2fvRbnbYYcd4qc//WlMnTo1m770pS/FCSecEK+//npUgt///vdx6623Zok5qA+xQqwQK8qfWMFnJVaIFWJF+ft9uVxXpNH3aBq+8IUvFIYPH15j2Z577lm4+OKLC5UifSUfeOCBQqVZuHBhdu5PP/10oRJtu+22hdtuu61Q7pYuXVrYbbfdCk8++WThiCOOKHz3u99t7EOiGRIrxAqxoryJFZSCWCFWiBXlbWkZXVeolGoiVq1aFS+//HJWLbO+NP/CCy802nGRj8WLF2f/79KlS0W95WvXro3/+I//yO7kpGZ85S5Vxx177LHxd3/3d419KDRTYkVlEyvECtgcYkVlEyvEiuamVWMfAJ9YtGhRdoHeo0ePGm9Jml+wYIG3qYylGzkjRoyIww47LPbZZ5+oBK+++mqWhFqxYkVsvfXW8cADD8Ree+3V2IfVoFLybdq0aVmZLdSXWFG5xAqxAjaXWFG5xAqxojmSlGpiUidlG/6wbLiM8nLuuefGjBkz4rnnnotKsccee8Qrr7wSH374YUyYMCFOO+20rJ+tck1MzZ07N7773e/GE088kQ1iAJ+VWFF5xAqxAraUWFF5xAqxojmSlGoitttuu2jZsuVGVVELFy7cqHqK8nHeeefFww8/nI1AmDoArxRt2rSJPn36ZI8HDBiQVQ/9/Oc/j1/84hdRjlLT3PS3nEbUrJYqI9Pnnjr4X7lyZfb3D59GrKhMYoVYIVawJcSKyiRWiBU3NtPrCn1KNaGL9HTBmkZiW1+aP+SQQxrtuGgYqQIu3cm4//7746mnnopddtklKv39SD+g5eroo4/Omiym6rDqKSXjTjnllOxxcwscNB6xorKIFRu/H2IFfDqxorKIFRu/H2JF86JSqglJ/Qp961vfyi5WU387aXjHOXPmxPDhw6OcLVu2LN55553i/KxZs7IL9dTp94477hjl2uH1PffcEw899FBss802xQq5Tp06Rfv27aOcXXrppTFkyJDo3bt3LF26NOtracqUKTFp0qQoV+kz3rC/sA4dOkTXrl0rph8xSkes+IRYIVaUG7GCUhIrPiFWiBXlZptyvK5o7OH/qOmmm24q7LTTToU2bdoUDjzwwIoYynPy5MmF9FXccDrttNMK5aq2803THXfcUSh3Z5xxRvE73q1bt8LRRx9deOKJJwqVprkP3UrjEivEinInVnxCrOCzECvEinInVpRHrKhK/2nsxBgAAAAAlUWfUgAAAADkTlIKAAAAgNxJSgEAAACQO0kpAAAAAHInKQUAAABA7iSlAAAAAMidpBQAAAAAuZOUAgAAACB3klIAAAAA5E5SCj7Ft7/97aiqqtpoeueddz7zezd+/Pjo3LmzzwCgmRMrABArYMu1qsdzoOJ8+ctfjjvuuKPGsm7dukVTsnr16mjdunVjHwZAxRIrABArYMuolILN0LZt2+jZs2eNqWXLlvHII49E//79o127drHrrrvG6NGjY82aNcXnXXfddbHvvvtGhw4donfv3nH22WfHsmXLsnVTpkyJ008/PRYvXlysvrriiiuydenxgw8+WOMYUkVVqqxK/vSnP2Xb/PrXv44jjzwye/277747W5eSZ3379s2W7bnnnnHzzTf7jAFyIFYAIFbAllEpBfX0+OOPx//5P/8nrr/++hg0aFD87//+b/zzP/9ztm7UqFHZ/1u0aJGt33nnnWPWrFlZUuqiiy7KEkWHHHJIjB07Nn70ox/FW2+9lW2/9dZbb9Ex/OAHP4h/+7d/yxJR6WLol7/8ZfbaN954YxxwwAExffr0GDZsWJYUO+2003zWADkTKwAQK2ATCsAmnXbaaYWWLVsWOnToUJy+/vWvFwYNGlS4+uqra2x71113FXr16lXnvn79618XunbtWpy/4447Cp06ddpou/Sn+cADD9RYlrZL2yezZs3Kthk7dmyNbXr37l245557aiy76qqrCgMHDvQpAzQgsQIAsQK2nEop2AxHHXVUjBs3rjifKo/69OkTv//97+MnP/lJcfnatWtjxYoV8dFHH8VWW20VkydPjquvvjreeOONWLJkSda0L61fvnx5to/PasCAAcXH7733XsydOzfOPPPMrDqqWnrNTp06+ZwBGphYAYBYAVtGUgo2Q3USan3r1q3L+pD62te+ttH2qT+n2bNnx9ChQ2P48OFx1VVXRZcuXeK5557LkkapU/JNSf1FfVIw9Te1PWf9xFY6niQ14fviF79YY7vU/xUADUusAECsgC0jKQX1dOCBB2Z9QW2YrKo2derUrEop9fmU+pZKUsfk62vTpk1WXbWhNLLf/Pnzi/Nvv/12Vn21KT169IjPfe5z8cc//jFOOeWUep4VAKUkVgAgVkDdJKWgnlIH5V/5yleyUfW+8Y1vZImnGTNmxKuvvho//vGP4/Of/3yWlLrhhhviuOOOi+effz5uueWWGvtIHaCn0fj++7//O/bff/+syV+avvSlL2WdlR988MFZBVTq0Lx169afekxp9L7zzz8/OnbsGEOGDImVK1dmybEPPvggRowY4bMGyJlYAYBYAZtQj36ooOI6rz3hhBNqXTdp0qTCIYccUmjfvn2hY8eOhS984QuFW2+9tbj+uuuuyzo+T+uPOeaYwp133pl1UP7BBx8Utxk+fHjW+XlaPmrUqGzZvHnzCoMHD846Vd9tt90KEydOrLWj8+nTp290TP/+7/9e6NevX6FNmzaFbbfdtnD44YcX7r///gZ4ZwCoJlYA8GnECthYVfrPppJWAAAAAFBqn3R0AwAAAAA5kpQCAAAAIHeSUgAAAADkTlIKAAAAgNxJSgEAAACQO0kpAAAAAHInKQUAAABA7iSlAAAAAMidpBQAAAAAuZOUAgAAACB3klIAAAAA5E5SCgAAAIDI2/8HeZ00pk4wHVcAAAAASUVORK5CYII=", "text/plain": [ "
" ] @@ -307,14 +333,14 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "id": "51487042", "metadata": { "execution": { - "iopub.execute_input": "2026-02-12T06:44:40.324067Z", - "iopub.status.busy": "2026-02-12T06:44:40.323949Z", - "iopub.status.idle": "2026-02-12T06:44:40.330061Z", - "shell.execute_reply": "2026-02-12T06:44:40.329803Z" + "iopub.execute_input": "2026-02-17T16:04:26.859282Z", + "iopub.status.busy": "2026-02-17T16:04:26.859145Z", + "iopub.status.idle": "2026-02-17T16:04:26.920943Z", + "shell.execute_reply": "2026-02-17T16:04:26.920429Z" }, "papermill": { "duration": 0.011995, @@ -415,14 +441,14 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "id": "fe9642eb", "metadata": { "execution": { - "iopub.execute_input": "2026-02-12T06:44:40.331507Z", - "iopub.status.busy": "2026-02-12T06:44:40.331433Z", - "iopub.status.idle": "2026-02-12T06:44:40.442446Z", - "shell.execute_reply": "2026-02-12T06:44:40.442156Z" + "iopub.execute_input": "2026-02-17T16:04:26.922442Z", + "iopub.status.busy": "2026-02-17T16:04:26.922331Z", + "iopub.status.idle": "2026-02-17T16:04:27.067800Z", + "shell.execute_reply": "2026-02-17T16:04:27.067219Z" }, "papermill": { "duration": 0.128911, @@ -436,7 +462,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -473,6 +499,76 @@ "plt.show()" ] }, + { + "cell_type": "markdown", + "id": "c5532f3f", + "metadata": {}, + "source": [ + "## Shared Diagnostics and Summary\n", + "\n", + "Use the built-in diagnostics and `summary()` methods for consistent reporting\n", + "across OT/EOT/Flow explainers.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "866ce1ea", + "metadata": { + "execution": { + "iopub.execute_input": "2026-02-17T16:04:27.069296Z", + "iopub.status.busy": "2026-02-17T16:04:27.069193Z", + "iopub.status.idle": "2026-02-17T16:04:27.074610Z", + "shell.execute_reply": "2026-02-17T16:04:27.073931Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "OT diagnostics\n", + "--------------------------------------------------\n", + "Latent independence (median dCor): 0.066532 [GOOD]\n", + "Distribution fidelity (MMD): 0.000000 [GOOD]\n", + "\n", + "X-space summary\n", + "==============================================================================\n", + "Feature Importance Results\n", + "==============================================================================\n", + "Method: OTExplainer\n", + "Number of features: 5\n", + "Significance level: 0.05\n", + "Alternative: greater\n", + "Practical margin: 0.0099\n", + "------------------------------------------------------------------------------\n", + " Feature Estimate Std Err CI Lower CI Upper P-value Sig\n", + "------------------------------------------------------------------------------\n", + " 0 1.3843 0.5065 0.5511 inf 0.0033 ***\n", + " 1 0.5322 0.1313 0.3163 inf 0.0000 ***\n", + " 2 0.0020 0.0026 -0.0023 inf 0.9987 \n", + " 3 0.0003 0.0026 -0.0039 inf 0.9999 \n", + " 4 0.0031 0.0027 -0.0013 inf 0.9944 \n", + "==============================================================================\n", + "Significant features: 2 / 5\n", + "---\n", + "Signif. codes: 0 '***' 0.01 '**' 0.05 '*' 0.1 ' ' 1\n", + "==============================================================================\n" + ] + } + ], + "source": [ + "_ = explainer(X_test)\n", + "diag = explainer.diagnostics\n", + "print(\"OT diagnostics\")\n", + "print(\"-\" * 50)\n", + "print(f\"Latent independence (median dCor): {diag['latent_independence_median']:.6f} [{diag['latent_independence_label']}]\")\n", + "print(f\"Distribution fidelity (MMD): {diag['distribution_fidelity_mmd']:.6f} [{diag['distribution_fidelity_label']}]\")\n", + "\n", + "print(\"\\nX-space summary\")\n", + "_ = explainer.summary(alpha=0.05, target='X', alternative='greater')\n" + ] + }, { "cell_type": "markdown", "id": "97247a77", @@ -532,10 +628,11 @@ "\n", "Key takeaways:\n", "\n", - "1. OTExplainer uses Gaussian OT to disentangle correlated features\n", - "2. Higher `nsamples` reduces variance at the cost of computation time\n", - "3. `sampling_method=\"resample\"` is recommended for most cases\n", - "4. The transformation to Z-space removes correlations for clean attribution" + "1. OTExplainer uses Gaussian OT to disentangle correlated features.\n", + "2. Higher `nsamples` reduces variance at the cost of computation time.\n", + "3. `sampling_method=\"resample\"` is recommended for most cases.\n", + "4. The transformation to Z-space removes correlations for clean attribution.\n", + "5. Shared diagnostics and `summary()` provide standardized inference reporting.\n" ] } ], @@ -550,7 +647,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.12" + "version": "3.10.19" }, "papermill": { "default_parameters": {}, diff --git a/docs/tutorials/quickstart.ipynb b/docs/tutorials/quickstart.ipynb index 47a1ae2..05464ac 100644 --- a/docs/tutorials/quickstart.ipynb +++ b/docs/tutorials/quickstart.ipynb @@ -1,5 +1,31 @@ { "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "a243e6bb", + "metadata": { + "execution": { + "iopub.execute_input": "2026-02-17T15:56:18.517156Z", + "iopub.status.busy": "2026-02-17T15:56:18.516895Z", + "iopub.status.idle": "2026-02-17T15:56:18.528720Z", + "shell.execute_reply": "2026-02-17T15:56:18.527512Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "FDFI version: 0.0.2\n" + ] + } + ], + "source": [ + "import fdfi\n", + "print('FDFI version:', fdfi.__version__)" + ] + }, { "cell_type": "markdown", "id": "b13c0b60", @@ -45,14 +71,14 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "id": "1fd3b39e", "metadata": { "execution": { - "iopub.execute_input": "2026-02-12T06:44:38.077241Z", - "iopub.status.busy": "2026-02-12T06:44:38.076575Z", - "iopub.status.idle": "2026-02-12T06:44:38.511512Z", - "shell.execute_reply": "2026-02-12T06:44:38.511208Z" + "iopub.execute_input": "2026-02-17T15:56:18.532132Z", + "iopub.status.busy": "2026-02-17T15:56:18.531903Z", + "iopub.status.idle": "2026-02-17T15:56:18.966970Z", + "shell.execute_reply": "2026-02-17T15:56:18.966308Z" }, "papermill": { "duration": 0.535767, @@ -93,14 +119,14 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "id": "e8088eb0", "metadata": { "execution": { - "iopub.execute_input": "2026-02-12T06:44:38.513335Z", - "iopub.status.busy": "2026-02-12T06:44:38.513229Z", - "iopub.status.idle": "2026-02-12T06:44:38.515856Z", - "shell.execute_reply": "2026-02-12T06:44:38.515615Z" + "iopub.execute_input": "2026-02-17T15:56:18.968825Z", + "iopub.status.busy": "2026-02-17T15:56:18.968675Z", + "iopub.status.idle": "2026-02-17T15:56:18.972018Z", + "shell.execute_reply": "2026-02-17T15:56:18.971487Z" }, "papermill": { "duration": 0.007344, @@ -161,14 +187,14 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "id": "492ea9db", "metadata": { "execution": { - "iopub.execute_input": "2026-02-12T06:44:38.517246Z", - "iopub.status.busy": "2026-02-12T06:44:38.517155Z", - "iopub.status.idle": "2026-02-12T06:44:38.519456Z", - "shell.execute_reply": "2026-02-12T06:44:38.519181Z" + "iopub.execute_input": "2026-02-17T15:56:18.973652Z", + "iopub.status.busy": "2026-02-17T15:56:18.973557Z", + "iopub.status.idle": "2026-02-17T15:56:18.979093Z", + "shell.execute_reply": "2026-02-17T15:56:18.978593Z" }, "papermill": { "duration": 0.005513, @@ -220,14 +246,14 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "id": "f8b8883f", "metadata": { "execution": { - "iopub.execute_input": "2026-02-12T06:44:38.520924Z", - "iopub.status.busy": "2026-02-12T06:44:38.520823Z", - "iopub.status.idle": "2026-02-12T06:44:38.523702Z", - "shell.execute_reply": "2026-02-12T06:44:38.523476Z" + "iopub.execute_input": "2026-02-17T15:56:18.980935Z", + "iopub.status.busy": "2026-02-17T15:56:18.980806Z", + "iopub.status.idle": "2026-02-17T15:56:18.984413Z", + "shell.execute_reply": "2026-02-17T15:56:18.983979Z" }, "papermill": { "duration": 0.006654, @@ -293,14 +319,14 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "id": "018a1e8c", "metadata": { "execution": { - "iopub.execute_input": "2026-02-12T06:44:38.525026Z", - "iopub.status.busy": "2026-02-12T06:44:38.524921Z", - "iopub.status.idle": "2026-02-12T06:44:38.526848Z", - "shell.execute_reply": "2026-02-12T06:44:38.526616Z" + "iopub.execute_input": "2026-02-17T15:56:18.986215Z", + "iopub.status.busy": "2026-02-17T15:56:18.986118Z", + "iopub.status.idle": "2026-02-17T15:56:18.988657Z", + "shell.execute_reply": "2026-02-17T15:56:18.988275Z" }, "papermill": { "duration": 0.0056, @@ -361,14 +387,14 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "id": "e1a48247", "metadata": { "execution": { - "iopub.execute_input": "2026-02-12T06:44:38.528179Z", - "iopub.status.busy": "2026-02-12T06:44:38.528101Z", - "iopub.status.idle": "2026-02-12T06:44:38.530492Z", - "shell.execute_reply": "2026-02-12T06:44:38.530267Z" + "iopub.execute_input": "2026-02-17T15:56:18.990260Z", + "iopub.status.busy": "2026-02-17T15:56:18.990162Z", + "iopub.status.idle": "2026-02-17T15:56:19.605601Z", + "shell.execute_reply": "2026-02-17T15:56:19.604985Z" }, "papermill": { "duration": 0.006332, @@ -389,16 +415,16 @@ "------------------------------------------------------------\n", " Feature Estimate SE CI Lower P-value\n", "------------------------------------------------------------\n", - " 0 0.7946 0.2767 0.3394 0.0020 *\n", - " 1 1.9705 0.6043 0.9765 0.0006 *\n", - " 2 0.1916 0.0724 0.0726 0.0041 *\n", - " 3 0.0088 0.0225 -0.0282 0.3475 \n", - " 4 0.0178 0.0227 -0.0196 0.2169 \n", - " 5 0.0071 0.0224 -0.0298 0.3753 \n", - " 6 0.0134 0.0225 -0.0237 0.2759 \n", - " 7 0.0029 0.0224 -0.0339 0.4482 \n", - " 8 0.0006 0.0224 -0.0362 0.4889 \n", - " 9 0.0306 0.0235 -0.0080 0.0963 \n", + " 0 0.7946 0.3302 0.2515 0.2051 \n", + " 1 1.9705 0.6306 0.9333 0.0108 *\n", + " 2 0.1916 0.1941 -0.1277 0.9560 \n", + " 3 0.0088 0.1815 -0.2897 0.9977 \n", + " 4 0.0178 0.1815 -0.2808 0.9973 \n", + " 5 0.0071 0.1815 -0.2914 0.9977 \n", + " 6 0.0134 0.1815 -0.2851 0.9975 \n", + " 7 0.0029 0.1815 -0.2956 0.9979 \n", + " 8 0.0006 0.1815 -0.2979 0.9980 \n", + " 9 0.0306 0.1816 -0.2681 0.9966 \n", "\n", "* = significant at alpha=0.05\n" ] @@ -445,14 +471,14 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "id": "b23ce403", "metadata": { "execution": { - "iopub.execute_input": "2026-02-12T06:44:38.531785Z", - "iopub.status.busy": "2026-02-12T06:44:38.531702Z", - "iopub.status.idle": "2026-02-12T06:44:38.534687Z", - "shell.execute_reply": "2026-02-12T06:44:38.534391Z" + "iopub.execute_input": "2026-02-17T15:56:19.607326Z", + "iopub.status.busy": "2026-02-17T15:56:19.607125Z", + "iopub.status.idle": "2026-02-17T15:56:19.615229Z", + "shell.execute_reply": "2026-02-17T15:56:19.614623Z" }, "papermill": { "duration": 0.007091, @@ -475,21 +501,22 @@ "Number of features: 10\n", "Significance level: 0.05\n", "Alternative: greater\n", + "Practical margin: 0.5226\n", "------------------------------------------------------------------------------\n", " Feature Estimate Std Err CI Lower CI Upper P-value Sig\n", "------------------------------------------------------------------------------\n", - " 0 0.7946 0.2767 0.3394 inf 0.0020 ***\n", - " 1 1.9705 0.6043 0.9765 inf 0.0006 ***\n", - " 2 0.1916 0.0724 0.0726 inf 0.0041 ***\n", - " 3 0.0088 0.0225 -0.0282 inf 0.3475 \n", - " 4 0.0178 0.0227 -0.0196 inf 0.2169 \n", - " 5 0.0071 0.0224 -0.0298 inf 0.3753 \n", - " 6 0.0134 0.0225 -0.0237 inf 0.2759 \n", - " 7 0.0029 0.0224 -0.0339 inf 0.4482 \n", - " 8 0.0006 0.0224 -0.0362 inf 0.4889 \n", - " 9 0.0306 0.0235 -0.0080 inf 0.0963 *\n", + " 0 0.7946 0.3302 0.2515 inf 0.2051 \n", + " 1 1.9705 0.6306 0.9333 inf 0.0108 **\n", + " 2 0.1916 0.1941 -0.1277 inf 0.9560 \n", + " 3 0.0088 0.1815 -0.2897 inf 0.9977 \n", + " 4 0.0178 0.1815 -0.2808 inf 0.9973 \n", + " 5 0.0071 0.1815 -0.2914 inf 0.9977 \n", + " 6 0.0134 0.1815 -0.2851 inf 0.9975 \n", + " 7 0.0029 0.1815 -0.2956 inf 0.9979 \n", + " 8 0.0006 0.1815 -0.2979 inf 0.9980 \n", + " 9 0.0306 0.1816 -0.2681 inf 0.9966 \n", "==============================================================================\n", - "Significant features: 3 / 10\n", + "Significant features: 1 / 10\n", "---\n", "Signif. codes: 0 '***' 0.01 '**' 0.05 '*' 0.1 ' ' 1\n", "==============================================================================\n" @@ -498,10 +525,10 @@ { "data": { "text/plain": [ - "\"==============================================================================\\nFeature Importance Results\\n==============================================================================\\nMethod: OTExplainer\\nNumber of features: 10\\nSignificance level: 0.05\\nAlternative: greater\\n------------------------------------------------------------------------------\\n Feature Estimate Std Err CI Lower CI Upper P-value Sig\\n------------------------------------------------------------------------------\\n 0 0.7946 0.2767 0.3394 inf 0.0020 ***\\n 1 1.9705 0.6043 0.9765 inf 0.0006 ***\\n 2 0.1916 0.0724 0.0726 inf 0.0041 ***\\n 3 0.0088 0.0225 -0.0282 inf 0.3475 \\n 4 0.0178 0.0227 -0.0196 inf 0.2169 \\n 5 0.0071 0.0224 -0.0298 inf 0.3753 \\n 6 0.0134 0.0225 -0.0237 inf 0.2759 \\n 7 0.0029 0.0224 -0.0339 inf 0.4482 \\n 8 0.0006 0.0224 -0.0362 inf 0.4889 \\n 9 0.0306 0.0235 -0.0080 inf 0.0963 *\\n==============================================================================\\nSignificant features: 3 / 10\\n---\\nSignif. codes: 0 '***' 0.01 '**' 0.05 '*' 0.1 ' ' 1\\n==============================================================================\"" + "\"==============================================================================\\nFeature Importance Results\\n==============================================================================\\nMethod: OTExplainer\\nNumber of features: 10\\nSignificance level: 0.05\\nAlternative: greater\\nPractical margin: 0.5226\\n------------------------------------------------------------------------------\\n Feature Estimate Std Err CI Lower CI Upper P-value Sig\\n------------------------------------------------------------------------------\\n 0 0.7946 0.3302 0.2515 inf 0.2051 \\n 1 1.9705 0.6306 0.9333 inf 0.0108 **\\n 2 0.1916 0.1941 -0.1277 inf 0.9560 \\n 3 0.0088 0.1815 -0.2897 inf 0.9977 \\n 4 0.0178 0.1815 -0.2808 inf 0.9973 \\n 5 0.0071 0.1815 -0.2914 inf 0.9977 \\n 6 0.0134 0.1815 -0.2851 inf 0.9975 \\n 7 0.0029 0.1815 -0.2956 inf 0.9979 \\n 8 0.0006 0.1815 -0.2979 inf 0.9980 \\n 9 0.0306 0.1816 -0.2681 inf 0.9966 \\n==============================================================================\\nSignificant features: 1 / 10\\n---\\nSignif. codes: 0 '***' 0.01 '**' 0.05 '*' 0.1 ' ' 1\\n==============================================================================\"" ] }, - "execution_count": 7, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } @@ -546,7 +573,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.12" + "version": "3.10.19" }, "papermill": { "default_parameters": {}, diff --git a/docs/user_guide/choosing_explainer.rst b/docs/user_guide/choosing_explainer.rst index 35ea080..c6c0c25 100644 --- a/docs/user_guide/choosing_explainer.rst +++ b/docs/user_guide/choosing_explainer.rst @@ -182,6 +182,28 @@ underlying distribution structure explainer = FlowExplainer(model.predict, X_background, fit_flow=False) explainer.set_flow(flow) +Shared Diagnostics (OT / EOT / Flow) +------------------------------------ + +All disentangled explainers expose a shared ``diagnostics`` payload: + +- ``latent_independence_median`` with qualitative label +- ``distribution_fidelity_mmd`` with qualitative label + +Lower is better for both metrics. Labels use the same thresholds across +explainers: + +- ``GOOD``: dCor < 0.10, MMD < 0.05 +- ``MODERATE``: dCor < 0.25, MMD < 0.15 +- ``POOR``: otherwise + +.. code-block:: python + + explainer = OTExplainer(model.predict, X_background) + diag = explainer.diagnostics + print(diag["latent_independence_median"], diag["latent_independence_label"]) + print(diag["distribution_fidelity_mmd"], diag["distribution_fidelity_label"]) + TreeExplainer ------------- diff --git a/docs/user_guide/concepts.rst b/docs/user_guide/concepts.rst index 4f4b73b..55254e1 100644 --- a/docs/user_guide/concepts.rst +++ b/docs/user_guide/concepts.rst @@ -122,6 +122,17 @@ varies with position and is computed via automatic differentiation. - When OT assumptions are too restrictive - When you have sufficient data (>500 samples) to train the flow +Shared Disentanglement Diagnostics +---------------------------------- + +All disentangled explainers (OT, EOT, Flow) report two common diagnostics: + +- **Latent independence**: median pairwise distance correlation in latent space. +- **Distribution fidelity**: MMD between original data and reconstructed data. + +Both are "lower is better" metrics and are reported with qualitative labels +(``GOOD``, ``MODERATE``, ``POOR``) using shared thresholds. + Relationship to Other Methods ----------------------------- diff --git a/fdfi/__init__.py b/fdfi/__init__.py index 46f6e8a..7952d84 100644 --- a/fdfi/__init__.py +++ b/fdfi/__init__.py @@ -5,7 +5,44 @@ Includes both DFI (Disentangled Feature Importance) and FDFI (Flow-DFI) methods. """ -__version__ = "0.0.1" +from importlib import metadata as importlib_metadata +from pathlib import Path +import re + + +def _version_from_pyproject() -> str: + """Read package version from pyproject.toml when running from source tree.""" + pyproject_path = Path(__file__).resolve().parents[1] / "pyproject.toml" + if not pyproject_path.exists(): + raise FileNotFoundError("pyproject.toml not found") + + content = pyproject_path.read_text(encoding="utf-8") + match = re.search(r'^version\s*=\s*"([^"]+)"\s*$', content, flags=re.MULTILINE) + if match is None: + raise ValueError("Could not parse version from pyproject.toml") + return match.group(1) + + +def _resolve_version() -> str: + """ + Resolve version without hardcoding. + + Priority: + 1) pyproject.toml (source/dev workflow, always aligned with project metadata) + 2) installed distribution metadata (wheel/sdist runtime) + """ + try: + return _version_from_pyproject() + except (FileNotFoundError, ValueError): + pass + + try: + return importlib_metadata.version("fdfi") + except importlib_metadata.PackageNotFoundError: + return "0.0.0" + + +__version__ = _resolve_version() __author__ = "FDFI Team" # Import main explainer classes when they are implemented diff --git a/fdfi/explainers.py b/fdfi/explainers.py index c6a30df..faf8f4d 100644 --- a/fdfi/explainers.py +++ b/fdfi/explainers.py @@ -9,7 +9,13 @@ from typing import Optional, Union, Callable, Any, Tuple from scipy.spatial.distance import cdist, pdist from scipy import stats -from .utils import TwoComponentMixture, detect_feature_types, gower_cost_matrix +from .utils import ( + TwoComponentMixture, + detect_feature_types, + gower_cost_matrix, + compute_latent_independence, + compute_mmd, +) @@ -71,6 +77,18 @@ def __init__( self._var_floor_mixture = None self._margin_mixture = None self._var_floor_value = None + self.verbose = kwargs.get("verbose", False) + self.diagnostics = None + self.compute_diagnostics = kwargs.get("compute_diagnostics", True) + self.diagnostics_subset_max_samples = kwargs.get( + "diagnostics_subset_max_samples", 1000 + ) + self.latent_independence_thresholds = kwargs.get( + "latent_independence_thresholds", (0.1, 0.25) + ) + self.distribution_fidelity_thresholds = kwargs.get( + "distribution_fidelity_thresholds", (0.05, 0.15) + ) fit_flow = kwargs.get("fit_flow", True) self.flow_engine = None @@ -97,8 +115,8 @@ def _adjust_se( self, se_raw: np.ndarray, var_floor_c: float = 0.1, - var_floor_method: str = "fixed", - var_floor_quantile: float = 0.05, + var_floor_method: str = "mixture", + var_floor_quantile: float = 0.95, ) -> np.ndarray: if self._last_n is None: return se_raw @@ -120,10 +138,10 @@ def conf_int( alpha: float = 0.05, target: str = "X", var_floor_c: float = 0.1, - var_floor_method: str = "fixed", + var_floor_method: str = "mixture", var_floor_quantile: float = 0.95, margin: float = 0.0, - margin_method: str = "fixed", + margin_method: str = "mixture", margin_quantile: float = 0.95, alternative: str = "two-sided", ) -> dict: @@ -247,6 +265,154 @@ def _format_summary(self, results: dict, alpha: float, print_output: bool = True if print_output: print(output) return output + + def _log(self, message: str, level: str = "INFO") -> None: + """Consistent, verbosity-aware logging with unified style.""" + v = getattr(self, "verbose", False) + if v is False: + return + if v in ("all", True, "final"): + print(f"[FDFI][{level.upper()}] {message}") + + @staticmethod + def _qualitative_score( + value: float, + thresholds: Tuple[float, float], + lower_is_better: bool = True, + ) -> str: + """ + Return GOOD / MODERATE / POOR label based on thresholds. + + thresholds: (good_cutoff, moderate_cutoff); behavior flips if lower_is_better=False. + """ + good, moderate = thresholds + if lower_is_better: + if value < good: + return "GOOD" + if value < moderate: + return "MODERATE" + return "POOR" + if value > moderate: + return "POOR" + if value > good: + return "MODERATE" + return "GOOD" + + def _decode_from_Z(self, Z: np.ndarray) -> np.ndarray: + """ + Decode latent-space samples to original feature space. + + Subclasses with disentanglement maps (OT/EOT/Flow) should implement this. + """ + raise NotImplementedError( + f"{self.__class__.__name__} does not implement latent decoding." + ) + + def _get_diagnostics_sources(self) -> Tuple[Optional[np.ndarray], Optional[np.ndarray]]: + """Return default (X_orig, Z_full) used for diagnostics.""" + return self.data, getattr(self, "Z_full", None) + + def _compute_diagnostics( + self, + X_orig: Optional[np.ndarray] = None, + Z_full: Optional[np.ndarray] = None, + report_title: Optional[str] = None, + ) -> Optional[dict]: + """ + Compute and store generic disentanglement diagnostics. + + Diagnostics: + - Latent independence: median distance correlation across latent dims. + - Distribution fidelity: Maximum Mean Discrepancy (MMD) between + original data and reconstructions. + """ + if not self.compute_diagnostics: + return None + + if X_orig is None or Z_full is None: + default_X, default_Z = self._get_diagnostics_sources() + if X_orig is None: + X_orig = default_X + if Z_full is None: + Z_full = default_Z + + if X_orig is None or Z_full is None: + return None + + X_arr = np.asarray(X_orig) + Z_arr = np.asarray(Z_full) + if X_arr.ndim != 2 or Z_arr.ndim != 2: + raise ValueError("X_orig and Z_full must both be 2D arrays.") + + n = min(X_arr.shape[0], Z_arr.shape[0]) + if n == 0: + return None + X_use = X_arr[:n] + Z_use = Z_arr[:n] + + subset_size = None + if ( + self.diagnostics_subset_max_samples is not None + and n > self.diagnostics_subset_max_samples + ): + subset_size = int(self.diagnostics_subset_max_samples) + + dcor_matrix, median_dcor = compute_latent_independence( + Z_use, subset_size=subset_size + ) + dcor_label = self._qualitative_score( + float(median_dcor), + thresholds=self.latent_independence_thresholds, + lower_is_better=True, + ) + + X_hat = self._decode_from_Z(Z_use) + mmd_score = compute_mmd(X_use, X_hat, subset_size=subset_size) + mmd_label = self._qualitative_score( + float(mmd_score), + thresholds=self.distribution_fidelity_thresholds, + lower_is_better=True, + ) + + self.diagnostics = { + "latent_independence_dcor": dcor_matrix, + "latent_independence_median": float(median_dcor), + "distribution_fidelity_mmd": float(mmd_score), + "latent_independence_label": dcor_label, + "distribution_fidelity_label": mmd_label, + } + + title = report_title if report_title is not None else self.__class__.__name__ + self._log(f"{title} Diagnostics", level="diag") + self._log( + f"Latent independence (median dCor): {median_dcor:.6f} [{dcor_label}] " + "-> lower is better", + level="diag", + ) + self._log( + f"Distribution fidelity (MMD): {mmd_score:.6f} [{mmd_label}] " + "-> lower is better", + level="diag", + ) + return self.diagnostics + + def diagnose( + self, + X_orig: Optional[np.ndarray] = None, + Z_full: Optional[np.ndarray] = None, + report_title: Optional[str] = None, + ) -> dict: + """Public API to compute (or recompute) diagnostics.""" + diagnostics = self._compute_diagnostics( + X_orig=X_orig, + Z_full=Z_full, + report_title=report_title, + ) + if diagnostics is None: + raise ValueError( + "Diagnostics unavailable. Ensure diagnostics are enabled and latent data exists." + ) + return diagnostics def __call__( self, @@ -500,6 +666,7 @@ def __init__( self.L_inv = eigenvecs @ np.diag(eigenvals**-0.5) @ eigenvecs.T self.Z_full = (data - self.mean) @ self.L_inv + self._compute_diagnostics(report_title="OTExplainer") def __call__(self, X: np.ndarray, **kwargs: Any) -> np.ndarray: @@ -575,6 +742,10 @@ def _phi_Z(self, Z: np.ndarray, y_pred: np.ndarray) -> np.ndarray: # Return per-sample UEIFs in latent space (no aggregation here) return ueifs_Z + def _decode_from_Z(self, Z: np.ndarray) -> np.ndarray: + """Decode Z to X using the Gaussian OT linear map.""" + return Z @ self.L + self.mean + class EOTExplainer(Explainer): """ @@ -589,6 +760,7 @@ class EOTExplainer(Explainer): - auto_epsilon: enable median-distance heuristic - stochastic_transport: sample from k(z|x) instead of barycentric map - target: "gaussian" or "empirical" transport target + - decode_method: "auto" (default), "knn", or "linear" latent decoder """ def __init__( self, @@ -611,6 +783,10 @@ def __init__( sampling_method: str = "resample", stochastic_transport: bool = False, n_transport_samples: int = 10, + decode_method: str = "auto", + decode_n_neighbors: int = 25, + decode_weights: Union[str, Callable] = "distance", + decode_leave_one_out: bool = True, random_state: int = 0, **kwargs: Any ): @@ -632,11 +808,18 @@ def __init__( self.sampling_method = sampling_method self.stochastic_transport = stochastic_transport self.n_transport_samples = n_transport_samples + self.decode_method = decode_method + self.decode_n_neighbors = decode_n_neighbors + self.decode_weights = decode_weights + self.decode_leave_one_out = decode_leave_one_out + self.decode_method_effective_ = "linear" self.random_state = random_state self.regularize = kwargs.get("regularize", 1e-6) self.transport_plan_ = None self.Z_target_ = None self.Z_gauss_ = None + self._decode_model = None + self.X_centered_ = None self.detected_types_ = None self.mean = np.mean(data, axis=0, keepdims=True) @@ -650,6 +833,7 @@ def __init__( self.L_inv = eigenvecs @ np.diag(eigenvals**-0.5) @ eigenvecs.T X_centered = data - self.mean + self.X_centered_ = X_centered Z_gauss = X_centered @ self.L_inv self.Z_gauss_ = Z_gauss if self.auto_epsilon: @@ -663,6 +847,10 @@ def __init__( else: raise ValueError(f"Unknown transport_type: {self.transport_type}") + self._build_decoder() + self.Z_full = self.Z_fit_ + self._compute_diagnostics(report_title="EOTExplainer") + def __call__(self, X: np.ndarray, **kwargs: Any) -> np.ndarray: n, d = X.shape Z = (X - self.mean) @ self.L_inv @@ -736,17 +924,29 @@ def compute_y_perm(j: int, rng: np.random.Generator, Z_pool: np.ndarray) -> np.n return ueifs_Z def _auto_epsilon(self, X_centered: np.ndarray) -> float: + """ + Auto-tune epsilon from latent geometry. + + We estimate pairwise distances in Gaussian-whitened latent space and use + a conservative shrinkage factor to avoid over-smoothing transport plans + on multi-modal data. + """ if X_centered.shape[0] < 2: return self.epsilon - n = min(1000, X_centered.shape[0]) + + Z_ref = X_centered @ self.L_inv + n = min(1000, Z_ref.shape[0]) rng = np.random.default_rng(self.random_state) - idx = rng.choice(X_centered.shape[0], size=n, replace=False) - X_sub = X_centered[idx] - dists = pdist(X_sub) - if dists.size == 0: + idx = rng.choice(Z_ref.shape[0], size=n, replace=False) + Z_sub = Z_ref[idx] + + sq_dists = pdist(Z_sub, metric="sqeuclidean") + if sq_dists.size == 0: return self.epsilon - median_dist = np.median(dists) - return (median_dist ** 2) / X_centered.shape[1] + + median_sq_dist = np.median(sq_dists) + eps = 0.25 * (median_sq_dist / Z_ref.shape[1]) + return max(eps, 1e-3) def _make_target(self, Z_gauss: np.ndarray) -> np.ndarray: rng = np.random.default_rng(self.random_state) @@ -818,6 +1018,98 @@ def _sample_transport_pool(self, rng: np.random.Generator) -> np.ndarray: return (1.0 - self.alpha) * self.Z_gauss_ + self.alpha * Z_entropic return Z_entropic + def _build_decoder(self) -> None: + """Build optional nonlinear decoder from latent Z to original X.""" + if self.decode_method == "linear": + self.decode_method_effective_ = "linear" + self._decode_model = None + return + if self.decode_method not in ("knn", "auto"): + raise ValueError( + "decode_method must be 'auto', 'linear', or 'knn'" + ) + try: + from sklearn.neighbors import NearestNeighbors + except ImportError as exc: + raise ImportError( + "decode_method='knn' requires scikit-learn." + ) from exc + + n_neighbors = int(max(1, min(self.decode_n_neighbors, self.Z_fit_.shape[0]))) + self._decode_model = NearestNeighbors(n_neighbors=n_neighbors) + self._decode_model.fit(self.Z_fit_) + + if self.decode_method == "knn": + self.decode_method_effective_ = "knn" + return + + # Auto-select the decoder with lower reconstruction MSE on training pairs. + X_linear = self.Z_fit_ @ self.L + mse_linear = float(np.mean((self.X_centered_ - X_linear) ** 2)) + X_knn = self._predict_knn_centered(self.Z_fit_) + mse_knn = float(np.mean((self.X_centered_ - X_knn) ** 2)) + + if mse_knn < mse_linear: + self.decode_method_effective_ = "knn" + else: + self.decode_method_effective_ = "linear" + self._decode_model = None + + def _predict_knn_centered(self, Z_arr: np.ndarray) -> np.ndarray: + """Predict centered X from Z via the configured kNN decoder.""" + if self._decode_model is None: + raise RuntimeError("kNN decoder is not initialized.") + + n_train = self.Z_fit_.shape[0] + k = int(max(1, min(self.decode_n_neighbors, n_train))) + k_query = min( + n_train, + k + 1 if self.decode_leave_one_out and n_train > 1 else k, + ) + dists, nbr_idx = self._decode_model.kneighbors( + Z_arr, n_neighbors=k_query, return_distance=True + ) + + X_centered_hat = np.zeros((Z_arr.shape[0], self.X_centered_.shape[1])) + for i in range(Z_arr.shape[0]): + row_idx = nbr_idx[i] + row_dist = dists[i] + + if ( + self.decode_leave_one_out + and row_dist.size > 1 + and row_dist[0] <= 1e-12 + ): + row_idx = row_idx[1:] + row_dist = row_dist[1:] + + row_idx = row_idx[:k] + row_dist = row_dist[:k] + X_neighbors = self.X_centered_[row_idx] + + if callable(self.decode_weights): + w = np.asarray(self.decode_weights(row_dist)) + if w.shape != row_dist.shape: + raise ValueError( + "decode_weights callable must return shape (n_neighbors,)." + ) + w = np.maximum(w, 0.0) + if w.sum() <= 0: + w = np.ones_like(row_dist) + w = w / w.sum() + X_centered_hat[i] = w @ X_neighbors + elif self.decode_weights == "uniform": + X_centered_hat[i] = X_neighbors.mean(axis=0) + elif self.decode_weights == "distance": + w = 1.0 / np.maximum(row_dist, 1e-12) + w = w / w.sum() + X_centered_hat[i] = w @ X_neighbors + else: + raise ValueError( + "decode_weights must be 'uniform', 'distance', or a callable." + ) + return X_centered_hat + def _sinkhorn(self, C: np.ndarray) -> np.ndarray: n, m = C.shape a = np.ones(n) / n @@ -840,6 +1132,23 @@ def _sinkhorn(self, C: np.ndarray) -> np.ndarray: row_sums = P.sum(axis=1, keepdims=True) return P / np.maximum(row_sums, 1e-300) + def _decode_from_Z(self, Z: np.ndarray) -> np.ndarray: + """ + Decode Z to X. + + - linear: Gaussian reference map X = ZL + mean + - knn: local nonlinear inverse map fitted on (Z_fit_, X_centered) + """ + Z_arr = np.asarray(Z) + if Z_arr.ndim != 2: + raise ValueError("Z must be a 2D array.") + + if self.decode_method_effective_ == "knn" and self._decode_model is not None: + X_centered_hat = self._predict_knn_centered(Z_arr) + else: + X_centered_hat = Z_arr @ self.L + return X_centered_hat + self.mean + DFIExplainer = OTExplainer @@ -893,6 +1202,16 @@ class FlowExplainer(Explainer): - True or 'all': Show full progress bar - 'final': Only print final step status (default) - False: Silent + compute_diagnostics : bool, default=True + Whether to compute disentanglement diagnostics at setup time. + flow_solver_rtol : float, default=1e-3 + Relative tolerance for default ODE integration in flow encode/decode. + flow_solver_atol : float, default=1e-5 + Absolute tolerance for default ODE integration in flow encode/decode. + diagnostics_solver_rtol : float, default=1e-6 + Relative tolerance for diagnostics round-trip integration. + diagnostics_solver_atol : float, default=1e-8 + Absolute tolerance for diagnostics round-trip integration. **kwargs : dict Additional arguments passed to FlowMatchingModel if creating default. @@ -939,11 +1258,19 @@ def __init__( method: str = "cpi", random_state: Optional[int] = None, verbose: Union[bool, str] = "final", + compute_diagnostics: bool = True, **kwargs: Any ): """Initialize the FlowExplainer.""" # Don't fit flow in base class - super().__init__(model, data, fit_flow=False, **kwargs) + super().__init__( + model, + data, + fit_flow=False, + verbose=verbose, + compute_diagnostics=compute_diagnostics, + **kwargs, + ) self.nsamples = nsamples self.sampling_method = sampling_method @@ -951,6 +1278,15 @@ def __init__( self.method = method.lower() self.verbose = verbose self.kwargs = kwargs + self.flow_solver_method = kwargs.get("flow_solver_method", "dopri5") + self.flow_solver_rtol = kwargs.get("flow_solver_rtol", 1e-3) + self.flow_solver_atol = kwargs.get("flow_solver_atol", 1e-5) + self.diagnostics_solver_method = kwargs.get( + "diagnostics_solver_method", self.flow_solver_method + ) + self.diagnostics_solver_rtol = kwargs.get("diagnostics_solver_rtol", 1e-6) + self.diagnostics_solver_atol = kwargs.get("diagnostics_solver_atol", 1e-8) + self.flow_training_seed = kwargs.get("flow_training_seed", self.random_state) if self.method not in ("cpi", "scpi", "both"): raise ValueError(f"method must be 'cpi', 'scpi', or 'both', got '{method}'") @@ -969,6 +1305,8 @@ def __init__( if flow_model is not None: # Use provided flow model self._encode_background() + if self.Z_full is not None: + self._refresh_flow_diagnostics() elif fit_flow and data is not None: # Create and fit default flow model self.fit_flow(num_steps=kwargs.get("num_steps", 5000), verbose=self.verbose) @@ -1017,6 +1355,13 @@ def fit_flow( raise ImportError( "Flow matching requires torch; install it with: pip install torch torchdiffeq" ) from exc + + import torch + if self.flow_training_seed is not None: + torch.manual_seed(int(self.flow_training_seed)) + if torch.cuda.is_available(): + torch.cuda.manual_seed_all(int(self.flow_training_seed)) + np.random.seed(int(self.flow_training_seed)) d = self.data.shape[1] self.flow_model = FlowMatchingModel( @@ -1030,12 +1375,15 @@ def fit_flow( ) _verbose = verbose if verbose is not None else getattr(self, 'verbose', 'final') - if _verbose is True or _verbose == 'all': - print("Training flow model...") + self.verbose = _verbose + if _verbose is True or _verbose == 'all' or _verbose == 'final': + self._log("Training flow model...", level="info") self.flow_model.fit(num_steps=num_steps, verbose=_verbose, **kwargs) # Encode background data self._encode_background() + if self.Z_full is not None: + self._refresh_flow_diagnostics() return self @@ -1059,6 +1407,8 @@ def set_flow(self, flow_model: Any) -> "FlowExplainer": """ self.flow_model = flow_model self._encode_background() + if self.Z_full is not None: + self._refresh_flow_diagnostics() return self def _encode_background(self) -> None: @@ -1066,29 +1416,91 @@ def _encode_background(self) -> None: if self.data is not None and self.flow_model is not None: self.Z_full = self._encode_to_Z(self.data) - def _encode_to_Z(self, X: np.ndarray) -> np.ndarray: + def _encode_to_Z( + self, + X: np.ndarray, + rtol: Optional[float] = None, + atol: Optional[float] = None, + method: Optional[str] = None, + ) -> np.ndarray: """Transform X to latent space Z.""" if self.flow_model is None: raise ValueError("Flow model not set. Call fit_flow() or set_flow() first.") + _rtol = self.flow_solver_rtol if rtol is None else rtol + _atol = self.flow_solver_atol if atol is None else atol + _method = self.flow_solver_method if method is None else method + import torch with torch.no_grad(): - Z = self.flow_model.sample_batch(X, t_span=(1, 0)) + Z = self.flow_model.sample_batch( + X, + t_span=(1, 0), + rtol=_rtol, + atol=_atol, + method=_method, + ) if isinstance(Z, torch.Tensor): Z = Z.cpu().numpy() return Z - def _decode_to_X(self, Z: np.ndarray) -> np.ndarray: + def _decode_to_X( + self, + Z: np.ndarray, + rtol: Optional[float] = None, + atol: Optional[float] = None, + method: Optional[str] = None, + ) -> np.ndarray: """Transform Z back to X space.""" if self.flow_model is None: raise ValueError("Flow model not set. Call fit_flow() or set_flow() first.") + _rtol = self.flow_solver_rtol if rtol is None else rtol + _atol = self.flow_solver_atol if atol is None else atol + _method = self.flow_solver_method if method is None else method + import torch with torch.no_grad(): - X_hat = self.flow_model.sample_batch(Z, t_span=(0, 1)) + X_hat = self.flow_model.sample_batch( + Z, + t_span=(0, 1), + rtol=_rtol, + atol=_atol, + method=_method, + ) if isinstance(X_hat, torch.Tensor): X_hat = X_hat.cpu().numpy() return X_hat + + def _decode_from_Z(self, Z: np.ndarray) -> np.ndarray: + """ + Decode Z to X for diagnostics using tighter ODE tolerances. + + This keeps reconstruction-fidelity diagnostics focused on model fit + rather than numerical integration error. + """ + return self._decode_to_X( + Z, + rtol=self.diagnostics_solver_rtol, + atol=self.diagnostics_solver_atol, + method=self.diagnostics_solver_method, + ) + + def _refresh_flow_diagnostics(self) -> None: + """Compute diagnostics from high-precision X -> Z -> X round-trip.""" + if self.data is None or self.flow_model is None: + return + Z_diag = self._encode_to_Z( + self.data, + rtol=self.diagnostics_solver_rtol, + atol=self.diagnostics_solver_atol, + method=self.diagnostics_solver_method, + ) + self._compute_diagnostics( + X_orig=self.data, + Z_full=Z_diag, + report_title="Flow Model", + ) def _compute_jacobian(self, Z: np.ndarray, batch_size: int = 50) -> np.ndarray: """ @@ -1131,7 +1543,13 @@ def _compute_jacobian(self, Z: np.ndarray, batch_size: int = 50) -> np.ndarray: def decoder_fn(z_single): """Decode a single Z vector to X.""" z_batch = z_single.unsqueeze(0) # (1, d) - x_batch = self.flow_model.sample_batch(z_batch, t_span=(0, 1)) + x_batch = self.flow_model.sample_batch( + z_batch, + t_span=(0, 1), + rtol=self.flow_solver_rtol, + atol=self.flow_solver_atol, + method=self.flow_solver_method, + ) if not isinstance(x_batch, torch.Tensor): x_batch = torch.tensor(x_batch, dtype=torch.float32, device=device) return x_batch.squeeze(0) # (d,) diff --git a/fdfi/models.py b/fdfi/models.py index d1219dc..3d6b31b 100644 --- a/fdfi/models.py +++ b/fdfi/models.py @@ -188,7 +188,14 @@ def fit(self, X=None, num_steps=20000, batch_size=512, lr=5e-4, show_plot=False, plt.grid(True) plt.show() - def sample_batch(self, x0, t_span=(0, 1)): + def sample_batch( + self, + x0, + t_span=(0, 1), + rtol=1e-3, + atol=1e-5, + method="dopri5", + ): self.model.eval() if isinstance(x0, np.ndarray): @@ -204,7 +211,7 @@ def odefunc(t, x): t_expand = torch.ones(x.size(0), 1, device=self.device) * t return self.model(x, t_expand) - out = odeint(odefunc, x0, t, rtol=1e-3, atol=1e-5, method='dopri5') + out = odeint(odefunc, x0, t, rtol=rtol, atol=atol, method=method) return out[-1] def Jacobi_Batch(self, x_batch, t_span=(0, 1)): @@ -249,4 +256,3 @@ def odefunc_aug(t, y_aug): return J1 - diff --git a/fdfi/utils.py b/fdfi/utils.py index e0601ec..254de52 100644 --- a/fdfi/utils.py +++ b/fdfi/utils.py @@ -378,3 +378,137 @@ def gower_cost_matrix( C += feature_weights[j] * np.abs(X[:, j:j + 1] - Z[:, j:j + 1].T) / feature_ranges[j] return C + + +def compute_latent_independence(Z: np.ndarray, subset_size: Optional[int] = None) -> Tuple[np.ndarray, float]: + """ + Compute pairwise distance correlation (dCor) between latent dimensions. + + Lower off-diagonal values indicate greater independence of latent factors. + + Parameters + ---------- + Z : np.ndarray + Latent representations. Shape (n_samples, n_latent_dims). + subset_size : int, optional + If provided and n_samples > subset_size, randomly subsample for efficiency. + + Returns + ------- + dcor_matrix : np.ndarray + Pairwise distance correlation matrix. Shape (d, d). + median_dcor : float + Median of off-diagonal entries as a single independence score. + """ + if Z.ndim != 2: + raise ValueError(f"Z must be 2D, got shape {Z.shape}") + + n, d = Z.shape + if d == 0: + raise ValueError("Z must have at least one latent dimension") + if d == 1: + return np.ones((1, 1), dtype=float), 0.0 + + if subset_size is not None and n > subset_size: + idx = np.random.choice(n, size=subset_size, replace=False) + Z = Z[idx] + n = subset_size + + # Build centered distance matrices once per latent dimension, then + # compute all pairwise distance covariances in one matrix multiply. + total_entries = d * n * n + storage_dtype = np.float32 if total_entries > 25_000_000 else np.float64 + centered = np.empty((d, n * n), dtype=storage_dtype) + + for j in range(d): + z = np.asarray(Z[:, j], dtype=np.float64) + dist = np.abs(z[:, None] - z[None, :]) + row_mean = dist.mean(axis=1, keepdims=True) + centered_dist = dist - row_mean - row_mean.T + dist.mean() + centered[j] = centered_dist.reshape(-1) + + dcov_sq = (centered @ centered.T).astype(np.float64, copy=False) / (n * n) + dcov_sq = (dcov_sq + dcov_sq.T) * 0.5 # numerical symmetry + + dcov_diag = np.clip(np.diag(dcov_sq), 0.0, None) + denom = np.sqrt(np.outer(dcov_diag, dcov_diag)) + dcor_matrix = np.zeros((d, d), dtype=np.float64) + valid = denom > 0 + dcor_matrix[valid] = np.sqrt(np.clip(dcov_sq[valid], 0.0, None) / denom[valid]) + np.fill_diagonal(dcor_matrix, 1.0) + + mask = ~np.eye(d, dtype=bool) + off_diag_values = dcor_matrix[mask] + median_dcor = float(np.median(off_diag_values)) + + return dcor_matrix, median_dcor + + +def compute_mmd( + X_real: np.ndarray, + X_generated: np.ndarray, + sigma: float = 1.0, + subset_size: Optional[int] = None, +) -> float: + """ + Compute Maximum Mean Discrepancy (MMD) with a Gaussian RBF kernel. + + Measures distributional distance between real and generated data. Lower + values indicate better fidelity. + + Parameters + ---------- + X_real : np.ndarray + Real data. Shape (n_real, n_features). + X_generated : np.ndarray + Generated or reconstructed data. Shape (n_gen, n_features). + sigma : float, default=1.0 + Bandwidth for the Gaussian kernel. + subset_size : int, optional + If provided, subsample each dataset to this size for efficiency. + + Returns + ------- + float + Non-negative MMD score. + """ + if X_real.ndim != 2 or X_generated.ndim != 2: + raise ValueError("Both X_real and X_generated must be 2D arrays") + + if X_real.shape[1] != X_generated.shape[1]: + raise ValueError("Feature dimensions must match") + if sigma <= 0: + raise ValueError("sigma must be positive") + + n_real, n_gen = X_real.shape[0], X_generated.shape[0] + + if subset_size is not None: + if n_real > subset_size: + idx_real = np.random.choice(n_real, size=subset_size, replace=False) + X_real = X_real[idx_real] + if n_gen > subset_size: + idx_gen = np.random.choice(n_gen, size=subset_size, replace=False) + X_generated = X_generated[idx_gen] + + X_real = np.asarray(X_real, dtype=np.float64) + X_generated = np.asarray(X_generated, dtype=np.float64) + + inv_two_sigma_sq = 1.0 / (2.0 * sigma * sigma) + + def kernel_mean(x: np.ndarray, y: np.ndarray) -> float: + x_sq = np.sum(x * x, axis=1, keepdims=True) + y_sq = np.sum(y * y, axis=1, keepdims=True).T + sq_dist = x_sq + y_sq - 2.0 * (x @ y.T) + np.maximum(sq_dist, 0.0, out=sq_dist) + sq_dist *= -inv_two_sigma_sq + np.exp(sq_dist, out=sq_dist) + return float(sq_dist.mean()) + + mmd_sq = ( + kernel_mean(X_real, X_real) + + kernel_mean(X_generated, X_generated) + - 2.0 * kernel_mean(X_real, X_generated) + ) + mmd = float(np.sqrt(np.maximum(mmd_sq, 0.0))) + + return mmd diff --git a/pyproject.toml b/pyproject.toml index 5db5208..56029f2 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta" [project] name = "fdfi" -version = "0.0.1" +version = "0.0.2" description = "Flow-Disentangled Feature Importance" readme = "README.md" authors = [ diff --git a/tests/test_explainers.py b/tests/test_explainers.py index f2f28d7..ebfe2cb 100644 --- a/tests/test_explainers.py +++ b/tests/test_explainers.py @@ -4,6 +4,7 @@ import pytest import numpy as np +import importlib.util from fdfi.explainers import ( Explainer, TreeExplainer, @@ -14,6 +15,8 @@ FlowExplainer, ) +HAS_TORCH = importlib.util.find_spec("torch") is not None + class TestExplainer: """Test the base Explainer class.""" @@ -200,6 +203,30 @@ def test_exp3_mean_variance_consistency(self): ) assert np.all(ci["ci_lower"][:10] > 0) + def test_diagnostics_populated(self): + X_train, _ = generate_exp3_data(n=120, seed=11) + explainer = OTExplainer(exp3_model, X_train, nsamples=5, random_state=0) + + diag = explainer.diagnostics + assert diag is not None + assert "latent_independence_median" in diag + assert "distribution_fidelity_mmd" in diag + assert diag["latent_independence_label"] in {"GOOD", "MODERATE", "POOR"} + assert diag["distribution_fidelity_label"] in {"GOOD", "MODERATE", "POOR"} + + def test_diagnostics_can_be_disabled(self): + X_train, _ = generate_exp3_data(n=80, seed=12) + explainer = OTExplainer( + exp3_model, + X_train, + nsamples=5, + random_state=0, + compute_diagnostics=False, + ) + assert explainer.diagnostics is None + with pytest.raises(ValueError, match="Diagnostics unavailable"): + explainer.diagnose() + class TestEOTExplainer: def test_exp3_mean_variance_consistency(self): @@ -244,12 +271,121 @@ def test_exp3_mean_variance_consistency(self): ) assert np.all(ci["ci_lower"][:10] > 0) + def test_diagnostics_populated(self): + X_train, _ = generate_exp3_data(n=90, seed=13) + explainer = EOTExplainer(exp3_model, X_train, nsamples=5, random_state=0) + + diag = explainer.diagnostics + assert diag is not None + assert "latent_independence_median" in diag + assert "distribution_fidelity_mmd" in diag + assert diag["latent_independence_label"] in {"GOOD", "MODERATE", "POOR"} + assert diag["distribution_fidelity_label"] in {"GOOD", "MODERATE", "POOR"} + + def test_auto_epsilon_handles_bimodal_data(self): + rng = np.random.default_rng(21) + n, d = 200, 5 + X_train = np.vstack( + [ + rng.standard_normal((n // 2, d)) - 2.0, + rng.standard_normal((n // 2, d)) + 2.0, + ] + ) + rng.shuffle(X_train) + + def bimodal_model(X): + return X[:, 0] ** 2 + 0.5 * X[:, 1] + + explainer = EOTExplainer( + bimodal_model, + X_train, + nsamples=10, + auto_epsilon=True, + random_state=0, + ) + + assert explainer.epsilon < 2.0 + assert explainer.diagnostics["latent_independence_median"] < 0.25 + assert explainer.diagnostics["distribution_fidelity_mmd"] < 0.25 + + def test_decode_method_validation(self): + X_train, _ = generate_exp3_data(n=80, seed=31) + with pytest.raises(ValueError, match="decode_method"): + EOTExplainer( + exp3_model, + X_train, + decode_method="unknown", + ) + + def test_auto_decoder_matches_best_reconstruction_mse(self): + rng = np.random.default_rng(22) + n, d = 200, 5 + X_train = np.vstack( + [ + rng.standard_normal((n // 2, d)) - 2.0, + rng.standard_normal((n // 2, d)) + 2.0, + ] + ) + rng.shuffle(X_train) + + def bimodal_model(X): + return X[:, 0] ** 2 + 0.5 * X[:, 1] + + linear_exp = EOTExplainer( + bimodal_model, + X_train, + nsamples=10, + auto_epsilon=False, + epsilon=0.2, + target="empirical", + decode_method="linear", + random_state=0, + ) + knn_exp = EOTExplainer( + bimodal_model, + X_train, + nsamples=10, + auto_epsilon=False, + epsilon=0.2, + target="empirical", + decode_method="knn", + random_state=0, + ) + auto_exp = EOTExplainer( + bimodal_model, + X_train, + nsamples=10, + auto_epsilon=False, + epsilon=0.2, + target="empirical", + decode_method="auto", + random_state=0, + ) + + x_lin = linear_exp._decode_from_Z(linear_exp.Z_full) + x_knn = knn_exp._decode_from_Z(knn_exp.Z_full) + mse_linear = float(np.mean((x_lin - X_train) ** 2)) + mse_knn = float(np.mean((x_knn - X_train) ** 2)) + best = "knn" if mse_knn < mse_linear else "linear" + assert auto_exp.decode_method_effective_ == best + + def test_auto_decoder_selects_valid_method(self): + X_train, _ = generate_exp3_data(n=120, seed=33) + explainer = EOTExplainer( + exp3_model, + X_train, + decode_method="auto", + random_state=0, + ) + assert explainer.decode_method_effective_ in {"linear", "knn"} + def simple_linear_model(X): """Simple linear model: y = x0 + 2*x1""" return X[:, 0] + 2 * X[:, 1] +@pytest.mark.skipif(not HAS_TORCH, reason="FlowExplainer tests require torch") class TestFlowExplainer: """Test the FlowExplainer class.""" @@ -498,6 +634,7 @@ def test_reproducibility(self): assert corr > 0.5, f"Rank correlation should be positive: {corr}" +@pytest.mark.skipif(not HAS_TORCH, reason="FlowExplainer tests require torch") class TestFlowVsOTExplainer: """Integration tests comparing FlowExplainer and OTExplainer.""" diff --git a/tests/test_utils.py b/tests/test_utils.py index 3c5f458..db53e1d 100644 --- a/tests/test_utils.py +++ b/tests/test_utils.py @@ -9,8 +9,11 @@ sample_background, get_feature_names, convert_to_link, - check_additivity + check_additivity, + compute_latent_independence, + compute_mmd, ) +from fdfi.explainers import FlowExplainer class TestValidateInput: @@ -145,3 +148,71 @@ def test_additivity_violation(self): satisfies, max_diff = check_additivity(shap_values, predictions, base_value, tol=1e-3) assert not satisfies assert max_diff > 1e-3 + + +class TestComputeLatentIndependence: + """Tests for compute_latent_independence.""" + + def test_independent_dims_have_low_dcor(self): + rng = np.random.default_rng(0) + Z = rng.standard_normal((200, 3)) + _, median_dcor = compute_latent_independence(Z) + assert median_dcor < 0.2 + + def test_correlated_dims_have_higher_dcor(self): + rng = np.random.default_rng(1) + z1 = rng.standard_normal(200) + z2 = z1 + rng.normal(0, 0.05, 200) + z3 = rng.standard_normal(200) + Z = np.vstack([z1, z2, z3]).T + _, median_dcor = compute_latent_independence(Z) + assert median_dcor > 0.1 + + +class TestComputeMMD: + """Tests for compute_mmd.""" + + def test_identical_sets_have_near_zero_mmd(self): + rng = np.random.default_rng(0) + X = rng.standard_normal((100, 4)) + mmd = compute_mmd(X, X.copy()) + assert mmd < 1e-6 + + def test_shifted_sets_increase_mmd(self): + rng = np.random.default_rng(1) + X_real = rng.standard_normal((200, 4)) + X_gen = X_real + 2.0 # clear shift + mmd = compute_mmd(X_real, X_gen) + assert mmd > 0.3 + + +class TestFlowExplainerDiagnostics: + """Tests for FlowExplainer diagnostics without requiring torch.""" + + def test_diagnostics_populated_and_labeled(self): + rng = np.random.default_rng(0) + X = rng.standard_normal((50, 3)) + + # Simple linear model + def model(x): + return x.sum(axis=1) + + explainer = FlowExplainer( + model=model, + data=X, + flow_model=None, + fit_flow=False, + verbose=False, + nsamples=5, + ) + + # Bypass flow decode with identity to avoid torch dependency + explainer._decode_to_X = lambda Z, **kwargs: Z + explainer.Z_full = X + explainer._compute_diagnostics(X_orig=X, Z_full=X, report_title="Flow Model") + + diag = explainer.diagnostics + assert "latent_independence_median" in diag + assert "distribution_fidelity_mmd" in diag + assert diag["latent_independence_label"] in {"GOOD", "MODERATE", "POOR"} + assert diag["distribution_fidelity_label"] in {"GOOD", "MODERATE", "POOR"} From 324fccfc31942b6077c24aa7e10727ac52d48343 Mon Sep 17 00:00:00 2001 From: jaydu1 <413075930@qq.com> Date: Wed, 18 Feb 2026 09:11:10 +0800 Subject: [PATCH 2/2] Update test_init.py --- tests/test_init.py | 15 ++++++++++++++- 1 file changed, 14 insertions(+), 1 deletion(-) diff --git a/tests/test_init.py b/tests/test_init.py index a46378b..18d1097 100644 --- a/tests/test_init.py +++ b/tests/test_init.py @@ -2,14 +2,27 @@ Tests for FDFI package initialization. """ +import re +from pathlib import Path + import fdfi +def _version_from_pyproject() -> str: + """Read package version from pyproject.toml.""" + pyproject_path = Path(__file__).resolve().parents[1] / "pyproject.toml" + content = pyproject_path.read_text(encoding="utf-8") + match = re.search(r'^version\s*=\s*"([^"]+)"\s*$', content, flags=re.MULTILINE) + if not match: + raise AssertionError("Could not parse version from pyproject.toml") + return match.group(1) + + def test_version(): """Test that version is defined.""" assert hasattr(fdfi, "__version__") assert isinstance(fdfi.__version__, str) - assert fdfi.__version__ == "0.0.1" + assert fdfi.__version__ == _version_from_pyproject() def test_package_imports():