cde_simulation.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "005359b9-90ab-434e-8004-bc97b5a1b2ad",
   "metadata": {},
   "source": [
    "# Weighted CDE estimation for a linear-Gaussian DAG\n",
    "\n",
    "May 2024"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7c81eae6-286d-48b2-858d-4d9dd67877c2",
   "metadata": {},
   "source": [
    "## Preamble"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "a1a15256-fe3c-45b7-822d-022215b9f6c2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "python version     : 3.10.13\n",
      "numpy version      : 1.26.3\n",
      "pandas version     : 2.1.4\n",
      "matplotlib version : 3.8.0\n",
      "seaborn version    : 0.12.2\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n"
     ]
    }
   ],
   "source": [
    "# General importations.\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import sys\n",
    "import time\n",
    "import platform\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib\n",
    "import seaborn as sns\n",
    "from scipy import stats\n",
    "\n",
    "import networkx as nx\n",
    "from sklearn.metrics import accuracy_score, f1_score, precision_score, recall_score\n",
    "from sklearn.linear_model import LinearRegression\n",
    "\n",
    "# Custom scripts.\n",
    "from ld3 import LD3\n",
    "from ldp import LDP\n",
    "from ldp_utils import LDPUtils\n",
    "from effect_estimation import EstimationPipeline\n",
    "from data_generation import DataGeneration\n",
    "\n",
    "plt.rcParams[\"figure.figsize\"] = (4,4)\n",
    "\n",
    "# View versioning.\n",
    "print(\"python version     :\", platform.python_version())\n",
    "print(\"numpy version      :\", np.__version__)\n",
    "print(\"pandas version     :\", pd.__version__)\n",
    "print(\"matplotlib version :\", matplotlib.__version__)\n",
    "print(\"seaborn version    :\", sns.__version__)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "29303497-4b67-4f20-94f8-179ad88fc91b",
   "metadata": {},
   "source": [
    "## Define functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "71fb8b91-9935-42dd-a732-8f49380cab37",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_ATE(data: pd.DataFrame, \n",
    "            x: str, \n",
    "            y: str, \n",
    "            covar: list, \n",
    "            model: str = \"linear\") -> float:\n",
    "    if model == \"linear\":\n",
    "        reg = LinearRegression().fit(data[[x] + covar], data[y])\n",
    "    elif model == \"logistic\":\n",
    "        reg = LogisticRegression(penalty = None, max_iter = 500).fit(data[[x] + covar], data[y])\n",
    "    ate = reg.coef_[0]\n",
    "    return ate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "a9b65517-f985-438f-8633-b7cab3cb895f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_nx(adjacency_matrix,\n",
    "            labels,\n",
    "            figsize = (10,10),\n",
    "            dpi = 200,\n",
    "            node_size = 800,\n",
    "            arrow_size = 10):\n",
    "    \n",
    "    g = nx.from_numpy_array(adjacency_matrix, create_using = nx.DiGraph)\n",
    "    plt.figure(figsize = figsize, dpi = dpi)  \n",
    "    nx.draw_shell(g, \n",
    "                 node_size = node_size, \n",
    "                 labels = dict(zip(list(range(len(labels))), labels)), \n",
    "                 arrowsize = arrow_size,\n",
    "                 node_color = \"pink\",\n",
    "                 with_labels = True)\n",
    "    plt.show()\n",
    "    plt.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "efabb35e-da47-4f16-936a-b393365f9270",
   "metadata": {},
   "source": [
    "## Estimation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "c4b940bb-881a-40da-85a4-858225ca06a9",
   "metadata": {},
   "outputs": [],
   "source": [
    "dg = DataGeneration()\n",
    "ldputils = LDPUtils()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "3687ad0e-f30d-4f6d-a05b-59f3c1cfeef2",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%capture\n",
    "replicates = 100\n",
    "f1_list = []\n",
    "precision_list = []\n",
    "recall_list = []\n",
    "sdc_list = []\n",
    "cde_list = []\n",
    "x_causes_y = 1\n",
    "true_acde = [\"Z1\", \"Z4b\", \"Z3c\", \"Z3d\", \"B2\", \"B3\", \"M2\"]\n",
    "for rep in range(replicates):\n",
    "    df = dg.generate_linear_gaussian(n = 10000,\n",
    "                                     x_causes_y = x_causes_y,\n",
    "                                     xy_coeff = 1.25,\n",
    "                                     coefficient_range = (0.75, 1.1))\n",
    "    display(df.head())\n",
    "\n",
    "    ld3 = LD3(data = df, \n",
    "              independence_test = \"fisher\")\n",
    "    start = time.time()\n",
    "    sdc,acde = ld3.get_sdc_cde_adjustment(exposure = \"X\", \n",
    "                                          outcome = \"Y\",\n",
    "                                          alpha = 0.01)\n",
    "    print(\"\\nResults complete in {}s.\".format(round(time.time() - start, 4)))\n",
    "    print(\"Total independence tests performed:\", ld3.total_tests)\n",
    "    \n",
    "    print(\"\\nSDC =\", sdc)\n",
    "    if not sdc:\n",
    "        print(\"No direct discrimination detected.\")\n",
    "    else:\n",
    "        print(\"Direct discrimination detected.\")\n",
    "    print(\"\\nTrue A_CDE      =\", sorted(true_acde))\n",
    "    print(\"Predicted A_CDE =\", sorted(acde))\n",
    "    cde = get_ATE(df, \n",
    "                  x = \"X\", \n",
    "                  y = \"Y\", \n",
    "                  covar = acde)\n",
    "    print(\"\\nPredicted weighted CDE:\", cde)\n",
    "    \n",
    "    bool_true = [1 if x in true_acde else 0 for x in df.columns]\n",
    "    bool_pred = [1 if x in acde else 0 for x in df.columns]\n",
    "    f1 = f1_score(bool_true, bool_pred)\n",
    "    precision = precision_score(bool_true, bool_pred)\n",
    "    recall = recall_score(bool_true, bool_pred)\n",
    "    f1_list.append(f1)\n",
    "    precision_list.append(precision)\n",
    "    recall_list.append(recall)\n",
    "    sdc_list.append(sdc == x_causes_y)\n",
    "    cde_list.append(cde)\n",
    "    print(\"\\nF1:\", f1)\n",
    "    print(\"Precision:\", precision)\n",
    "    print(\"Recall:\", recall)\n",
    "    print()\n",
    "    \n",
    "    df_results = pd.DataFrame({\"Variable\": ld3.pred_label_dict.keys(),\n",
    "                               \"Label\": ld3.pred_label_dict.values()})\n",
    "    display(df_results)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "7f59641b-44b1-449d-8792-92ed427d0093",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SDC accuracy: 1.0\n",
      "Mean weighted CDE 1.25 [1.25,1.26] (variance = 0.0016820754149553868).\n",
      "\n",
      "Mean F1         = 0.99 [0.99,1.0]\n",
      "Mean precision  = 0.99 [0.98,1.0]\n",
      "Mean recall     = 1.0 [1.0,1.0]\n",
      "Mean F1         = 0.99 [0.99,1.0]\n"
     ]
    }
   ],
   "source": [
    "print(\"SDC accuracy:\", np.sum(sdc_list) / len(sdc_list))\n",
    "mean, ci = ldputils.get_ci(cde_list)\n",
    "print(\"Mean weighted CDE {} [{},{}] (variance = {}).\".format(round(mean,2), round(ci[0],2), round(ci[1],2), np.var(cde_list)))\n",
    "\n",
    "mean, ci = ldputils.get_ci(f1_list)\n",
    "print(\"\\nMean F1         = {} [{},{}]\".format(round(mean,2), round(ci[0],2), round(ci[1],2)))\n",
    "mean, ci = ldputils.get_ci(precision_list)\n",
    "print(\"Mean precision  = {} [{},{}]\".format(round(mean,2), round(ci[0],2), round(ci[1],2)))\n",
    "mean, ci = ldputils.get_ci(recall_list)\n",
    "print(\"Mean recall     = {} [{},{}]\".format(round(mean,2), round(ci[0],2), round(ci[1],2)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4488cb8c-454c-4d08-9ea4-af9db52a4ff6",
   "metadata": {},
   "source": [
    "## End of document"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "ICP",
   "language": "python",
   "name": "icp"
  },
  "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.10.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}