plots_abcd.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Plots for the A-ICP vs. ABCD comparison"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib import gridspec\n",
    "import scipy\n",
    "from src import utils, evaluation\n",
    "import copy\n",
    "import pickle\n",
    "import scipy.stats"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Path to result files"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### ABCD results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "filenames_abcd_50 = [\n",
    "\"experiments/pp_1590137549_n_samples:500_n_batches:50_max_interventions:1_strategy:entropy_intervention_strength:7.0_starting_samples:50_target:0_intervention_type:gauss_target_allowed:True.pickle\",  \n",
    "\"experiments/pp_1590063013_n_samples:500_n_batches:50_max_interventions:1_strategy:entropy_intervention_strength:7.0_starting_samples:50_target:0_intervention_type:gauss_target_allowed:True.pickle\",\n",
    "\"experiments/pp_1590423584_n_samples:500_n_batches:50_max_interventions:1_strategy:entropy_intervention_strength:7.0_starting_samples:50_target:0_intervention_type:gauss_target_allowed:True.pickle\",\n",
    "\"experiments/pp_1590415394_n_samples:500_n_batches:50_max_interventions:1_strategy:entropy_intervention_strength:7.0_starting_samples:50_target:0_intervention_type:gauss_target_allowed:True.pickle\"]\n",
    "\n",
    "filenames_abcd_100 = [\n",
    "\"experiments/pp_1590293014_n_samples:500_n_batches:50_max_interventions:1_strategy:entropy_intervention_strength:7.0_starting_samples:100_target:0_intervention_type:gauss_target_allowed:True.pickle\",  \n",
    "\"experiments/pp_1590424805_n_samples:500_n_batches:50_max_interventions:1_strategy:entropy_intervention_strength:7.0_starting_samples:100_target:0_intervention_type:gauss_target_allowed:True.pickle\",    \n",
    "\"experiments/pp_1590371595_n_samples:500_n_batches:50_max_interventions:1_strategy:entropy_intervention_strength:7.0_starting_samples:100_target:0_intervention_type:gauss_target_allowed:True.pickle\",  \n",
    "\"experiments/pp_1590529676_n_samples:500_n_batches:50_max_interventions:1_strategy:entropy_intervention_strength:7.0_starting_samples:100_target:0_intervention_type:gauss_target_allowed:True.pickle\"]\n",
    "\n",
    "filenames_abcd_1000 = [\n",
    "\"experiments/pp_1590427369_n_samples:500_n_batches:50_max_interventions:1_strategy:entropy_intervention_strength:7.0_starting_samples:1000_target:0_intervention_type:gauss_target_allowed:True.pickle\",\n",
    "\"experiments/pp_1590448655_n_samples:500_n_batches:50_max_interventions:1_strategy:entropy_intervention_strength:7.0_starting_samples:1000_target:0_intervention_type:gauss_target_allowed:True.pickle\",  \n",
    "\"experiments/pp_1590232841_n_samples:500_n_batches:50_max_interventions:1_strategy:entropy_intervention_strength:7.0_starting_samples:1000_target:0_intervention_type:gauss_target_allowed:True.pickle\",\n",
    "\"experiments/pp_1590180816_n_samples:500_n_batches:50_max_interventions:1_strategy:entropy_intervention_strength:7.0_starting_samples:1000_target:0_intervention_type:gauss_target_allowed:True.pickle\"]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### AICP results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "filenames_aicp_50 = [\"experiments/results_1590603441_runs_4_max_iter_50_tag_abcd_load_dataset_dataset_3_abcd_True_G_4_do_False_i_mean_7.0_i_var_1.0_finite_True_n_10_n_obs_50_alpha_0.002.pickle\"]\n",
    "filenames_aicp_100 = [\"experiments/results_1590625350_runs_4_max_iter_50_tag_abcd_load_dataset_dataset_3_abcd_True_G_4_do_False_i_mean_7.0_i_var_1.0_finite_True_n_10_n_obs_100_alpha_0.002.pickle\"]\n",
    "filenames_aicp_1000 = [\"experiments/results_1591653728_runs_4_max_iter_50_tag_abcd_euler_load_dataset_dataset_3_abcd_True_G_4_do_False_i_mean_7.0_i_var_1.0_finite_True_n_10_n_obs_1000_alpha_0.002.pickle\"]\n",
    "\n",
    "filenames_aicp_50 = [\"experiments/results_1602518528_runs:4_max_iter:50_tag:abcd50_load_dataset:dataset_abcd:True_G:4_do:True_i_mean:7.0_i_var:1.0_finite:True_n:10_n_obs:50_alpha:0.002.pickle\"]\n",
    "filenames_aicp_100 =[\"experiments/results_1602516532_runs:4_max_iter:50_tag:abcd100_load_dataset:dataset_abcd:True_G:4_do:True_i_mean:7.0_i_var:1.0_finite:True_n:10_n_obs:100_alpha:0.002.pickle\"]\n",
    "filenames_aicp_1000 =[\"experiments/results_1602514182_runs:4_max_iter:50_tag:abcd1000_load_dataset:dataset_abcd:True_G:4_do:True_i_mean:7.0_i_var:1.0_finite:True_n:10_n_obs:1000_alpha:0.002.pickle\"]\n",
    "\n",
    "filenames_aicp_1000 = [\"experiments/results_1602603150_runs:4_max_iter:50_tag:abcd91_load_dataset:dataset_abcd:True_G:4_do:True_i_mean:9.0_i_var:1.0_finite:True_n:10_n_obs:1000_alpha:0.002.pickle\"]\n",
    "filenames_aicp_100 = [\"experiments/results_1602630721_runs:4_max_iter:50_tag:abcd101_load_dataset:dataset_abcd:True_G:4_do:True_i_mean:10.0_i_var:1.0_finite:True_n:10_n_obs:100_alpha:0.002.pickle\"]\n",
    "filenames_aicp_50 = [\"experiments/results_1602632644_runs:4_max_iter:50_tag:abcd101_load_dataset:dataset_abcd:True_G:4_do:True_i_mean:10.0_i_var:1.0_finite:True_n:10_n_obs:50_alpha:0.002.pickle\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plotting setup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set tex formatting for plots\n",
    "from matplotlib import rc\n",
    "rc('font',**{'family':'serif','sans-serif':['Computer Modern Roman']})\n",
    "rc('text', usetex=True)\n",
    "#plt.rcParams[\"font.family\"] = \"serif\"\n",
    "#plt.rcParams[\"font.serif\"] = [\"Computer Modern Roman\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set legend size\n",
    "from matplotlib.font_manager import FontProperties\n",
    "fontP = FontProperties()\n",
    "fontP.set_size('medium')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.collections.PathCollection at 0x7f81f32a49e8>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Colors\n",
    "def to_rgb(H, b=1, a=1):\n",
    "    RGBa = []\n",
    "    for h in H:\n",
    "        h = h.lstrip(\"#\")\n",
    "        RGBa.append(tuple(int(h[i:i+2], 16) / 256 * b for i in (0, 2, 4)) + (a,))\n",
    "    return np.array(RGBa)\n",
    "\n",
    "cmap = matplotlib.cm.get_cmap('tab20')\n",
    "# Colorblind safe palette\n",
    "base = ['#d73027', '#fc8d59', '#fee090', '#91bfdb', '#4575b4', '#020202',]\n",
    "plt.scatter(np.arange(len(base)), np.ones(len(base)), c = base)\n",
    "#base = [base[i] for i in [0,1,3]]\n",
    "colors = to_rgb(base)\n",
    "colorsa = to_rgb(base, a=0.5)\n",
    "colorsb = to_rgb(base, b=0.7)\n",
    "plt.scatter(np.arange(len(colors)), np.zeros(len(colors)), c = colors)\n",
    "plt.scatter(np.arange(len(colors)), np.ones(len(colors))*0.5, c = colorsa)\n",
    "plt.scatter(np.arange(len(colors)), np.ones(len(colors))*-0.5, c = colorsb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Auxiliary functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def jaccard_distance(A,B,p=None):\n",
    "    A = set(A) if type(A) is not set else A\n",
    "    B = set(B) if type(B) is not set else B\n",
    "    return len(A & B) / len(A | B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_trajectories_abcd(abcd_results, metric=jaccard_distance, estimate=\"max\"):\n",
    "    Trajectories = []\n",
    "    Type1Errors = []\n",
    "    for graph in abcd_results:\n",
    "        _id, truth, _mec_size, runs = graph\n",
    "        for posteriors in runs:\n",
    "            # Trajectory of each run\n",
    "            trajectory = []\n",
    "            error_trajectory = []\n",
    "            for (Parents, probs) in posteriors:\n",
    "                distances = np.array(list(map(lambda parents: metric(truth, parents), Parents)))\n",
    "                if estimate == \"weighted\":\n",
    "                    weighted_metric = distances @ probs\n",
    "                elif estimate == \"max\":\n",
    "                    weighted_metric = distances[np.argmax(probs)]\n",
    "                trajectory.append(weighted_metric)\n",
    "                type1error = not set.issubset(set(Parents[np.argmax(probs)]), set(truth))\n",
    "                error_trajectory.append(type1error)\n",
    "            Type1Errors.append(error_trajectory)\n",
    "            Trajectories.append(trajectory)\n",
    "    return np.array(Trajectories), np.array(Type1Errors)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mec_sizes(results):\n",
    "    return list(map(lambda result: result[0], results))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_trajectories_aicp(results, cases, max_iter, metric=jaccard_distance):\n",
    "    runs = len(results[0])\n",
    "    N = len(results[0][0])\n",
    "    P = len(results)\n",
    "\n",
    "    no_ints = np.zeros((len(results), runs, N))\n",
    "    all_trajectories = {}\n",
    "    all_type1_errors = {}\n",
    "    names = []\n",
    "    for k, policy_runs in enumerate(results):\n",
    "        name = policy_runs[0][0].policy\n",
    "        print(\"Processing results for %s policy\" % name, end=\"\")\n",
    "        names.append(name)\n",
    "        trajectories = np.ones((N*runs, max_iter+1))\n",
    "        type1_errors = np.zeros((N*runs, max_iter+1))\n",
    "        for i,run_results in enumerate(policy_runs):\n",
    "            no_ints[k, i,:] = list(map(lambda result: len(result.interventions()), run_results))\n",
    "            for j, result in enumerate(run_results):\n",
    "                estimates = list(map(lambda step: step[0], result.history[0::])) + [result.estimate]                \n",
    "                trajectory = list(map(lambda estimate: metric(cases[j].truth, estimate, cases[j].sem.p), estimates))\n",
    "                type1_error = list(map(lambda estimate: not set.issubset(estimate, cases[j].truth), estimates))\n",
    "                trajectories[i*N+j,0:len(trajectory)] = trajectory\n",
    "                type1_errors[i*N+j,0:len(type1_error)] = type1_error\n",
    "        all_trajectories[name] = trajectories\n",
    "        all_type1_errors[name] = type1_errors\n",
    "        print(\" done\")\n",
    "    return all_trajectories, all_type1_errors, N, P, runs, names, no_ints"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Helper functions for processing AICP results\n",
    "def load_experiments(filename):\n",
    "    f = open(filename, \"rb\")\n",
    "    results = pickle.load(f)\n",
    "    return results[0], results[1::]\n",
    "\n",
    "def merge_runs(old, new, min_merge=False):\n",
    "    if len(old) == len(new) or (len(old) < len(new) and min_merge):\n",
    "        for i in range(len(old)):\n",
    "            old[i] += new[i].copy()\n",
    "    else:\n",
    "        raise Exception(\"Cannot merge\")\n",
    "    return old\n",
    "\n",
    "# Main function\n",
    "def load_results(filenames, alg, same_graphs=False):\n",
    "    # Load results for ABCD\n",
    "    if alg == \"abcd\":\n",
    "        results = []\n",
    "        processed = []\n",
    "        for filename in filenames:\n",
    "            results += pickle.load(open(filename, \"rb\"))\n",
    "        G = int(len(results) / len(filenames)) if same_graphs else len(results)\n",
    "        # Turn posteriors into a list of runs\n",
    "        for i in range(G):\n",
    "            (mec0, truth0, target0, posteriors0) = results[i]\n",
    "            runs = [posteriors0]\n",
    "            # If filenames correspond to different runs, merge results\n",
    "            if same_graphs:\n",
    "                for j in range(1,len(filenames)):\n",
    "                    (mec, truth, target, posteriors) = results[i+j*G]                    \n",
    "                    assert mec == mec0 and truth0 == truth and target0 == target\n",
    "                    runs.append(posteriors)\n",
    "            processed += [(mec0, truth0, target0, runs)]\n",
    "        print(\"\\nLoaded a total of %d graphs with %d runs\" % (G, len(runs)))\n",
    "        return processed\n",
    "    # Load results for AICP\n",
    "    elif alg == \"aicp\":\n",
    "        cases, results = load_experiments(filenames[0])\n",
    "        for filename in filenames[1::]:\n",
    "            print(\"Loading %s\" % filename)\n",
    "            new_cases, new_results = load_experiments(filename)\n",
    "            cases += new_cases\n",
    "            for k in range(len(results)):\n",
    "                results[k] = merge_runs(results[k], new_results[k])\n",
    "        print(\"\\nLoaded a total of %d graphs with %d runs each\" % (len(results[0][0]), len(results[0])))\n",
    "    return cases, results"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Load and process data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Load ABCD results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Loaded a total of 100 graphs with 4 runs\n",
      "\n",
      "Loaded a total of 100 graphs with 4 runs\n",
      "\n",
      "Loaded a total of 100 graphs with 4 runs\n"
     ]
    }
   ],
   "source": [
    "results_abcd_1000 = load_results(filenames_abcd_1000, \"abcd\", True)\n",
    "Trajectories_abcd_1000, Type1Errors_abcd_1000 = compute_trajectories_abcd(results_abcd_1000, estimate=\"weighted\")\n",
    "mec_sizes1000 = mec_sizes(results_abcd_1000)\n",
    "\n",
    "results_abcd_100 = load_results(filenames_abcd_100, \"abcd\", True)\n",
    "Trajectories_abcd_100, Type1Errors_abcd_100 = compute_trajectories_abcd(results_abcd_100, estimate=\"weighted\")\n",
    "\n",
    "results_abcd_50 = load_results(filenames_abcd_50, \"abcd\", True)\n",
    "Trajectories_abcd_50, Type1Errors_abcd_50 = compute_trajectories_abcd(results_abcd_50, estimate=\"weighted\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Load A-ICP results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Loaded a total of 100 graphs with 4 runs each\n",
      "Processing results for random policy done\n",
      "Processing results for e + r policy done\n",
      "Processing results for e policy done\n",
      "Processing results for r policy done\n",
      "\n",
      "Loaded a total of 100 graphs with 4 runs each\n",
      "Processing results for random policy done\n",
      "Processing results for e + r policy done\n",
      "Processing results for e policy done\n",
      "Processing results for r policy done\n",
      "\n",
      "Loaded a total of 100 graphs with 4 runs each\n",
      "Processing results for random policy done\n",
      "Processing results for e + r policy done\n",
      "Processing results for e policy done\n",
      "Processing results for r policy done\n"
     ]
    }
   ],
   "source": [
    "cases, results_aicp_1000 = load_results(filenames_aicp_1000, \"aicp\")\n",
    "Trajectories_aicp_1000, Type1Error_aicp_1000, _, _, _, _, _ = compute_trajectories_aicp(results_aicp_1000, cases, 50)\n",
    "\n",
    "cases, results_aicp_100 = load_results(filenames_aicp_100, \"aicp\")\n",
    "Trajectories_aicp_100, Type1Error_aicp_100, _, _, _, _, _ = compute_trajectories_aicp(results_aicp_100, cases, 50)\n",
    "\n",
    "cases, results_aicp_50 = load_results(filenames_aicp_50, \"aicp\")\n",
    "Trajectories_aicp_50, Type1Error_aicp_50, _, _, _, _, _ = compute_trajectories_aicp(results_aicp_50, cases, 50)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plot A: Jaccard simmilarity + Type 1 error (for one initial setting)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 612x144 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "gs = gridspec.GridSpec(1, 2, wspace=0.2, hspace=0.15)\n",
    "plt.figure(figsize=(8.5,2))\n",
    "plot_iter = 51\n",
    "level = 0.01\n",
    "# =========================\n",
    "# == JACCARD SIMMILARITY ==\n",
    "\n",
    "ylim = [0,1]\n",
    "labcd = \"-.\"\n",
    "laicp = \"-\"\n",
    "mean_abcd = Trajectories_abcd_1000.mean(axis=0)[0:plot_iter]\n",
    "mean_aicp = Trajectories_aicp_1000[\"e\"].mean(axis=0)[0:plot_iter]\n",
    "\n",
    "# Plot for 1000 initial samples\n",
    "plt.subplot(gs[0])\n",
    "ax = plt.gca()\n",
    "ax.plot(mean_abcd, c=colors[4], label=\"ABCD\", linewidth=1.5, linestyle=labcd)\n",
    "ax.plot(mean_aicp, c=colors[2], label=\"AICP w/ e policy\", linewidth=1.5, linestyle=laicp)\n",
    "plt.ylabel(\"Avg. Jaccard similarity\")\n",
    "plt.xlabel(\"Intervention number\")\n",
    "plt.ylim(ylim)\n",
    "\n",
    "# =======================\n",
    "# == TYPE 1 ERROR RATE ==\n",
    "\n",
    "ylim = [-0.02,0.8]\n",
    "level = 0.1\n",
    "# Plot for 1000 initial samples\n",
    "plt.subplot(gs[1])\n",
    "ax = plt.gca()\n",
    "ax.plot(np.mean(Type1Errors_abcd_1000, axis=0)[0:plot_iter], c=colors[4], label=\"ABCD\", linewidth=1.5, linestyle=labcd)\n",
    "ax.plot(np.mean(Type1Error_aicp_1000[\"e\"], axis=0)[0:plot_iter], c=colors[2], label=\"A-ICP w/ e policy\", linewidth=1.5, linestyle=laicp)\n",
    "ax.plot([0, plot_iter-1], [level, level], color = 'red', linestyle=\"--\", label=\"%s level\" % level)\n",
    "plt.xlabel(\"Intervention number\")\n",
    "plt.ylabel(\"FWER\")\n",
    "plt.ylim(ylim)\n",
    "ax.legend(prop=fontP, ncol=5, bbox_to_anchor=(.55, -.27))\n",
    "\n",
    "plt.savefig(\"figures/abcd_vs_aicp.pdf\", bbox_inches='tight')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plot B: Jaccard simmilarity + Type 1 error (for all initial settings)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 612x612 with 6 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "gs = gridspec.GridSpec(3, 3, wspace=0.10, hspace=0.15)\n",
    "plt.figure(figsize=(8.5,8.5))\n",
    "plot_iter = 51\n",
    "# =========================\n",
    "# == JACCARD SIMMILARITY ==\n",
    "\n",
    "ylim = [0,1]\n",
    "labcd = \"-.\"\n",
    "laicp = \"-\"\n",
    "# Plot for 1000 initial samples\n",
    "plt.subplot(gs[0])\n",
    "ax = plt.gca()\n",
    "ax.plot(Trajectories_abcd_1000.mean(axis=0)[0:plot_iter], c=colors[4], label=\"ABCD\", linewidth=1.5, linestyle=labcd)\n",
    "ax.plot(Trajectories_aicp_1000[\"e\"].mean(axis=0)[0:plot_iter], c=colors[2], label=\"AICP w/ e policy\", linewidth=1.5, linestyle=laicp)\n",
    "plt.ylabel(\"Avg. Jaccard similarity\")\n",
    "ax.text(0.5,1.04,\"1000 observational datapoints\", transform=ax.transAxes, fontsize=11, ha=\"center\")\n",
    "plt.ylim(ylim)\n",
    "\n",
    "# Plot for 100 initial samples\n",
    "plt.subplot(gs[1])\n",
    "ax = plt.gca()\n",
    "ax.plot(Trajectories_abcd_100.mean(axis=0)[0:plot_iter], c=colors[4], label=\"ABCD\", linewidth=1.5, linestyle=labcd)\n",
    "ax.plot(Trajectories_aicp_100[\"e\"].mean(axis=0)[0:plot_iter], c=colors[2], label=\"AICP w/ e policy\", linewidth=1.5, linestyle=laicp)\n",
    "ax.set_yticklabels([])\n",
    "ax.text(0.5,1.04,\"100 observational datapoints\", transform=ax.transAxes, fontsize=11, ha=\"center\")\n",
    "plt.ylim(ylim)\n",
    "\n",
    "# Plot for 50 initial samples\n",
    "plt.subplot(gs[2])\n",
    "ax = plt.gca()\n",
    "ax.plot(Trajectories_abcd_50.mean(axis=0)[0:plot_iter], c=colors[4], label=\"ABCD\", linewidth=1.5, linestyle=labcd)\n",
    "ax.plot(Trajectories_aicp_50[\"e\"].mean(axis=0)[0:plot_iter], c=colors[2], label=\"AICP w/ e policy\", linewidth=1.5, linestyle=laicp)\n",
    "ax.set_yticklabels([])\n",
    "ax.text(0.5,1.04,\"50 observational datapoints\", transform=ax.transAxes, fontsize=11, ha=\"center\")\n",
    "plt.ylim(ylim)\n",
    "\n",
    "# =======================\n",
    "# == TYPE 1 ERROR RATE ==\n",
    "\n",
    "ylim = [-0.02,0.8]\n",
    "level = 0.1\n",
    "\n",
    "# Plot for 1000 initial samples\n",
    "plt.subplot(gs[3])\n",
    "ax = plt.gca()\n",
    "ax.plot(np.mean(Type1Errors_abcd_1000, axis=0)[0:plot_iter], c=colors[4], label=\"ABCD\", linewidth=1.5, linestyle=labcd)\n",
    "ax.plot(np.mean(Type1Error_aicp_1000[\"e\"], axis=0)[0:plot_iter], c=colors[2], label=\"AICP w/ e policy\", linewidth=1.5, linestyle=laicp)\n",
    "plt.xlabel(\"Intervention number\")\n",
    "plt.ylabel(\"FWER\")\n",
    "plt.ylim(ylim)\n",
    "ax.plot([0, plot_iter-1], [level, level], color = 'red', linestyle=\"--\", label=\"%s level\" % level)\n",
    "\n",
    "# Plot for 100 initial samples\n",
    "plt.subplot(gs[4])\n",
    "ax = plt.gca()\n",
    "ax.plot(np.mean(Type1Errors_abcd_100, axis=0)[0:plot_iter], c=colors[4], label=\"ABCD\", linewidth=1.5, linestyle=labcd)\n",
    "ax.plot(np.mean(Type1Error_aicp_100[\"e\"], axis=0)[0:plot_iter], c=colors[2], label=\"AICP w/ e policy\", linewidth=1.5, linestyle=laicp)\n",
    "plt.xlabel(\"Intervention number\")\n",
    "ax.set_yticklabels([])\n",
    "plt.ylim(ylim)\n",
    "ax.plot([0, plot_iter-1], [level, level], color = 'red', linestyle=\"--\", label=\"%s level\" % level)\n",
    "\n",
    "# Plot for 50 initial samples\n",
    "plt.subplot(gs[5])\n",
    "ax = plt.gca()\n",
    "ax.plot(np.mean(Type1Errors_abcd_50, axis=0)[0:plot_iter], c=colors[4], label=\"ABCD\", linewidth=1.5, linestyle=labcd)\n",
    "ax.plot(np.mean(Type1Error_aicp_50[\"e\"], axis=0)[0:plot_iter], c=colors[2], label=\"A-ICP w/ e policy\", linewidth=1.5, linestyle=laicp)\n",
    "plt.xlabel(\"Intervention number\")\n",
    "ax.set_yticklabels([])\n",
    "plt.ylim(ylim)\n",
    "ax.plot([0, plot_iter-1], [level, level], color = 'red', linestyle=\"--\", label=\"%s level\" % level)\n",
    "ax.legend(prop=fontP, ncol=5, bbox_to_anchor=(0.4, -.25))\n",
    "\n",
    "plt.savefig(\"figures/abcd_vs_aicp_all.pdf\", bbox_inches='tight')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plot C: Distribution of sizes of the Markov equivalence classes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "68\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 180x180 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(2.5, 2.5))\n",
    "print(max(mec_sizes1000))\n",
    "plt.hist(mec_sizes1000, np.arange(100), rwidth=1, align='mid', color=\"#BABABA\")#colorsb[2])\n",
    "plt.xlabel(\"Size of the observational MEC\")\n",
    "plt.ylabel(\"Number of graphs\")\n",
    "plt.savefig(\"figures/mec_sizes.pdf\", bbox_inches='tight')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plot D: Metric distributions vs. intervention number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_trajectories_dist(Trajectories, axes, color=None):\n",
    "    bplot = axes.boxplot(Trajectories,\n",
    "                         vert=True,  # vertical box alignment\n",
    "                         patch_artist=True,\n",
    "                         medianprops = {'color': 'black'})\n",
    "    if color is not None:\n",
    "        for i,patch in enumerate(bplot['boxes']):\n",
    "            patch.set_facecolor(color)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'Jaccard similarity')"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 612x612 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "gs = gridspec.GridSpec(4, 1, wspace=0.10, hspace=0.40)\n",
    "plt.figure(figsize=(8.5,8.5))\n",
    "\n",
    "plt.subplot(gs[0])\n",
    "ax = plt.gca()\n",
    "plot_trajectories_dist(Trajectories_abcd_1000, ax, color=colorsa[5])\n",
    "plt.title(\"ABCD\")\n",
    "ax.set_xticks(np.arange(1,52,5))\n",
    "ax.set_xticklabels(np.arange(0,51,5))\n",
    "plt.ylabel(\"Jaccard similarity\")\n",
    "\n",
    "plt.subplot(gs[1])\n",
    "ax = plt.gca()\n",
    "plot_trajectories_dist(Trajectories_aicp_1000[\"e\"], ax, color=colorsa[1])\n",
    "plt.title(\"A-ICP w/ e policy\")\n",
    "ax.set_xticks(np.arange(1,52,5))\n",
    "ax.set_xticklabels(np.arange(0,51,5))\n",
    "plt.ylabel(\"Jaccard similarity\")\n",
    "\n",
    "plt.subplot(gs[2])\n",
    "ax = plt.gca()\n",
    "plot_trajectories_dist(Trajectories_aicp_1000[\"r\"], ax, color=colorsa[2])\n",
    "plt.title(\"A-ICP w/ r policy\")\n",
    "plt.ylabel(\"Jaccard similarity\")\n",
    "ax.set_xticks(np.arange(1,52,5))\n",
    "ax.set_xticklabels(np.arange(0,51,5))\n",
    "\n",
    "plt.subplot(gs[3])\n",
    "ax = plt.gca()\n",
    "plot_trajectories_dist(Trajectories_aicp_1000[\"e + r\"], ax, color=colorsa[3])\n",
    "plt.title(\"A-ICP w/ e + r policy\")\n",
    "ax.set_xticks(np.arange(1,52,5))\n",
    "ax.set_xticklabels(np.arange(0,51,5))\n",
    "plt.xlabel(\"Intervention number\")\n",
    "plt.ylabel(\"Jaccard similarity\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plot E: Metric mean vs. intervention number, for all policies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 612x180 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "gs = gridspec.GridSpec(1, 3, wspace=0.10, hspace=0.15)\n",
    "plt.figure(figsize=(8.5,2.5))\n",
    "\n",
    "ylim = [0,1]\n",
    "\n",
    "# Plot for 1000 initial samples\n",
    "plt.subplot(gs[0])\n",
    "ax = plt.gca()\n",
    "ax.plot(Trajectories_abcd_1000.mean(axis=0), c=colors[5], label=\"ABCD\", linewidth=1.5)\n",
    "ax.plot(Trajectories_aicp_1000[\"random\"].mean(axis=0), c=colors[0], label=\"A-ICP w/ random policy\", linewidth=1.5)\n",
    "ax.plot(Trajectories_aicp_1000[\"e\"].mean(axis=0), c=colors[1], label=\"A-ICP w/ e policy\", linewidth=1.5)\n",
    "ax.plot(Trajectories_aicp_1000[\"r\"].mean(axis=0), c=colors[2], label=\"A-ICP w/ r policy\", linewidth=1.5)\n",
    "ax.plot(Trajectories_aicp_1000[\"e + r\"].mean(axis=0), c=colors[3], label=\"A-ICP w/ e + r policy\", linewidth=1.5)\n",
    "plt.xlabel(\"Intervention number\")\n",
    "plt.ylabel(\"Avg. Jaccard Simmilarity\")\n",
    "ax.text(0.5,1.04,\"1000 observational datapoints\", transform=ax.transAxes, fontsize=11, ha=\"center\")\n",
    "plt.ylim(ylim)\n",
    "\n",
    "# Plot for 100 initial samples\n",
    "plt.subplot(gs[1])\n",
    "ax = plt.gca()\n",
    "ax.plot(Trajectories_abcd_100.mean(axis=0), c=colors[5], label=\"ABCD\", linewidth=1.5)\n",
    "ax.plot(Trajectories_aicp_100[\"random\"].mean(axis=0), c=colors[0], label=\"A-ICP w/ random policy\", linewidth=1.5)\n",
    "ax.plot(Trajectories_aicp_100[\"e\"].mean(axis=0), c=colors[1], label=\"A-ICP w/ e policy\", linewidth=1.5)\n",
    "ax.plot(Trajectories_aicp_100[\"r\"].mean(axis=0), c=colors[2], label=\"A-ICP w/ r policy\", linewidth=1.5)\n",
    "ax.plot(Trajectories_aicp_100[\"e + r\"].mean(axis=0), c=colors[3], label=\"A-ICP w/ e + r policy\", linewidth=1.5)\n",
    "plt.xlabel(\"Intervention number\")\n",
    "ax.set_yticklabels([])\n",
    "ax.text(0.5,1.04,\"100 observational datapoints\", transform=ax.transAxes, fontsize=11, ha=\"center\")\n",
    "plt.ylim(ylim)\n",
    "\n",
    "# Plot for 50 initial samples\n",
    "plt.subplot(gs[2])\n",
    "ax = plt.gca()\n",
    "ax.plot(Trajectories_abcd_50.mean(axis=0), c=colors[5], label=\"ABCD\", linewidth=1.5)\n",
    "ax.plot(Trajectories_aicp_50[\"random\"].mean(axis=0), c=colors[0], label=\"A-ICP w/ random policy\", linewidth=1.5)\n",
    "ax.plot(Trajectories_aicp_50[\"e\"].mean(axis=0), c=colors[1], label=\"A-ICP w/ e policy\", linewidth=1.5)\n",
    "ax.plot(Trajectories_aicp_50[\"r\"].mean(axis=0), c=colors[2], label=\"A-ICP w/ r policy\", linewidth=1.5)\n",
    "ax.plot(Trajectories_aicp_50[\"e + r\"].mean(axis=0), c=colors[3], label=\"A-ICP w/ e + r policy\", linewidth=1.5)\n",
    "plt.xlabel(\"Intervention number\")\n",
    "ax.set_yticklabels([])\n",
    "ax.text(0.5,1.04,\"50 observational datapoints\", transform=ax.transAxes, fontsize=11, ha=\"center\")\n",
    "plt.ylim(ylim)\n",
    "\n",
    "ax.legend(prop=fontP, ncol=3, bbox_to_anchor=(0.75, -.25))\n",
    "\n",
    "plt.savefig(\"figures/abcd_vs_aicp_jaccard.pdf\", bbox_inches='tight')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}