diff --git a/MyIA.AI.Notebooks/Probas/DecisionTheory/Causal-Bridges/DoWhy-4-Sensibilite-Confounder-Cache.ipynb b/MyIA.AI.Notebooks/Probas/DecisionTheory/Causal-Bridges/DoWhy-4-Sensibilite-Confounder-Cache.ipynb
new file mode 100644
index 0000000000..9995bf8d34
--- /dev/null
+++ b/MyIA.AI.Notebooks/Probas/DecisionTheory/Causal-Bridges/DoWhy-4-Sensibilite-Confounder-Cache.ipynb
@@ -0,0 +1,1504 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "624e14af",
+ "metadata": {
+ "papermill": {
+ "duration": 0.002558,
+ "end_time": "2026-09-13T02:06:54.296487+00:00",
+ "exception": false,
+ "start_time": "2026-09-13T02:06:54.293929+00:00",
+ "status": "completed"
+ },
+ "tags": []
+ },
+ "source": [
+ "# DoWhy-4 — Le confondeur non observé : sensibilité, pas certitude\n",
+ "\n",
+ "DoWhy-1 exigeait un estimand **nommé** ; DoWhy-3 découvrait le graphe avec sa\n",
+ "borne structurelle (le CPDAG ambigu). Il reste l'hypothèse qu'aucun graphe\n",
+ "observé ne peut trancher : **l'absence de confondeur NON OBSERVÉ**. On ne\n",
+ "peut ni la tester, ni la découvrir — on peut la **chiffrer**.\n",
+ "\n",
+ "L'énoncé cible de ce notebook (issue #14049) :\n",
+ "\n",
+ "> « Quelle force devrait avoir un confondeur caché pour annuler cet effet ? »\n",
+ "\n",
+ "— **un chiffre, pas une réserve rhétorique**. Trois formalisations SOTA de la\n",
+ "même question, toutes réellement exécutées par `dowhy` (0.14) :\n",
+ "\n",
+ "| Formalisation | Moteur | Monde | Le chiffre |\n",
+ "|---|---|---|---|\n",
+ "| Robustness value (R² partiel) | `refute_estimate` → `linear-partial-R2` | continu | le R² partiel minimal qui annule |\n",
+ "| E-value (Ding & VanderWeele) | `refute_estimate` → `e-value` | binaire (RR) | le RR minimal qui annule |\n",
+ "| Bornes de Rosenbaum (Γ) | calcul exact binomial sur paires | binaire apparié | le Γ* qui rend non significatif |\n",
+ "\n",
+ "Et le pont concret : `direct-simulation` — un confondeur simulé de force\n",
+ "croissante, et la **courbe de bascule** de l'estimé ajusté."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "975783c6",
+ "metadata": {
+ "execution": {
+ "iopub.execute_input": "2026-09-13T02:06:54.311117Z",
+ "iopub.status.busy": "2026-09-13T02:06:54.310844Z",
+ "iopub.status.idle": "2026-09-13T02:06:56.429330Z",
+ "shell.execute_reply": "2026-09-13T02:06:56.428796Z"
+ },
+ "papermill": {
+ "duration": 2.122835,
+ "end_time": "2026-09-13T02:06:56.429704+00:00",
+ "exception": false,
+ "start_time": "2026-09-13T02:06:54.306869+00:00",
+ "status": "completed"
+ },
+ "tags": []
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "organe : Causal-Bridges\n"
+ ]
+ }
+ ],
+ "source": [
+ "from pathlib import Path\n",
+ "import sys\n",
+ "\n",
+ "import numpy as np\n",
+ "import pandas as pd\n",
+ "\n",
+ "_fichier_organe = next(Path.cwd().rglob(\"dowhy_sensitivity_organs.py\"))\n",
+ "sys.path.insert(0, str(_fichier_organe.parent))\n",
+ "import dowhy_sensitivity_organs as dso\n",
+ "\n",
+ "pd.set_option(\"display.precision\", 3)\n",
+ "print(\"organe :\", _fichier_organe.parent.name)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a671d79a",
+ "metadata": {
+ "papermill": {
+ "duration": 0.003449,
+ "end_time": "2026-09-13T02:06:56.435974+00:00",
+ "exception": false,
+ "start_time": "2026-09-13T02:06:56.432525+00:00",
+ "status": "completed"
+ },
+ "tags": []
+ },
+ "source": [
+ "## 1. Le monde A — l'analyste et son angle mort\n",
+ "\n",
+ "Un traitement continu $X$, une issue continue $Y$, un confondeur **observé**\n",
+ "$C$ — et un confondeur **caché** $U$ que l'analyste ne mesure pas :\n",
+ "\n",
+ "$$X = 0.7\\,U + 0.5\\,C + \\varepsilon_X \\qquad Y = 0.5\\,X + 0.9\\,U + 0.4\\,C + \\varepsilon_Y$$\n",
+ "\n",
+ "L'effet vrai vaut $\\tau = 0.5$. L'analyste ajuste sur $\\{C\\}$ — le mieux\n",
+ "qu'il puisse faire avec ses données. Le générateur expose deux vues : la vue\n",
+ "**analyste** (`X, Y, C`) et la vue **oracle** (avec `U`), qui servira de\n",
+ "vérité terrain."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "45ca444b",
+ "metadata": {
+ "execution": {
+ "iopub.execute_input": "2026-09-13T02:06:56.443659Z",
+ "iopub.status.busy": "2026-09-13T02:06:56.443012Z",
+ "iopub.status.idle": "2026-09-13T02:06:56.473674Z",
+ "shell.execute_reply": "2026-09-13T02:06:56.472837Z"
+ },
+ "papermill": {
+ "duration": 0.034203,
+ "end_time": "2026-09-13T02:06:56.473286+00:00",
+ "exception": false,
+ "start_time": "2026-09-13T02:06:56.439083+00:00",
+ "status": "completed"
+ },
+ "tags": []
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "vue analyste : ['X', 'Y', 'C']\n"
+ ]
+ },
+ {
+ "data": {
+ "text/html": [
+ "
\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " | \n",
+ " X | \n",
+ " Y | \n",
+ " C | \n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ " | 0 | \n",
+ " -0.594 | \n",
+ " -0.900 | \n",
+ " -0.675 | \n",
+ "
\n",
+ " \n",
+ " | 1 | \n",
+ " -0.191 | \n",
+ " -0.719 | \n",
+ " -0.145 | \n",
+ "
\n",
+ " \n",
+ " | 2 | \n",
+ " 0.070 | \n",
+ " -0.359 | \n",
+ " -0.792 | \n",
+ "
\n",
+ " \n",
+ " | 3 | \n",
+ " 1.243 | \n",
+ " 1.485 | \n",
+ " -0.308 | \n",
+ "
\n",
+ " \n",
+ " | 4 | \n",
+ " -2.068 | \n",
+ " -2.152 | \n",
+ " -1.894 | \n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
"
+ ],
+ "text/plain": [
+ " X Y C\n",
+ "0 -0.594 -0.900 -0.675\n",
+ "1 -0.191 -0.719 -0.145\n",
+ "2 0.070 -0.359 -0.792\n",
+ "3 1.243 1.485 -0.308\n",
+ "4 -2.068 -2.152 -1.894"
+ ]
+ },
+ "execution_count": 2,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "df_monde = dso.generer_donnees_continues(n=2000, seed=42)\n",
+ "df_oracle = dso.generer_donnees_continues(n=2000, seed=42, cacher_u=False)\n",
+ "\n",
+ "print(\"vue analyste :\", list(df_monde.columns))\n",
+ "df_monde.head()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "fb05fe80",
+ "metadata": {
+ "papermill": {
+ "duration": 0.003314,
+ "end_time": "2026-09-13T02:06:56.479935+00:00",
+ "exception": false,
+ "start_time": "2026-09-13T02:06:56.476621+00:00",
+ "status": "completed"
+ },
+ "tags": []
+ },
+ "source": [
+ "### L'estimé naïf\n",
+ "\n",
+ "`dowhy` identifie l'ajustement backdoor $\\{C\\}$ et estime par régression\n",
+ "linéaire. C'est l'estimé que publierait l'étude : significatif, propre,\n",
+ "bref — et biaisé par $U$."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "5745acba",
+ "metadata": {
+ "execution": {
+ "iopub.execute_input": "2026-09-13T02:06:56.485992Z",
+ "iopub.status.busy": "2026-09-13T02:06:56.485795Z",
+ "iopub.status.idle": "2026-09-13T02:07:08.553875Z",
+ "shell.execute_reply": "2026-09-13T02:07:08.553273Z"
+ },
+ "papermill": {
+ "duration": 12.072317,
+ "end_time": "2026-09-13T02:07:08.553860+00:00",
+ "exception": false,
+ "start_time": "2026-09-13T02:06:56.481543+00:00",
+ "status": "completed"
+ },
+ "tags": []
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "estime naive (ajustement C) = 1.159\n",
+ "IC 95 % = [1.116, 1.202]\n",
+ "effet vrai (simulateur) = 0.5\n"
+ ]
+ }
+ ],
+ "source": [
+ "res_naif = dso.estimer_effet_continu(df_monde)\n",
+ "print(f\"estime naive (ajustement C) = {res_naif.value:.3f}\")\n",
+ "print(f\"IC 95 % = [{res_naif.ic[0]:.3f}, {res_naif.ic[1]:.3f}]\")\n",
+ "print(f\"effet vrai (simulateur) = {dso.TAU_VRAI}\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "dde019c0",
+ "metadata": {
+ "papermill": {
+ "duration": 0.002845,
+ "end_time": "2026-09-13T02:07:08.560040+00:00",
+ "exception": false,
+ "start_time": "2026-09-13T02:07:08.557195+00:00",
+ "status": "completed"
+ },
+ "tags": []
+ },
+ "source": [
+ "### L'oracle — ce que l'analyste ne peut PAS faire\n",
+ "\n",
+ "Par construction du monde, ajuster sur $\\{C, U\\}$ restaure l'effet vrai.\n",
+ "L'écart entre naïf et oracle mesure le travail que $U$ fait en silence."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "82e9cdbc",
+ "metadata": {
+ "execution": {
+ "iopub.execute_input": "2026-09-13T02:07:08.567543Z",
+ "iopub.status.busy": "2026-09-13T02:07:08.567035Z",
+ "iopub.status.idle": "2026-09-13T02:07:08.583050Z",
+ "shell.execute_reply": "2026-09-13T02:07:08.582596Z"
+ },
+ "papermill": {
+ "duration": 0.021815,
+ "end_time": "2026-09-13T02:07:08.583655+00:00",
+ "exception": false,
+ "start_time": "2026-09-13T02:07:08.561840+00:00",
+ "status": "completed"
+ },
+ "tags": []
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "oracle (ajustement C+U) = 0.532 (effet vrai 0.5)\n",
+ "biais du a U = +0.627\n"
+ ]
+ }
+ ],
+ "source": [
+ "from dowhy import CausalModel\n",
+ "\n",
+ "modele_oracle = CausalModel(data=df_oracle, treatment=\"X\", outcome=\"Y\", common_causes=[\"C\", \"U\"])\n",
+ "estimand_oracle = modele_oracle.identify_effect(proceed_when_unidentifiable=True)\n",
+ "estime_oracle = modele_oracle.estimate_effect(estimand_oracle, method_name=\"backdoor.linear_regression\")\n",
+ "print(f\"oracle (ajustement C+U) = {estime_oracle.value:.3f} (effet vrai {dso.TAU_VRAI})\")\n",
+ "print(f\"biais du a U = {res_naif.value - estime_oracle.value:+.3f}\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "7524011c",
+ "metadata": {
+ "papermill": {
+ "duration": 0.002574,
+ "end_time": "2026-09-13T02:07:08.589422+00:00",
+ "exception": false,
+ "start_time": "2026-09-13T02:07:08.586848+00:00",
+ "status": "completed"
+ },
+ "tags": []
+ },
+ "source": [
+ "## 2. La robustness value — le R² partiel qui annule\n",
+ "\n",
+ "Question : *quelle force un confondeur caché devrait-il avoir pour annuler\n",
+ "cet effet ?* Cinelli & Hazlett (2020) y répondent par la **robustness\n",
+ "value** : le $R^2$ partiel minimal qu'un confondeur devrait avoir **avec le\n",
+ "traitement ET avec l'issue** (après ajustement de $\\{C\\}$, à force égale\n",
+ "des deux côtés) pour ramener l'estimé à zéro. `dowhy` la calcule via le\n",
+ "refuter `add_unobserved_common_cause` en mode `linear-partial-R2`.\n",
+ "\n",
+ "- `robustness_value` : annuler l'estimé (le ramener à 0) ;\n",
+ "- `robustness_value_alpha` : le rendre statistiquement non significatif."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "fc69d326",
+ "metadata": {
+ "execution": {
+ "iopub.execute_input": "2026-09-13T02:07:08.597052Z",
+ "iopub.status.busy": "2026-09-13T02:07:08.596671Z",
+ "iopub.status.idle": "2026-09-13T02:07:08.608871Z",
+ "shell.execute_reply": "2026-09-13T02:07:08.608436Z"
+ },
+ "papermill": {
+ "duration": 0.016909,
+ "end_time": "2026-09-13T02:07:08.609559+00:00",
+ "exception": false,
+ "start_time": "2026-09-13T02:07:08.592650+00:00",
+ "status": "completed"
+ },
+ "tags": []
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "robustness value (annuler) = 0.677\n",
+ "robustness value (non significatif) = 0.665\n",
+ "R2 partiel de X avec Y | C = 0.587\n"
+ ]
+ }
+ ],
+ "source": [
+ "rob = dso.robustesse_partielle_r2(res_naif.model, res_naif.estimand, res_naif.estimate)\n",
+ "print(f\"robustness value (annuler) = {rob.robustness_value:.3f}\")\n",
+ "print(f\"robustness value (non significatif) = {rob.robustness_value_alpha:.3f}\")\n",
+ "print(f\"R2 partiel de X avec Y | C = {rob.r2yt_w:.3f}\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "80be1c0b",
+ "metadata": {
+ "papermill": {
+ "duration": 0.002949,
+ "end_time": "2026-09-13T02:07:08.615223+00:00",
+ "exception": false,
+ "start_time": "2026-09-13T02:07:08.612274+00:00",
+ "status": "completed"
+ },
+ "tags": []
+ },
+ "source": [
+ "### La vérité terrain : le R² partiel **réel** de U\n",
+ "\n",
+ "Le RV est un seuil ; il ne dit rien des confondeurs qui existent. Mais notre\n",
+ "monde est simulé : sur la vue oracle, on **mesure** le $R^2$ partiel réel de\n",
+ "$U$ — avec $X$ (après $C$) et avec $Y$ (après $X, C$) — et on le compare au\n",
+ "seuil. C'est le geste que le praticien remplace par sa connaissance du\n",
+ "domaine : « un cache aussi fort que *tel* facteur connu »."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "6d95bba5",
+ "metadata": {
+ "execution": {
+ "iopub.execute_input": "2026-09-13T02:07:08.622286Z",
+ "iopub.status.busy": "2026-09-13T02:07:08.621973Z",
+ "iopub.status.idle": "2026-09-13T02:07:08.634324Z",
+ "shell.execute_reply": "2026-09-13T02:07:08.633496Z"
+ },
+ "papermill": {
+ "duration": 0.018269,
+ "end_time": "2026-09-13T02:07:08.635601+00:00",
+ "exception": false,
+ "start_time": "2026-09-13T02:07:08.617332+00:00",
+ "status": "completed"
+ },
+ "tags": []
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "R2 partiel reel de U avec X | C = 0.493\n",
+ "R2 partiel reel de U avec Y | X,C = 0.427\n",
+ "robustness value = 0.677\n",
+ "\n",
+ "verdict : SURVIT_A_CE_CONFOUNDEUR\n",
+ "RESULTAT : l'association survit a ce confondeur -- meme a force egale des deux cotes au niveau de son cote le plus fort (0.49 < RV 0.68), le cache n'annule pas l'estime. ATTENTION : survivre a l'annulation n'est pas etre juste -- l'estime reste biaisé tant que le confondeur n'est pas mesure.\n"
+ ]
+ }
+ ],
+ "source": [
+ "r2_u_x = dso.r2_partiel(df_oracle, \"X\", \"U\", [\"C\"])\n",
+ "r2_u_y = dso.r2_partiel(df_oracle, \"Y\", \"U\", [\"X\", \"C\"])\n",
+ "print(f\"R2 partiel reel de U avec X | C = {r2_u_x:.3f}\")\n",
+ "print(f\"R2 partiel reel de U avec Y | X,C = {r2_u_y:.3f}\")\n",
+ "print(f\"robustness value = {rob.robustness_value:.3f}\")\n",
+ "\n",
+ "verdict_a = dso.verdict_sensibilite(r2_u_x, r2_u_y, rob)\n",
+ "print(f\"\\nverdict : {verdict_a['verdict']}\")\n",
+ "print(verdict_a['message'])"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a88b77a4",
+ "metadata": {
+ "papermill": {
+ "duration": 0.003107,
+ "end_time": "2026-09-13T02:07:08.640836+00:00",
+ "exception": false,
+ "start_time": "2026-09-13T02:07:08.637729+00:00",
+ "status": "completed"
+ },
+ "tags": []
+ },
+ "source": [
+ "### Survivre n'est pas être juste\n",
+ "\n",
+ "Le verdict dit que l'association **survit** à un confondeur de la force de\n",
+ "$U$ : même à force égale des deux côtés au niveau de son côté le plus fort\n",
+ "(0.49 < 0.68), le cache n'annule pas l'estimé. Mais le tableau des trois\n",
+ "nombres raconte l'histoire complète :\n",
+ "\n",
+ "| quantité | valeur | rôle |\n",
+ "|---|---|---|\n",
+ "| estimé naïf | 1.159 | ce que l'étude publie |\n",
+ "| oracle $\\{C, U\\}$ | 0.532 | l'effet vrai du simulateur |\n",
+ "| robustness value | 0.677 | la force qui annulerait |\n",
+ "| $R^2$ réel de $U$ | 0.49 / 0.43 | la force du cache **réel** |\n",
+ "\n",
+ "$U$ réduit l'estimé de moitié sans pouvoir l'annuler : **la sensibilité\n",
+ "chiffre l'attaque, elle ne certifie pas l'estimé**."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "39e773fc",
+ "metadata": {
+ "execution": {
+ "iopub.execute_input": "2026-09-13T02:07:08.649454Z",
+ "iopub.status.busy": "2026-09-13T02:07:08.648995Z",
+ "iopub.status.idle": "2026-09-13T02:07:08.656718Z",
+ "shell.execute_reply": "2026-09-13T02:07:08.656251Z"
+ },
+ "papermill": {
+ "duration": 0.012106,
+ "end_time": "2026-09-13T02:07:08.656176+00:00",
+ "exception": false,
+ "start_time": "2026-09-13T02:07:08.644070+00:00",
+ "status": "completed"
+ },
+ "tags": []
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " | \n",
+ " quantite | \n",
+ " valeur | \n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ " | 0 | \n",
+ " estime naif (ajuste C) | \n",
+ " 1.159 | \n",
+ "
\n",
+ " \n",
+ " | 1 | \n",
+ " oracle (ajuste C+U) | \n",
+ " 0.532 | \n",
+ "
\n",
+ " \n",
+ " | 2 | \n",
+ " effet vrai | \n",
+ " 0.500 | \n",
+ "
\n",
+ " \n",
+ " | 3 | \n",
+ " robustness value | \n",
+ " 0.677 | \n",
+ "
\n",
+ " \n",
+ " | 4 | \n",
+ " R2 reel U avec X | \n",
+ " 0.493 | \n",
+ "
\n",
+ " \n",
+ " | 5 | \n",
+ " R2 reel U avec Y | \n",
+ " 0.427 | \n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
"
+ ],
+ "text/plain": [
+ " quantite valeur\n",
+ "0 estime naif (ajuste C) 1.159\n",
+ "1 oracle (ajuste C+U) 0.532\n",
+ "2 effet vrai 0.500\n",
+ "3 robustness value 0.677\n",
+ "4 R2 reel U avec X 0.493\n",
+ "5 R2 reel U avec Y 0.427"
+ ]
+ },
+ "execution_count": 7,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "synthese_a = pd.DataFrame({\n",
+ " \"quantite\": [\"estime naif (ajuste C)\", \"oracle (ajuste C+U)\", \"effet vrai\",\n",
+ " \"robustness value\", \"R2 reel U avec X\", \"R2 reel U avec Y\"],\n",
+ " \"valeur\": [res_naif.value, estime_oracle.value, dso.TAU_VRAI,\n",
+ " rob.robustness_value, r2_u_x, r2_u_y],\n",
+ "})\n",
+ "synthese_a"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "75bace71",
+ "metadata": {
+ "papermill": {
+ "duration": 0.004746,
+ "end_time": "2026-09-13T02:07:08.664474+00:00",
+ "exception": false,
+ "start_time": "2026-09-13T02:07:08.659728+00:00",
+ "status": "completed"
+ },
+ "tags": []
+ },
+ "source": [
+ "## 3. Le confondeur simulé — voir la bascule\n",
+ "\n",
+ "Le refuter `direct-simulation` rend le mécanisme concret : on injecte dans\n",
+ "les données un confondeur gaussien $U^*$ de coefficient $\\kappa_t$ sur $X$\n",
+ "et $\\kappa_y$ sur $Y$, puis on ré-estime l'effet backdoor **avec $U^*$ dans\n",
+ "l'ensemble d'ajustement**. Quand $\\kappa_y$ croît, l'estimé ajusté descend —\n",
+ "la **courbe de bascule**. Le point de franchissement de zéro est le chiffre\n",
+ "cherché, en unités du monde (coefficients de régression).\n",
+ "\n",
+ "D'abord à $\\kappa_t = 0.7$ fixé (la force réelle de $U$ sur $X$) :"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "73dffbd7",
+ "metadata": {
+ "execution": {
+ "iopub.execute_input": "2026-09-13T02:07:08.672270Z",
+ "iopub.status.busy": "2026-09-13T02:07:08.671792Z",
+ "iopub.status.idle": "2026-09-13T02:07:08.810654Z",
+ "shell.execute_reply": "2026-09-13T02:07:08.810119Z"
+ },
+ "papermill": {
+ "duration": 0.143589,
+ "end_time": "2026-09-13T02:07:08.811114+00:00",
+ "exception": false,
+ "start_time": "2026-09-13T02:07:08.667525+00:00",
+ "status": "completed"
+ },
+ "tags": []
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ " k kappa_t estime_ajuste\n",
+ "0.0 0.7 0.755\n",
+ "0.2 0.7 0.674\n",
+ "0.4 0.7 0.562\n",
+ "0.6 0.7 0.482\n",
+ "0.8 0.7 0.391\n",
+ "1.0 0.7 0.265\n",
+ "1.2 0.7 0.212\n",
+ "1.4 0.7 0.093\n",
+ "1.6 0.7 -0.034\n",
+ "1.8 0.7 -0.043"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "\n",
+ "\n",
+ "kappa de bascule (kappa_t=0.7) = 1.55\n"
+ ]
+ }
+ ],
+ "source": [
+ "bascule_kt = dso.confondeur_simule(res_naif.model, res_naif.estimand, res_naif.estimate,\n",
+ " k_fixe=0.7, k_max=1.8, pas=0.2)\n",
+ "print(bascule_kt.to_string(index=False))\n",
+ "kappa_kt = dso.kappa_bascule(bascule_kt)\n",
+ "print(f\"\\nkappa de bascule (kappa_t=0.7) = {kappa_kt:.2f}\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "id": "81dcee46",
+ "metadata": {
+ "execution": {
+ "iopub.execute_input": "2026-09-13T02:07:08.819087Z",
+ "iopub.status.busy": "2026-09-13T02:07:08.818849Z",
+ "iopub.status.idle": "2026-09-13T02:07:09.318651Z",
+ "shell.execute_reply": "2026-09-13T02:07:09.317531Z"
+ },
+ "papermill": {
+ "duration": 0.506043,
+ "end_time": "2026-09-13T02:07:09.319974+00:00",
+ "exception": false,
+ "start_time": "2026-09-13T02:07:08.813931+00:00",
+ "status": "completed"
+ },
+ "tags": []
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "%matplotlib inline\n",
+ "import matplotlib.pyplot as plt\n",
+ "\n",
+ "bascule_diag = dso.confondeur_simule(res_naif.model, res_naif.estimand, res_naif.estimate,\n",
+ " k_max=1.4, pas=0.1, diagonale=True)\n",
+ "kappa_diag = dso.kappa_bascule(bascule_diag)\n",
+ "\n",
+ "fig, ax = plt.subplots(figsize=(7, 4))\n",
+ "ax.plot(bascule_diag[\"k\"], bascule_diag[\"estime_ajuste\"], \"o-\", label=\"estime ajuste\")\n",
+ "ax.axhline(0.0, color=\"gray\", lw=1)\n",
+ "ax.axhline(estime_oracle.value, color=\"green\", ls=\"--\", lw=1, label=f\"oracle C+U ({estime_oracle.value:.2f})\")\n",
+ "if kappa_diag is not None:\n",
+ " ax.axvline(kappa_diag, color=\"red\", ls=\":\", label=f\"kappa* diag = {kappa_diag:.2f}\")\n",
+ "ax.set_xlabel(\"force du confondeur simule (k des deux cotes)\")\n",
+ "ax.set_ylabel(\"estime backdoor ajuste\")\n",
+ "ax.set_title(\"Courbe de bascule : le confondeur simule annule l'effet\")\n",
+ "ax.legend()\n",
+ "plt.tight_layout()\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "eef4e621",
+ "metadata": {
+ "papermill": {
+ "duration": 0.00357,
+ "end_time": "2026-09-13T02:07:09.327151+00:00",
+ "exception": false,
+ "start_time": "2026-09-13T02:07:09.323581+00:00",
+ "status": "completed"
+ },
+ "tags": []
+ },
+ "source": [
+ "**Le rapport de forces.** À force égale des deux côtés, il faut\n",
+ "$\\kappa \\approx 1.1$ pour annuler l'association — deux fois la force réelle\n",
+ "de $U$ sur $X$ (0.7). Un résultat contre-intuitif mérite d'être mesuré :\n",
+ "**renforcer $U$ ne rend PAS l'association plus fragile**. Si $U$ est plus\n",
+ "fort, l'association observée grossit *avec* lui, et la robustness value\n",
+ "monte (mesuré : $U$ à 1.8/1.8 → RV 0.89 ; à 2.6/2.6 → RV 0.94). Le RV\n",
+ "mesure un *rapport* de forces, pas une constante — c'est l'objet de\n",
+ "l'exercice 1."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "08591fca",
+ "metadata": {
+ "papermill": {
+ "duration": 0.003659,
+ "end_time": "2026-09-13T02:07:09.334096+00:00",
+ "exception": false,
+ "start_time": "2026-09-13T02:07:09.330437+00:00",
+ "status": "completed"
+ },
+ "tags": []
+ },
+ "source": [
+ "## 4. Le monde B — risques relatifs et E-value\n",
+ "\n",
+ "Le monde continu parlait en $R^2$ ; l'épidémiologie parle en **risques\n",
+ "relatifs**. Nouveau monde : $X$ binaire (exposé/non exposé), $Y$ binaire et\n",
+ "**rare** (~7 %), risques multiplicatifs (lien log) — le RR conditionnel vrai\n",
+ "vaut $e^{0.4} \\approx 1.49$, et le GLM de Poisson à lien log de `dowhy` est\n",
+ "bien spécifié."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "id": "20c44ba5",
+ "metadata": {
+ "execution": {
+ "iopub.execute_input": "2026-09-13T02:07:09.344960Z",
+ "iopub.status.busy": "2026-09-13T02:07:09.344587Z",
+ "iopub.status.idle": "2026-09-13T02:07:09.356958Z",
+ "shell.execute_reply": "2026-09-13T02:07:09.356310Z"
+ },
+ "papermill": {
+ "duration": 0.018757,
+ "end_time": "2026-09-13T02:07:09.357938+00:00",
+ "exception": false,
+ "start_time": "2026-09-13T02:07:09.339181+00:00",
+ "status": "completed"
+ },
+ "tags": []
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "P(Y=1) = 0.072 (issue rare)\n",
+ "P(X=1) = 0.508\n",
+ "RR brut = 1.823 RR vrai (simulateur) = 1.492\n"
+ ]
+ }
+ ],
+ "source": [
+ "df_binaire = dso.generer_donnees_binaires(n=3000, seed=42)\n",
+ "print(f\"P(Y=1) = {df_binaire['Y'].mean():.3f} (issue rare)\")\n",
+ "print(f\"P(X=1) = {df_binaire['X'].mean():.3f}\")\n",
+ "rr_brut = df_binaire.groupby(\"X\")[\"Y\"].mean()[1] / df_binaire.groupby(\"X\")[\"Y\"].mean()[0]\n",
+ "print(f\"RR brut = {rr_brut:.3f} RR vrai (simulateur) = {np.exp(dso.B_X):.3f}\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "790e7814",
+ "metadata": {
+ "papermill": {
+ "duration": 0.004557,
+ "end_time": "2026-09-13T02:07:09.365367+00:00",
+ "exception": false,
+ "start_time": "2026-09-13T02:07:09.360810+00:00",
+ "status": "completed"
+ },
+ "tags": []
+ },
+ "source": [
+ "### Le RR ajusté — et un piège de l'API\n",
+ "\n",
+ "`dowhy` estime le RR par `backdoor.generalized_linear_model` (Poisson, lien\n",
+ "log) en ajustant $\\{C\\}$. **Piège mesuré** : `estimate.value` rend un\n",
+ "contraste *marginal* sur l'échelle des probabilités prédites (~1.04), pas le\n",
+ "RR — le log-RR se lit sur le **coefficient** du traitement (l'organe\n",
+ "l'encapsule). Le $U$ caché fait monter le RR ajusté au-dessus du vrai."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "id": "b6a5e184",
+ "metadata": {
+ "execution": {
+ "iopub.execute_input": "2026-09-13T02:07:09.374383Z",
+ "iopub.status.busy": "2026-09-13T02:07:09.374036Z",
+ "iopub.status.idle": "2026-09-13T02:07:24.420337Z",
+ "shell.execute_reply": "2026-09-13T02:07:24.419859Z"
+ },
+ "papermill": {
+ "duration": 15.052709,
+ "end_time": "2026-09-13T02:07:24.420677+00:00",
+ "exception": false,
+ "start_time": "2026-09-13T02:07:09.367968+00:00",
+ "status": "completed"
+ },
+ "tags": []
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "RR ajuste C (coefficient) = 1.790 IC 95 % [1.352, 2.371]\n",
+ "RR vrai (simulateur) = 1.492\n",
+ "contraste marginal .value = 0.041 <- PAS le RR (piege encapsule)\n"
+ ]
+ }
+ ],
+ "source": [
+ "rr = dso.estimer_rr_binaire(df_binaire)\n",
+ "print(f\"RR ajuste C (coefficient) = {rr.rr:.3f} IC 95 % [{rr.rr_inf:.3f}, {rr.rr_sup:.3f}]\")\n",
+ "print(f\"RR vrai (simulateur) = {np.exp(dso.B_X):.3f}\")\n",
+ "print(f\"contraste marginal .value = {rr.estimate.value:.3f} <- PAS le RR (piege encapsule)\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6fdc042a",
+ "metadata": {
+ "papermill": {
+ "duration": 0.004052,
+ "end_time": "2026-09-13T02:07:24.428681+00:00",
+ "exception": false,
+ "start_time": "2026-09-13T02:07:24.424629+00:00",
+ "status": "completed"
+ },
+ "tags": []
+ },
+ "source": [
+ "### L'E-value — le RR minimal qui annule\n",
+ "\n",
+ "L'E-value de Ding & VanderWeele (2017) : la force d'association minimale,\n",
+ "**sur l'échelle des risques relatifs**, qu'un confondeur caché devrait avoir\n",
+ "**avec le traitement ET avec l'issue** (conditionnellement aux covariables\n",
+ "mesurées) pour expliquer *entièrement* l'association. `dowhy` l'implémente\n",
+ "des packages R `EValue`/`tipr`, avec deux lectures :\n",
+ "\n",
+ "- pour l'estimé ponctuel : un cache de RR ≥ E-value des deux côtés annule ;\n",
+ "- pour la borne d'IC la plus proche de 1 : un cache plus faible suffit déjà.\n",
+ "\n",
+ "Et le **benchmark de McGowan & Greevy** : on retire chaque covariable\n",
+ "mesurée, on ré-estime, on mesure le déplacement — l'« E-value observé » de\n",
+ "$C$ donne l'échelle des forces *réelles* de l'étude."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "id": "eb5d0c66",
+ "metadata": {
+ "execution": {
+ "iopub.execute_input": "2026-09-13T02:07:24.437763Z",
+ "iopub.status.busy": "2026-09-13T02:07:24.437474Z",
+ "iopub.status.idle": "2026-09-13T02:07:24.455875Z",
+ "shell.execute_reply": "2026-09-13T02:07:24.455427Z"
+ },
+ "papermill": {
+ "duration": 0.025062,
+ "end_time": "2026-09-13T02:07:24.456391+00:00",
+ "exception": false,
+ "start_time": "2026-09-13T02:07:24.431329+00:00",
+ "status": "completed"
+ },
+ "tags": []
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "RR converti = 1.790\n",
+ "E-value (estime) = 2.98\n",
+ "E-value (borne d'IC) = 2.04\n",
+ "\n",
+ "benchmark McGowan-Greevy (retirer la covariable, re-estimer) :\n",
+ " converted_est converted_lower_ci converted_upper_ci observed_covariate_e_value\n",
+ "dropped_covariate \n",
+ "C 1.823 1.378 2.413 1.16\n"
+ ]
+ }
+ ],
+ "source": [
+ "ev = dso.sensibilite_e_value(rr.model, rr.estimand, rr.estimate)\n",
+ "print(f\"RR converti = {ev.rr_converti:.3f}\")\n",
+ "print(f\"E-value (estime) = {ev.evalue_estime:.2f}\")\n",
+ "print(f\"E-value (borne d'IC) = {ev.evalue_ic_limite:.2f}\")\n",
+ "print(\"\\nbenchmark McGowan-Greevy (retirer la covariable, re-estimer) :\")\n",
+ "print(ev.benchmarking.round(3).to_string())"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "id": "12016cd6",
+ "metadata": {
+ "execution": {
+ "iopub.execute_input": "2026-09-13T02:07:24.466189Z",
+ "iopub.status.busy": "2026-09-13T02:07:24.465844Z",
+ "iopub.status.idle": "2026-09-13T02:07:24.758499Z",
+ "shell.execute_reply": "2026-09-13T02:07:24.757293Z"
+ },
+ "papermill": {
+ "duration": 0.299521,
+ "end_time": "2026-09-13T02:07:24.759482+00:00",
+ "exception": false,
+ "start_time": "2026-09-13T02:07:24.459961+00:00",
+ "status": "completed"
+ },
+ "tags": []
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "# les contours de bascule : (RR cache-traitement) x (RR cache-issue) qui annulent\n",
+ "ev.analyzer.plot(xy_limit=6.5)\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 14,
+ "id": "a78ae042",
+ "metadata": {
+ "execution": {
+ "iopub.execute_input": "2026-09-13T02:07:24.778000Z",
+ "iopub.status.busy": "2026-09-13T02:07:24.777437Z",
+ "iopub.status.idle": "2026-09-13T02:07:24.784499Z",
+ "shell.execute_reply": "2026-09-13T02:07:24.783322Z"
+ },
+ "papermill": {
+ "duration": 0.018252,
+ "end_time": "2026-09-13T02:07:24.785468+00:00",
+ "exception": false,
+ "start_time": "2026-09-13T02:07:24.767216+00:00",
+ "status": "completed"
+ },
+ "tags": []
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "verdict : ROBUSTE_RELATIVEMENT_AUX_OBSERVES (rapport 2.57x)\n",
+ "RESULTAT : E-value 2.98 contre un maximum observe de 1.16 -- un confondeur cache devrait etre 2.6x plus fort (echelle E-value) que le meilleur confondeur mesure pour annuler l'association. La robustesse est relative aux forces observees dans CETTE etude, pas une certification d'absence de confondeur.\n",
+ "\n",
+ "formule RR + sqrt(RR(RR-1)) = 2.9796 vs dowhy 2.9796\n"
+ ]
+ }
+ ],
+ "source": [
+ "verdict_b = dso.verdict_e_value(ev)\n",
+ "print(f\"verdict : {verdict_b['verdict']} (rapport {verdict_b['rapport']:.2f}x)\")\n",
+ "print(verdict_b['message'])\n",
+ "\n",
+ "# controle independent : la formule fermee de VanderWeele-Ding\n",
+ "rr_conv = ev.rr_converti\n",
+ "evalue_formule = rr_conv + (rr_conv * (rr_conv - 1)) ** 0.5\n",
+ "print(f\"\\nformule RR + sqrt(RR(RR-1)) = {evalue_formule:.4f} vs dowhy {ev.evalue_estime:.4f}\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a447b5cb",
+ "metadata": {
+ "papermill": {
+ "duration": 0.007262,
+ "end_time": "2026-09-13T02:07:24.799669+00:00",
+ "exception": false,
+ "start_time": "2026-09-13T02:07:24.792407+00:00",
+ "status": "completed"
+ },
+ "tags": []
+ },
+ "source": [
+ "**Lire un E-value nu est impossible** — « 3.0, c'est grand ? » n'a pas de\n",
+ "réponse universelle. Le benchmark répond : le meilleur confondeur *mesuré*\n",
+ "de cette étude ($C$, qui fait pourtant passer le RR de 1.49 à 1.79) a un\n",
+ "E-value observé de **1.16**. Un cache qui annulerait devrait être **2.6×\n",
+ "plus fort que ce confondeur réel**. La robustesse est *relative aux forces\n",
+ "observées dans l'étude* — un résultat, pas une certification."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "50a1534e",
+ "metadata": {
+ "papermill": {
+ "duration": 0.007993,
+ "end_time": "2026-09-13T02:07:24.816800+00:00",
+ "exception": false,
+ "start_time": "2026-09-13T02:07:24.808807+00:00",
+ "status": "completed"
+ },
+ "tags": []
+ },
+ "source": [
+ "## 5. Les bornes de Rosenbaum — Γ*, le déséquilibre qui masque\n",
+ "\n",
+ "Troisième formalisation, sur **paires appariées** : on apparie exactement\n",
+ "chaque exposé à un non-exposé de même strate de $C$. Seules les paires\n",
+ "**discordantes** (l'un malade, l'autre sain) renseignent : sous l'hypothèse\n",
+ "nulle sans biais caché, chacune est un tirage à pile ou face. Un\n",
+ "déséquilibre caché $\\Gamma$ borne la probabilité d'un tirage dans\n",
+ "$[1/(1+\\Gamma), \\Gamma/(1+\\Gamma)]$ — d'où des **bornes exactes** de la\n",
+ "p-valeur du test du signe (Rosenbaum 2002, chap. 4 ; calcul binomial\n",
+ "exact, il n'existe pas de package Python établi pour cette borne)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 15,
+ "id": "20e47b68",
+ "metadata": {
+ "execution": {
+ "iopub.execute_input": "2026-09-13T02:07:24.835131Z",
+ "iopub.status.busy": "2026-09-13T02:07:24.834719Z",
+ "iopub.status.idle": "2026-09-13T02:07:24.939727Z",
+ "shell.execute_reply": "2026-09-13T02:07:24.939309Z"
+ },
+ "papermill": {
+ "duration": 0.115186,
+ "end_time": "2026-09-13T02:07:24.940522+00:00",
+ "exception": false,
+ "start_time": "2026-09-13T02:07:24.825336+00:00",
+ "status": "completed"
+ },
+ "tags": []
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "paires discordantes m = 193 ; succes (traite malade) s = 122\n",
+ "p-valeur observee (Gamma=1) = 1.48e-04\n"
+ ]
+ }
+ ],
+ "source": [
+ "discordantes = dso.paires_appariees(df_binaire, seed=0)\n",
+ "m, s = len(discordantes), int(discordantes.sum())\n",
+ "p_obs = dso.bornes_rosenbaum(s, m, 1.0)[1]\n",
+ "print(f\"paires discordantes m = {m} ; succes (traite malade) s = {s}\")\n",
+ "print(f\"p-valeur observee (Gamma=1) = {p_obs:.2e}\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 16,
+ "id": "0dbb8ed2",
+ "metadata": {
+ "execution": {
+ "iopub.execute_input": "2026-09-13T02:07:24.950859Z",
+ "iopub.status.busy": "2026-09-13T02:07:24.950490Z",
+ "iopub.status.idle": "2026-09-13T02:07:24.957916Z",
+ "shell.execute_reply": "2026-09-13T02:07:24.957410Z"
+ },
+ "papermill": {
+ "duration": 0.012652,
+ "end_time": "2026-09-13T02:07:24.957857+00:00",
+ "exception": false,
+ "start_time": "2026-09-13T02:07:24.945205+00:00",
+ "status": "completed"
+ },
+ "tags": []
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ " Gamma p_basse p_haute\n",
+ " 1.00 1.5e-04 1.5e-04\n",
+ " 1.33 1.1e-08 4.9e-02\n",
+ " 1.50 6.6e-11 2.0e-01\n",
+ " 2.00 2.2e-17 8.6e-01\n",
+ " 3.00 4.8e-29 1.0e+00\n",
+ "\n",
+ "Gamma* (borne haute croise 0.05) = 1.33\n"
+ ]
+ }
+ ],
+ "source": [
+ "lignes = []\n",
+ "for g in (1.0, 1.33, 1.5, 2.0, 3.0):\n",
+ " lo, hi = dso.bornes_rosenbaum(s, m, g)\n",
+ " lignes.append({\"Gamma\": g, \"p_basse\": f\"{lo:.1e}\", \"p_haute\": f\"{hi:.1e}\"})\n",
+ "bornes = pd.DataFrame(lignes)\n",
+ "print(bornes.to_string(index=False))\n",
+ "\n",
+ "gamma_etoile = dso.gamma_critique(s, m)\n",
+ "print(f\"\\nGamma* (borne haute croise 0.05) = {gamma_etoile:.2f}\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 17,
+ "id": "ba5be3e4",
+ "metadata": {
+ "execution": {
+ "iopub.execute_input": "2026-09-13T02:07:24.968363Z",
+ "iopub.status.busy": "2026-09-13T02:07:24.968155Z",
+ "iopub.status.idle": "2026-09-13T02:07:25.112408Z",
+ "shell.execute_reply": "2026-09-13T02:07:25.112020Z"
+ },
+ "papermill": {
+ "duration": 0.152161,
+ "end_time": "2026-09-13T02:07:25.113630+00:00",
+ "exception": false,
+ "start_time": "2026-09-13T02:07:24.961469+00:00",
+ "status": "completed"
+ },
+ "tags": []
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "gammas = np.linspace(1.0, 3.0, 60)\n",
+ "p_hautes = [dso.bornes_rosenbaum(s, m, g)[1] for g in gammas]\n",
+ "p_basses = [dso.bornes_rosenbaum(s, m, g)[0] for g in gammas]\n",
+ "\n",
+ "fig, ax = plt.subplots(figsize=(7, 4))\n",
+ "ax.fill_between(gammas, p_basses, p_hautes, alpha=0.3, label=\"p-valeur bornee\")\n",
+ "ax.axhline(0.05, color=\"black\", ls=\"--\", lw=1, label=\"seuil 0.05\")\n",
+ "ax.axvline(gamma_etoile, color=\"red\", ls=\":\", label=f\"Gamma* = {gamma_etoile:.2f}\")\n",
+ "ax.set_yscale(\"log\")\n",
+ "ax.set_xlabel(\"desiquilibre cache Gamma\")\n",
+ "ax.set_ylabel(\"p-valeur (echelle log)\")\n",
+ "ax.set_title(\"Bornes de Rosenbaum : le pire des mondes compatibles\")\n",
+ "ax.legend()\n",
+ "plt.tight_layout()\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c377fd39",
+ "metadata": {
+ "papermill": {
+ "duration": 0.005241,
+ "end_time": "2026-09-13T02:07:25.122392+00:00",
+ "exception": false,
+ "start_time": "2026-09-13T02:07:25.117151+00:00",
+ "status": "completed"
+ },
+ "tags": []
+ },
+ "source": [
+ "## 6. Synthèse — trois chiffres pour une même question\n",
+ "\n",
+ "« Quelle force devrait avoir un confondeur caché pour annuler cet effet ? »\n",
+ "\n",
+ "| Monde | Formalisation | Le chiffre | Contre quoi le lire |\n",
+ "|---|---|---|---|\n",
+ "| Continu (naïf 1.16) | robustness value | **0.68** de R² partiel | $R^2$ réel de $U$ : 0.49 |\n",
+ "| Continu (bascule) | $\\kappa$ simulé | **1.5** ($\\kappa_t = 0.7$) | coefficients du monde |\n",
+ "| Binaire (RR 1.79) | E-value | **2.98** | E-value observé de $C$ : 1.16 |\n",
+ "| Paires (m=193) | Rosenbaum | **Γ\\* = 1.33** | Γ d'un biais plausible |\n",
+ "\n",
+ "Ce que les trois formalisations s'accordent à dire : **la sensibilité ne\n",
+ "dit pas que l'effet est vrai — elle dit à quel point il est attaquable**.\n",
+ "L'association du monde A survit à son $U$ réel tout en étant réduite de\n",
+ "moitié ; l'association du monde B exige un cache bien plus fort que $C$,\n",
+ "mais un déséquilibre d'appariement modeste (Γ 1.33) suffirait à la masquer.\n",
+ "Un chiffre par monde, pas une réserve rhétorique."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ed06bb67",
+ "metadata": {
+ "papermill": {
+ "duration": 0.005168,
+ "end_time": "2026-09-13T02:07:25.131238+00:00",
+ "exception": false,
+ "start_time": "2026-09-13T02:07:25.126070+00:00",
+ "status": "completed"
+ },
+ "tags": []
+ },
+ "source": [
+ "## Exercice 1 — Le rapport de forces : renforcer U vs affaiblir l'effet\n",
+ "\n",
+ "Deux intuitions à confronter aux mesures, sur le monde A :\n",
+ "\n",
+ "1. **Renforcer le cache** : régénérer avec `coef_u_x=1.8, coef_u_y=1.8`.\n",
+ " Mesurer naive, RV et R² réels de U — le verdict bascule-t-il ?\n",
+ "2. **Affaiblir le signal** : régénérer avec `tau=0.2, bruit_y=3.0`\n",
+ " (l'effet vrai chute, le bruit monte). Mêmes mesures — et cette fois ?\n",
+ "\n",
+ "Conclure : pourquoi le RV monte-t-il quand U se renforce, et pourquoi\n",
+ "affaiblir l'effet (pas renforcer le cache) rend l'association annulable ?\n",
+ "\n",
+ "# attendu : cas 1 -> SURVIT (RV ~0.89 > R2U ~0.87) : l'association OBSERVEE grossit avec U\n",
+ "# attendu : cas 2 -> ANNULABLE (RV ~0.25 < R2U ~0.49) : meme un cache aussi fort que U annule"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 18,
+ "id": "1008ca41",
+ "metadata": {
+ "execution": {
+ "iopub.execute_input": "2026-09-13T02:07:25.141511Z",
+ "iopub.status.busy": "2026-09-13T02:07:25.141316Z",
+ "iopub.status.idle": "2026-09-13T02:07:25.144204Z",
+ "shell.execute_reply": "2026-09-13T02:07:25.143749Z"
+ },
+ "papermill": {
+ "duration": 0.010047,
+ "end_time": "2026-09-13T02:07:25.144703+00:00",
+ "exception": false,
+ "start_time": "2026-09-13T02:07:25.134656+00:00",
+ "status": "completed"
+ },
+ "tags": []
+ },
+ "outputs": [],
+ "source": [
+ "resultats_ex1 = None # TODO etudiant\n",
+ "# Etape 1 : df_fort = dso.generer_donnees_continues(seed=42, cacher_u=False, coef_u_x=1.8, coef_u_y=1.8)\n",
+ "# Etape 2 : estimer + robustesse_partielle_r2 + r2_partiel + verdict_sensibilite (comme sections 1-2)\n",
+ "# Etape 3 : idem avec tau=0.2, bruit_y=3.0\n",
+ "# Indice : sur la vue cacher_u=False, estimer sur df[[\"X\", \"Y\", \"C\"]] ; les R2 sur la vue complete"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5aac9232",
+ "metadata": {
+ "papermill": {
+ "duration": 0.004949,
+ "end_time": "2026-09-13T02:07:25.155646+00:00",
+ "exception": false,
+ "start_time": "2026-09-13T02:07:25.150697+00:00",
+ "status": "completed"
+ },
+ "tags": []
+ },
+ "source": [
+ "## Exercice 2 — L'E-value de l'IC et la taille d'échantillon\n",
+ "\n",
+ "L'E-value de l'estimé (2.98) dépasse celui de l'IC (2.04). Refaire\n",
+ "l'analyse du monde B avec `n=10000` :\n",
+ "\n",
+ "1. Pourquoi l'IC se resserre-t-il, et que fait l'E-value de **l'IC** ?\n",
+ "2. Pourquoi l'E-value de **l'estimé** bouge-t-il à peine ?\n",
+ "\n",
+ "# attendu : IC plus etroit -> sa borne s'eloigne de 1 -> E-value(IC) MONTE vers l'E-value(estime)\n",
+ "# attendu : l'estime ponctuel converge (biais de U constant) -> son E-value est presque inchange"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 19,
+ "id": "d553bff7",
+ "metadata": {
+ "execution": {
+ "iopub.execute_input": "2026-09-13T02:07:25.165725Z",
+ "iopub.status.busy": "2026-09-13T02:07:25.165508Z",
+ "iopub.status.idle": "2026-09-13T02:07:25.168522Z",
+ "shell.execute_reply": "2026-09-13T02:07:25.168087Z"
+ },
+ "papermill": {
+ "duration": 0.009094,
+ "end_time": "2026-09-13T02:07:25.169055+00:00",
+ "exception": false,
+ "start_time": "2026-09-13T02:07:25.159961+00:00",
+ "status": "completed"
+ },
+ "tags": []
+ },
+ "outputs": [],
+ "source": [
+ "resultats_ex2 = None # TODO etudiant\n",
+ "# Etape 1 : df_b_grand = dso.generer_donnees_binaires(n=10000, seed=42)\n",
+ "# Etape 2 : estimer_rr_binaire puis sensibilite_e_value, comparer a la section 4\n",
+ "# Indice : comparer (rr.rr_inf, ev.evalue_ic_limite, ev.evalue_estime) a n=3000 vs n=10000"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a6ffd8c3",
+ "metadata": {
+ "papermill": {
+ "duration": 0.004679,
+ "end_time": "2026-09-13T02:07:25.178506+00:00",
+ "exception": false,
+ "start_time": "2026-09-13T02:07:25.173827+00:00",
+ "status": "completed"
+ },
+ "tags": []
+ },
+ "source": [
+ "## Exercice 3 — Γ* d'un effet plus faible\n",
+ "\n",
+ "Reprendre le monde B avec `b_x=0.2` (RR vrai $e^{0.2} \\approx 1.22$) :\n",
+ "ré-apparier, recompter $(m, s)$, recalculer Γ*. Comparer au Γ\\* = 1.33 de\n",
+ "la section 5 et conclure : Γ* mesure-t-il la *vérité* de l'effet ou sa\n",
+ "*solidité statistique face au pire des mondes* ?\n",
+ "\n",
+ "# attendu : effet plus faible -> Gamma* plus proche de 1 (un desequilibre cache plus faible suffit)\n",
+ "# attendu : Gamma* peut rester > 1 tant que l'effet est detectable : solidite, pas verite"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 20,
+ "id": "6bab523a",
+ "metadata": {
+ "execution": {
+ "iopub.execute_input": "2026-09-13T02:07:25.188618Z",
+ "iopub.status.busy": "2026-09-13T02:07:25.188419Z",
+ "iopub.status.idle": "2026-09-13T02:07:25.191348Z",
+ "shell.execute_reply": "2026-09-13T02:07:25.190969Z"
+ },
+ "papermill": {
+ "duration": 0.010005,
+ "end_time": "2026-09-13T02:07:25.191469+00:00",
+ "exception": false,
+ "start_time": "2026-09-13T02:07:25.181464+00:00",
+ "status": "completed"
+ },
+ "tags": []
+ },
+ "outputs": [],
+ "source": [
+ "resultats_ex3 = None # TODO etudiant\n",
+ "# Etape 1 : df_b_faible = dso.generer_donnees_binaires(n=3000, seed=42, b_x=0.2)\n",
+ "# Etape 2 : paires_appariees -> (m, s) ; bornes_rosenbaum sur une grille ; gamma_critique\n",
+ "# Indice : dso.gamma_critique(s, m) suffit pour le chiffre ; verifier que m reste ~150-200"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "69ad617f",
+ "metadata": {
+ "papermill": {
+ "duration": 0.004166,
+ "end_time": "2026-09-13T02:07:25.200802+00:00",
+ "exception": false,
+ "start_time": "2026-09-13T02:07:25.196636+00:00",
+ "status": "completed"
+ },
+ "tags": []
+ },
+ "source": [
+ "## À retenir\n",
+ "\n",
+ "1. **L'hypothèse de non-confondance invérifiable se chiffre.** Trois\n",
+ " formalisations (R² partiel, E-value, Γ de Rosenbaum), trois unités, une\n",
+ " même question : *quelle force annulerait cet effet ?*\n",
+ "2. **Un seuil ne suffit pas : il faut l'échelle.** Le RV se lit contre les\n",
+ " $R^2$ réels des variables connues ; l'E-value contre l'E-value observé\n",
+ " des covariables mesurées ; Γ\\* contre le Γ d'un biais plausible.\n",
+ "3. **Le rapport de forces est relatif.** Renforcer le confondeur caché\n",
+ " renforce l'association observée : c'est affaiblir l'effet vrai (signal\n",
+ " faible sous bruit) qui rend l'association annulable.\n",
+ "4. **Survivre n'est pas être juste.** Le monde A survit à son $U$ tout en\n",
+ " étant réduit de moitié ; aucune analyse de sensibilité ne remplace la\n",
+ " mesure du confondeur — elle dit combien elle coûte de l'ignorer.\n",
+ "\n",
+ "Série DoWhy (retour au [README](README.md)) : DoWhy-1 l'estimand, DoWhy-2 le\n",
+ "contrefactuel, DoWhy-3 le graphe, **DoWhy-4 le confondeur caché**, DoWhy-5\n",
+ "l'instrument faible."
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (coursia-ml-training)",
+ "language": "python",
+ "name": "coursia-ml-training"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.13.3"
+ },
+ "papermill": {
+ "default_parameters": {},
+ "duration": 34.172391,
+ "end_time": "2026-09-13T02:07:25.881590+00:00",
+ "environment_variables": {},
+ "exception": null,
+ "input_path": "D:\\Dev\\CoursIA-14049-dw4\\MyIA.AI.Notebooks\\Probas\\DecisionTheory\\Causal-Bridges\\DoWhy-4-Sensibilite-Confounder-Cache.ipynb",
+ "output_path": "D:\\Dev\\CoursIA-14049-dw4\\MyIA.AI.Notebooks\\Probas\\DecisionTheory\\Causal-Bridges\\DoWhy-4-Sensibilite-Confounder-Cache_output.ipynb",
+ "parameters": {},
+ "start_time": "2026-09-13T02:06:51.709199+00:00",
+ "version": "2.7.0"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
\ No newline at end of file
diff --git a/MyIA.AI.Notebooks/Probas/DecisionTheory/Causal-Bridges/README.md b/MyIA.AI.Notebooks/Probas/DecisionTheory/Causal-Bridges/README.md
index c06f9286db..18e6bfa814 100644
--- a/MyIA.AI.Notebooks/Probas/DecisionTheory/Causal-Bridges/README.md
+++ b/MyIA.AI.Notebooks/Probas/DecisionTheory/Causal-Bridges/README.md
@@ -14,6 +14,7 @@
| [DoWhy-1 — Exiger un estimand](DoWhy-1-Estimand-et-Intervention.ipynb) | ~45 min | Identification causale **nommée** via `dowhy` (backdoor, front-door, instrumentale) sur un cas complet ; sensibilité au graphe **mesurée** quand une hypothèse saute |
| [DoWhy-2 — Le contrefactuel individuel](DoWhy-2-Contrefactuel-Individuel.ipynb) | ~40 min | Troisième échelon de Pearl : `dowhy.gcm` (abduction-action-prédiction) sur **un individu** ; l'effet moyen nul cache une CATE linéaire ±3 ; fragilité du chiffre individuel à la spécification du mécanisme |
| [DoWhy-3 — Le graphe qu'on n'a pas](DoWhy-3-Decouverte-de-Structure.ipynb) | ~45 min | Découverte de structure via `causal-learn` (PC, GES, LiNGAM) : classes d'équivalence de Markov, verdict **CPDAG ambigu = résultat** ; LiNGAM tranche sous non-gaussianité mais rend un DAG faux-silencieux sinon ; l'ambiguïté se propage à l'estimand (3 extensions du même CPDAG → 3 estimands dowhy) |
+| [DoWhy-4 — Le confondeur non observé](DoWhy-4-Sensibilite-Confounder-Cache.ipynb) | ~50 min | Sensibilité, pas certitude : « quelle force devrait avoir un confondeur caché pour annuler cet effet ? » — robustness value de Cinelli-Hazlett (`linear-partial-R2`), **E-value natif** `dowhy` avec benchmark McGowan-Greevy, bornes de Rosenbaum exactes (Γ*), courbe de bascule du confondeur simulé (`direct-simulation`) |
| [DoWhy-5 — L'instrument faible](DoWhy-5-Instrument-Faible.ipynb) | ~45 min | Variable instrumentale via `dowhy.CausalModel` (pipeline `identify` + `estimate(iv.instrumental_variable)` + `refute`) ; F-stat Staiger-Stock, biais IV vs OLS, **verdict NON_IDENTIFIABLE** honnête sur exclusion violée ; complète le 2SLS from scratch de la cellule 40 de `Quasi-Experimental.ipynb` |
| [Quasi-Experimental](Quasi-Experimental.ipynb) | ~50 min | Méthodes quasi-expérimentales (DiD, contrôle synthétique, RDD, variables instrumentales) sur données réalistes ; estimands et hypothèses d'identification explicités |
@@ -65,3 +66,9 @@ Exercices de DoWhy-3 (découverte de structure) :
1. **L'ambiguïté ne se résout pas avec des données** — pour `n ∈ {500, 2000, 10000}`, constater que le CPDAG de PC garde `C–X` et `X–M` ambiguës : la classe de Markov est une borne structurelle, pas un problème de taille d'échantillon.
2. **`alpha` de PC, le compromis mesuré** — pour `alpha ∈ {0.2, 0.05, 0.01}` sur 5 seeds : arêtes parasites à `0.2`, v-structure perdue environ 1 seed sur 4 à `0.05` (mesuré sur ce monde), propre à `0.01` au prix de la puissance sur signaux faibles — il n'y a pas d'alpha gratuit.
3. **Diagnostiquer l'échec silencieux de LiNGAM** — sur 5 seeds gaussiens : DAG complet, faux et instable inter-seeds ; l'instabilité est le seul signal que l'hypothèse de non-gaussianité ne tient pas, la librairie reste muette.
+
+Exercices de DoWhy-4 (sensibilité au confondeur non observé) :
+
+1. **Le rapport de forces** — renforcer le cache (`coef_u_*=1.8`) : la robustness value MONTE avec l'association observée (ça survit encore) ; affaiblir le signal (`tau=0.2, bruit_y=3.0`) : le RV passe sous le R² réel de U et le verdict bascule en ANNULABLE — c'est l'effet faible qu'on annule, pas le cache fort.
+2. **L'E-value de l'IC et la taille d'échantillon** — à `n=10000` l'IC se resserre, sa borne s'éloigne de 1 et l'E-value de l'IC monte vers celui de l'estimé ; l'estimé ponctuel (biais constant de U) bouge à peine.
+3. **Γ\* d'un effet plus faible** — reprendre le monde binaire à `b_x=0.2`, ré-apparier et recalculer Γ* : plus proche de 1 ; Γ\* mesure la solidité statistique face au pire des mondes, pas la vérité de l'effet.
diff --git a/MyIA.AI.Notebooks/Probas/DecisionTheory/Causal-Bridges/dowhy_sensitivity_organs.py b/MyIA.AI.Notebooks/Probas/DecisionTheory/Causal-Bridges/dowhy_sensitivity_organs.py
new file mode 100644
index 0000000000..54c2a5e9ff
--- /dev/null
+++ b/MyIA.AI.Notebooks/Probas/DecisionTheory/Causal-Bridges/dowhy_sensitivity_organs.py
@@ -0,0 +1,652 @@
+"""Organes canoniques de la ligne dowhy -- sensibilite au confondeur cache (DoWhy-4).
+
+Issue #14049 (grain DoWhy-4). DoWhy-1 suppose le graphe, DoWhy-3 le decouvre
+(avec sa borne structurelle). Ce module attaque l'hypothese qu'aucun des deux
+ne peut trancher : **l'existence d'un confondeur NON OBSERVE**. L'enonce cible
+de l'issue : « quelle force devrait avoir un confondeur cache pour annuler cet
+effet ? » -- un chiffre, pas une reserve rhetorique.
+
+Trois formalisations SOTA de la meme question, reellement executees (regle F /
+SOTA-OK -- ``dowhy`` natif, jamais de reimplementation jouet) :
+
+1. **Robustness value (R2 partiel)** -- Cinelli & Hazlett 2020, via
+ ``refute_estimate(..., simulation_method="linear-partial-R2")`` : le R2
+ partiel minimal qu'un confondeur cache devrait avoir AVEC le traitement ET
+ AVEC l'issue (apres ajustement) pour annuler l'estime. Repondu sur monde
+ continu lineaire.
+2. **E-value** -- Ding & VanderWeele 2017, via ``simulation_method="e-value"``
+ (implemente des R packages EValue/tipr) : sur l'echelle des risques
+ relatifs, la force d'association minimale qu'un confondeur cache devrait
+ avoir avec le traitement ET l'issue pour expliquer entierement
+ l'association. Avec le benchmark McGowan & Greevy : l'E-value OBSERVE de
+ chaque covariable mesuree, pour comparer l'hypothetique au reel.
+3. **Bornes de Rosenbaum (Gamma)** -- Rosenbaum 2002 : sur paires appariees,
+ le facteur de desequilibre cache minimal Gamma* qui rend l'effet non
+ significatif. Calcul exact binomial (il n'existe pas de package Python
+ etabli pour cette borne -- R ``rbounds`` est la reference ; la borne EST
+ une binomiale, le calcul exact est la methode, pas un contournement).
+
+Et le pont concret : ``confondeur_simule`` execute le refuter
+``direct-simulation`` de dowhy -- un confondeur U* de force croissante est
+injecte, l'estime ajuste est recalcule, la COURBE DE BASCULE montre ou
+l'effet croise zero.
+
+Pieges API dowhy 0.14 que ce module encapsule, mesures :
+
+1. ``linear-partial-R2`` exige ``effect_fraction_on_treatment`` et
+ ``effect_fraction_on_outcome`` en **LISTES**. Un int devient un array 0-d
+ qui s'effondre en scalaire -> ``any()`` sur un float leve TypeError ; un
+ ndarray n'est pas dans ``[int, list, float]`` -> l'attribut n'est jamais
+ assigne -> AttributeError.
+2. ``linear-partial-R2`` exige ``benchmark_common_causes`` explicite : sans
+ lui, ``r2tu_w`` reste None et ``compute_bias_adjusted`` crashe sur NoneType.
+3. GLM : ``estimate_effect(...).value`` rend un CONTRASTE MARGINAL (ratio de
+ risques predits, ~1.04 mesure), pas le RR. Le log-RR du lien log se lit
+ sur le COEFFICIENT (position 1 -- dowhy renomme les regressieurs x1, x2).
+4. L'E-value de la borne d'IC peut valoir ``None`` quand l'IC contient deja 1
+ (l'association est deja « tippee » au seuil).
+5. Verifie : l'E-value rendu par dowhy vaut exactement
+ ``RR + sqrt(RR * (RR - 1))`` (2.9796 mesure contre la formule).
+
+Resultats enseignes (mesures, 10 seeds, monde par defaut) :
+
+- Monde continu : estime naive ~1.15 (vrai 0.5, oracle ajuste C+U ~0.53),
+ robustness value ~0.68 ; le U REEL de ce monde a un R2 partiel de ~0.49
+ avec X et ~0.45 avec Y -- en dessous du RV : l'association ne peut pas etre
+ annulee par un confondeur de cette force, mais elle est quand meme reduite
+ de moitie. La sensibilite ne certifie pas l'estime ; elle chiffre l'attaque.
+- Monde binaire : RR naive ~1.8 (vrai 1.49), E-value ~3.0, E-value de l'IC
+ ~2.0, E-value OBSERVE du confondeur mesure C ~1.16 -- un cache qui
+ annulerait devrait etre bien plus fort que C. Gamma* de Rosenbaum ~1.3 :
+ un desequilibre cache modeste suffirait a masquer l'effet apparie.
+
+Fonctions exposees
+------------------
+
+- ``generer_donnees_continues(n, seed, cacher_u, coef_u_x, coef_u_y)`` --
+ monde A : X continu, Y continu, confondeur observe C + confondeur cache U.
+- ``generer_donnees_binaires(n, seed, cacher_u, b_x, b_u_y)`` -- monde B :
+ X binaire, Y binaire rare (~7 %), C binaire ; risques multiplicatifs
+ (lien log), RR vrai = exp(B_X) ~ 1.49.
+- ``estimer_effet_continu(donnees)`` -- dowhy backdoor linear_regression,
+ ajustement {C} (U invisible a l'analyste).
+- ``robustesse_partielle_r2(model, estimand, estimate, benchmark)`` -- le
+ chiffre de Cinelli-Hazlett : robustness_value (annuler) et
+ robustness_value_alpha (rendre non significatif).
+- ``r2_partiel(donnees, cible, variable, ajustement)`` -- le R2 partiel
+ exact d'une variable (statsmodels OLS imbriques) : la verite terrain
+ quand la variable est observee.
+- ``confondeur_simule(model, estimand, estimate, k_fixe, k_max, pas,
+ diagonale)`` -- refute_estimate direct-simulation en boucle : la courbe de
+ bascule de l'estime ajuste contre la force du confondeur simule.
+- ``kappa_bascule(tableau)`` -- le point de bascule (interpolation au
+ franchissement de zero).
+- ``estimer_rr_binaire(donnees)`` -- dowhy GLM Poisson lien log, RR lu sur
+ le coefficient (piege 3 encapsule).
+- ``sensibilite_e_value(model, estimand, estimate, tracer)`` -- l'E-value
+ dowhy natif + les benchmarks McGowan-Greevy.
+- ``paires_appariees(donnees, seed)`` -- appariement exact 1:1 sur C, rend
+ les paires discordantes (1 = traite malade / temoin sain).
+- ``bornes_rosenbaum(succes, m, gamma)`` -- bornes exactes de la p-valeur du
+ test du signe sous desequilibre cache Gamma.
+- ``gamma_critique(succes, m, seuil)`` -- Gamma* : la borne haute croise le
+ seuil.
+- ``verdict_sensibilite(r2_u_x, r2_u_y, robustesse)`` / ``verdict_e_value`` --
+ les verdicts honnetes.
+
+Doctrine de parametrisation (cf. ``dowhy_organs.py``,
+``dowhy_discovery_organs.py``) : RandomState LOCAL par fonction, constantes
+en module documentees, dataclasses de sortie, imports lourds dans les
+fonctions.
+
+References
+----------
+
+- Notebook consommateur : ``DoWhy-4-Sensibilite-Confounder-Cache.ipynb``.
+- Robustness value : Cinelli & Hazlett, « Making Sense of Sensitivity :
+ Extending Omitted-Variable Bias », JRSS-B 82 (2020).
+- E-value : VanderWeele & Ding, « Sensitivity Analysis in Observational
+ Research: Introducing the E-Value », Annals of Internal Medicine 167
+ (2017) ; benchmark McGowan & Greevy Jr., arXiv:2011.07030.
+- Bornes : Rosenbaum, « Observational Studies » (2e ed., Springer 2002),
+ chap. 4 (le test du signe sur paires discordantes).
+- API dowhy 0.14 : ``CausalModel.refute_estimate(method_name=
+ "add_unobserved_common_cause", simulation_method=...)``.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional, Tuple
+
+import numpy as np
+import pandas as pd
+
+# ---------------------------------------------------------------------------
+# Constantes par defaut -- l'unique verite des deux simulateurs
+# ---------------------------------------------------------------------------
+# Monde A (continu), tous bruits gaussiens independants :
+# U ~ N(0, 1) confondeur CACHE
+# C ~ N(0, 1) confondeur OBSERVE
+# X = COEF_U_X * U + COEF_C_X * C + N(0, BRUIT_X)
+# Y = TAU_VRAI * X + COEF_U_Y * U + COEF_C_Y * C + N(0, BRUIT_Y)
+# L'analyste ne voit que (X, Y, C) : son ajustement backdoor {C} laisse U
+# faire le travail -> l'estime naive (~1.15) est biaisé vers le haut contre
+# l'effet vrai TAU_VRAI = 0.5 (oracle ajuste C+U ~ 0.53).
+TAU_VRAI: float = 0.5
+COEF_U_X: float = 0.7
+COEF_C_X: float = 0.5
+COEF_U_Y: float = 0.9
+COEF_C_Y: float = 0.4
+BRUIT_X: float = 0.7
+BRUIT_Y: float = 0.7
+N_A_DEFAUT: int = 2000
+
+# Monde B (binaire, issue rare ~ 7 %) :
+# U ~ N(0, 1) ; C ~ Bernoulli(P_C)
+# X ~ Bernoulli(sigmoid(LOGIT_U * U + LOGIT_C * C + LOGIT_A))
+# P(Y=1) = clip(exp(A0 + B_X * X + B_U_Y * U + B_C_Y * C), 0, 1)
+# Risques multiplicatifs (lien log) : le GLM Poisson lien log de dowhy est
+# bien specifie, et le RR vrai vaut exp(B_X) ~ 1.49. U cache fait monter le
+# RR naive ajuste-C a ~1.8.
+B_X: float = 0.4
+B_U_Y: float = 0.5
+B_C_Y: float = 0.3
+A0: float = -3.2
+LOGIT_U: float = 0.9
+LOGIT_C: float = 0.5
+LOGIT_A: float = -0.3
+P_C: float = 0.4
+N_B_DEFAUT: int = 3000
+
+SEUIL_ALPHA: float = 0.05
+SEED_SIMULATION: int = 20260913 # re-seed du RNG global de dowhy (cf. confondeur_simule)
+
+
+# ---------------------------------------------------------------------------
+# Generateurs -- RandomState LOCALE, reproductible, U optionnellement cache
+# ---------------------------------------------------------------------------
+def generer_donnees_continues(
+ n: int = N_A_DEFAUT,
+ seed: int = 42,
+ cacher_u: bool = True,
+ coef_u_x: float = COEF_U_X,
+ coef_u_y: float = COEF_U_Y,
+ tau: float = TAU_VRAI,
+ bruit_y: float = BRUIT_Y,
+) -> pd.DataFrame:
+ """Monde A : traitement continu, issue continue, confondeur cache U.
+
+ ``cacher_u=True`` (defaut) rend la vue ANALYSTE (X, Y, C) -- celle que
+ voit le praticien qui soupconne un confondeur cache sans le mesurer.
+ ``cacher_u=False`` rend la vue ORACLE (avec U), pour la verite terrain
+ (R2 partiels reels, estime ajuste C+U). ``coef_u_*``, ``tau`` et
+ ``bruit_y`` permettent d'explorer : renforcer U renforce l'association
+ OBSERVEE autant que l'attaque (le RV monte avec) ; affaiblir l'effet
+ vrai sous bruit eleve fait baisser le RV sous la force de U --
+ l'association devient annulable (mesure : exercice 1 du notebook).
+ """
+ rng = np.random.RandomState(seed)
+ u = rng.normal(0, 1, n)
+ c = rng.normal(0, 1, n)
+ x = coef_u_x * u + COEF_C_X * c + rng.normal(0, BRUIT_X, n)
+ y = tau * x + coef_u_y * u + COEF_C_Y * c + rng.normal(0, bruit_y, n)
+ donnees = {"X": x, "Y": y, "C": c}
+ if not cacher_u:
+ donnees["U"] = u
+ return pd.DataFrame(donnees)
+
+
+def generer_donnees_binaires(
+ n: int = N_B_DEFAUT,
+ seed: int = 42,
+ cacher_u: bool = True,
+ b_x: float = B_X,
+ b_u_y: float = B_U_Y,
+) -> pd.DataFrame:
+ """Monde B : traitement binaire, issue binaire rare, C binaire.
+
+ Vue analyste (X, Y, C) par defaut, oracle avec U sinon. Les risques sont
+ multiplicatifs (lien log) : le RR conditionnel vrai vaut ``exp(b_x)``.
+ """
+ rng = np.random.RandomState(seed)
+ u = rng.normal(0, 1, n)
+ c = (rng.uniform(0, 1, n) < P_C).astype(int)
+ p_x = 1.0 / (1.0 + np.exp(-(LOGIT_U * u + LOGIT_C * c + LOGIT_A)))
+ x = (rng.uniform(0, 1, n) < p_x).astype(int)
+ p_y = np.clip(np.exp(A0 + b_x * x + b_u_y * u + B_C_Y * c), 0.0, 1.0)
+ y = (rng.uniform(0, 1, n) < p_y).astype(int)
+ donnees = {"X": x, "Y": y, "C": c}
+ if not cacher_u:
+ donnees["U"] = u
+ return pd.DataFrame(donnees)
+
+
+# ---------------------------------------------------------------------------
+# Monde A : estime naive + robustesse value (R2 partiel)
+# ---------------------------------------------------------------------------
+@dataclass
+class ResultatEffetContinu:
+ """Estime backdoor dowhy du monde A, avec le necessaire pour refuter."""
+
+ model: object
+ estimand: object
+ estimate: object
+ value: float
+ se: float
+ ic: Tuple[float, float]
+
+
+def estimer_effet_continu(donnees: pd.DataFrame) -> ResultatEffetContinu:
+ """Estime dowhy backdoor (linear_regression) en ajustant {C} seulement.
+
+ C'est l'estime NAIF : U n'est pas dans les donnees de l'analyste. Le
+ modele dowhy construit ici est reutilise par tous les refuters de
+ sensibilite (robustesse_partielle_r2, confondeur_simule).
+ """
+ from dowhy import CausalModel
+
+ colonnes = [c for c in donnees.columns if c in ("X", "Y", "C")]
+ model = CausalModel(
+ data=donnees[colonnes], treatment="X", outcome="Y", common_causes=["C"]
+ )
+ estimand = model.identify_effect(proceed_when_unidentifiable=True)
+ estimate = model.estimate_effect(
+ estimand, method_name="backdoor.linear_regression", test_significance=True
+ )
+ se = float(np.atleast_1d(estimate.get_standard_error())[0])
+ return ResultatEffetContinu(
+ model=model,
+ estimand=estimand,
+ estimate=estimate,
+ value=float(estimate.value),
+ se=se,
+ ic=(float(estimate.value - 1.96 * se), float(estimate.value + 1.96 * se)),
+ )
+
+
+@dataclass
+class ResultatRobustesse:
+ """Le chiffre de Cinelli-Hazlett : la force qui annule l'effet."""
+
+ robustness_value: float
+ robustness_value_alpha: float
+ r2yt_w: float
+ stats: Dict[str, object]
+ benchmarking: pd.DataFrame
+ analyzer: object
+
+
+def robustesse_partielle_r2(
+ model: object,
+ estimand: object,
+ estimate: object,
+ benchmark: Optional[List[str]] = None,
+) -> ResultatRobustesse:
+ """Robustness value via ``simulation_method="linear-partial-R2"``.
+
+ ``robustness_value`` : le R2 partiel minimal d'un confondeur cache AVEC
+ le traitement ET avec l'issue (apres ajustement de {C}) pour ANNULER
+ l'estime (le ramener a zero). ``robustness_value_alpha`` : idem pour le
+ rendre statistiquement non significatif.
+
+ Encapsule les pieges 1 et 2 du docstring module : fractions passees en
+ LISTES et ``benchmark_common_causes`` explicite (defaut : ["C"]).
+ """
+ if benchmark is None:
+ benchmark = ["C"]
+ refut = model.refute_estimate(
+ estimand,
+ estimate,
+ method_name="add_unobserved_common_cause",
+ simulation_method="linear-partial-R2",
+ significance_level=SEUIL_ALPHA,
+ benchmark_common_causes=benchmark,
+ effect_fraction_on_treatment=[1.0],
+ effect_fraction_on_outcome=[1.0],
+ plot_estimate=False,
+ )
+ return ResultatRobustesse(
+ robustness_value=float(refut.stats["robustness_value"]),
+ robustness_value_alpha=float(refut.stats["robustness_value_alpha"]),
+ r2yt_w=float(refut.stats["r2yt_w"]),
+ stats=dict(refut.stats),
+ benchmarking=refut.benchmarking_results,
+ analyzer=refut,
+ )
+
+
+def r2_partiel(
+ donnees: pd.DataFrame,
+ cible: str,
+ variable: str,
+ ajustement: List[str],
+) -> float:
+ """R2 partiel exact de ``variable`` pour ``cible`` apres ``ajustement``.
+
+ Regression lineaire imbriquee (statsmodels OLS) :
+ ``R2_partiel = (R2_plein - R2_reduit) / (1 - R2_reduit)``. C'est la
+ verite terrain quand la variable est observee : le R2 partiel REEL du
+ confondeur cache U se calcule sur la vue oracle, puis se compare a la
+ robustness value.
+ """
+ import statsmodels.api as sm
+
+ exogenes = [c for c in ajustement if c != variable]
+ r_plein = sm.OLS(donnees[cible], sm.add_constant(donnees[exogenes + [variable]])).fit()
+ r_reduit = sm.OLS(donnees[cible], sm.add_constant(donnees[exogenes])).fit()
+ return float((r_plein.rsquared - r_reduit.rsquared) / (1.0 - r_reduit.rsquared))
+
+
+def verdict_sensibilite(
+ r2_u_x: float,
+ r2_u_y: float,
+ robustesse: ResultatRobustesse,
+) -> Dict[str, object]:
+ """Le verdict honnete du monde continu : survive a QUEL confondeur.
+
+ La robustness value de Cinelli & Hazlett est le seuil pour un
+ confondeur de force EGALE des deux cotes (meme R2 partiel avec le
+ traitement et avec l'issue). La comparaison juste pour un confondeur
+ reel de forces (r2_u_x, r2_u_y) : meme en prenant son cote le plus
+ fort des deux cotes, annule-t-il ? Si max(r2_u_x, r2_u_y) < RV, aucun
+ cache aussi fort que ce confondeur n'annule l'estime. Comparer les R2
+ partiels REELS d'un confondeur connu au RV chiffre exactement
+ l'attaque, sans certifier l'estime.
+ """
+ rv = robustesse.robustness_value
+ force_max = max(r2_u_x, r2_u_y)
+ if force_max < rv:
+ message = (
+ f"RESULTAT : l'association survit a ce confondeur -- meme a force "
+ f"egale des deux cotes au niveau de son cote le plus fort "
+ f"({force_max:.2f} < RV {rv:.2f}), le cache n'annule pas l'estime. "
+ f"ATTENTION : survivre a l'annulation n'est pas etre juste -- "
+ f"l'estime reste biaisé tant que le confondeur n'est pas mesure."
+ )
+ verdict = "SURVIT_A_CE_CONFOUNDEUR"
+ else:
+ message = (
+ f"RESULTAT : l'association est annulable -- un cache a force egale "
+ f"des deux cotes de {force_max:.2f} (>= RV {rv:.2f}) suffit a "
+ f"expliquer l'estime. L'effet observe n'est PAS distingue d'un "
+ f"biais de cette force : c'est un chiffre, pas une certification."
+ )
+ verdict = "ANNULABLE_PAR_CE_CONFOUNDEUR"
+ return {"verdict": verdict, "robustness_value": rv, "message": message}
+
+
+# ---------------------------------------------------------------------------
+# Monde A : le confondeur simule -- la courbe de bascule
+# ---------------------------------------------------------------------------
+def confondeur_simule(
+ model: object,
+ estimand: object,
+ estimate: object,
+ k_fixe: float = 0.7,
+ k_max: float = 1.6,
+ pas: float = 0.2,
+ diagonale: bool = False,
+) -> pd.DataFrame:
+ """Refuter par confondeur SIMULE (direct-simulation) en balayant la force.
+
+ Pour chaque valeur k, un confondeur U* gaussien est injecte dans les
+ donnees avec un coefficient k sur l'issue (et k_fixe sur le traitement ;
+ en mode ``diagonale``, k des deux cotes -- la convention « meme force des
+ deux cotes » de l'E-value), puis l'estime backdoor est recalcule avec
+ U* dans l'ensemble d'ajustement. Rend un DataFrame [k, kappa_t,
+ estime_ajuste] : la courbe de bascule.
+
+ Appels monovalueurs (le mode grille de dowhy ne rend que (min, max) --
+ la matrice complete serait dans new_effect_array ; la boucle garde le
+ couple (k, estime) explicite).
+
+ REPRODUCTIBILITE : dowhy tire U* du RNG numpy GLOBAL
+ (``scipy.stats.norm().rvs`` sans graine) -- sans re-seed, la courbe
+ varie d'un process a l'autre. Chaque appel re-seed le RNG global avec
+ une graine derivee de l'indice, la courbe est byte-reproductible.
+ """
+ valeurs = np.round(np.arange(0.0, k_max + pas / 2, pas), 4)
+ lignes = []
+ for i, k in enumerate(valeurs):
+ k_t = float(k) if diagonale else float(k_fixe)
+ np.random.seed(SEED_SIMULATION + i)
+ refut = model.refute_estimate(
+ estimand,
+ estimate,
+ method_name="add_unobserved_common_cause",
+ simulation_method="direct-simulation",
+ confounders_effect_on_treatment="linear",
+ confounders_effect_on_outcome="linear",
+ effect_strength_on_treatment=k_t,
+ effect_strength_on_outcome=float(k),
+ plotmethod=None,
+ )
+ lignes.append(
+ {
+ "k": float(k),
+ "kappa_t": k_t,
+ "estime_ajuste": float(np.atleast_1d(refut.new_effect)[0]),
+ }
+ )
+ return pd.DataFrame(lignes)
+
+
+def kappa_bascule(tableau: pd.DataFrame) -> Optional[float]:
+ """Le point de bascule : premiere valeur de k ou l'estime croise zero.
+
+ Interpolation lineaire entre le dernier positif et le premier
+ non-positif. Rend None si la courbe ne bascule pas dans la plage
+ balayee.
+ """
+ estimes = tableau["estime_ajuste"].to_numpy()
+ ks = tableau["k"].to_numpy()
+ for i in range(1, len(estimes)):
+ if estimes[i - 1] > 0 >= estimes[i]:
+ e0, e1 = estimes[i - 1], estimes[i]
+ k0, k1 = ks[i - 1], ks[i]
+ if e0 == e1:
+ return float(k1)
+ return float(k0 + (k1 - k0) * e0 / (e0 - e1))
+ return None
+
+
+# ---------------------------------------------------------------------------
+# Monde B : RR binaire (GLM Poisson) + E-value natif
+# ---------------------------------------------------------------------------
+@dataclass
+class ResultatRR:
+ """RR de Poisson lien log, lu sur le coefficient (piege 3 encapsule)."""
+
+ model: object
+ estimand: object
+ estimate: object
+ log_rr: float
+ se_log_rr: float
+ rr: float
+ rr_inf: float
+ rr_sup: float
+
+
+def estimer_rr_binaire(donnees: pd.DataFrame) -> ResultatRR:
+ """Estime le RR via dowhy ``backdoor.generalized_linear_model`` (Poisson).
+
+ PIEGE ENCAPSULE : ``estimate_effect(...).value`` rend un contraste
+ marginal sur l'echelle des probabilites predites (~1.04 mesure sur le
+ monde par defaut), PAS le risque relatif. Le log-RR du lien log se lit
+ sur le coefficient du traitement, en position 1 -- dowhy renomme les
+ regressieurs (x1 = traitement, x2.. = confondeurs). L'IC est
+ ``coef +- 1.96 * se`` retransforme par exp.
+ """
+ import statsmodels.api as sm
+ from dowhy import CausalModel
+
+ colonnes = [c for c in donnees.columns if c in ("X", "Y", "C")]
+ model = CausalModel(
+ data=donnees[colonnes], treatment="X", outcome="Y", common_causes=["C"]
+ )
+ estimand = model.identify_effect(proceed_when_unidentifiable=True)
+ estimate = model.estimate_effect(
+ estimand,
+ method_name="backdoor.generalized_linear_model",
+ method_params={"init_params": {"glm_family": sm.families.Poisson()}},
+ test_significance=True,
+ )
+ ajuste = estimate.estimator.model
+ log_rr = float(ajuste.params.iloc[1])
+ se = float(ajuste.bse.iloc[1])
+ return ResultatRR(
+ model=model,
+ estimand=estimand,
+ estimate=estimate,
+ log_rr=log_rr,
+ se_log_rr=se,
+ rr=float(np.exp(log_rr)),
+ rr_inf=float(np.exp(log_rr - 1.96 * se)),
+ rr_sup=float(np.exp(log_rr + 1.96 * se)),
+ )
+
+
+@dataclass
+class ResultatEValue:
+ """L'E-value dowhy natif + le benchmark des covariables mesurees."""
+
+ rr_converti: float
+ evalue_estime: float
+ evalue_ic_limite: Optional[float]
+ benchmarking: pd.DataFrame
+ analyzer: object
+ stats: Dict[str, object]
+
+
+def sensibilite_e_value(
+ model: object,
+ estimand: object,
+ estimate: object,
+ tracer: bool = False,
+) -> ResultatEValue:
+ """L'E-value de Ding & VanderWeele, calcule par dowhy (des R EValue/tipr).
+
+ ``evalue_estime`` : la force d'association minimale (echelle RR) qu'un
+ confondeur cache devrait avoir AVEC le traitement ET avec l'issue,
+ conditionnellement aux covariables mesurees, pour expliquer ENTIEREMENT
+ l'association estimee. ``evalue_ic_limite`` : idem pour la borne de l'IC
+ la plus proche de 1 (None si l'IC contient deja 1 -- piege 4).
+
+ ``benchmarking`` : l'E-value OBSERVE de chaque covariable mesuree
+ (McGowan & Greevy : on la retire, on re-estime, on mesure le
+ deplacement) -- l'hypothetique compare au reel.
+ """
+ refut = model.refute_estimate(
+ estimand,
+ estimate,
+ method_name="add_unobserved_common_cause",
+ simulation_method="e-value",
+ plot_estimate=tracer,
+ )
+ return ResultatEValue(
+ rr_converti=float(refut.stats["converted_estimate"]),
+ evalue_estime=float(refut.stats["evalue_estimate"]),
+ evalue_ic_limite=(
+ None
+ if refut.stats.get("evalue_lower_ci") is None
+ else float(refut.stats["evalue_lower_ci"])
+ ),
+ benchmarking=refut.benchmarking_results,
+ analyzer=refut,
+ stats=dict(refut.stats),
+ )
+
+
+def verdict_e_value(evalue: ResultatEValue) -> Dict[str, object]:
+ """Le verdict honnete du monde binaire : robuste par RAPPORT a quoi.
+
+ Un E-value brut (ex. 3.0) ne se lit pas dans l'absolu -- « 3 c'est
+ grand ? » n'a pas de reponse universelle. Le benchmark McGowan-Greevy
+ donne l'echelle : si le confondeur MESURE le plus fort de l'etude a un
+ E-value observe de 1.2, un cache qui annulerait devrait etre ~2.5x plus
+ fort que ce confondeur reel. La robustesse est RELATIVE aux forces
+ observees dans l'etude -- un RESULTAT, pas une certification.
+ """
+ observes = evalue.benchmarking["observed_covariate_e_value"].astype(float)
+ plus_fort_observe = float(observes.max())
+ rapport = evalue.evalue_estime / plus_fort_observe if plus_fort_observe > 0 else float("inf")
+ if rapport >= 1.5:
+ verdict = "ROBUSTE_RELATIVEMENT_AUX_OBSERVES"
+ conclusion = (
+ f"un confondeur cache devrait etre {rapport:.1f}x plus fort "
+ f"(echelle E-value) que le meilleur confondeur mesure pour "
+ f"annuler l'association"
+ )
+ else:
+ verdict = "FRAGILE_RELATIVEMENT_AUX_OBSERVES"
+ conclusion = (
+ f"un confondeur cache seulement {rapport:.1f}x plus fort que le "
+ f"meilleur confondeur mesure suffirait a annuler l'association"
+ )
+ message = (
+ f"RESULTAT : E-value {evalue.evalue_estime:.2f} contre un maximum "
+ f"observe de {plus_fort_observe:.2f} -- {conclusion}. La robustesse "
+ f"est relative aux forces observees dans CETTE etude, pas une "
+ f"certification d'absence de confondeur."
+ )
+ return {"verdict": verdict, "rapport": float(rapport), "message": message}
+
+
+# ---------------------------------------------------------------------------
+# Monde B : paires appariees et bornes de Rosenbaum (exactes)
+# ---------------------------------------------------------------------------
+def paires_appariees(donnees: pd.DataFrame, seed: int = 0) -> np.ndarray:
+ """Appariement exact 1:1 sur C ; rend les paires DISCORDANTES.
+
+ Chaque paire (un traite, un temoin de la meme strate de C, tirage
+ aleatoire reproductible) contribue 1 si le traite est malade et le
+ temoin sain, 0 sinon. Les paires concordantes (meme issue) ne
+ renseignent pas : le test du signe de Rosenbaum ne vit que sur les
+ discordantes.
+ """
+ rng = np.random.RandomState(seed)
+ indicateurs: List[int] = []
+ for strate in sorted(donnees["C"].unique()):
+ d = donnees[donnees["C"] == strate]
+ traites = d[d["X"] == 1].sample(frac=1, random_state=rng)
+ temoins = d[d["X"] == 0].sample(frac=1, random_state=rng)
+ m = min(len(traites), len(temoins))
+ for (_, a), (_, b) in zip(traites.iloc[:m].iterrows(), temoins.iloc[:m].iterrows()):
+ if a["Y"] != b["Y"]:
+ indicateurs.append(int(a["Y"] == 1 and b["Y"] == 0))
+ return np.array(indicateurs, dtype=int)
+
+
+def bornes_rosenbaum(succes: int, m: int, gamma: float) -> Tuple[float, float]:
+ """Bornes exactes de la p-valeur du test du signe sous biais cache Gamma.
+
+ Sous l'hypothese nulle sans biais cache, chaque paire discordante est un
+ tirage equitable (p = 1/2) de « le traite est le malade ». Un
+ desequilibre cache Gamma borne p dans [1/(1+Gamma), Gamma/(1+Gamma)] ;
+ les bornes de la p-valeur sont les queues binomiales exactes a ces deux
+ extremums (Rosenbaum 2002, chap. 4). Gamma = 1 rend la p-valeur observee.
+ """
+ from scipy import stats as sps
+
+ if gamma < 1.0:
+ raise ValueError("Gamma >= 1 requis (Gamma = 1 : absence de biais cache)")
+ p_basse = float(sps.binom.sf(succes - 1, m, 1.0 / (1.0 + gamma)))
+ p_haute = float(sps.binom.sf(succes - 1, m, gamma / (1.0 + gamma)))
+ return p_basse, p_haute
+
+
+def gamma_critique(succes: int, m: int, seuil: float = SEUIL_ALPHA) -> float:
+ """Gamma* : le desequilibre cache minimal qui rend l'effet non significatif.
+
+ Plus petit Gamma tel que la borne HAUTE de la p-valeur atteint le seuil
+ (dichotomie sur la fonction continue en Gamma). C'est le chiffre de
+ Rosenbaum : « a partir d'un desequilibre cache de Gamma*, meme le pire
+ des mondes compatibles explique l'association appariée ».
+ """
+ from scipy.optimize import brentq
+
+ def ecart(g: float) -> float:
+ return bornes_rosenbaum(succes, m, g)[1] - seuil
+
+ return float(brentq(ecart, 1.0, 100.0))
diff --git a/MyIA.AI.Notebooks/Probas/DecisionTheory/Causal-Bridges/tests/test_dowhy_sensitivity_organs.py b/MyIA.AI.Notebooks/Probas/DecisionTheory/Causal-Bridges/tests/test_dowhy_sensitivity_organs.py
new file mode 100644
index 0000000000..9137b4224d
--- /dev/null
+++ b/MyIA.AI.Notebooks/Probas/DecisionTheory/Causal-Bridges/tests/test_dowhy_sensitivity_organs.py
@@ -0,0 +1,380 @@
+"""Tests pytest pour dowhy_sensitivity_organs.py -- grain DoWhy-4 de l'issue #14049.
+
+Issue #14049, acceptance 4 : « chaque notebook de la serie DoWhy expose
+un organe importable des sa livraison, et les tests verifient la sortie
+du module contre la valeur attendue ». Ce fichier EST le consommateur
+externe de l'organe (avec le notebook).
+
+Strategie de test (meme convention que test_dowhy_discovery_organs.py) :
+on **execute reellement** les refuters de sensibilite de dowhy 0.14 (pas
+de mock, H.1) et on verifie que :
+
+(a) ``generer_donnees_continues`` / ``generer_donnees_binaires``
+ respectent la RandomState LOCALE, la vue analyste vs oracle
+ (cacher_u), et les proprietes du monde binaire (issue rare) ;
+(b) l'estime naif du monde A (~1.16 pour un effet vrai de 0.5) est
+ biaise vers le haut par le confondeur cache U -- et l'oracle
+ dowhy ajuste {C, U} restaure ~0.53 ;
+(c) la robustness value de Cinelli-Hazlett vaut ~0.68 sur le monde par
+ defaut, avec ses benchmarks ;
+(d) le R2 partiel REEL de U (~0.49 / ~0.43) se mesure sur la vue oracle
+ et reste sous le RV : verdict SURVIT -- mais le monde affaibli
+ (tau=0.2, bruit_y=3.0) bascule en ANNULABLE ;
+(e) la courbe de bascule du confondeur simule est reproductible
+ (re-seed du RNG global) et croise zero vers kappa ~1.5 (kappa_t=0.7)
+ et ~1.1 (diagonale) ;
+(f) le RR binaire se lit sur le COEFFICIENT GLM (~1.79), pas sur le
+ contraste marginal .value (~1.04) -- le piege API encapsule ;
+(g) l'E-value dowhy natif vaut ~2.98, exactement RR + sqrt(RR(RR-1)),
+ avec le benchmark McGowan-Greevy de C a ~1.16 : verdict ROBUSTE
+ RELATIVEMENT AUX OBSERVES ;
+(h) les bornes de Rosenbaum sont exactes : p_bas == p_haut a Gamma=1,
+ la borne haute croit avec Gamma, Gamma* ~1.33 rend non significatif ;
+(i) anti-derive : les cellules cles du notebook consomment l'organe et
+ produisent les memes donnees que l'appel canonique.
+
+Les tolerances sont celles de la serie : mondes DGP-connus, coefficients
+forts, n=2000/3000 -- les valeurs ci-dessus sont stables sur 10 seeds
+(mesurees avant l'ecriture de ces tests), les tests fixent seed=42.
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+import pytest
+
+# Import direct sans packaging : on ajoute le dossier parent
+# (Probas/DecisionTheory/Causal-Bridges/) au sys.path.
+_PARENT_DIR = Path(__file__).resolve().parent.parent
+if str(_PARENT_DIR) not in sys.path:
+ sys.path.insert(0, str(_PARENT_DIR))
+
+import dowhy_sensitivity_organs as dso
+
+NB_PATH = _PARENT_DIR / "DoWhy-4-Sensibilite-Confounder-Cache.ipynb"
+
+
+# ---------------------------------------------------------------------------
+# (a) Generateurs
+# ---------------------------------------------------------------------------
+def test_generer_continues_formes_et_vues():
+ """Vue analyste (X, Y, C) vs oracle (avec U) ; meme graine = meme monde."""
+ df = dso.generer_donnees_continues(n=2000, seed=42)
+ df_o = dso.generer_donnees_continues(n=2000, seed=42, cacher_u=False)
+ assert df.shape == (2000, 3)
+ assert list(df.columns) == ["X", "Y", "C"]
+ assert list(df_o.columns) == ["X", "Y", "C", "U"]
+ # la vue analyste est la projection de la vue oracle
+ pd.testing.assert_frame_equal(df, df_o[["X", "Y", "C"]])
+
+
+def test_generer_continues_seed_reproductible():
+ pd.testing.assert_frame_equal(
+ dso.generer_donnees_continues(seed=7),
+ dso.generer_donnees_continues(seed=7),
+ )
+ assert not dso.generer_donnees_continues(seed=7).equals(
+ dso.generer_donnees_continues(seed=8)
+ )
+
+
+def test_generer_binaires_issue_rare_et_binaires():
+ """Monde B : X et Y binaires, issue rare (< 15 %), C binaire."""
+ df = dso.generer_donnees_binaires(n=3000, seed=42)
+ assert df.shape == (3000, 3)
+ assert set(df["X"].unique()) <= {0, 1}
+ assert set(df["Y"].unique()) <= {0, 1}
+ assert set(df["C"].unique()) <= {0, 1}
+ assert df["Y"].mean() < 0.15, "l'issue doit etre rare (~7 %)"
+
+
+def test_generer_binaires_param_b_x_change_le_rr():
+ """b_x est le log-RR vrai : l'affaiblir rapproche le RR brut de 1."""
+ df_fort = dso.generer_donnees_binaires(n=8000, seed=42, b_x=0.8)
+ rr_fort = df_fort.groupby("X")["Y"].mean()[1] / df_fort.groupby("X")["Y"].mean()[0]
+ df_faible = dso.generer_donnees_binaires(n=8000, seed=42, b_x=0.1)
+ rr_faible = df_faible.groupby("X")["Y"].mean()[1] / df_faible.groupby("X")["Y"].mean()[0]
+ assert rr_fort > rr_faible
+
+
+# ---------------------------------------------------------------------------
+# (b) Monde A : estime naif biaise, oracle qui restaure
+# ---------------------------------------------------------------------------
+def test_estime_naif_est_biaise_par_u():
+ """L'estime naif (~1.16) depasse l'effet vrai 0.5 : le travail de U."""
+ df = dso.generer_donnees_continues(seed=42)
+ res = dso.estimer_effet_continu(df)
+ assert abs(res.value - 1.159) < 0.02
+ assert res.ic[0] < res.value < res.ic[1]
+ assert res.value > dso.TAU_VRAI + 0.3, "le biais de U doit etre substantiel"
+
+
+def test_oracle_dowhy_restaure_effet_vrai():
+ """Ajuster {C, U} (vue oracle) ramene l'estime a ~0.53 (vrai 0.5)."""
+ from dowhy import CausalModel
+
+ df_o = dso.generer_donnees_continues(seed=42, cacher_u=False)
+ modele = CausalModel(data=df_o, treatment="X", outcome="Y", common_causes=["C", "U"])
+ estimand = modele.identify_effect(proceed_when_unidentifiable=True)
+ oracle = modele.estimate_effect(estimand, method_name="backdoor.linear_regression")
+ assert abs(float(oracle.value) - dso.TAU_VRAI) < 0.1
+
+
+# ---------------------------------------------------------------------------
+# (c) Robustness value (Cinelli-Hazlett via dowhy)
+# ---------------------------------------------------------------------------
+def test_robustesse_partielle_r2_valeurs_mesurees():
+ """RV ~0.677 (annuler), RV_alpha ~0.665 (non significatif), r2yt_w ~0.587."""
+ df = dso.generer_donnees_continues(seed=42)
+ res = dso.estimer_effet_continu(df)
+ rob = dso.robustesse_partielle_r2(res.model, res.estimand, res.estimate)
+ assert abs(rob.robustness_value - 0.677) < 0.01
+ assert abs(rob.robustness_value_alpha - 0.665) < 0.01
+ assert 0 < rob.robustness_value_alpha < rob.robustness_value < 1
+ assert len(rob.benchmarking) == 1, "une ligne de benchmark par covariable (C)"
+
+
+# ---------------------------------------------------------------------------
+# (d) R2 partiel reel de U + verdicts
+# ---------------------------------------------------------------------------
+def test_r2_partiel_valeurs_et_identite():
+ """R2 reel de U (~0.493/~0.427) ; proprietes formelles du R2 partiel."""
+ df_o = dso.generer_donnees_continues(seed=42, cacher_u=False)
+ assert abs(dso.r2_partiel(df_o, "X", "U", ["C"]) - 0.493) < 0.01
+ assert abs(dso.r2_partiel(df_o, "Y", "U", ["X", "C"]) - 0.427) < 0.01
+ # une variable explique elle-meme completement sa propre regression
+ assert abs(dso.r2_partiel(df_o, "U", "U", []) - 1.0) < 1e-9
+
+
+def test_verdict_survit_sur_le_monde_defaut():
+ """max(R2 U) ~0.49 < RV ~0.68 : l'association SURVIT a ce confondeur."""
+ df = dso.generer_donnees_continues(seed=42)
+ df_o = dso.generer_donnees_continues(seed=42, cacher_u=False)
+ res = dso.estimer_effet_continu(df)
+ rob = dso.robustesse_partielle_r2(res.model, res.estimand, res.estimate)
+ v = dso.verdict_sensibilite(
+ dso.r2_partiel(df_o, "X", "U", ["C"]),
+ dso.r2_partiel(df_o, "Y", "U", ["X", "C"]),
+ rob,
+ )
+ assert v["verdict"] == "SURVIT_A_CE_CONFOUNDEUR"
+ assert "RESULTAT" in v["message"]
+ assert "ATTENTION" in v["message"], "survivre n'est pas etre juste"
+
+
+def test_verdict_survit_meme_a_u_renforce():
+ """Piege pedagogique : renforcer U fait MONTER le RV -- ca survit encore."""
+ df_o = dso.generer_donnees_continues(seed=42, cacher_u=False, coef_u_x=1.8, coef_u_y=1.8)
+ res = dso.estimer_effet_continu(df_o[["X", "Y", "C"]])
+ rob = dso.robustesse_partielle_r2(res.model, res.estimand, res.estimate)
+ v = dso.verdict_sensibilite(
+ dso.r2_partiel(df_o, "X", "U", ["C"]),
+ dso.r2_partiel(df_o, "Y", "U", ["X", "C"]),
+ rob,
+ )
+ assert rob.robustness_value > 0.8, "le RV doit grimper avec U"
+ assert v["verdict"] == "SURVIT_A_CE_CONFOUNDEUR"
+
+
+def test_verdict_annulable_monde_affaibli():
+ """Signal affaibli (tau=0.2, bruit_y=3.0) : RV ~0.25 passe sous R2 U."""
+ df_o = dso.generer_donnees_continues(seed=42, cacher_u=False, tau=0.2, bruit_y=3.0)
+ res = dso.estimer_effet_continu(df_o[["X", "Y", "C"]])
+ rob = dso.robustesse_partielle_r2(res.model, res.estimand, res.estimate)
+ v = dso.verdict_sensibilite(
+ dso.r2_partiel(df_o, "X", "U", ["C"]),
+ dso.r2_partiel(df_o, "Y", "U", ["X", "C"]),
+ rob,
+ )
+ assert res.value > 0, "l'association reste observable"
+ assert v["verdict"] == "ANNULABLE_PAR_CE_CONFOUNDEUR"
+ assert "RESULTAT" in v["message"]
+
+
+def test_verdict_annulable_cas_unitaire():
+ """Branche ANNULABLE sur entrees synthetiques (fonction pure)."""
+ rob = dso.ResultatRobustesse(
+ robustness_value=0.3, robustness_value_alpha=0.25, r2yt_w=0.5,
+ stats={}, benchmarking=pd.DataFrame(), analyzer=None,
+ )
+ v = dso.verdict_sensibilite(0.5, 0.4, rob)
+ assert v["verdict"] == "ANNULABLE_PAR_CE_CONFOUNDEUR"
+ assert "RESULTAT" in v["message"]
+
+
+# ---------------------------------------------------------------------------
+# (e) Confondeur simule : courbe de bascule reproductible
+# ---------------------------------------------------------------------------
+def test_courbe_bascule_reproductible_et_croise_zero():
+ """La courbe (re-seed global) est identique d'un appel a l'autre."""
+ df = dso.generer_donnees_continues(seed=42)
+ res = dso.estimer_effet_continu(df)
+ t1 = dso.confondeur_simule(res.model, res.estimand, res.estimate,
+ k_fixe=0.7, k_max=1.8, pas=0.2)
+ t2 = dso.confondeur_simule(res.model, res.estimand, res.estimate,
+ k_fixe=0.7, k_max=1.8, pas=0.2)
+ pd.testing.assert_frame_equal(t1, t2)
+ assert abs(float(t1.iloc[-1]["estime_ajuste"]) - (-0.043)) < 0.03
+ kappa = dso.kappa_bascule(t1)
+ assert kappa is not None and 1.3 < kappa < 1.8
+
+
+def test_courbe_bascule_diagonale():
+ """A force egale des deux cotes, la bascule tombe vers kappa ~1.06."""
+ df = dso.generer_donnees_continues(seed=42)
+ res = dso.estimer_effet_continu(df)
+ t = dso.confondeur_simule(res.model, res.estimand, res.estimate,
+ k_max=1.4, pas=0.1, diagonale=True)
+ assert (t["kappa_t"] == t["k"]).all(), "diagonale : meme force des deux cotes"
+ assert float(t.iloc[0]["estime_ajuste"]) == pytest.approx(res.value, abs=1e-6), (
+ "k=0 sans confondeur simule doit rendre l'estime initial"
+ )
+ kappa = dso.kappa_bascule(t)
+ assert kappa is not None and 0.9 < kappa < 1.3
+
+
+def test_kappa_bascule_sans_croisement():
+ tab = pd.DataFrame({"k": [0.0, 0.5, 1.0], "estime_ajuste": [1.0, 0.5, 0.1]})
+ assert dso.kappa_bascule(tab) is None
+
+
+# ---------------------------------------------------------------------------
+# (f) Monde B : RR sur le coefficient, pas le contraste marginal
+# ---------------------------------------------------------------------------
+def test_rr_binaire_sur_le_coefficient():
+ """RR ~1.79 (biais de U au-dessus du vrai 1.49) ; le piege .value ~1.04."""
+ df = dso.generer_donnees_binaires(seed=42)
+ rr = dso.estimer_rr_binaire(df)
+ assert abs(rr.rr - 1.790) < 0.01
+ assert rr.rr_inf < rr.rr < rr.rr_sup
+ assert abs(rr.rr_inf - 1.352) < 0.02 and abs(rr.rr_sup - 2.371) < 0.02
+ # le piege encapsule : le contraste marginal n'est PAS le RR
+ assert abs(float(rr.estimate.value) - rr.rr) > 0.3
+
+
+# ---------------------------------------------------------------------------
+# (g) E-value dowhy natif + benchmark McGowan-Greevy
+# ---------------------------------------------------------------------------
+def test_e_value_valeurs_et_formule():
+ """E-value ~2.98, exactement RR + sqrt(RR(RR-1)) ; benchmark C ~1.16."""
+ df = dso.generer_donnees_binaires(seed=42)
+ rr = dso.estimer_rr_binaire(df)
+ ev = dso.sensibilite_e_value(rr.model, rr.estimand, rr.estimate)
+ assert abs(ev.rr_converti - 1.790) < 0.01
+ assert abs(ev.evalue_estime - 2.9796) < 0.01
+ assert ev.evalue_ic_limite is not None
+ assert abs(ev.evalue_ic_limite - 2.0409) < 0.01
+ assert ev.evalue_ic_limite < ev.evalue_estime, "l'IC est plus fragile que l'estime"
+ # controle independant : formule fermee de VanderWeele-Ding
+ formule = ev.rr_converti + np.sqrt(ev.rr_converti * (ev.rr_converti - 1))
+ assert abs(formule - ev.evalue_estime) < 1e-9
+ bench = float(ev.benchmarking["observed_covariate_e_value"].iloc[0])
+ assert abs(bench - 1.160) < 0.01
+
+
+def test_verdict_e_value_robuste_relativement_aux_observes():
+ df = dso.generer_donnees_binaires(seed=42)
+ rr = dso.estimer_rr_binaire(df)
+ ev = dso.sensibilite_e_value(rr.model, rr.estimand, rr.estimate)
+ v = dso.verdict_e_value(ev)
+ assert v["verdict"] == "ROBUSTE_RELATIVEMENT_AUX_OBSERVES"
+ assert abs(v["rapport"] - 2.57) < 0.15
+ assert "RESULTAT" in v["message"]
+
+
+# ---------------------------------------------------------------------------
+# (h) Bornes de Rosenbaum exactes
+# ---------------------------------------------------------------------------
+def test_paires_appariees_reproductibles():
+ df = dso.generer_donnees_binaires(seed=42)
+ d1 = dso.paires_appariees(df, seed=0)
+ d2 = dso.paires_appariees(df, seed=0)
+ assert (m := len(d1)) == 193
+ assert int(d1.sum()) == 122
+ np.testing.assert_array_equal(d1, d2)
+
+
+def test_bornes_rosenbaum_proprietes():
+ """Gamma=1 : bornes egales a la p-valeur observee ; la borne haute croit."""
+ s, m = 122, 193
+ p_bas, p_haut = dso.bornes_rosenbaum(s, m, 1.0)
+ assert p_bas == pytest.approx(p_haut)
+ assert p_haut == pytest.approx(1.48e-04, rel=0.05)
+ precedente = p_haut
+ for g in (1.2, 1.5, 2.0, 3.0):
+ lo, hi = dso.bornes_rosenbaum(s, m, g)
+ assert lo < p_bas, "la borne basse descend avec Gamma"
+ assert hi > precedente, "la borne haute monte avec Gamma"
+ precedente = hi
+ assert dso.bornes_rosenbaum(s, m, 1.0)[0] == pytest.approx(
+ dso.bornes_rosenbaum(s, m, 1.0)[1]
+ )
+
+
+def test_gamma_critique_rend_non_significatif():
+ s, m = 122, 193
+ g = dso.gamma_critique(s, m)
+ assert abs(g - 1.332) < 0.01
+ # a Gamma*, la borne haute atteint exactement le seuil
+ _, p_haut = dso.bornes_rosenbaum(s, m, g)
+ assert p_haut == pytest.approx(0.05, abs=1e-6)
+ # juste en dessous, l'effet reste significatif dans le pire des mondes
+ _, p_haut_avant = dso.bornes_rosenbaum(s, m, g - 0.05)
+ assert p_haut_avant < 0.05
+
+
+def test_bornes_rosenbaum_gamma_invalide():
+ with pytest.raises(ValueError):
+ dso.bornes_rosenbaum(10, 20, 0.5)
+
+
+# ---------------------------------------------------------------------------
+# (i) Anti-derive : le notebook consomme l'organe
+# ---------------------------------------------------------------------------
+def _lire_cellule(nb_path: Path, cell_index: int) -> str:
+ nb = json.load(open(nb_path, encoding="utf-8"))
+ return "".join(nb["cells"][cell_index]["source"])
+
+
+def test_notebook_cellule_dgp_byte_identique_module():
+ """La cellule DGP (index 3) consomme l'organe, sans redefinition locale."""
+ src = _lire_cellule(NB_PATH, 3)
+ assert "dso.generer_donnees_continues" in src
+ g: dict = {"dso": dso}
+ exec(compile(src, "", "exec"), g)
+ pd.testing.assert_frame_equal(
+ g["df_monde"], dso.generer_donnees_continues(n=2000, seed=42)
+ )
+
+
+def test_notebook_cellule_robustesse_consomme_lorgane():
+ src = _lire_cellule(NB_PATH, 9)
+ assert "dso.robustesse_partielle_r2" in src
+
+
+def test_notebook_cellule_evalue_consomme_lorgane():
+ src = _lire_cellule(NB_PATH, 23)
+ assert "dso.sensibilite_e_value" in src
+ verdict_src = _lire_cellule(NB_PATH, 25)
+ assert "dso.verdict_e_value" in verdict_src
+
+
+def test_notebook_sans_erreur_volontaire_et_trois_exercices():
+ """C.1 : aucun raise/assert/1-0 volontaire ; 3 stubs TODO etudiant."""
+ nb = json.load(open(NB_PATH, encoding="utf-8"))
+ tout = "\n".join("".join(c["source"]) for c in nb["cells"] if c["cell_type"] == "code")
+ assert "raise NotImplementedError" not in tout
+ assert "assert False" not in tout
+ assert "1/0" not in tout
+ assert tout.count("TODO etudiant") >= 3
+ # et le notebook execute : toutes les cellules code ont un execution_count
+ assert all(
+ c.get("execution_count") is not None
+ for c in nb["cells"]
+ if c["cell_type"] == "code"
+ )