diff --git a/docs/source/example_notebooks/dowhy_causal_discovery_example.ipynb b/docs/source/example_notebooks/dowhy_causal_discovery_example.ipynb index f1f3096095..22e5b8a53a 100644 --- a/docs/source/example_notebooks/dowhy_causal_discovery_example.ipynb +++ b/docs/source/example_notebooks/dowhy_causal_discovery_example.ipynb @@ -6,12 +6,12 @@ "source": [ "# Causal Discovery example\n", "\n", - "The goal of this notebook is to show how causal discovery methods can work with DoWhy. We use discovery methods from [Causal Discovery Tool (CDT)](https://github.com/FenTechSolutions/CausalDiscoveryToolbox) repo. As we will see, causal discovery methods are not fool-proof and there is no guarantee that they will recover the correct causal graph. Even for the simple examples below, there is a large variance in results. These methods, however, may be combined usefully with domain knowledge to construct the final causal graph." + "The goal of this notebook is to show how causal discovery methods can work with DoWhy. We use discovery methods from [causal-learn](https://github.com/py-why/causal-learn) repo. As we will see, causal discovery methods require appropriate assumptions for the correctness guarantees, adn thus there will be variance across results returned by different methods in practice. These methods, however, may be combined usefully with domain knowledge to construct the final causal graph." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -37,7 +37,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -67,7 +67,7 @@ "source": [ "# Experiments on the Auto-MPG dataset\n", "\n", - "In this section, we will use a dataset on the technical specification of cars. The dataset is downloaded from UCI Machine Learning Repository. The dataset contains 9 attributes and 398 instances. We do not know the true causal graph for the dataset and will use CDT to discover it. The causal graph obtained will then be used to estimate the causal effect.\n" + "In this section, we will use a dataset on the technical specification of cars. The dataset is downloaded from UCI Machine Learning Repository. The dataset contains 9 attributes and 398 instances. We do not know the true causal graph for the dataset and will use causal-learn to discover it. The causal graph obtained will then be used to estimate the causal effect.\n" ] }, { @@ -79,9 +79,109 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(392, 6)\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
mpgcylindersdisplacementhorsepowerweightacceleration
018.08.0307.0130.03504.012.0
115.08.0350.0165.03693.011.5
218.08.0318.0150.03436.011.0
316.08.0304.0150.03433.012.0
417.08.0302.0140.03449.010.5
\n", + "
" + ], + "text/plain": [ + " mpg cylinders displacement horsepower weight acceleration\n", + "0 18.0 8.0 307.0 130.0 3504.0 12.0\n", + "1 15.0 8.0 350.0 165.0 3693.0 11.5\n", + "2 18.0 8.0 318.0 150.0 3436.0 11.0\n", + "3 16.0 8.0 304.0 150.0 3433.0 12.0\n", + "4 17.0 8.0 302.0 140.0 3449.0 10.5" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "data_mpg = pd.read_csv('http://archive.ics.uci.edu/ml/machine-learning-databases/auto-mpg/auto-mpg.data-original',\n", " delim_whitespace=True, header=None,\n", @@ -98,354 +198,992 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Causal Discovery with Causal Discovery Tool (CDT)\n", + "# Causal Discovery with causal-learn\n", "\n", - "We use the CDT library to perform causal discovery on the Auto-MPG dataset. We use three methods for causal discovery here -LiNGAM, PC and GES. These methods are widely used and do not take much time to run. Hence, these are ideal for an introduction to the topic. Other neural network based methods are also available in CDT and the users are encouraged to try them out by themselves. \n", + "We use the causal-learn library to perform causal discovery on the Auto-MPG dataset. We use three methods for causal discovery here: PC, FCI and GES. These methods are widely used and do not take much time to run. Hence, these are ideal for an introduction to the topic. Causal-learn provides a comprehensive list of well-tested causal-discovery methods, and readers are welcome to explore.\n", "\n", "The documentation for the methods used are as follows:\n", - "- LiNGAM [[link]](https://fentechsolutions.github.io/CausalDiscoveryToolbox/html/_modules/cdt/causality/graph/LiNGAM.html)\n", - "- PC [[link]](https://fentechsolutions.github.io/CausalDiscoveryToolbox/html/_modules/cdt/causality/graph/PC.html)\n", - "- GES [[link]](https://fentechsolutions.github.io/CausalDiscoveryToolbox/html/_modules/cdt/causality/graph/GES.html)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from cdt.causality.graph import LiNGAM, PC, GES\n", + "- PC [[link]](https://causal-learn.readthedocs.io/en/latest/search_methods_index/Constraint-based%20causal%20discovery%20methods/PC.html)\n", + "- GES [[link]](https://causal-learn.readthedocs.io/en/latest/search_methods_index/Score-based%20causal%20discovery%20methods/GES.html)\n", + "- LiNGAM [[link]](https://causal-learn.readthedocs.io/en/latest/search_methods_index/Causal%20discovery%20methods%20based%20on%20constrained%20functional%20causal%20models/lingam.html#ica-based-lingam)\n", "\n", - "graphs = {}\n", - "labels = [f'{col}' for i, col in enumerate(data_mpg.columns)]\n", - "functions = {\n", - " 'LiNGAM' : LiNGAM,\n", - " 'PC' : PC,\n", - " 'GES' : GES,\n", - "}\n", - "\n", - "for method, lib in functions.items():\n", - " obj = lib()\n", - " output = obj.predict(data_mpg)\n", - " adj_matrix = nx.to_numpy_array(output)\n", - " adj_matrix = np.asarray(adj_matrix)\n", - " graph_dot = make_graph(adj_matrix, labels)\n", - " graphs[method] = graph_dot\n", - "\n", - "# Visualize graphs\n", - "for method, graph in graphs.items():\n", - " print(\"Method : %s\"%(method))\n", - " display(graph)" + "More methods could be found in the causal-learn documentation [[link]](https://causal-learn.readthedocs.io/en/latest/)." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "As you can see, no two methods agree on the graphs. PC and GES effectively produce an undirected graph whereas LiNGAM produces a directed graph. We use only the LiNGAM method in the next section." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Estimate causal effects using Linear Regression\n", - "\n", - "Now let us see whether these differences in the graphs also lead to significant differences in the causal estimate of effect of *mpg* on *weight*." + "We first try the PC algorithm with default parameters." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "1ed197e9f5ec42c8bf7fc51c5ece4485", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/6 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "for method, graph in graphs.items():\n", - " if method != \"LiNGAM\":\n", - " continue\n", - " print('\\n*****************************************************************************\\n')\n", - " print(\"Causal Discovery Method : %s\"%(method))\n", - " \n", - " # Obtain valid dot format\n", - " graph_dot = str_to_dot(graph.source)\n", - "\n", - " # Define Causal Model\n", - " model=CausalModel(\n", - " data = data_mpg,\n", - " treatment='mpg',\n", - " outcome='weight',\n", - " graph=graph_dot)\n", - "\n", - " # Identification\n", - " identified_estimand = model.identify_effect(proceed_when_unidentifiable=True)\n", - " print(identified_estimand)\n", - " \n", - " # Estimation\n", - " estimate = model.estimate_effect(identified_estimand,\n", - " method_name=\"backdoor.linear_regression\",\n", - " control_value=0,\n", - " treatment_value=1,\n", - " confidence_intervals=True,\n", - " test_significance=True)\n", - " print(\"Causal Estimate is \" + str(estimate.value))" + "from causallearn.search.ConstraintBased.PC import pc\n", + "\n", + "labels = [f'{col}' for i, col in enumerate(data_mpg.columns)]\n", + "data = data_mpg.to_numpy()\n", + "\n", + "cg = pc(data)\n", + "\n", + "# Visualization using pydot\n", + "from causallearn.utils.GraphUtils import GraphUtils\n", + "import matplotlib.image as mpimg\n", + "import matplotlib.pyplot as plt\n", + "import io\n", + "\n", + "pyd = GraphUtils.to_pydot(cg.G, labels=labels)\n", + "tmp_png = pyd.create_png(f=\"png\")\n", + "fp = io.BytesIO(tmp_png)\n", + "img = mpimg.imread(fp, format='png')\n", + "plt.axis('off')\n", + "plt.imshow(img)\n", + "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "As mentioned earlier, due to the absence of directed edges, no backdoor, instrmental or frontdoor variables can be found out for PC and GES. Thus, causal effect estimation is not possible for these methods. However, LiNGAM does discover a DAG and hence, its possible to output a causal estimate for LiNGAM. The estimate is still pretty far from the original estimate of -70.466 (which can be calculated from the graph)." + "Then we have a causal graph discovered by PC. Let us also try GES to see its result." ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": 5, "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "# Experiments on the Sachs dataset\n", + "from causallearn.search.ScoreBased.GES import ges\n", "\n", - "The dataset consists of the simultaneous measurements of 11 phosphorylated proteins and phospholipids derived from thousands of individual primary immune system cells, subjected to both general and specific molecular interventions (Sachs et al., 2005).\n", + "# default parameters\n", + "Record = ges(data)\n", "\n", - "The specifications of the dataset are as follows - \n", - "- Number of nodes: 11\n", - "- Number of arcs: 17\n", - "- Number of parameters: 178\n", - "- Average Markov blanket size: 3.09\n", - "- Average degree: 3.09\n", - "- Maximum in-degree: 3\n", - "- Number of instances: 7466\n", + "# Visualization using pydot\n", + "from causallearn.utils.GraphUtils import GraphUtils\n", + "import matplotlib.image as mpimg\n", + "import matplotlib.pyplot as plt\n", + "import io\n", "\n", - "The original causal graph is known for the Sachs dataset and we compare the original graph with the ones discovered using CDT in this section." + "pyd = GraphUtils.to_pydot(Record['G'], labels=labels)\n", + "tmp_png = pyd.create_png(f=\"png\")\n", + "fp = io.BytesIO(tmp_png)\n", + "img = mpimg.imread(fp, format='png')\n", + "plt.axis('off')\n", + "plt.imshow(img)\n", + "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## 1. Load the data" + "Well, these two results are different, which is not rare when applying causal discovery on real-world dataset, since the required assumptions on the data-generating process are hard to verify.\n", + "\n", + "In addition, the graphs returned by PC and GES are CPDAGs instead of DAGs, so it is possible to have undirected edges (e.g., the result returned by GES). Thus, causal effect estimataion is difficult for those methods, since there may be absence of backdoor, instrumental or frontdoor variables. In order to get a DAG, we decide to try LiNGAM on our dataset." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/svg+xml": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "%3\n", + "\n", + "\n", + "\n", + "mpg\n", + "\n", + "mpg\n", + "\n", + "\n", + "\n", + "displacement\n", + "\n", + "displacement\n", + "\n", + "\n", + "\n", + "mpg->displacement\n", + "\n", + "\n", + "-0.64\n", + "\n", + "\n", + "\n", + "horsepower\n", + "\n", + "horsepower\n", + "\n", + "\n", + "\n", + "mpg->horsepower\n", + "\n", + "\n", + "-1.40\n", + "\n", + "\n", + "\n", + "weight\n", + "\n", + "weight\n", + "\n", + "\n", + "\n", + "mpg->weight\n", + "\n", + "\n", + "-17.70\n", + "\n", + "\n", + "\n", + "cylinders\n", + "\n", + "cylinders\n", + "\n", + "\n", + "\n", + "cylinders->mpg\n", + "\n", + "\n", + "-3.55\n", + "\n", + "\n", + "\n", + "cylinders->displacement\n", + "\n", + "\n", + "40.12\n", + "\n", + "\n", + "\n", + "cylinders->horsepower\n", + "\n", + "\n", + "10.14\n", + "\n", + "\n", + "\n", + "acceleration\n", + "\n", + "acceleration\n", + "\n", + "\n", + "\n", + "cylinders->acceleration\n", + "\n", + "\n", + "-0.82\n", + "\n", + "\n", + "\n", + "displacement->weight\n", + "\n", + "\n", + "5.24\n", + "\n", + "\n", + "\n", + "horsepower->displacement\n", + "\n", + "\n", + "0.83\n", + "\n", + "\n", + "\n", + "horsepower->weight\n", + "\n", + "\n", + "6.49\n", + "\n", + "\n", + "\n", + "acceleration->horsepower\n", + "\n", + "\n", + "-4.77\n", + "\n", + "\n", + "\n", + "acceleration->weight\n", + "\n", + "\n", + "61.92\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "from cdt.data import load_dataset\n", - "data_sachs, graph_sachs = load_dataset(\"sachs\")\n", + "from causallearn.search.FCMBased import lingam\n", + "model = lingam.ICALiNGAM()\n", + "model.fit(data)\n", "\n", - "data_sachs.dropna(inplace=True)\n", - "print(data_sachs.shape)\n", - "data_sachs.head()" + "from causallearn.search.FCMBased.lingam.utils import make_dot\n", + "make_dot(model.adjacency_matrix_, labels=labels)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Ground truth of the causal graph" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "labels = [f'{col}' for i, col in enumerate(data_sachs.columns)]\n", - "adj_matrix = nx.to_numpy_array(graph_sachs)\n", - "adj_matrix = np.asarray(adj_matrix)\n", - "graph_dot = make_graph(adj_matrix, labels)\n", - "display(graph_dot)" + "Now we have a DAG and are ready to estimate the causal effects based on that." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "# Causal Discovery with Causal Discovery Tool (CDT)\n", - "\n", - "We use the CDT library to perform causal discovery on the Auto-MPG dataset. We use three methods for causal discovery here -LiNGAM, PC and GES. These methods are widely used and do not take much time to run. Hence, these are ideal for an introduction to the topic. Other neural network based methods are also available in CDT and the users the encourages to try them out by themselves. \n", + "## Estimate causal effects using Linear Regression\n", "\n", - "The documentation for the methods used in as follows:\n", - "- LiNGAM [[link]](https://fentechsolutions.github.io/CausalDiscoveryToolbox/html/_modules/cdt/causality/graph/LiNGAM.html)\n", - "- PC [[link]](https://fentechsolutions.github.io/CausalDiscoveryToolbox/html/_modules/cdt/causality/graph/PC.html)\n", - "- GES [[link]](https://fentechsolutions.github.io/CausalDiscoveryToolbox/html/_modules/cdt/causality/graph/GES.html)" + "Now let us see the estimate of causal effect of *mpg* on *weight*." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Estimand type: EstimandType.NONPARAMETRIC_ATE\n", + "\n", + "### Estimand : 1\n", + "Estimand name: backdoor\n", + "Estimand expression:\n", + " d \n", + "──────(E[weight|cylinders])\n", + "d[mpg] \n", + "Estimand assumption 1, Unconfoundedness: If U→{mpg} and U→weight then P(weight|mpg,cylinders,U) = P(weight|mpg,cylinders)\n", + "\n", + "### Estimand : 2\n", + "Estimand name: iv\n", + "No such variable(s) found!\n", + "\n", + "### Estimand : 3\n", + "Estimand name: frontdoor\n", + "No such variable(s) found!\n", + "\n", + "Causal Estimate is -38.940973656209735\n" + ] + } + ], "source": [ - "from cdt.causality.graph import LiNGAM, PC, GES\n", + "# Obtain valid dot format\n", + "graph_dot = make_graph(model.adjacency_matrix_, labels=labels)\n", "\n", - "graphs = {}\n", - "graphs_nx = {}\n", - "labels = [f'{col}' for i, col in enumerate(data_sachs.columns)]\n", - "functions = {\n", - " 'LiNGAM' : LiNGAM,\n", - " 'PC' : PC,\n", - " 'GES' : GES,\n", - "}\n", - "\n", - "for method, lib in functions.items():\n", - " obj = lib()\n", - " output = obj.predict(data_sachs)\n", - " graphs_nx[method] = output\n", - " adj_matrix = nx.to_numpy_array(output)\n", - " adj_matrix = np.asarray(adj_matrix)\n", - " graph_dot = make_graph(adj_matrix, labels)\n", - " graphs[method] = graph_dot\n", - "\n", - "# Visualize graphs\n", - "for method, graph in graphs.items():\n", - " print(\"Method : %s\"%(method))\n", - " display(graph)" + "# Define Causal Model\n", + "model=CausalModel(\n", + " data = data_mpg,\n", + " treatment='mpg',\n", + " outcome='weight',\n", + " graph=str_to_dot(graph_dot.source))\n", + "\n", + "# Identification\n", + "identified_estimand = model.identify_effect(proceed_when_unidentifiable=True)\n", + "print(identified_estimand)\n", + "\n", + "# Estimation\n", + "estimate = model.estimate_effect(identified_estimand,\n", + " method_name=\"backdoor.linear_regression\",\n", + " control_value=0,\n", + " treatment_value=1,\n", + " confidence_intervals=True,\n", + " test_significance=True)\n", + "print(\"Causal Estimate is \" + str(estimate.value))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "As you can see, no two methods agree on the graphs. Next we study the causal effects of these different graphs" + "# Experiments on the Sachs dataset\n", + "\n", + "The dataset consists of the simultaneous measurements of 11 phosphorylated proteins and phospholipids derived from thousands of individual primary immune system cells, subjected to both general and specific molecular interventions (Sachs et al., 2005).\n", + "\n", + "The specifications of the dataset are as follows - \n", + "- Number of nodes: 11\n", + "- Number of arcs: 17\n", + "- Number of parameters: 178\n", + "- Average Markov blanket size: 3.09\n", + "- Average degree: 3.09\n", + "- Maximum in-degree: 3\n", + "- Number of instances: 7466" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Estimate effects using Linear Regression\n", - "\n", - "Now let us see whether these differences in the graphs also lead to significant differences in the causal estimate of effect of *PIP2* on *PKC*." + "## 1. Load the data" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(7466, 11)\n", + "['raf', 'mek', 'plc', 'pip2', 'pip3', 'erk', 'akt', 'pka', 'pkc', 'p38', 'jnk']\n" + ] + } + ], "source": [ - "for method, graph in graphs.items():\n", - " if method != \"LiNGAM\":\n", - " continue\n", - " print('\\n*****************************************************************************\\n')\n", - " print(\"Causal Discovery Method : %s\"%(method))\n", - "\n", - " # Obtain valid dot format\n", - " graph_dot = str_to_dot(graph.source)\n", - "\n", - " # Define Causal Model\n", - " model=CausalModel(\n", - " data = data_sachs,\n", - " treatment='PIP2',\n", - " outcome='PKC',\n", - " graph=graph_dot)\n", - "\n", - " # Identification\n", - " identified_estimand = model.identify_effect(proceed_when_unidentifiable=True)\n", - " print(identified_estimand)\n", - "\n", - " # Estimation\n", - " estimate = model.estimate_effect(identified_estimand,\n", - " method_name=\"backdoor.linear_regression\",\n", - " control_value=0,\n", - " treatment_value=1,\n", - " confidence_intervals=True,\n", - " test_significance=True)\n", - " print(\"Causal Estimate is \" + str(estimate.value))" + "from causallearn.utils.Dataset import load_dataset\n", + "\n", + "data_sachs, labels = load_dataset(\"sachs\")\n", + "\n", + "print(data.shape)\n", + "print(labels)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "From the causal estimates obtained, it can be seen that the three estimates differ in different aspects. The graph obtained using LiNGAM contains a backdoor path and instrumental variables. On the other hand, the graph obtained using PC contains a backdoor path and a frontdoor path. However, despite these differences, both obtain the same mean causal estimate.\n", + "# Causal Discovery with causal-learn\n", "\n", - "The graph obtained using GES contains only a backdoor path with different backdoor variables and obtains a different causal estimate than the first two cases. " + "We use the three causal discovery methods mentioned above (PC, GES, and LiNGAM) to find the causal graphs." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Graph Validation\n", - "\n", - "We compare the graphs obtained with the true causal graph using the causal discovery methods using 2 graph distance metrics - Structural Hamming Distance (SHD) and Structural Intervention Distance (SID). SHD between two graphs is, in simple terms, the number of edge insertions, deletions or flips in order to transform one graph to another graph. SID, on the other hand, is based on a graphical criterion only and quantifies the closeness between two DAGs in terms of their corresponding causal inference statements." + "First, let us take a look at how PC works." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "bc0f31d1492e4934994a6d4ba68f1ad3", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/11 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "from cdt.metrics import SHD, SHD_CPDAG, SID, SID_CPDAG\n", - "from numpy.random import randint\n", - "\n", - "for method, graph in graphs_nx.items():\n", - " print(\"***********************************************************\")\n", - " print(\"Method: %s\"%(method))\n", - " tar, pred = graph_sachs, graph\n", - " print(\"SHD_CPDAG = %f\"%(SHD_CPDAG(tar, pred)))\n", - " print(\"SHD = %f\"%(SHD(tar, pred, double_for_anticausal=False)))\n", - " print(\"SID_CPDAG = [%f, %f]\"%(SID_CPDAG(tar, pred)))\n", - " print(\"SID = %f\"%(SID(tar, pred)))" + "graphs = {}\n", + "graphs_nx = {}\n", + "labels = [f'{col}' for i, col in enumerate(labels)]\n", + "data = data_sachs\n", + "\n", + "from causallearn.search.ConstraintBased.PC import pc\n", + "\n", + "cg = pc(data)\n", + "\n", + "# Visualization using pydot\n", + "from causallearn.utils.GraphUtils import GraphUtils\n", + "import matplotlib.image as mpimg\n", + "import matplotlib.pyplot as plt\n", + "import io\n", + "\n", + "pyd = GraphUtils.to_pydot(cg.G, labels=labels)\n", + "tmp_png = pyd.create_png(f=\"png\")\n", + "fp = io.BytesIO(tmp_png)\n", + "img = mpimg.imread(fp, format='png')\n", + "plt.axis('off')\n", + "plt.imshow(img)\n", + "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "The graph similarity metrics show that the scores are the lowest for the LiNGAM method of graph extraction. Hence, of the three methods used, LiNGAM provides the graph that is most similar to the original graph." + "Then, let us try GES." ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": 16, "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "## Graph Refutation\n", + "from causallearn.search.ScoreBased.GES import ges\n", + "\n", + "# default parameters\n", + "Record = ges(data)\n", "\n", - "Here, we use the same SHD and SID metric to find out how different the discovered graph are from each other." + "# Visualization using pydot\n", + "from causallearn.utils.GraphUtils import GraphUtils\n", + "import matplotlib.image as mpimg\n", + "import matplotlib.pyplot as plt\n", + "import io\n", + "\n", + "pyd = GraphUtils.to_pydot(Record['G'], labels=labels)\n", + "tmp_png = pyd.create_png(f=\"png\")\n", + "fp = io.BytesIO(tmp_png)\n", + "img = mpimg.imread(fp, format='png')\n", + "plt.axis('off')\n", + "plt.imshow(img)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "And also LiNGAM." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 25, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/svg+xml": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "%3\n", + "\n", + "\n", + "\n", + "raf\n", + "\n", + "raf\n", + "\n", + "\n", + "\n", + "mek\n", + "\n", + "mek\n", + "\n", + "\n", + "\n", + "raf->mek\n", + "\n", + "\n", + "1.48\n", + "\n", + "\n", + "\n", + "pka\n", + "\n", + "pka\n", + "\n", + "\n", + "\n", + "raf->pka\n", + "\n", + "\n", + "0.55\n", + "\n", + "\n", + "\n", + "pkc\n", + "\n", + "pkc\n", + "\n", + "\n", + "\n", + "raf->pkc\n", + "\n", + "\n", + "-0.13\n", + "\n", + "\n", + "\n", + "jnk\n", + "\n", + "jnk\n", + "\n", + "\n", + "\n", + "raf->jnk\n", + "\n", + "\n", + "-0.02\n", + "\n", + "\n", + "\n", + "mek->pka\n", + "\n", + "\n", + "-0.50\n", + "\n", + "\n", + "\n", + "mek->pkc\n", + "\n", + "\n", + "0.10\n", + "\n", + "\n", + "\n", + "p38\n", + "\n", + "p38\n", + "\n", + "\n", + "\n", + "mek->p38\n", + "\n", + "\n", + "0.03\n", + "\n", + "\n", + "\n", + "plc\n", + "\n", + "plc\n", + "\n", + "\n", + "\n", + "plc->raf\n", + "\n", + "\n", + "0.14\n", + "\n", + "\n", + "\n", + "plc->mek\n", + "\n", + "\n", + "0.04\n", + "\n", + "\n", + "\n", + "pip2\n", + "\n", + "pip2\n", + "\n", + "\n", + "\n", + "plc->pip2\n", + "\n", + "\n", + "1.58\n", + "\n", + "\n", + "\n", + "akt\n", + "\n", + "akt\n", + "\n", + "\n", + "\n", + "plc->akt\n", + "\n", + "\n", + "0.28\n", + "\n", + "\n", + "\n", + "plc->pka\n", + "\n", + "\n", + "-0.49\n", + "\n", + "\n", + "\n", + "plc->pkc\n", + "\n", + "\n", + "0.05\n", + "\n", + "\n", + "\n", + "plc->p38\n", + "\n", + "\n", + "0.06\n", + "\n", + "\n", + "\n", + "plc->jnk\n", + "\n", + "\n", + "0.10\n", + "\n", + "\n", + "\n", + "pip2->pkc\n", + "\n", + "\n", + "0.03\n", + "\n", + "\n", + "\n", + "pip3\n", + "\n", + "pip3\n", + "\n", + "\n", + "\n", + "pip3->mek\n", + "\n", + "\n", + "-0.06\n", + "\n", + "\n", + "\n", + "pip3->plc\n", + "\n", + "\n", + "0.37\n", + "\n", + "\n", + "\n", + "pip3->pip2\n", + "\n", + "\n", + "0.80\n", + "\n", + "\n", + "\n", + "pip3->akt\n", + "\n", + "\n", + "-0.17\n", + "\n", + "\n", + "\n", + "pip3->pkc\n", + "\n", + "\n", + "-0.10\n", + "\n", + "\n", + "\n", + "pip3->jnk\n", + "\n", + "\n", + "-0.05\n", + "\n", + "\n", + "\n", + "erk\n", + "\n", + "erk\n", + "\n", + "\n", + "\n", + "erk->raf\n", + "\n", + "\n", + "-1.47\n", + "\n", + "\n", + "\n", + "erk->mek\n", + "\n", + "\n", + "-0.24\n", + "\n", + "\n", + "\n", + "erk->plc\n", + "\n", + "\n", + "0.59\n", + "\n", + "\n", + "\n", + "erk->akt\n", + "\n", + "\n", + "1.90\n", + "\n", + "\n", + "\n", + "erk->pka\n", + "\n", + "\n", + "4.81\n", + "\n", + "\n", + "\n", + "erk->pkc\n", + "\n", + "\n", + "-0.33\n", + "\n", + "\n", + "\n", + "erk->p38\n", + "\n", + "\n", + "-0.16\n", + "\n", + "\n", + "\n", + "erk->jnk\n", + "\n", + "\n", + "-0.29\n", + "\n", + "\n", + "\n", + "akt->raf\n", + "\n", + "\n", + "0.75\n", + "\n", + "\n", + "\n", + "akt->mek\n", + "\n", + "\n", + "0.15\n", + "\n", + "\n", + "\n", + "akt->pka\n", + "\n", + "\n", + "-0.58\n", + "\n", + "\n", + "\n", + "akt->pkc\n", + "\n", + "\n", + "0.25\n", + "\n", + "\n", + "\n", + "akt->p38\n", + "\n", + "\n", + "0.15\n", + "\n", + "\n", + "\n", + "akt->jnk\n", + "\n", + "\n", + "0.27\n", + "\n", + "\n", + "\n", + "pka->p38\n", + "\n", + "\n", + "-0.02\n", + "\n", + "\n", + "\n", + "pkc->pka\n", + "\n", + "\n", + "-0.59\n", + "\n", + "\n", + "\n", + "pkc->p38\n", + "\n", + "\n", + "4.95\n", + "\n", + "\n", + "\n", + "pkc->jnk\n", + "\n", + "\n", + "1.47\n", + "\n", + "\n", + "\n", + "p38->jnk\n", + "\n", + "\n", + "0.04\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "import itertools\n", - "from numpy.random import randint\n", - "from cdt.metrics import SHD, SHD_CPDAG, SID, SID_CPDAG\n", - "\n", - "# Find combinations of pair of methods to compare\n", - "combinations = list(itertools.combinations(graphs_nx, 2))\n", - "\n", - "for pair in combinations:\n", - " print(\"***********************************************************\")\n", - " graph1 = graphs_nx[pair[0]]\n", - " graph2 = graphs_nx[pair[1]]\n", - " print(\"Methods: %s and %s\"%(pair[0], pair[1]))\n", - " print(\"SHD_CPDAG = %f\"%(SHD_CPDAG(graph1, graph2)))\n", - " print(\"SHD = %f\"%(SHD(graph1, graph2, double_for_anticausal=False)))\n", - " print(\"SID_CPDAG = [%f, %f]\"%(SID_CPDAG(graph1, graph2)))\n", - " print(\"SID = %f\"%(SID(graph1, graph2)))" + "from causallearn.search.FCMBased import lingam\n", + "model = lingam.ICALiNGAM()\n", + "model.fit(data)\n", + "\n", + "from causallearn.search.FCMBased.lingam.utils import make_dot\n", + "make_dot(model.adjacency_matrix_, labels=labels)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "The values for the metrics show how different the graphs are from each other. A higher distance value implies that the difference between the graphs is more." + "## Estimate effects using Linear Regression\n", + "\n", + "Similarly, let us use the DAG returned by LiNGAM to estimate the causal effect of *PIP2* on *PKC*." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 29, "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Estimand type: EstimandType.NONPARAMETRIC_ATE\n", + "\n", + "### Estimand : 1\n", + "Estimand name: backdoor\n", + "Estimand expression:\n", + " d \n", + "───────(E[pkc|plc,pip3])\n", + "d[pip₂] \n", + "Estimand assumption 1, Unconfoundedness: If U→{pip2} and U→pkc then P(pkc|pip2,plc,pip3,U) = P(pkc|pip2,plc,pip3)\n", + "\n", + "### Estimand : 2\n", + "Estimand name: iv\n", + "No such variable(s) found!\n", + "\n", + "### Estimand : 3\n", + "Estimand name: frontdoor\n", + "No such variable(s) found!\n", + "\n", + "Causal Estimate is 0.03397189228452291\n" + ] + } + ], + "source": [ + "# Obtain valid dot format\n", + "graph_dot = make_graph(model.adjacency_matrix_, labels=labels)\n", + "\n", + "data_df = pd.DataFrame(data=data, columns=labels)\n", + "\n", + "# Define Causal Model\n", + "model_est=CausalModel(\n", + " data = data_df,\n", + " treatment='pip2',\n", + " outcome='pkc',\n", + " graph=str_to_dot(graph_dot.source))\n", + "\n", + "# Identification\n", + "identified_estimand = model_est.identify_effect(proceed_when_unidentifiable=False)\n", + "print(identified_estimand)\n", + "\n", + "# Estimation\n", + "estimate = model_est.estimate_effect(identified_estimand,\n", + " method_name=\"backdoor.linear_regression\",\n", + " control_value=0,\n", + " treatment_value=1,\n", + " confidence_intervals=True,\n", + " test_significance=True)\n", + "print(\"Causal Estimate is \" + str(estimate.value))" + ] } ], "metadata": { @@ -464,7 +1202,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.12" + "version": "3.8.17" }, "metadata": { "interpreter": {