From 93aba11b40ceba6665a17996b0eab8d5abe75efa Mon Sep 17 00:00:00 2001 From: Zachary Clement Date: Thu, 18 May 2023 10:06:12 -0400 Subject: [PATCH] causal discovery post --- causal_discovery_store_distance.ipynb | 4190 +++++++++++++++++++++++++ 1 file changed, 4190 insertions(+) create mode 100644 causal_discovery_store_distance.ipynb diff --git a/causal_discovery_store_distance.ipynb b/causal_discovery_store_distance.ipynb new file mode 100644 index 0000000..2f5270a --- /dev/null +++ b/causal_discovery_store_distance.ipynb @@ -0,0 +1,4190 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "8a2b1d76", + "metadata": {}, + "source": [ + "# Causal discovery using Julia: A brief introduction, a simulation, and a possible use case\n", + "\n", + "In situations where the causal structure a dataset is unknown, algorithms can be used to estimate DAGs for use in causual inference." + ] + }, + { + "cell_type": "markdown", + "id": "34538ef6", + "metadata": {}, + "source": [ + "In [this blog post](https://medium.com/juliazoid/simulating-causal-effects-with-julia-47abca8ab73), I introduced the concept of a DAG (directed acyclic graph), and why a DAG is necessary for causal inference. While DAGs are a powerful tool for inferring causal effects, if an incorrect DAG is used to conduct an analysis, the resulting parameter estimates will be biased. In cases when researchers are uncertain about the causal structure of the data, but still want to conduct causal inference, causal discovery algorithms can be a useful as a first step to determining causal relationships" + ] + }, + { + "cell_type": "markdown", + "id": "fdfa8a70", + "metadata": {}, + "source": [ + "### Causal diagram used in this article\n", + "\n", + "In this article, we will simulate spending patterns at a store. We will have covariates for age, a person's distance from the store, a person's personal income, the population density of the person's neighborhood, and the zoning restrictions in place around the person's neighborhood. " + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "id": "33762d17", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m\u001b[1m Resolving\u001b[22m\u001b[39m package versions...\n", + "\u001b[32m\u001b[1m Installed\u001b[22m\u001b[39m CausalInference ─ v0.9.1\n", + "\u001b[32m\u001b[1m Updating\u001b[22m\u001b[39m `~/.julia/environments/v1.8/Project.toml`\n", + " \u001b[90m [8e462317] \u001b[39m\u001b[93m~ CausalInference v0.9.1 `/Volumes/SanDisk/repos/CausalInference.jl#tikz_better_regex` ⇒ v0.9.1\u001b[39m\n", + "\u001b[32m\u001b[1m Updating\u001b[22m\u001b[39m `~/.julia/environments/v1.8/Manifest.toml`\n", + " \u001b[90m [8e462317] \u001b[39m\u001b[93m~ CausalInference v0.9.1 `/Volumes/SanDisk/repos/CausalInference.jl#tikz_better_regex` ⇒ v0.9.1\u001b[39m\n", + "\u001b[32m\u001b[1mPrecompiling\u001b[22m\u001b[39m project...\n", + "\u001b[33m ✓ \u001b[39mCausalInference\n", + " 1 dependency successfully precompiled in 8 seconds. 329 already precompiled. 1 skipped during auto due to previous errors.\n", + " \u001b[33m1\u001b[39m dependency precompiled but a different version is currently loaded. Restart julia to access the new version\n" + ] + } + ], + "source": [ + "using Pkg\n", + "Pkg.add(\"CausalInference\")" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "04079c0c", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "image/svg+xml": [ + "\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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " Spending\n", + " \n", + " \n", + " \n", + " \n", + " Age\n", + " \n", + " \n", + " \n", + " \n", + " StoreDistance\n", + " \n", + " \n", + " \n", + " \n", + " PersonalIncome\n", + " \n", + " \n", + " \n", + " \n", + " PopulationDensity\n", + " \n", + " \n", + " \n", + " \n", + " Zoning\n", + " \n", + " \n", + "\n", + "\n" + ], + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " Spending\n", + " \n", + " \n", + " \n", + " \n", + " Age\n", + " \n", + " \n", + " \n", + " \n", + " StoreDistance\n", + " \n", + " \n", + " \n", + " \n", + " PersonalIncome\n", + " \n", + " \n", + " \n", + " \n", + " PopulationDensity\n", + " \n", + " \n", + " \n", + " \n", + " Zoning\n", + " \n", + " \n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), UnitBox{Float64, Float64, Float64, Float64}(-1.2, -1.2, 2.4, 2.4, 0.0mm, 0.0mm, 0.0mm, 0.0mm), nothing, nothing, nothing, List([Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.LinePrimitive}(Compose.LinePrimitive[Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.8939339828220179cx, -0.8939339828220179cy), (0.8939339828220179cx, 0.8939339828220179cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.8658359213500126cx, -0.9329179606750063cy), (0.19916925468334587cx, -0.40041537265832705cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.40041537265832694cx, -0.199169254683346cy), (0.9329179606750063cx, 0.8658359213500126cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.85cx, 1.0cy), (0.85cx, 1.0cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.8939339828220179cx, 0.8939339828220179cy), (-0.4393993505113155cx, 0.4393993505113154cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.85cx, -0.33333333333333337cy), (0.18333333333333326cx, -0.33333333333333337cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.8939339828220179cx, -0.22726731615535126cy), (-0.4393993505113155cx, 0.22726731615535115cy)])], Symbol(\"\"))]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(1.2247448713915892mm)]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.8274509803921568,0.8274509803921568,0.8274509803921568,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.LinePrimitive}(Compose.LinePrimitive[Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.8516721566479479cx, 0.8033032041183529cy), (0.8939339828220179cx, 0.8939339828220179cy), (0.8033032041183529cx, 0.8516721566479479cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.13041619736506527cx, -0.4730309158249882cy), (0.19916925468334587cx, -0.40041537265832705cy), (0.09982498575904862cx, -0.41184849261295486cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.9214848407203785cx, 0.7664916524257154cy), (0.9329179606750063cx, 0.8658359213500126cy), (0.8603024175083452cx, 0.797082864031732cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.7560307379214091cx, 0.9657979856674331cy), (0.85cx, 1.0cy), (0.7560307379214091cx, 1.034202014332567cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.5300301292149805cx, 0.48166117668538533cy), (-0.4393993505113155cx, 0.4393993505113154cy), (-0.48166117668538544cx, 0.5300301292149804cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.08936407125474241cx, -0.36753534766590024cy), (0.18333333333333326cx, -0.33333333333333337cy), (0.08936407125474241cx, -0.2991313190007665cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.48166117668538544cx, 0.13663653745168614cy), (-0.4393993505113155cx, 0.22726731615535115cy), (-0.5300301292149805cx, 0.1850054899812812cy)])], Symbol(\"\"))]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(1.2247448713915892mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.8274509803921568,0.8274509803921568,0.8274509803921568,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([]), List([Compose.Property{Compose.FontSizePrimitive}(Compose.FontSizePrimitive[Compose.FontSizePrimitive(4.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}}(Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}[Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((1.0cx, 1.0cy), 0.06w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-1.0cx, -1.0cy), 0.06w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((0.33333333333333326cx, -0.33333333333333337cy), 0.06w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-1.0cx, 1.0cy), 0.06w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-0.33333333333333337cx, 0.33333333333333326cy), 0.06w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-1.0cx, -0.33333333333333337cy), 0.06w)], Symbol(\"\"))]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(0.0mm), Compose.LineWidthPrimitive(0.0mm), Compose.LineWidthPrimitive(0.0mm), Compose.LineWidthPrimitive(0.0mm), Compose.LineWidthPrimitive(0.0mm), Compose.LineWidthPrimitive(0.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,1.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.25098039215686274,0.8784313725490196,0.8156862745098039,1.0)), Compose.FillPrimitive(RGBA{Float64}(0.25098039215686274,0.8784313725490196,0.8156862745098039,1.0)), Compose.FillPrimitive(RGBA{Float64}(0.25098039215686274,0.8784313725490196,0.8156862745098039,1.0)), Compose.FillPrimitive(RGBA{Float64}(0.8274509803921568,0.8274509803921568,0.8274509803921568,1.0)), Compose.FillPrimitive(RGBA{Float64}(0.25098039215686274,0.8784313725490196,0.8156862745098039,1.0)), Compose.FillPrimitive(RGBA{Float64}(0.8274509803921568,0.8274509803921568,0.8274509803921568,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}}(Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}[Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((1.0cx, 1.0cy), \"Spending\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm)), Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((-1.0cx, -1.0cy), \"Age\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm)), Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((0.33333333333333326cx, -0.33333333333333337cy), \"Store\\nDistance\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm)), Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((-1.0cx, 1.0cy), \"Personal\\nIncome\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm)), Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((-0.33333333333333337cx, 0.33333333333333326cy), \"Population\\nDensity\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm)), Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((-1.0cx, -0.33333333333333337cy), \"Zoning\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm))], Symbol(\"\"))]), List([Compose.Property{Compose.FontSizePrimitive}(Compose.FontSizePrimitive[Compose.FontSizePrimitive(3.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\"))]), List([]), List([]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\"))" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "using Graphs, GraphPlot\n", + "using Compose, Cairo, Fontconfig\n", + "using Colors\n", + "\n", + "g = SimpleDiGraph(6)\n", + "add_edge!(g, 3,1)\n", + "add_edge!(g, 4,1)\n", + "add_edge!(g, 4,5)\n", + "add_edge!(g, 6,3)\n", + "add_edge!(g, 6,5)\n", + "add_edge!(g, 2,1)\n", + "add_edge!(g, 2,3)\n", + "\n", + "\n", + "\n", + "\n", + "nodelabel = [\"Spending\", \"Age\", \"Store\\nDistance\",\n", + " \"Personal\\nIncome\", \"Population\\nDensity\", \"Zoning\"\n", + "\n", + "]\n", + "x_dims = Dict(\"Spending\" =>4, \n", + " \"Age\"=>1, \n", + " \"Store\\nDistance\"=>3, \n", + " \"Personal\\nIncome\"=>1, \n", + " \"Population\\nDensity\"=>2, \n", + " \"Zoning\"=>1)\n", + "locs_x = [x_dims[label] for label in nodelabel]\n", + "y_dims = Dict(\"Spending\" =>4, \n", + " \"Age\"=>1, \n", + " \"Gender\"=>1, \n", + " \"Store\\nDistance\"=>2, \n", + " \"Personal\\nIncome\"=>4, \n", + " \"Population\\nDensity\"=>3, \n", + " \"Zoning\"=>2)\n", + "locs_y = [y_dims[label] for label in nodelabel]\n", + "\n", + "\n", + "\n", + "nodefillc_dict = \n", + "Dict(\"Spending\" =>colorant\"turquoise\", \n", + " \"Age\"=>colorant\"turquoise\", \n", + " \"Gender\"=>colorant\"turquoise\", \n", + " \"Store\\nDistance\"=>colorant\"turquoise\", \n", + " \"Personal\\nIncome\"=>colorant\"lightgrey\", \n", + " \"Population\\nDensity\"=>colorant\"turquoise\", \n", + " \"Zoning\"=>colorant\"lightgrey\")\n", + "\n", + "nodefillc = [nodefillc_dict[label] for label in nodelabel]\n", + "\n", + "nodestrokelw = [0, 0, 0, 0, 0, 0]\n", + "\n", + "\n", + "g_plot = gplot(g, locs_x, locs_y, nodelabel=nodelabel, \n", + " nodestrokec = \"black\", nodestrokelw = nodestrokelw, NODESIZE = .15, NODELABELSIZE = 3, nodefillc=nodefillc)\n", + "draw(PNG(\"causal_discovery_1.png\", 16cm, 16cm),g_plot)\n", + "g_plot" + ] + }, + { + "cell_type": "markdown", + "id": "4ee968ad", + "metadata": {}, + "source": [ + "As shown in the DAG, we will assume that: \n", + "1. Older people spend more than younger people\n", + "2. Older people will choose to live farther from stores than younger people (this is kind of contrived, but my wife has told me before that she wouldn't ever want to live more than an hour from a Target, so it could be true in some hypothetical world)\n", + "3. Zoning requirements may force stores to be located at a greater distance from the individual\n", + "4. Zoning requirements influence population density in the area\n", + "5. Individuals with higher personal income levels will be willing to live in areas of higher population density\n", + "6. Individuals with higher personal income levels will spend more at stores\n", + "7. There are no outside variables that are a common cause of any variables we have mentioned\n", + "\n", + "We will further assume that information on age, distance from stores, spending patterns, and populationi density in an individual's zip code are available to the analysis, but that information on zoning and personal income is expensive to obtain. \n", + "\n", + "This simulation is intended to evaluate whether causal discovery may be used in a specific use case. Imagine that we are working on a marketing team, and we want to get a precise estimate of the effect of distance from the store on spending patterns. Further imagine that we want to avoid spending too much money on obtaining information regarding zoning patterns and personal income, but that that information is available at a given cost per customer. \n", + "\n", + "In this scenario, we might be able to spend a relatively small amount of money to obtain all available for a small subset of the patients, and use that data to create a causal diagram. Then, we could use that causal diagram to determine which variables in our freely available dataset we should condition on to do our analysis." + ] + }, + { + "cell_type": "markdown", + "id": "ecc1ed04", + "metadata": {}, + "source": [ + "By looking at the DAG, we can see that we can block the backdoor path by conditioning by age alone. " + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "2ea5dd64", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "image/svg+xml": [ + "\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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " Spending\n", + " \n", + " \n", + " \n", + " \n", + " Age\n", + " \n", + " \n", + " \n", + " \n", + " StoreDistance\n", + " \n", + " \n", + " \n", + " \n", + " PersonalIncome\n", + " \n", + " \n", + " \n", + " \n", + " PopulationDensity\n", + " \n", + " \n", + " \n", + " \n", + " Zoning\n", + " \n", + " \n", + "\n", + "\n" + ], + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " Spending\n", + " \n", + " \n", + " \n", + " \n", + " Age\n", + " \n", + " \n", + " \n", + " \n", + " StoreDistance\n", + " \n", + " \n", + " \n", + " \n", + " PersonalIncome\n", + " \n", + " \n", + " \n", + " \n", + " PopulationDensity\n", + " \n", + " \n", + " \n", + " \n", + " Zoning\n", + " \n", + " \n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), UnitBox{Float64, Float64, Float64, Float64}(-1.2, -1.2, 2.4, 2.4, 0.0mm, 0.0mm, 0.0mm, 0.0mm), nothing, nothing, nothing, List([Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.LinePrimitive}(Compose.LinePrimitive[Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.8939339828220179cx, -0.8939339828220179cy), (0.8939339828220179cx, 0.8939339828220179cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.8658359213500126cx, -0.9329179606750063cy), (0.19916925468334587cx, -0.40041537265832705cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.40041537265832694cx, -0.199169254683346cy), (0.9329179606750063cx, 0.8658359213500126cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.85cx, 1.0cy), (0.85cx, 1.0cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.8939339828220179cx, 0.8939339828220179cy), (-0.4393993505113155cx, 0.4393993505113154cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.85cx, -0.33333333333333337cy), (0.18333333333333326cx, -0.33333333333333337cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.8939339828220179cx, -0.22726731615535126cy), (-0.4393993505113155cx, 0.22726731615535115cy)])], Symbol(\"\"))]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(1.2247448713915892mm)]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.8274509803921568,0.8274509803921568,0.8274509803921568,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.LinePrimitive}(Compose.LinePrimitive[Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.8516721566479479cx, 0.8033032041183529cy), (0.8939339828220179cx, 0.8939339828220179cy), (0.8033032041183529cx, 0.8516721566479479cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.13041619736506527cx, -0.4730309158249882cy), (0.19916925468334587cx, -0.40041537265832705cy), (0.09982498575904862cx, -0.41184849261295486cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.9214848407203785cx, 0.7664916524257154cy), (0.9329179606750063cx, 0.8658359213500126cy), (0.8603024175083452cx, 0.797082864031732cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.7560307379214091cx, 0.9657979856674331cy), (0.85cx, 1.0cy), (0.7560307379214091cx, 1.034202014332567cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.5300301292149805cx, 0.48166117668538533cy), (-0.4393993505113155cx, 0.4393993505113154cy), (-0.48166117668538544cx, 0.5300301292149804cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.08936407125474241cx, -0.36753534766590024cy), (0.18333333333333326cx, -0.33333333333333337cy), (0.08936407125474241cx, -0.2991313190007665cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.48166117668538544cx, 0.13663653745168614cy), (-0.4393993505113155cx, 0.22726731615535115cy), (-0.5300301292149805cx, 0.1850054899812812cy)])], Symbol(\"\"))]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(1.2247448713915892mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.8274509803921568,0.8274509803921568,0.8274509803921568,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([]), List([Compose.Property{Compose.FontSizePrimitive}(Compose.FontSizePrimitive[Compose.FontSizePrimitive(4.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}}(Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}[Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((1.0cx, 1.0cy), 0.06w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-1.0cx, -1.0cy), 0.06w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((0.33333333333333326cx, -0.33333333333333337cy), 0.06w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-1.0cx, 1.0cy), 0.06w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-0.33333333333333337cx, 0.33333333333333326cy), 0.06w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-1.0cx, -0.33333333333333337cy), 0.06w)], Symbol(\"\"))]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(0.0mm), Compose.LineWidthPrimitive(1.2247448713915892mm), Compose.LineWidthPrimitive(0.0mm), Compose.LineWidthPrimitive(0.0mm), Compose.LineWidthPrimitive(0.0mm), Compose.LineWidthPrimitive(0.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,1.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.25098039215686274,0.8784313725490196,0.8156862745098039,1.0)), Compose.FillPrimitive(RGBA{Float64}(0.25098039215686274,0.8784313725490196,0.8156862745098039,1.0)), Compose.FillPrimitive(RGBA{Float64}(0.25098039215686274,0.8784313725490196,0.8156862745098039,1.0)), Compose.FillPrimitive(RGBA{Float64}(0.8274509803921568,0.8274509803921568,0.8274509803921568,1.0)), Compose.FillPrimitive(RGBA{Float64}(0.25098039215686274,0.8784313725490196,0.8156862745098039,1.0)), Compose.FillPrimitive(RGBA{Float64}(0.8274509803921568,0.8274509803921568,0.8274509803921568,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}}(Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}[Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((1.0cx, 1.0cy), \"Spending\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm)), Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((-1.0cx, -1.0cy), \"Age\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm)), Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((0.33333333333333326cx, -0.33333333333333337cy), \"Store\\nDistance\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm)), Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((-1.0cx, 1.0cy), \"Personal\\nIncome\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm)), Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((-0.33333333333333337cx, 0.33333333333333326cy), \"Population\\nDensity\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm)), Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((-1.0cx, -0.33333333333333337cy), \"Zoning\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm))], Symbol(\"\"))]), List([Compose.Property{Compose.FontSizePrimitive}(Compose.FontSizePrimitive[Compose.FontSizePrimitive(3.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\"))]), List([]), List([]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\"))" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\n", + "\n", + "nodestrokelw = [0, 2, 0, 0, 0, 0]\n", + "\n", + "\n", + "g_plot = gplot(g, locs_x, locs_y, nodelabel=nodelabel, \n", + " nodestrokec = \"black\", nodestrokelw = nodestrokelw, NODESIZE = .15, NODELABELSIZE = 3, nodefillc=nodefillc)\n", + "draw(PNG(\"causal_discovery_2.png\", 16cm, 16cm),g_plot)\n", + "g_plot" + ] + }, + { + "cell_type": "markdown", + "id": "2bb05756", + "metadata": {}, + "source": [ + "However, if we were to condition on population density, we would be conditioning on a collider (also known as [M bias](https://towardsdatascience.com/causal-inference-in-data-science-structure-of-m-bias-with-confounding-adjustment-70e4a263ad08)) and opening a backdoor path between store distance and spending." + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "id": "3ec1d23c", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "image/svg+xml": [ + "\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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " Spending\n", + " \n", + " \n", + " \n", + " \n", + " Age\n", + " \n", + " \n", + " \n", + " \n", + " StoreDistance\n", + " \n", + " \n", + " \n", + " \n", + " PersonalIncome\n", + " \n", + " \n", + " \n", + " \n", + " PopulationDensity\n", + " \n", + " \n", + " \n", + " \n", + " Zoning\n", + " \n", + " \n", + "\n", + "\n" + ], + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " Spending\n", + " \n", + " \n", + " \n", + " \n", + " Age\n", + " \n", + " \n", + " \n", + " \n", + " StoreDistance\n", + " \n", + " \n", + " \n", + " \n", + " PersonalIncome\n", + " \n", + " \n", + " \n", + " \n", + " PopulationDensity\n", + " \n", + " \n", + " \n", + " \n", + " Zoning\n", + " \n", + " \n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "Context(BBox{l,t,r,b,w,h = 0.0w,0.0h, 1.0w,1.0h, 1.0w,1.0h}, UnitBox{Float64, Float64, Float64, Float64}(-1.2, -1.2, 2.4, 2.4, 0.0mm, 0.0mm, 0.0mm, 0.0mm), nothing, nothing, nothing, List([Context(BBox{l,t,r,b,w,h = 0.0w,0.0h, 1.0w,1.0h, 1.0w,1.0h}, nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.LinePrimitive}(Compose.LinePrimitive[Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.8939339828220179cx, -0.8939339828220179cy), (0.8939339828220179cx, 0.8939339828220179cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.8658359213500126cx, -0.9329179606750063cy), (0.19916925468334587cx, -0.40041537265832705cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.40041537265832694cx, -0.199169254683346cy), (0.9329179606750063cx, 0.8658359213500126cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.85cx, 1.0cy), (0.85cx, 1.0cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.8939339828220179cx, 0.8939339828220179cy), (-0.4393993505113155cx, 0.4393993505113154cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.85cx, -0.33333333333333337cy), (0.18333333333333326cx, -0.33333333333333337cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.8939339828220179cx, -0.22726731615535126cy), (-0.4393993505113155cx, 0.22726731615535115cy)])], Symbol(\"\"))]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(1.2247448713915892mm)]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.8274509803921568,0.8274509803921568,0.8274509803921568,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(BBox{l,t,r,b,w,h = 0.0w,0.0h, 1.0w,1.0h, 1.0w,1.0h}, nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.LinePrimitive}(Compose.LinePrimitive[Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.8516721566479479cx, 0.8033032041183529cy), (0.8939339828220179cx, 0.8939339828220179cy), (0.8033032041183529cx, 0.8516721566479479cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.13041619736506527cx, -0.4730309158249882cy), (0.19916925468334587cx, -0.40041537265832705cy), (0.09982498575904862cx, -0.41184849261295486cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.9214848407203785cx, 0.7664916524257154cy), (0.9329179606750063cx, 0.8658359213500126cy), (0.8603024175083452cx, 0.797082864031732cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.7560307379214091cx, 0.9657979856674331cy), (0.85cx, 1.0cy), (0.7560307379214091cx, 1.034202014332567cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.5300301292149805cx, 0.48166117668538533cy), (-0.4393993505113155cx, 0.4393993505113154cy), (-0.48166117668538544cx, 0.5300301292149804cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.08936407125474241cx, -0.36753534766590024cy), (0.18333333333333326cx, -0.33333333333333337cy), (0.08936407125474241cx, -0.2991313190007665cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.48166117668538544cx, 0.13663653745168614cy), (-0.4393993505113155cx, 0.22726731615535115cy), (-0.5300301292149805cx, 0.1850054899812812cy)])], Symbol(\"\"))]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(1.2247448713915892mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.8274509803921568,0.8274509803921568,0.8274509803921568,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(BBox{l,t,r,b,w,h = 0.0w,0.0h, 1.0w,1.0h, 1.0w,1.0h}, nothing, nothing, nothing, nothing, List([]), List([]), List([Compose.Property{Compose.FontSizePrimitive}(Compose.FontSizePrimitive[Compose.FontSizePrimitive(4.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(BBox{l,t,r,b,w,h = 0.0w,0.0h, 1.0w,1.0h, 1.0w,1.0h}, nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}}(Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}[Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((1.0cx, 1.0cy), 0.06w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-1.0cx, -1.0cy), 0.06w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((0.33333333333333326cx, -0.33333333333333337cy), 0.06w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-1.0cx, 1.0cy), 0.06w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-0.33333333333333337cx, 0.33333333333333326cy), 0.06w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-1.0cx, -0.33333333333333337cy), 0.06w)], Symbol(\"\"))]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(0.0mm), Compose.LineWidthPrimitive(1.2247448713915892mm), Compose.LineWidthPrimitive(0.0mm), Compose.LineWidthPrimitive(0.0mm), Compose.LineWidthPrimitive(1.2247448713915892mm), Compose.LineWidthPrimitive(0.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,1.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.25098039215686274,0.8784313725490196,0.8156862745098039,1.0)), Compose.FillPrimitive(RGBA{Float64}(0.25098039215686274,0.8784313725490196,0.8156862745098039,1.0)), Compose.FillPrimitive(RGBA{Float64}(0.25098039215686274,0.8784313725490196,0.8156862745098039,1.0)), Compose.FillPrimitive(RGBA{Float64}(0.8274509803921568,0.8274509803921568,0.8274509803921568,1.0)), Compose.FillPrimitive(RGBA{Float64}(0.25098039215686274,0.8784313725490196,0.8156862745098039,1.0)), Compose.FillPrimitive(RGBA{Float64}(0.8274509803921568,0.8274509803921568,0.8274509803921568,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(BBox{l,t,r,b,w,h = 0.0w,0.0h, 1.0w,1.0h, 1.0w,1.0h}, nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}}(Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}[Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((1.0cx, 1.0cy), \"Spending\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm)), Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((-1.0cx, -1.0cy), \"Age\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm)), Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((0.33333333333333326cx, -0.33333333333333337cy), \"Store\\nDistance\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm)), Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((-1.0cx, 1.0cy), \"Personal\\nIncome\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm)), Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((-0.33333333333333337cx, 0.33333333333333326cy), \"Population\\nDensity\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm)), Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((-1.0cx, -0.33333333333333337cy), \"Zoning\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm))], Symbol(\"\"))]), List([Compose.Property{Compose.FontSizePrimitive}(Compose.FontSizePrimitive[Compose.FontSizePrimitive(3.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\"))]), List([]), List([]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\"))" + ] + }, + "execution_count": 64, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "nodestrokelw = [0, 2, 0, 0, 2, 0]\n", + "\n", + "\n", + "g_plot = gplot(g, locs_x, locs_y, nodelabel=nodelabel, \n", + " nodestrokec = \"black\", nodestrokelw = nodestrokelw, NODESIZE = .15, NODELABELSIZE = 3, nodefillc=nodefillc)\n", + "draw(PNG(\"causal_discovery_m_bias.png\", 16cm, 16cm),g_plot)\n", + "g_plot" + ] + }, + { + "cell_type": "markdown", + "id": "d5a11e41", + "metadata": {}, + "source": [ + "We could of course condition on all of these variables, but it would be expensive to obtain data for all customers, and our confidence intervals would be wide because of [multicollinearity](https://en.wikipedia.org/wiki/Multicollinearity). " + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "id": "59598840", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "image/svg+xml": [ + "\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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " Spending\n", + " \n", + " \n", + " \n", + " \n", + " Age\n", + " \n", + " \n", + " \n", + " \n", + " StoreDistance\n", + " \n", + " \n", + " \n", + " \n", + " PersonalIncome\n", + " \n", + " \n", + " \n", + " \n", + " PopulationDensity\n", + " \n", + " \n", + " \n", + " \n", + " Zoning\n", + " \n", + " \n", + "\n", + "\n" + ], + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " Spending\n", + " \n", + " \n", + " \n", + " \n", + " Age\n", + " \n", + " \n", + " \n", + " \n", + " StoreDistance\n", + " \n", + " \n", + " \n", + " \n", + " PersonalIncome\n", + " \n", + " \n", + " \n", + " \n", + " PopulationDensity\n", + " \n", + " \n", + " \n", + " \n", + " Zoning\n", + " \n", + " \n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "Context(BBox{l,t,r,b,w,h = 0.0w,0.0h, 1.0w,1.0h, 1.0w,1.0h}, UnitBox{Float64, Float64, Float64, Float64}(-1.2, -1.2, 2.4, 2.4, 0.0mm, 0.0mm, 0.0mm, 0.0mm), nothing, nothing, nothing, List([Context(BBox{l,t,r,b,w,h = 0.0w,0.0h, 1.0w,1.0h, 1.0w,1.0h}, nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.LinePrimitive}(Compose.LinePrimitive[Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.8939339828220179cx, -0.8939339828220179cy), (0.8939339828220179cx, 0.8939339828220179cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.8658359213500126cx, -0.9329179606750063cy), (0.19916925468334587cx, -0.40041537265832705cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.40041537265832694cx, -0.199169254683346cy), (0.9329179606750063cx, 0.8658359213500126cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.85cx, 1.0cy), (0.85cx, 1.0cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.8939339828220179cx, 0.8939339828220179cy), (-0.4393993505113155cx, 0.4393993505113154cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.85cx, -0.33333333333333337cy), (0.18333333333333326cx, -0.33333333333333337cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.8939339828220179cx, -0.22726731615535126cy), (-0.4393993505113155cx, 0.22726731615535115cy)])], Symbol(\"\"))]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(1.2247448713915892mm)]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.8274509803921568,0.8274509803921568,0.8274509803921568,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(BBox{l,t,r,b,w,h = 0.0w,0.0h, 1.0w,1.0h, 1.0w,1.0h}, nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.LinePrimitive}(Compose.LinePrimitive[Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.8516721566479479cx, 0.8033032041183529cy), (0.8939339828220179cx, 0.8939339828220179cy), (0.8033032041183529cx, 0.8516721566479479cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.13041619736506527cx, -0.4730309158249882cy), (0.19916925468334587cx, -0.40041537265832705cy), (0.09982498575904862cx, -0.41184849261295486cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.9214848407203785cx, 0.7664916524257154cy), (0.9329179606750063cx, 0.8658359213500126cy), (0.8603024175083452cx, 0.797082864031732cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.7560307379214091cx, 0.9657979856674331cy), (0.85cx, 1.0cy), (0.7560307379214091cx, 1.034202014332567cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.5300301292149805cx, 0.48166117668538533cy), (-0.4393993505113155cx, 0.4393993505113154cy), (-0.48166117668538544cx, 0.5300301292149804cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.08936407125474241cx, -0.36753534766590024cy), (0.18333333333333326cx, -0.33333333333333337cy), (0.08936407125474241cx, -0.2991313190007665cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.48166117668538544cx, 0.13663653745168614cy), (-0.4393993505113155cx, 0.22726731615535115cy), (-0.5300301292149805cx, 0.1850054899812812cy)])], Symbol(\"\"))]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(1.2247448713915892mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.8274509803921568,0.8274509803921568,0.8274509803921568,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(BBox{l,t,r,b,w,h = 0.0w,0.0h, 1.0w,1.0h, 1.0w,1.0h}, nothing, nothing, nothing, nothing, List([]), List([]), List([Compose.Property{Compose.FontSizePrimitive}(Compose.FontSizePrimitive[Compose.FontSizePrimitive(4.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(BBox{l,t,r,b,w,h = 0.0w,0.0h, 1.0w,1.0h, 1.0w,1.0h}, nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}}(Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}[Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((1.0cx, 1.0cy), 0.06w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-1.0cx, -1.0cy), 0.06w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((0.33333333333333326cx, -0.33333333333333337cy), 0.06w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-1.0cx, 1.0cy), 0.06w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-0.33333333333333337cx, 0.33333333333333326cy), 0.06w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-1.0cx, -0.33333333333333337cy), 0.06w)], Symbol(\"\"))]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(0.0mm), Compose.LineWidthPrimitive(1.2247448713915892mm), Compose.LineWidthPrimitive(0.0mm), Compose.LineWidthPrimitive(1.2247448713915892mm), Compose.LineWidthPrimitive(1.2247448713915892mm), Compose.LineWidthPrimitive(1.2247448713915892mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,1.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.25098039215686274,0.8784313725490196,0.8156862745098039,1.0)), Compose.FillPrimitive(RGBA{Float64}(0.25098039215686274,0.8784313725490196,0.8156862745098039,1.0)), Compose.FillPrimitive(RGBA{Float64}(0.25098039215686274,0.8784313725490196,0.8156862745098039,1.0)), Compose.FillPrimitive(RGBA{Float64}(0.8274509803921568,0.8274509803921568,0.8274509803921568,1.0)), Compose.FillPrimitive(RGBA{Float64}(0.25098039215686274,0.8784313725490196,0.8156862745098039,1.0)), Compose.FillPrimitive(RGBA{Float64}(0.8274509803921568,0.8274509803921568,0.8274509803921568,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(BBox{l,t,r,b,w,h = 0.0w,0.0h, 1.0w,1.0h, 1.0w,1.0h}, nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}}(Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}[Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((1.0cx, 1.0cy), \"Spending\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm)), Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((-1.0cx, -1.0cy), \"Age\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm)), Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((0.33333333333333326cx, -0.33333333333333337cy), \"Store\\nDistance\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm)), Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((-1.0cx, 1.0cy), \"Personal\\nIncome\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm)), Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((-0.33333333333333337cx, 0.33333333333333326cy), \"Population\\nDensity\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm)), Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((-1.0cx, -0.33333333333333337cy), \"Zoning\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm))], Symbol(\"\"))]), List([Compose.Property{Compose.FontSizePrimitive}(Compose.FontSizePrimitive[Compose.FontSizePrimitive(3.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\"))]), List([]), List([]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\"))" + ] + }, + "execution_count": 66, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "nodestrokelw = [0, 2, 0, 2, 2, 2]\n", + "\n", + "\n", + "g_plot = gplot(g, locs_x, locs_y, nodelabel=nodelabel, \n", + " nodestrokec = \"black\", nodestrokelw = nodestrokelw, NODESIZE = .15, NODELABELSIZE = 3, nodefillc=nodefillc)\n", + "draw(PNG(\"causal_discovery_3.png\", 16cm, 16cm),g_plot)\n", + "g_plot" + ] + }, + { + "cell_type": "markdown", + "id": "31af0202", + "metadata": {}, + "source": [ + "First, let's define a function to simulate data from this DAG" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "b1f76f0f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "get_data" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "using DataFrames\n", + "\"\"\"\n", + "Create a dataframe with the relationships shown in the DAG\n", + "\"\"\"\n", + "function get_data(n::Int, actual_spending_decrease::Float64 = -2.0)\n", + " age = rand(n) .* 50 \n", + " zoning = rand(n) \n", + " personal_income = rand(n) \n", + " store_distance = ( rand(n) .* .1 .+ (age ./ 100) .+ zoning ) .* 100 ## pretend that people who are old live farther from stores\n", + "\n", + " \n", + " population_density = (zoning .+ personal_income .+ rand(n) )\n", + " spending = ((personal_income .* 100) .+ age .+ (store_distance .* actual_spending_decrease) .+ rand(n) * 100)\n", + "## Note: the order of these needs to be the same as the order of the names in the original DAG so that the causal discovery algorithm can work right\n", + " return DataFrame(spending = spending, age = age, store_distance = store_distance,\n", + " personal_income = personal_income, \n", + " population_density = population_density, \n", + " zoning = zoning, )\n", + " \n", + "end\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "d34bda8d", + "metadata": {}, + "source": [ + "If we conduct an unadjusted analysis, we will get a biased estimate of the effect of store distance on spending" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "id": "af58eb8a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "StatsModels.TableRegressionModel{LinearModel{GLM.LmResp{Vector{Float64}}, GLM.DensePredChol{Float64, LinearAlgebra.CholeskyPivoted{Float64, Matrix{Float64}, Vector{Int64}}}}, Matrix{Float64}}\n", + "\n", + "spending ~ 1 + store_distance\n", + "\n", + "Coefficients:\n", + "────────────────────────────────────────────────────────────────────────────────\n", + " Coef. Std. Error t Pr(>|t|) Lower 95% Upper 95%\n", + "────────────────────────────────────────────────────────────────────────────────\n", + "(Intercept) 109.103 0.0510028 2139.15 <1e-99 109.003 109.203\n", + "store_distance -1.80103 0.000590968 -3047.59 <1e-99 -1.80219 -1.79987\n", + "────────────────────────────────────────────────────────────────────────────────" + ] + }, + "execution_count": 67, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "using GLM \n", + "df = get_data(5000000)\n", + "lm(@formula(spending ~ store_distance), df)" + ] + }, + { + "cell_type": "markdown", + "id": "df4da5e1", + "metadata": {}, + "source": [ + "As discussed above, if we condition only on age, we obtain an unbiased estimate of the effect of store distance on spending (-2.0)" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "id": "4af0cb65", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "StatsModels.TableRegressionModel{LinearModel{GLM.LmResp{Vector{Float64}}, GLM.DensePredChol{Float64, LinearAlgebra.CholeskyPivoted{Float64, Matrix{Float64}, Vector{Int64}}}}, Matrix{Float64}}\n", + "\n", + "spending ~ 1 + store_distance + age\n", + "\n", + "Coefficients:\n", + "───────────────────────────────────────────────────────────────────────────────\n", + " Coef. Std. Error t Pr(>|t|) Lower 95% Upper 95%\n", + "───────────────────────────────────────────────────────────────────────────────\n", + "(Intercept) 99.9799 0.0503169 1987.01 <1e-99 99.8813 100.079\n", + "store_distance -1.99915 0.000629403 -3176.26 <1e-99 -2.00038 -1.99792\n", + "age 0.99863 0.00141326 706.61 <1e-99 0.99586 1.0014\n", + "───────────────────────────────────────────────────────────────────────────────" + ] + }, + "execution_count": 68, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "lm(@formula(spending ~ store_distance + age), df)" + ] + }, + { + "cell_type": "markdown", + "id": "e716c9d9", + "metadata": {}, + "source": [ + "And, if we were to condition on both age and population density (the \"free\" variables available to us) we would induce M-bias and have a biased estimate again" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "id": "05872134", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "StatsModels.TableRegressionModel{LinearModel{GLM.LmResp{Vector{Float64}}, GLM.DensePredChol{Float64, LinearAlgebra.CholeskyPivoted{Float64, Matrix{Float64}, Vector{Int64}}}}, Matrix{Float64}}\n", + "\n", + "spending ~ 1 + store_distance + age + population_density\n", + "\n", + "Coefficients:\n", + "───────────────────────────────────────────────────────────────────────────────────\n", + " Coef. Std. Error t Pr(>|t|) Lower 95% Upper 95%\n", + "───────────────────────────────────────────────────────────────────────────────────\n", + "(Intercept) 52.4224 0.0571568 917.17 <1e-99 52.3104 52.5345\n", + "store_distance -2.49213 0.000666522 -3739.00 <1e-99 -2.49343 -2.49082\n", + "age 1.49162 0.00128333 1162.31 <1e-99 1.48911 1.49414\n", + "population_density 49.7762 0.0386726 1287.12 <1e-99 49.7004 49.852\n", + "───────────────────────────────────────────────────────────────────────────────────" + ] + }, + "execution_count": 69, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "lm(@formula(spending ~ store_distance + age + population_density), df)" + ] + }, + { + "cell_type": "markdown", + "id": "73d9e97d", + "metadata": {}, + "source": [ + "We could also adjust on all of the possible variables, but notice how the standard error values are much higher here than when we just adjusted for age alone. " + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "id": "af3a9855", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "StatsModels.TableRegressionModel{LinearModel{GLM.LmResp{Vector{Float64}}, GLM.DensePredChol{Float64, LinearAlgebra.CholeskyPivoted{Float64, Matrix{Float64}, Vector{Int64}}}}, Matrix{Float64}}\n", + "\n", + "spending ~ 1 + store_distance + age + population_density + zoning + personal_income\n", + "\n", + "Coefficients:\n", + "────────────────────────────────────────────────────────────────────────────────────────\n", + " Coef. Std. Error t Pr(>|t|) Lower 95% Upper 95%\n", + "────────────────────────────────────────────────────────────────────────────────────────\n", + "(Intercept) 49.9691 0.0516369 967.70 <1e-99 49.8679 50.0703\n", + "store_distance -1.994 0.00447123 -445.96 <1e-99 -2.00276 -1.98524\n", + "age 0.993022 0.00455984 217.78 <1e-99 0.984085 1.00196\n", + "population_density 0.00501536 0.0447225 0.11 0.9107 -0.0826392 0.0926699\n", + "zoning -0.557078 0.451542 -1.23 0.2173 -1.44208 0.327928\n", + "personal_income 100.012 0.0632306 1581.70 <1e-99 99.8881 100.136\n", + "────────────────────────────────────────────────────────────────────────────────────────" + ] + }, + "execution_count": 70, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "lm(@formula(spending ~ store_distance + age + population_density + zoning + personal_income), df)" + ] + }, + { + "cell_type": "markdown", + "id": "738b07eb", + "metadata": {}, + "source": [ + "Now that we understand what's going on, let's see if causal discovery is able to recover our DAG from the simulated data. In this post, I'll use the `CausalInference` Julia package to attempt to recover causal relationships." + ] + }, + { + "cell_type": "markdown", + "id": "01723019", + "metadata": {}, + "source": [ + "### PC vs FCI algorithms\n", + "\n", + "The `CausalInference` Julia package uses two algorithms for causal discovery. The PC algorithm (named after Peter Spirtes and Clark Glymour) can be used in situations where causal sufficiency can be assumed. That is, the PC algorithm should only be used when a researcher is sure that there are no common causes of any variables included. In the PC algorithms, an edge (or line between variables) can indicate that two variables may have a common cause (if an edge is bidirectional), an edge can indicate that one variable is a cause of the other variable (if an edge is unidirectional) or that there is no relationship between the two variables (shown by no edges between the two varibles).\n", + "\n", + "The FCI (Fast Causal Inference) algorithm is intended for use in cases where there may be unmeasured confounders between variables. There are many types of edges in graphs produced by FCI, and the documentation for [this python package](https://causal-learn.readthedocs.io/en/latest/search_methods_index/Constraint-based%20causal%20discovery%20methods/FCI.html) is a good resource for understaanding what they mean. " + ] + }, + { + "cell_type": "markdown", + "id": "3bcc825f", + "metadata": {}, + "source": [ + "In both algorithms, one may set the cutoff `p` associated with the test for dependence between nodes. If `p` is very low, the resulting graph may have too few edges." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "5093c6c3", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "image/svg+xml": [ + "\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", + " Spending\n", + " \n", + " \n", + " \n", + " \n", + " Age\n", + " \n", + " \n", + " \n", + " \n", + " StoreDistance\n", + " \n", + " \n", + " \n", + " \n", + " PersonalIncome\n", + " \n", + " \n", + " \n", + " \n", + " PopulationDensity\n", + " \n", + " \n", + " \n", + " \n", + " Zoning\n", + " \n", + " \n", + "\n", + "\n" + ], + "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", + " Spending\n", + " \n", + " \n", + " \n", + " \n", + " Age\n", + " \n", + " \n", + " \n", + " \n", + " StoreDistance\n", + " \n", + " \n", + " \n", + " \n", + " PersonalIncome\n", + " \n", + " \n", + " \n", + " \n", + " PopulationDensity\n", + " \n", + " \n", + " \n", + " \n", + " Zoning\n", + " \n", + " \n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), UnitBox{Float64, Float64, Float64, Float64}(-1.2, -1.2, 2.4, 2.4, 0.0mm, 0.0mm, 0.0mm, 0.0mm), nothing, nothing, nothing, List([Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.LinePrimitive}(Compose.LinePrimitive[Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.8658359213500126cx, -0.9329179606750063cy), (0.19916925468334587cx, -0.40041537265832705cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.8939339828220179cx, 0.8939339828220179cy), (-0.4393993505113155cx, 0.4393993505113154cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.4393993505113155cx, 0.4393993505113154cy), (-0.8939339828220179cx, 0.8939339828220179cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.85cx, -0.33333333333333337cy), (0.18333333333333326cx, -0.33333333333333337cy)])], Symbol(\"\"))]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(1.2247448713915892mm)]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.8274509803921568,0.8274509803921568,0.8274509803921568,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.LinePrimitive}(Compose.LinePrimitive[Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.13041619736506527cx, -0.4730309158249882cy), (0.19916925468334587cx, -0.40041537265832705cy), (0.09982498575904862cx, -0.41184849261295486cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.5300301292149805cx, 0.48166117668538533cy), (-0.4393993505113155cx, 0.4393993505113154cy), (-0.48166117668538544cx, 0.5300301292149804cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.8033032041183529cx, 0.8516721566479479cy), (-0.8939339828220179cx, 0.8939339828220179cy), (-0.8516721566479479cx, 0.8033032041183529cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.08936407125474241cx, -0.36753534766590024cy), (0.18333333333333326cx, -0.33333333333333337cy), (0.08936407125474241cx, -0.2991313190007665cy)])], Symbol(\"\"))]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(1.2247448713915892mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.8274509803921568,0.8274509803921568,0.8274509803921568,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([]), List([Compose.Property{Compose.FontSizePrimitive}(Compose.FontSizePrimitive[Compose.FontSizePrimitive(4.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}}(Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}[Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((1.0cx, 1.0cy), 0.06w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-1.0cx, -1.0cy), 0.06w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((0.33333333333333326cx, -0.33333333333333337cy), 0.06w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-1.0cx, 1.0cy), 0.06w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-0.33333333333333337cx, 0.33333333333333326cy), 0.06w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-1.0cx, -0.33333333333333337cy), 0.06w)], Symbol(\"\"))]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(0.0mm), Compose.LineWidthPrimitive(0.0mm), Compose.LineWidthPrimitive(0.0mm), Compose.LineWidthPrimitive(0.0mm), Compose.LineWidthPrimitive(0.0mm), Compose.LineWidthPrimitive(0.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,1.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.25098039215686274,0.8784313725490196,0.8156862745098039,1.0)), Compose.FillPrimitive(RGBA{Float64}(0.25098039215686274,0.8784313725490196,0.8156862745098039,1.0)), Compose.FillPrimitive(RGBA{Float64}(0.25098039215686274,0.8784313725490196,0.8156862745098039,1.0)), Compose.FillPrimitive(RGBA{Float64}(0.8274509803921568,0.8274509803921568,0.8274509803921568,1.0)), Compose.FillPrimitive(RGBA{Float64}(0.25098039215686274,0.8784313725490196,0.8156862745098039,1.0)), Compose.FillPrimitive(RGBA{Float64}(0.8274509803921568,0.8274509803921568,0.8274509803921568,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}}(Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}[Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((1.0cx, 1.0cy), \"Spending\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm)), Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((-1.0cx, -1.0cy), \"Age\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm)), Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((0.33333333333333326cx, -0.33333333333333337cy), \"Store\\nDistance\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm)), Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((-1.0cx, 1.0cy), \"Personal\\nIncome\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm)), Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((-0.33333333333333337cx, 0.33333333333333326cy), \"Population\\nDensity\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm)), Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((-1.0cx, -0.33333333333333337cy), \"Zoning\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm))], Symbol(\"\"))]), List([Compose.Property{Compose.FontSizePrimitive}(Compose.FontSizePrimitive[Compose.FontSizePrimitive(3.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\"))]), List([]), List([]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\"))" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "using CausalInference\n", + "using TikzGraphs\n", + "df = get_data(300)\n", + "est_g = pcalg(df, 0.00000000000001, gausscitest)\n", + "nodestrokelw = [0, 0, 0, 0, 0, 0]\n", + "g_plot = gplot(est_g, locs_x, locs_y, nodelabel=nodelabel, \n", + " nodestrokec = \"black\", nodestrokelw = nodestrokelw, NODESIZE = .15, NODELABELSIZE = 3, nodefillc=nodefillc)\n", + "draw(PNG(\"causal_discovery_4.png\", 16cm, 16cm),g_plot)\n", + "g_plot" + ] + }, + { + "cell_type": "markdown", + "id": "fe5c0152", + "metadata": {}, + "source": [ + "If `p` is too high, the resulting graph will probably have too many edges:" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "bba03d44", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "image/svg+xml": [ + "\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", + " \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", + " Spending\n", + " \n", + " \n", + " \n", + " \n", + " Age\n", + " \n", + " \n", + " \n", + " \n", + " StoreDistance\n", + " \n", + " \n", + " \n", + " \n", + " PersonalIncome\n", + " \n", + " \n", + " \n", + " \n", + " PopulationDensity\n", + " \n", + " \n", + " \n", + " \n", + " Zoning\n", + " \n", + " \n", + "\n", + "\n" + ], + "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", + " \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", + " Spending\n", + " \n", + " \n", + " \n", + " \n", + " Age\n", + " \n", + " \n", + " \n", + " \n", + " StoreDistance\n", + " \n", + " \n", + " \n", + " \n", + " PersonalIncome\n", + " \n", + " \n", + " \n", + " \n", + " PopulationDensity\n", + " \n", + " \n", + " \n", + " \n", + " Zoning\n", + " \n", + " \n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), UnitBox{Float64, Float64, Float64, Float64}(-1.2, -1.2, 2.4, 2.4, 0.0mm, 0.0mm, 0.0mm, 0.0mm), nothing, nothing, nothing, List([Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.LinePrimitive}(Compose.LinePrimitive[Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.8939339828220179cx, -0.8939339828220179cy), (0.8939339828220179cx, 0.8939339828220179cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.8658359213500126cx, -0.9329179606750063cy), (0.19916925468334587cx, -0.40041537265832705cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.40041537265832694cx, -0.199169254683346cy), (0.9329179606750063cx, 0.8658359213500126cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.85cx, 1.0cy), (0.85cx, 1.0cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.8939339828220179cx, 0.8939339828220179cy), (-0.4393993505113155cx, 0.4393993505113154cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-1.0cx, 0.85cy), (-1.0cx, -0.18333333333333338cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.22726731615535123cx, 0.22726731615535115cy), (0.22726731615535115cx, -0.22726731615535123cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.4393993505113155cx, 0.22726731615535112cy), (-0.8939339828220179cx, -0.22726731615535126cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.8751924558493235cx, -0.250128303899549cy), (0.8751924558493235cx, 0.9167949705662156cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.85cx, -0.33333333333333337cy), (0.18333333333333326cx, -0.33333333333333337cy)])], Symbol(\"\"))]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(1.2247448713915892mm)]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.8274509803921568,0.8274509803921568,0.8274509803921568,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.LinePrimitive}(Compose.LinePrimitive[Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.8516721566479479cx, 0.8033032041183529cy), (0.8939339828220179cx, 0.8939339828220179cy), (0.8033032041183529cx, 0.8516721566479479cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.13041619736506527cx, -0.4730309158249882cy), (0.19916925468334587cx, -0.40041537265832705cy), (0.09982498575904862cx, -0.41184849261295486cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.9214848407203785cx, 0.7664916524257154cy), (0.9329179606750063cx, 0.8658359213500126cy), (0.8603024175083452cx, 0.797082864031732cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.7560307379214091cx, 0.9657979856674331cy), (0.85cx, 1.0cy), (0.7560307379214091cx, 1.034202014332567cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.5300301292149805cx, 0.48166117668538533cy), (-0.4393993505113155cx, 0.4393993505113154cy), (-0.48166117668538544cx, 0.5300301292149804cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-1.034202014332567cx, -0.08936407125474254cy), (-1.0cx, -0.18333333333333338cy), (-0.9657979856674331cx, -0.08936407125474252cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.13663653745168614cx, -0.18500548998128127cy), (0.22726731615535115cx, -0.22726731615535123cy), (0.1850054899812812cx, -0.13663653745168625cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.8516721566479479cx, -0.13663653745168625cy), (-0.8939339828220179cx, -0.22726731615535126cy), (-0.8033032041183529cx, -0.1850054899812813cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.815977167739695cx, 0.8362124063597218cy), (0.8751924558493235cx, 0.9167949705662156cy), (0.778033439616549cx, 0.8931279985444407cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.08936407125474241cx, -0.36753534766590024cy), (0.18333333333333326cx, -0.33333333333333337cy), (0.08936407125474241cx, -0.2991313190007665cy)])], Symbol(\"\"))]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(1.2247448713915892mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.8274509803921568,0.8274509803921568,0.8274509803921568,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([]), List([Compose.Property{Compose.FontSizePrimitive}(Compose.FontSizePrimitive[Compose.FontSizePrimitive(4.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}}(Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}[Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((1.0cx, 1.0cy), 0.06w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-1.0cx, -1.0cy), 0.06w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((0.33333333333333326cx, -0.33333333333333337cy), 0.06w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-1.0cx, 1.0cy), 0.06w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-0.33333333333333337cx, 0.33333333333333326cy), 0.06w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-1.0cx, -0.33333333333333337cy), 0.06w)], Symbol(\"\"))]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(0.0mm), Compose.LineWidthPrimitive(0.0mm), Compose.LineWidthPrimitive(0.0mm), Compose.LineWidthPrimitive(0.0mm), Compose.LineWidthPrimitive(0.0mm), Compose.LineWidthPrimitive(0.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,1.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.25098039215686274,0.8784313725490196,0.8156862745098039,1.0)), Compose.FillPrimitive(RGBA{Float64}(0.25098039215686274,0.8784313725490196,0.8156862745098039,1.0)), Compose.FillPrimitive(RGBA{Float64}(0.25098039215686274,0.8784313725490196,0.8156862745098039,1.0)), Compose.FillPrimitive(RGBA{Float64}(0.8274509803921568,0.8274509803921568,0.8274509803921568,1.0)), Compose.FillPrimitive(RGBA{Float64}(0.25098039215686274,0.8784313725490196,0.8156862745098039,1.0)), Compose.FillPrimitive(RGBA{Float64}(0.8274509803921568,0.8274509803921568,0.8274509803921568,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}((0.0w, 0.0h), (1.0w, 1.0h)), nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}}(Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}[Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((1.0cx, 1.0cy), \"Spending\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm)), Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((-1.0cx, -1.0cy), \"Age\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm)), Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((0.33333333333333326cx, -0.33333333333333337cy), \"Store\\nDistance\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm)), Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((-1.0cx, 1.0cy), \"Personal\\nIncome\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm)), Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((-0.33333333333333337cx, 0.33333333333333326cy), \"Population\\nDensity\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm)), Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((-1.0cx, -0.33333333333333337cy), \"Zoning\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm))], Symbol(\"\"))]), List([Compose.Property{Compose.FontSizePrimitive}(Compose.FontSizePrimitive[Compose.FontSizePrimitive(3.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\"))]), List([]), List([]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\"))" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "est_g = pcalg(df, .9, gausscitest)\n", + "nodestrokelw = [0, 0, 0, 0, 0, 0]\n", + "g_plot = gplot(est_g, locs_x, locs_y, nodelabel=nodelabel, \n", + " nodestrokec = \"black\", nodestrokelw = nodestrokelw, NODESIZE = .15, NODELABELSIZE = 3, nodefillc=nodefillc)\n", + "draw(PNG(\"causal_discovery_5.png\", 16cm, 16cm),g_plot)\n", + "g_plot" + ] + }, + { + "cell_type": "markdown", + "id": "d861e5c0", + "metadata": {}, + "source": [ + "The [package documentation](https://mschauer.github.io/CausalInference.jl/latest/examples/pc_basic_examples/) uses a parameter value of 0.01, which we will use for the rest of the post. In practice, `p` should be selected based on the size of the data (because tests done on a larger dataset will be more powerful even at the same cutoff level) and a range of parameter values should be used for sensitivity analyses. Note that the DAG we recover using 0.01 as our parameter value is the same as our original DAG" + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "id": "04ad22e1", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "image/svg+xml": [ + "\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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " Spending\n", + " \n", + " \n", + " \n", + " \n", + " Age\n", + " \n", + " \n", + " \n", + " \n", + " StoreDistance\n", + " \n", + " \n", + " \n", + " \n", + " PersonalIncome\n", + " \n", + " \n", + " \n", + " \n", + " PopulationDensity\n", + " \n", + " \n", + " \n", + " \n", + " Zoning\n", + " \n", + " \n", + "\n", + "\n" + ], + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " Spending\n", + " \n", + " \n", + " \n", + " \n", + " Age\n", + " \n", + " \n", + " \n", + " \n", + " StoreDistance\n", + " \n", + " \n", + " \n", + " \n", + " PersonalIncome\n", + " \n", + " \n", + " \n", + " \n", + " PopulationDensity\n", + " \n", + " \n", + " \n", + " \n", + " Zoning\n", + " \n", + " \n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "Context(BBox{l,t,r,b,w,h = 0.0w,0.0h, 1.0w,1.0h, 1.0w,1.0h}, UnitBox{Float64, Float64, Float64, Float64}(-1.2, -1.2, 2.4, 2.4, 0.0mm, 0.0mm, 0.0mm, 0.0mm), nothing, nothing, nothing, List([Context(BBox{l,t,r,b,w,h = 0.0w,0.0h, 1.0w,1.0h, 1.0w,1.0h}, nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.LinePrimitive}(Compose.LinePrimitive[Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.8939339828220179cx, -0.8939339828220179cy), (0.8939339828220179cx, 0.8939339828220179cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.8658359213500126cx, -0.9329179606750063cy), (0.19916925468334587cx, -0.40041537265832705cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.40041537265832694cx, -0.199169254683346cy), (0.9329179606750063cx, 0.8658359213500126cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.85cx, 1.0cy), (0.85cx, 1.0cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.8939339828220179cx, 0.8939339828220179cy), (-0.4393993505113155cx, 0.4393993505113154cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.85cx, -0.33333333333333337cy), (0.18333333333333326cx, -0.33333333333333337cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.8939339828220179cx, -0.22726731615535126cy), (-0.4393993505113155cx, 0.22726731615535115cy)])], Symbol(\"\"))]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(1.2247448713915892mm)]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.8274509803921568,0.8274509803921568,0.8274509803921568,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(BBox{l,t,r,b,w,h = 0.0w,0.0h, 1.0w,1.0h, 1.0w,1.0h}, nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.LinePrimitive}(Compose.LinePrimitive[Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.8516721566479479cx, 0.8033032041183529cy), (0.8939339828220179cx, 0.8939339828220179cy), (0.8033032041183529cx, 0.8516721566479479cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.13041619736506527cx, -0.4730309158249882cy), (0.19916925468334587cx, -0.40041537265832705cy), (0.09982498575904862cx, -0.41184849261295486cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.9214848407203785cx, 0.7664916524257154cy), (0.9329179606750063cx, 0.8658359213500126cy), (0.8603024175083452cx, 0.797082864031732cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.7560307379214091cx, 0.9657979856674331cy), (0.85cx, 1.0cy), (0.7560307379214091cx, 1.034202014332567cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.5300301292149805cx, 0.48166117668538533cy), (-0.4393993505113155cx, 0.4393993505113154cy), (-0.48166117668538544cx, 0.5300301292149804cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(0.08936407125474241cx, -0.36753534766590024cy), (0.18333333333333326cx, -0.33333333333333337cy), (0.08936407125474241cx, -0.2991313190007665cy)]), Compose.LinePrimitive{Tuple{Measure, Measure}}(Tuple{Measure, Measure}[(-0.48166117668538544cx, 0.13663653745168614cy), (-0.4393993505113155cx, 0.22726731615535115cy), (-0.5300301292149805cx, 0.1850054899812812cy)])], Symbol(\"\"))]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(1.2247448713915892mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.8274509803921568,0.8274509803921568,0.8274509803921568,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(BBox{l,t,r,b,w,h = 0.0w,0.0h, 1.0w,1.0h, 1.0w,1.0h}, nothing, nothing, nothing, nothing, List([]), List([]), List([Compose.Property{Compose.FontSizePrimitive}(Compose.FontSizePrimitive[Compose.FontSizePrimitive(4.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(BBox{l,t,r,b,w,h = 0.0w,0.0h, 1.0w,1.0h, 1.0w,1.0h}, nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}}(Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}[Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((1.0cx, 1.0cy), 0.06w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-1.0cx, -1.0cy), 0.06w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((0.33333333333333326cx, -0.33333333333333337cy), 0.06w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-1.0cx, 1.0cy), 0.06w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-0.33333333333333337cx, 0.33333333333333326cy), 0.06w), Compose.CirclePrimitive{Tuple{Measure, Measure}, Measure}((-1.0cx, -0.33333333333333337cy), 0.06w)], Symbol(\"\"))]), List([Compose.Property{Compose.LineWidthPrimitive}(Compose.LineWidthPrimitive[Compose.LineWidthPrimitive(0.0mm), Compose.LineWidthPrimitive(0.0mm), Compose.LineWidthPrimitive(0.0mm), Compose.LineWidthPrimitive(0.0mm), Compose.LineWidthPrimitive(0.0mm), Compose.LineWidthPrimitive(0.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,1.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.25098039215686274,0.8784313725490196,0.8156862745098039,1.0)), Compose.FillPrimitive(RGBA{Float64}(0.25098039215686274,0.8784313725490196,0.8156862745098039,1.0)), Compose.FillPrimitive(RGBA{Float64}(0.25098039215686274,0.8784313725490196,0.8156862745098039,1.0)), Compose.FillPrimitive(RGBA{Float64}(0.8274509803921568,0.8274509803921568,0.8274509803921568,1.0)), Compose.FillPrimitive(RGBA{Float64}(0.25098039215686274,0.8784313725490196,0.8156862745098039,1.0)), Compose.FillPrimitive(RGBA{Float64}(0.8274509803921568,0.8274509803921568,0.8274509803921568,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\")), Context(BBox{l,t,r,b,w,h = 0.0w,0.0h, 1.0w,1.0h, 1.0w,1.0h}, nothing, nothing, nothing, nothing, List([]), List([Compose.Form{Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}}(Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}[Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((1.0cx, 1.0cy), \"Spending\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm)), Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((-1.0cx, -1.0cy), \"Age\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm)), Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((0.33333333333333326cx, -0.33333333333333337cy), \"Store\\nDistance\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm)), Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((-1.0cx, 1.0cy), \"Personal\\nIncome\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm)), Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((-0.33333333333333337cx, 0.33333333333333326cy), \"Population\\nDensity\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm)), Compose.TextPrimitive{Tuple{Measures.Length{:cx, Float64}, Measures.Length{:cy, Float64}}, Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}, Tuple{Measures.AbsoluteLength, Measures.AbsoluteLength}}((-1.0cx, -0.33333333333333337cy), \"Zoning\", Compose.HCenter(), Compose.VCenter(), Rotation{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}(0.0, (0.5w, 0.5h)), (0.0mm, 0.0mm))], Symbol(\"\"))]), List([Compose.Property{Compose.FontSizePrimitive}(Compose.FontSizePrimitive[Compose.FontSizePrimitive(3.0mm)]), Compose.Property{Compose.StrokePrimitive}(Compose.StrokePrimitive[Compose.StrokePrimitive(RGBA{Float64}(0.0,0.0,0.0,0.0))]), Compose.Property{Compose.FillPrimitive}(Compose.FillPrimitive[Compose.FillPrimitive(RGBA{Float64}(0.0,0.0,0.0,1.0))])]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\"))]), List([]), List([]), 0, false, false, false, false, nothing, nothing, 0.0, Symbol(\"\"))" + ] + }, + "execution_count": 72, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "est_g = pcalg(df, 0.01, gausscitest)\n", + "nodestrokelw = [0, 0, 0, 0, 0, 0]\n", + "g_plot = gplot(est_g, locs_x, locs_y, nodelabel=nodelabel, \n", + " nodestrokec = \"black\", nodestrokelw = nodestrokelw, NODESIZE = .15, NODELABELSIZE = 3, nodefillc=nodefillc)\n", + "draw(PNG(\"causal_discovery_6.png\", 16cm, 16cm),g_plot)\n", + "g_plot" + ] + }, + { + "cell_type": "markdown", + "id": "eb75b158", + "metadata": {}, + "source": [ + "Now, let's look at how the FCI algorithm handles these data. (The nodes are oriented differently because we are using a different graphing library here to accommodate the different types of edges.) Note that I increased the sample size a lot, and it still ended up with one of the arrows reversed. I believe that the FCI algorithm would do better if we used longitudinal data, and gave the algorithm more information on which causal relationships are impossible." + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "1f736e37", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[33m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[33m\u001b[1mWarning: \u001b[22m\u001b[39mtest.pdf already exists, overwriting!\n", + "\u001b[33m\u001b[1m└ \u001b[22m\u001b[39m\u001b[90m@ TikzPictures ~/.julia/packages/TikzPictures/4zjh8/src/TikzPictures.jl:333\u001b[39m\n" + ] + }, + { + "data": { + "image/svg+xml": [ + "\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", + "\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", + " \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", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "TikzPicture(\"\\\\graph [layered layout, , ] {\\n1/\\\"spending\\\" [draw, rounded corners, fill=blue!10],\\n2/\\\"age\\\" [draw, rounded corners, fill=blue!10],\\n3/\\\"store\\\\_distance\\\" [draw, rounded corners, fill=blue!10],\\n4/\\\"personal\\\\_income\\\" [draw, rounded corners, fill=blue!10],\\n5/\\\"population\\\\_density\\\" [draw, rounded corners, fill=blue!10],\\n6/\\\"zoning\\\" [draw, rounded corners, fill=blue!10],\\n;\\n1 -> [,] 2;\\n1 -> [,<-,] 3;\\n1 -> [,<-o,] 4;\\n2 -> [,] 3;\\n3 -> [,<-o,] 6;\\n4 -> [,o->,] 5;\\n5 -> [,<-o,] 6;\\n};\\n\", \"scale=2\", \"\\\\usepackage{fontspec}\\n\\\\setmainfont{Latin Modern Math}\\n\\\\usetikzlibrary{arrows}\\n\\\\usetikzlibrary{graphs}\\n\\\\usetikzlibrary{graphdrawing}\\n\\n% from: https://tex.stackexchange.com/questions/453132/fresh-install-of-tl2018-no-tikz-graph-drawing-libraries-found\\n\\\\usepackage{luacode}\\n\\\\begin{luacode*}\\n\\tfunction pgf_lookup_and_require(name)\\n\\tlocal sep = package.config:sub(1,1)\\n\\tlocal function lookup(name)\\n\\tlocal sub = name:gsub('%.',sep) \\n\\tif kpse.find_file(sub, 'lua') then\\n\\trequire(name)\\n\\telseif kpse.find_file(sub, 'clua') then\\n\\tcollectgarbage('stop') \\n\\trequire(name)\\n\\tcollectgarbage('restart')\\n\\telse\\n\\treturn false\\n\\tend\\n\\treturn true\\n\\tend\\n\\treturn\\n\\tlookup('pgf.gd.' .. name .. '.library') or\\n\\tlookup('pgf.gd.' .. name) or\\n\\tlookup(name .. '.library') or\\n\\tlookup(name) \\n\\tend\\n\\\\end{luacode*}\\n\\n\\\\usegdlibrary{layered}\", \"tikzpicture\", \"\", \"\", true, true)" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "using TikzPictures\n", + "df = get_data(1000000)\n", + "est_g = fcialg(df, 0.1, gausscitest)\n", + "p = plot_fci_graph_tikz(est_g, [col for col in names(df)])\n", + "TikzPictures.save(TikzPictures.PDF(\"test\"), p)\n", + "p" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "a842e08a", + "metadata": {}, + "outputs": [ + { + "data": { + "image/svg+xml": [ + "\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", + "\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", + "\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", + " \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" + ], + "text/plain": [ + "TikzPicture(\"\\\\graph [layered layout, , ] {\\n1/\\\"curly\\\\{braces\\\\}\\\" [draw, rounded corners, fill=blue!10],\\n2/\\\"dollar\\\\\\$sign\\\" [draw, rounded corners, fill=blue!10],\\n3/\\\"under\\\\_score\\\\^{}caret\\\" [draw, rounded corners, fill=blue!10],\\n4/\\\"amper\\\\&sand\\\" [draw, rounded corners, fill=blue!10],\\n5/\\\"hash\\\\#tag\\\" [draw, rounded corners, fill=blue!10],\\n6/\\\"per\\\\%cent\\\" [draw, rounded corners, fill=blue!10],\\n;\\n1 -> [,] 2;\\n1 -> [,<-,] 3;\\n1 -> [,<-o,] 4;\\n2 -> [,] 3;\\n3 -> [,<-o,] 6;\\n4 -> [,o->,] 5;\\n5 -> [,<-o,] 6;\\n};\\n\", \"scale=2\", \"\\\\usepackage{fontspec}\\n\\\\setmainfont{Latin Modern Math}\\n\\\\usetikzlibrary{arrows}\\n\\\\usetikzlibrary{graphs}\\n\\\\usetikzlibrary{graphdrawing}\\n\\n% from: https://tex.stackexchange.com/questions/453132/fresh-install-of-tl2018-no-tikz-graph-drawing-libraries-found\\n\\\\usepackage{luacode}\\n\\\\begin{luacode*}\\n\\tfunction pgf_lookup_and_require(name)\\n\\tlocal sep = package.config:sub(1,1)\\n\\tlocal function lookup(name)\\n\\tlocal sub = name:gsub('%.',sep) \\n\\tif kpse.find_file(sub, 'lua') then\\n\\trequire(name)\\n\\telseif kpse.find_file(sub, 'clua') then\\n\\tcollectgarbage('stop') \\n\\trequire(name)\\n\\tcollectgarbage('restart')\\n\\telse\\n\\treturn false\\n\\tend\\n\\treturn true\\n\\tend\\n\\treturn\\n\\tlookup('pgf.gd.' .. name .. '.library') or\\n\\tlookup('pgf.gd.' .. name) or\\n\\tlookup(name .. '.library') or\\n\\tlookup(name) \\n\\tend\\n\\\\end{luacode*}\\n\\n\\\\usegdlibrary{layered}\", \"tikzpicture\", \"\", \"\", true, true)" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "## for testing \n", + "names_to_use = [\"curly{braces}\"\n", + " \"dollar\\$sign\"\n", + " \"under_score^caret\"\n", + " \"amper&sand\"\n", + " \"hash#tag\"\n", + " \"per%cent\"]\n", + "p = plot_fci_graph_tikz(est_g, names_to_use)\n", + "p" + ] + }, + { + "cell_type": "markdown", + "id": "b335803e", + "metadata": {}, + "source": [ + "Now, we will define some functions to conduct our simulations." + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "bd4f5d09", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "simulate_discovery_pc" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "using CausalInference\n", + "\n", + "\"\"\"Create data and determine whether the causal discovery algorithm worked correctly\"\"\"\n", + "function simulate_discovery_pc(n::Int)\n", + " df = get_data(n)\n", + " est_g = pcalg(df, 0.01, gausscitest)\n", + " return est_g == g\n", + " \n", + " \n", + "end" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "id": "362a3353", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "get_confint_width_control_all" + ] + }, + "execution_count": 46, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "using GLM, Distributions\n", + "\"\"\"Get the confidence interval of the desired parameter when controlling for all covariates\"\"\"\n", + "function get_confint_width_control_all(n::Int)\n", + " df = get_data(n)\n", + " mod = lm(@formula(spending ~ store_distance + age + population_density + zoning + personal_income), df)\n", + " return stderror(mod)[2] * 2* quantile(Normal(0.0, 1.0),.975)\n", + " \n", + "end" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "id": "2de31d53", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "get_confint_width_control_age" + ] + }, + "execution_count": 47, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\"\"\"Get the confidence interval of the desired parameter when controlling for just age\"\"\"\n", + "function get_confint_width_control_age(n::Int)\n", + " df = get_data(n)\n", + " mod = lm(@formula(spending ~ store_distance + age), df)\n", + " return stderror(mod)[2] * 2* quantile(Normal(0.0, 1.0),.975)\n", + " \n", + "end" + ] + }, + { + "cell_type": "markdown", + "id": "40534a58", + "metadata": {}, + "source": [ + "And, we'll use simulation to see how causal inference might do under many possible sample sizes. Here, we'll pretend that there are 100,000 possible customers in our store's dataset, so we get information on age and population density for \"free\" for all of those customers. However, we may choose to purchase additional information for a smaller number of customers." + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "id": "6f3ad753", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "9-element Vector{Int64}:\n", + " 200\n", + " 500\n", + " 1000\n", + " 2000\n", + " 3000\n", + " 5000\n", + " 8000\n", + " 10000\n", + " 100000" + ] + }, + "execution_count": 48, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sample_sizes = [200,500,1000, 2000, 3000, 5000, 8000, 10000, 100000]" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "id": "15639f14", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "9-element Vector{Float64}:\n", + " 2.8115630705511534\n", + " 1.7676608862714198\n", + " 1.244541315132393\n", + " 0.8793204902309119\n", + " 0.7164897592324871\n", + " 0.5547073387754579\n", + " 0.43917852198231894\n", + " 0.39189421712184797\n", + " 0.12395185564974553" + ] + }, + "execution_count": 49, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "widths_control_all = [ mean([get_confint_width_control_all(sample_size) for i in 1:50]) \n", + " for sample_size in sample_sizes]" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "id": "d316d9e3", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "9-element Vector{Float64}:\n", + " 0.39066356290977355\n", + " 0.24687584500294046\n", + " 0.17445306399686047\n", + " 0.12343422155246556\n", + " 0.10035008540387573\n", + " 0.0782271754568998\n", + " 0.06165551987110357\n", + " 0.05514468317732508\n", + " 0.017436101603674883" + ] + }, + "execution_count": 55, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "widths_control_age = [ mean([get_confint_width_control_age(sample_size) for i in 1:50]) \n", + " for sample_size in sample_sizes]" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "id": "7c720344", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "9-element Vector{Float64}:\n", + " 0.02\n", + " 0.08\n", + " 0.26\n", + " 0.66\n", + " 0.9\n", + " 0.98\n", + " 1.0\n", + " 1.0\n", + " 0.98" + ] + }, + "execution_count": 51, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "prop_correct_dag = [ mean([simulate_discovery_pc(sample_size) for i in 1:50]) \n", + " for sample_size in sample_sizes]" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "id": "a0f86f08", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.017441668616459544" + ] + }, + "execution_count": 52, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "estimate_from_age_control = mean([get_confint_width_control_age(sample_sizes[length(sample_sizes)]) \n", + " for i in 1:500]) ## Assume that we can get this data for free\n" + ] + }, + { + "cell_type": "markdown", + "id": "73d73110", + "metadata": {}, + "source": [ + "Finally, let's look at how the efficiency of estimation changes as we increase our sample size. \n", + "\n", + "In this hypothetical scenario, there are three possible strategies we could use to estimate the effect of store distance on spending. \n", + "1. Sample a given amount of data (e.g. for 3,000 customers), and use all variables (both those which we have \"free\" and \"expensive\" data for to estimate the effect \n", + "2. Sample a given amount of data, use causal discovery to identify age as the variable that needs to be controlled, and estimate the effect controlling for only age on the smaller subsample of data \n", + "3. Sample a given amount of data, use causal discovery to identify age as the variable that needs to be controlled, and estimate the effect controlling for only age on the full population that we have \"free\" data for (100,000 customers) \n", + "\n", + "Note that both controlling for age and controlling for all possible variables yield unbiased estimates of our causal parameter.\n", + "\n", + "In our graph, we can see that the confidence interval width for age (estimated from strategies 2 and 3) is always smaller than the interval width when controlling for all variables. However, we can only realistically use those strategies if we have enough data to correctly identify the causal structure of the data. So, strategy 2 and 3 are always better than strategy 1 as long as we have at least 5,000 patients. \n", + "\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "id": "5f234539", + "metadata": {}, + "outputs": [ + { + "data": { + "image/svg+xml": [ + "\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" + ] + }, + "execution_count": 62, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "using StatsPlots\n", + "p = StatsPlots.plot(xlabel = \"Sample size\", ylabel = \"Confidence Interval Width\")\n", + "p_twin = StatsPlots.twinx(p)\n", + "\n", + "StatsPlots.plot!(p, sample_sizes, widths_control_all,xaxis=:log, \n", + " legend = :right, linecolor = :steelblue, label = \"Controlling for all\")\n", + "StatsPlots.plot!(p, sample_sizes, widths_control_age,xaxis=:log, \n", + " legend = :right, linecolor = :turquoise, label = \"Controlling for Age\")\n", + "\n", + "StatsPlots.plot!(p_twin, sample_sizes, [i * 100 for i in prop_correct_dag], xaxis=:log, legend = :topright, linecolor = :green, \n", + "label = \"% correct DAGs\", ylabel = \"Proportion of correct DAGs\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "417d23dc", + "metadata": {}, + "source": [ + "In this example, I used `gausscitest`, which assumes that relationships between variables are linear. This may not hold in many situations. \n", + "\n", + "In my previous posts, I have discussed how [double machine learning](https://medium.com/@clementzach_38631/double-machine-learning-for-causal-inference-from-a-partially-linear-model-ada4c39914e3) may be used to recover estimates of causal parameters in these situations, so causal inference could still be done in those situations as long as you have a valid causal discovery algorithm. \n", + "\n", + "If you find yourself in a situation where the assumption of linear relationships between covariates is untenable, you can still do causal discovery! If you're using the Julia package I used in this package, you just need to use `cmitest` rather than `gausscitest` as demonstrated in [this example](https://mschauer.github.io/CausalInference.jl/latest/examples/pc_cmi_examples/). This will take much longer because the algorithm for assessing independence without assuming linearity is much more complicated than the algorithm which assumes linearity, but it enables you to use causal inference in situations where you do not think that linear relationships between covariates will hold. " + ] + }, + { + "cell_type": "markdown", + "id": "db0e7a9e", + "metadata": {}, + "source": [ + "And, I've said this before, but I want to just reiterate that you should be cautious about use causal discovery methods in cases when there are [unmeasured common causes of variables in your dataset](https://arxiv.org/pdf/2106.02234.pdf) or in cases of selection bias, regardless of the algorithm you use. In reality, it's probably next to impossible to rule out these possibilities, but causal discovery is a fun thing to learn about anyway!" + ] + }, + { + "cell_type": "markdown", + "id": "274eb527", + "metadata": {}, + "source": [ + "If you're interested in learning more, here are a couple of resources: \n", + "\n", + "[Causation, Prediction, and Search book (the definitive resource)](https://philarchive.org/archive/SPICPA-2)\n", + "\n", + "[A chapter from Cosma Shalizi](https://www.stat.cmu.edu/~cshalizi/uADA/12/lectures/ch25.pdf)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b5ff5a24", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Julia 1.8.3", + "language": "julia", + "name": "julia-1.8" + }, + "language_info": { + "file_extension": ".jl", + "mimetype": "application/julia", + "name": "julia", + "version": "1.8.3" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}