{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "nbsphinx": "hidden"
   },
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 1;\n",
       "                var nbb_unformatted_code = \"%load_ext nb_black\\nimport os\\n\\nPAPER_ROOT = os.path.expanduser(os.environ.get(\\\"PAPER_ROOT\\\", \\\".\\\"))\";\n",
       "                var nbb_formatted_code = \"%load_ext nb_black\\nimport os\\n\\nPAPER_ROOT = os.path.expanduser(os.environ.get(\\\"PAPER_ROOT\\\", \\\".\\\"))\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%load_ext nb_black\n",
    "import os\n",
    "\n",
    "PAPER_ROOT = os.path.expanduser(os.environ.get(\"PAPER_ROOT\", \".\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Comparison of XSMC and PSMC"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Setup code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "code_folding": []
   },
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 2;\n",
       "                var nbb_unformatted_code = \"import xsmc\\nimport xsmc.sampler\\nfrom xsmc import Segmentation\\nfrom xsmc.supporting.plotting import *\\nfrom xsmc.supporting.kde_ne import kde_ne\\nimport matplotlib.pyplot as plt\\nimport numpy as np\\nimport msprime as msp\\nfrom scipy.interpolate import PPoly\\nimport tskit\\nfrom concurrent.futures import ProcessPoolExecutor, ThreadPoolExecutor\\nimport logging\\nimport os.path\\n\\nlogging.getLogger(\\\"xsmc\\\").setLevel(logging.INFO)\";\n",
       "                var nbb_formatted_code = \"import xsmc\\nimport xsmc.sampler\\nfrom xsmc import Segmentation\\nfrom xsmc.supporting.plotting import *\\nfrom xsmc.supporting.kde_ne import kde_ne\\nimport matplotlib.pyplot as plt\\nimport numpy as np\\nimport msprime as msp\\nfrom scipy.interpolate import PPoly\\nimport tskit\\nfrom concurrent.futures import ProcessPoolExecutor, ThreadPoolExecutor\\nimport logging\\nimport os.path\\n\\nlogging.getLogger(\\\"xsmc\\\").setLevel(logging.INFO)\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import xsmc\n",
    "import xsmc.sampler\n",
    "from xsmc import Segmentation\n",
    "from xsmc.supporting.plotting import *\n",
    "from xsmc.supporting.kde_ne import kde_ne\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import msprime as msp\n",
    "from scipy.interpolate import PPoly\n",
    "import tskit\n",
    "from concurrent.futures import ProcessPoolExecutor, ThreadPoolExecutor\n",
    "import logging\n",
    "import os.path\n",
    "\n",
    "logging.getLogger(\"xsmc\").setLevel(logging.INFO)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 3;\n",
       "                var nbb_unformatted_code = \"# Ensure reproducibility in posterior sampling\\nnp.random.seed(1)\\n\\n\\ndef seed():\\n    return np.random.randint(1, np.iinfo(np.int32).max)\";\n",
       "                var nbb_formatted_code = \"# Ensure reproducibility in posterior sampling\\nnp.random.seed(1)\\n\\n\\ndef seed():\\n    return np.random.randint(1, np.iinfo(np.int32).max)\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Ensure reproducibility in posterior sampling\n",
    "np.random.seed(1)\n",
    "\n",
    "\n",
    "def seed():\n",
    "    return np.random.randint(1, np.iinfo(np.int32).max)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `xsmc.supporting.psmc` module runs Li & Durbin's original PSMC method on tree sequence data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Collecting git+https://github.com/terhorst/mspsmc@e583e196f\n",
      "  Cloning https://github.com/terhorst/mspsmc (to revision e583e196f) to /tmp/pip-req-build-z7s9zpy2\n",
      "\u001b[33m  WARNING: Did not find branch or tag 'e583e196f', assuming revision or ref.\u001b[0m\n",
      "Requirement already satisfied (use --upgrade to upgrade): mspsmc==0.1.0 from git+https://github.com/terhorst/mspsmc@e583e196f in /home/terhorst/opt/py37/lib/python3.7/site-packages\n",
      "Requirement already satisfied: scipy in /home/terhorst/opt/py37/lib/python3.7/site-packages (from mspsmc==0.1.0) (1.4.1)\n",
      "Requirement already satisfied: numpy in /home/terhorst/opt/py37/lib/python3.7/site-packages (from mspsmc==0.1.0) (1.18.2)\n",
      "Requirement already satisfied: tskit in /home/terhorst/opt/py37/lib/python3.7/site-packages (from mspsmc==0.1.0) (0.3.1)\n",
      "Requirement already satisfied: jsonschema in /home/terhorst/opt/py37/lib/python3.7/site-packages (from tskit->mspsmc==0.1.0) (3.1.1)\n",
      "Requirement already satisfied: h5py in /home/terhorst/opt/py37/lib/python3.7/site-packages (from tskit->mspsmc==0.1.0) (2.10.0)\n",
      "Requirement already satisfied: attrs>=19.1.0 in /home/terhorst/opt/py37/lib/python3.7/site-packages (from tskit->mspsmc==0.1.0) (19.3.0)\n",
      "Requirement already satisfied: svgwrite in /home/terhorst/opt/py37/lib/python3.7/site-packages (from tskit->mspsmc==0.1.0) (1.3.1)\n",
      "Requirement already satisfied: importlib-metadata in /home/terhorst/opt/py37/lib/python3.7/site-packages (from jsonschema->tskit->mspsmc==0.1.0) (0.23)\n",
      "Requirement already satisfied: pyrsistent>=0.14.0 in /home/terhorst/opt/py37/lib/python3.7/site-packages (from jsonschema->tskit->mspsmc==0.1.0) (0.15.4)\n",
      "Requirement already satisfied: setuptools in /home/terhorst/opt/py37/lib/python3.7/site-packages (from jsonschema->tskit->mspsmc==0.1.0) (49.3.2)\n",
      "Requirement already satisfied: six>=1.11.0 in /home/terhorst/opt/py37/lib/python3.7/site-packages (from jsonschema->tskit->mspsmc==0.1.0) (1.14.0)\n",
      "Requirement already satisfied: pyparsing>=2.0.1 in /home/terhorst/opt/py37/lib/python3.7/site-packages (from svgwrite->tskit->mspsmc==0.1.0) (2.4.2)\n",
      "Requirement already satisfied: zipp>=0.5 in /home/terhorst/opt/py37/lib/python3.7/site-packages (from importlib-metadata->jsonschema->tskit->mspsmc==0.1.0) (0.6.0)\n",
      "Requirement already satisfied: more-itertools in /home/terhorst/opt/py37/lib/python3.7/site-packages (from zipp>=0.5->importlib-metadata->jsonschema->tskit->mspsmc==0.1.0) (7.2.0)\n",
      "Building wheels for collected packages: mspsmc\n",
      "  Building wheel for mspsmc (setup.py) ... \u001b[?25ldone\n",
      "\u001b[?25h  Created wheel for mspsmc: filename=mspsmc-0.1.0-py2.py3-none-any.whl size=5757 sha256=6961418aa633d0180cec574751c509435246e3a7d5541bd1d739840903c4ee9e\n",
      "  Stored in directory: /tmp/pip-ephem-wheel-cache-5a52eh0a/wheels/af/38/87/3eee2ca03eb580f4df9e22215d1e0ff5a8914f16a45cf26f93\n",
      "Successfully built mspsmc\n",
      "\u001b[33mWARNING: You are using pip version 20.2.3; however, version 20.2.4 is available.\n",
      "You should consider upgrading via the '/home/terhorst/opt/py37/bin/python3 -m pip install --upgrade pip' command.\u001b[0m\n"
     ]
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 4;\n",
       "                var nbb_unformatted_code = \"!pip install git+https://github.com/terhorst/mspsmc@e583e196f\";\n",
       "                var nbb_formatted_code = \"!pip install git+https://github.com/terhorst/mspsmc@e583e196f\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "!pip install git+https://github.com/terhorst/mspsmc@e583e196f"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "code_folding": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'0.6.5-r67'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 5;\n",
       "                var nbb_unformatted_code = \"# psmc code\\nimport os\\n\\nos.environ[\\\"PSMC_PATH\\\"] = \\\"/scratch/psmc/psmc\\\"  # update as needed if running locally\\nimport mspsmc\\n\\n\\ndef run_psmc(reps, rho_over_theta=1.0):\\n    def f(data, *args):\\n        return mspsmc.msPSMC([(data, (0, 1))]).estimate(*args)\\n\\n    with ThreadPoolExecutor() as p:\\n        futs = [p.submit(f, data, \\\"-r\\\", 1.0 / rho_over_theta) for data in reps]\\n        res = [f.result() for f in futs]\\n    rescaled = []\\n    for r in res:\\n        # See Appendix I of https://github.com/lh3/psmc/blob/master/README\\n        N0 = r.theta / (4 * mu) / 100\\n        rescaled.append(r.Ne.rescale(2 * N0))\\n    return rescaled\\n\\n\\nmspsmc.__psmc__version__\";\n",
       "                var nbb_formatted_code = \"# psmc code\\nimport os\\n\\nos.environ[\\\"PSMC_PATH\\\"] = \\\"/scratch/psmc/psmc\\\"  # update as needed if running locally\\nimport mspsmc\\n\\n\\ndef run_psmc(reps, rho_over_theta=1.0):\\n    def f(data, *args):\\n        return mspsmc.msPSMC([(data, (0, 1))]).estimate(*args)\\n\\n    with ThreadPoolExecutor() as p:\\n        futs = [p.submit(f, data, \\\"-r\\\", 1.0 / rho_over_theta) for data in reps]\\n        res = [f.result() for f in futs]\\n    rescaled = []\\n    for r in res:\\n        # See Appendix I of https://github.com/lh3/psmc/blob/master/README\\n        N0 = r.theta / (4 * mu) / 100\\n        rescaled.append(r.Ne.rescale(2 * N0))\\n    return rescaled\\n\\n\\nmspsmc.__psmc__version__\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# psmc code\n",
    "import os\n",
    "\n",
    "os.environ[\"PSMC_PATH\"] = \"/scratch/psmc/psmc\"  # update as needed if running locally\n",
    "import mspsmc\n",
    "\n",
    "\n",
    "def run_psmc(reps, rho_over_theta=1.0):\n",
    "    def f(data, *args):\n",
    "        return mspsmc.msPSMC([(data, (0, 1))]).estimate(*args)\n",
    "\n",
    "    with ThreadPoolExecutor() as p:\n",
    "        futs = [p.submit(f, data, \"-r\", 1.0 / rho_over_theta) for data in reps]\n",
    "        res = [f.result() for f in futs]\n",
    "    rescaled = []\n",
    "    for r in res:\n",
    "        # See Appendix I of https://github.com/lh3/psmc/blob/master/README\n",
    "        N0 = r.theta / (4 * mu) / 100\n",
    "        rescaled.append(r.Ne.rescale(2 * N0))\n",
    "    return rescaled\n",
    "\n",
    "\n",
    "mspsmc.__psmc__version__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "code_folding": []
   },
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 6;\n",
       "                var nbb_unformatted_code = \"# other supporting functions\\nL = int(5e7)  # length of simulated chromosome\\nmu = 1.4e-8  # mutation rate/bp/gen\\nM = 25  # number of replicates\\n\\n\\ndef parallel_sample(reps, j=100, k=int(L / 50_000), rho_over_theta=1.0):\\n    xs = [\\n        xsmc.XSMC(data, focal=0, panel=[1], rho_over_theta=rho_over_theta)\\n        for data in reps\\n    ]\\n    with ThreadPoolExecutor() as p:\\n        futs = [\\n            p.submit(x.sample_heights, j=j, k=k, seed=seed()) for i, x in enumerate(xs)\\n        ]\\n        return np.array(\\n            [f.result() * 2 * x.theta / (4 * mu) for f, x in zip(futs, xs)]\\n        )  # rescale each sampled path by 2N0 so that segment heights are in generations\\n\\n\\ndef parallel_sample0(reps, j=100, k=int(L / 50_000), rho_over_theta=1.0):\\n    xs = [\\n        xsmc.XSMC(data, focal=0, panel=[1], rho_over_theta=rho_over_theta)\\n        for data in reps\\n    ]\\n    with ProcessPoolExecutor() as p:\\n        futs = [\\n            p.submit(x.sample, k=j, seed=seed(), prime=True) for i, x in enumerate(xs)\\n        ]\\n        paths = [\\n            [p.rescale(2 * x.theta / (4 * mu)) for p in f.result()]\\n            for f, x in zip(futs, xs)\\n        ]  # rescale each sampled path by 2N0 so that segment heights are in generations\\n    return np.array([[p(np.random.uniform(0, L, k)) for p in path] for path in paths])\\n\\n\\ndef sim_data(de, **kwargs):\\n    d = dict(\\n        sample_size=2,\\n        recombination_rate=1.4e-8,\\n        mutation_rate=mu,\\n        length=L,\\n        demographic_events=de,\\n    )\\n\\n    d.update(kwargs)\\n    with ThreadPoolExecutor() as p:\\n        futs = [p.submit(msp.simulate, **d, random_seed=seed()) for i in range(M)]\\n        return [f.result() for f in futs]\\n\\n\\ndef summarize_lines(xys, x0):\\n    \\\"summarize a collection of lines by plotting their median and IQR\\\"\\n    y0 = []\\n    for x, y in xys:\\n        f = interp1d(\\n            x, y, bounds_error=False\\n        )  # interpolate linearly to a common set of points\\n        y0.append(f(x0))\\n    return np.nanquantile(y0, [0.5, 0.25, 0.75], axis=0)  # median, q25, q75\\n\\n\\ndef plot_summary(ax, lines, x, label=None, **kwargs):\\n    all_x = np.concatenate([l[0] for l in lines]).reshape(-1)\\n    m, q25, q75 = summarize_lines(lines, x)\\n    ax.plot(x, m / 2, label=label, **kwargs)\\n    ax.fill_between(x, q25 / 2, q75 / 2, **kwargs, alpha=0.5)\\n\\n\\ndef plot_combined(lines_psmc, lines_xsmc, truth, ax=None):\\n    if ax is None:\\n        ax = plt.gca()\\n    x = np.geomspace(1e2, 1e6, 200)\\n    for lines, label, color in zip(\\n        [lines_xsmc, lines_psmc], [\\\"XSMC\\\", \\\"PSMC\\\"], [\\\"tab:blue\\\", \\\"tab:red\\\"]\\n    ):\\n        #         for i, (x, y) in enumerate(lines):\\n        #             ax.plot(\\n        #                 x,\\n        #                 y,\\n        #                 color=color,\\n        #                 label=label if i == 0 else None,\\n        #                 alpha=5.0 / len(lines),\\n        #             )\\n        plot_summary(ax, lines, x, label=label, color=color)\\n    ax.plot(\\n        *truth, \\\"--\\\", color=\\\"darkgrey\\\", label=\\\"Truth\\\", drawstyle=\\\"steps-post\\\", zorder=0\\n    )\\n    ax.set_xscale(\\\"log\\\")\\n    ax.set_yscale(\\\"log\\\")\\n    ax.set_xlim(1e2, 1e5)\\n    ax.set_ylim(1e3, 1e6)\";\n",
       "                var nbb_formatted_code = \"# other supporting functions\\nL = int(5e7)  # length of simulated chromosome\\nmu = 1.4e-8  # mutation rate/bp/gen\\nM = 25  # number of replicates\\n\\n\\ndef parallel_sample(reps, j=100, k=int(L / 50_000), rho_over_theta=1.0):\\n    xs = [\\n        xsmc.XSMC(data, focal=0, panel=[1], rho_over_theta=rho_over_theta)\\n        for data in reps\\n    ]\\n    with ThreadPoolExecutor() as p:\\n        futs = [\\n            p.submit(x.sample_heights, j=j, k=k, seed=seed()) for i, x in enumerate(xs)\\n        ]\\n        return np.array(\\n            [f.result() * 2 * x.theta / (4 * mu) for f, x in zip(futs, xs)]\\n        )  # rescale each sampled path by 2N0 so that segment heights are in generations\\n\\n\\ndef parallel_sample0(reps, j=100, k=int(L / 50_000), rho_over_theta=1.0):\\n    xs = [\\n        xsmc.XSMC(data, focal=0, panel=[1], rho_over_theta=rho_over_theta)\\n        for data in reps\\n    ]\\n    with ProcessPoolExecutor() as p:\\n        futs = [\\n            p.submit(x.sample, k=j, seed=seed(), prime=True) for i, x in enumerate(xs)\\n        ]\\n        paths = [\\n            [p.rescale(2 * x.theta / (4 * mu)) for p in f.result()]\\n            for f, x in zip(futs, xs)\\n        ]  # rescale each sampled path by 2N0 so that segment heights are in generations\\n    return np.array([[p(np.random.uniform(0, L, k)) for p in path] for path in paths])\\n\\n\\ndef sim_data(de, **kwargs):\\n    d = dict(\\n        sample_size=2,\\n        recombination_rate=1.4e-8,\\n        mutation_rate=mu,\\n        length=L,\\n        demographic_events=de,\\n    )\\n\\n    d.update(kwargs)\\n    with ThreadPoolExecutor() as p:\\n        futs = [p.submit(msp.simulate, **d, random_seed=seed()) for i in range(M)]\\n        return [f.result() for f in futs]\\n\\n\\ndef summarize_lines(xys, x0):\\n    \\\"summarize a collection of lines by plotting their median and IQR\\\"\\n    y0 = []\\n    for x, y in xys:\\n        f = interp1d(\\n            x, y, bounds_error=False\\n        )  # interpolate linearly to a common set of points\\n        y0.append(f(x0))\\n    return np.nanquantile(y0, [0.5, 0.25, 0.75], axis=0)  # median, q25, q75\\n\\n\\ndef plot_summary(ax, lines, x, label=None, **kwargs):\\n    all_x = np.concatenate([l[0] for l in lines]).reshape(-1)\\n    m, q25, q75 = summarize_lines(lines, x)\\n    ax.plot(x, m / 2, label=label, **kwargs)\\n    ax.fill_between(x, q25 / 2, q75 / 2, **kwargs, alpha=0.5)\\n\\n\\ndef plot_combined(lines_psmc, lines_xsmc, truth, ax=None):\\n    if ax is None:\\n        ax = plt.gca()\\n    x = np.geomspace(1e2, 1e6, 200)\\n    for lines, label, color in zip(\\n        [lines_xsmc, lines_psmc], [\\\"XSMC\\\", \\\"PSMC\\\"], [\\\"tab:blue\\\", \\\"tab:red\\\"]\\n    ):\\n        #         for i, (x, y) in enumerate(lines):\\n        #             ax.plot(\\n        #                 x,\\n        #                 y,\\n        #                 color=color,\\n        #                 label=label if i == 0 else None,\\n        #                 alpha=5.0 / len(lines),\\n        #             )\\n        plot_summary(ax, lines, x, label=label, color=color)\\n    ax.plot(\\n        *truth, \\\"--\\\", color=\\\"darkgrey\\\", label=\\\"Truth\\\", drawstyle=\\\"steps-post\\\", zorder=0\\n    )\\n    ax.set_xscale(\\\"log\\\")\\n    ax.set_yscale(\\\"log\\\")\\n    ax.set_xlim(1e2, 1e5)\\n    ax.set_ylim(1e3, 1e6)\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# other supporting functions\n",
    "L = int(5e7)  # length of simulated chromosome\n",
    "mu = 1.4e-8  # mutation rate/bp/gen\n",
    "M = 25  # number of replicates\n",
    "\n",
    "\n",
    "def parallel_sample(reps, j=100, k=int(L / 50_000), rho_over_theta=1.0):\n",
    "    xs = [\n",
    "        xsmc.XSMC(data, focal=0, panel=[1], rho_over_theta=rho_over_theta)\n",
    "        for data in reps\n",
    "    ]\n",
    "    with ThreadPoolExecutor() as p:\n",
    "        futs = [\n",
    "            p.submit(x.sample_heights, j=j, k=k, seed=seed()) for i, x in enumerate(xs)\n",
    "        ]\n",
    "        return np.array(\n",
    "            [f.result() * 2 * x.theta / (4 * mu) for f, x in zip(futs, xs)]\n",
    "        )  # rescale each sampled path by 2N0 so that segment heights are in generations\n",
    "\n",
    "\n",
    "def parallel_sample0(reps, j=100, k=int(L / 50_000), rho_over_theta=1.0):\n",
    "    xs = [\n",
    "        xsmc.XSMC(data, focal=0, panel=[1], rho_over_theta=rho_over_theta)\n",
    "        for data in reps\n",
    "    ]\n",
    "    with ProcessPoolExecutor() as p:\n",
    "        futs = [\n",
    "            p.submit(x.sample, k=j, seed=seed(), prime=True) for i, x in enumerate(xs)\n",
    "        ]\n",
    "        paths = [\n",
    "            [p.rescale(2 * x.theta / (4 * mu)) for p in f.result()]\n",
    "            for f, x in zip(futs, xs)\n",
    "        ]  # rescale each sampled path by 2N0 so that segment heights are in generations\n",
    "    return np.array([[p(np.random.uniform(0, L, k)) for p in path] for path in paths])\n",
    "\n",
    "\n",
    "def sim_data(de, **kwargs):\n",
    "    d = dict(\n",
    "        sample_size=2,\n",
    "        recombination_rate=1.4e-8,\n",
    "        mutation_rate=mu,\n",
    "        length=L,\n",
    "        demographic_events=de,\n",
    "    )\n",
    "\n",
    "    d.update(kwargs)\n",
    "    with ThreadPoolExecutor() as p:\n",
    "        futs = [p.submit(msp.simulate, **d, random_seed=seed()) for i in range(M)]\n",
    "        return [f.result() for f in futs]\n",
    "\n",
    "\n",
    "def summarize_lines(xys, x0):\n",
    "    \"summarize a collection of lines by plotting their median and IQR\"\n",
    "    y0 = []\n",
    "    for x, y in xys:\n",
    "        f = interp1d(\n",
    "            x, y, bounds_error=False\n",
    "        )  # interpolate linearly to a common set of points\n",
    "        y0.append(f(x0))\n",
    "    return np.nanquantile(y0, [0.5, 0.25, 0.75], axis=0)  # median, q25, q75\n",
    "\n",
    "\n",
    "def plot_summary(ax, lines, x, label=None, **kwargs):\n",
    "    all_x = np.concatenate([l[0] for l in lines]).reshape(-1)\n",
    "    m, q25, q75 = summarize_lines(lines, x)\n",
    "    ax.plot(x, m / 2, label=label, **kwargs)\n",
    "    ax.fill_between(x, q25 / 2, q75 / 2, **kwargs, alpha=0.5)\n",
    "\n",
    "\n",
    "def plot_combined(lines_psmc, lines_xsmc, truth, ax=None):\n",
    "    if ax is None:\n",
    "        ax = plt.gca()\n",
    "    x = np.geomspace(1e2, 1e6, 200)\n",
    "    for lines, label, color in zip(\n",
    "        [lines_xsmc, lines_psmc], [\"XSMC\", \"PSMC\"], [\"tab:blue\", \"tab:red\"]\n",
    "    ):\n",
    "        #         for i, (x, y) in enumerate(lines):\n",
    "        #             ax.plot(\n",
    "        #                 x,\n",
    "        #                 y,\n",
    "        #                 color=color,\n",
    "        #                 label=label if i == 0 else None,\n",
    "        #                 alpha=5.0 / len(lines),\n",
    "        #             )\n",
    "        plot_summary(ax, lines, x, label=label, color=color)\n",
    "    ax.plot(\n",
    "        *truth, \"--\", color=\"darkgrey\", label=\"Truth\", drawstyle=\"steps-post\", zorder=0\n",
    "    )\n",
    "    ax.set_xscale(\"log\")\n",
    "    ax.set_yscale(\"log\")\n",
    "    ax.set_xlim(1e2, 1e5)\n",
    "    ax.set_ylim(1e3, 1e6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 7;\n",
       "                var nbb_unformatted_code = \"from collections import Counter\\nfrom scipy.signal import convolve\\nfrom xsmc.supporting.kde_ne import *\\n\\n\\ndef parallel_kde(sampled_heights, **kwargs):\\n    with ProcessPoolExecutor() as p:\\n        futs = [p.submit(kde_ne, h.reshape(-1), **kwargs) for h in sampled_heights]\\n        return [(f.result()[0], f.result()[1]) for f in futs]\";\n",
       "                var nbb_formatted_code = \"from collections import Counter\\nfrom scipy.signal import convolve\\nfrom xsmc.supporting.kde_ne import *\\n\\n\\ndef parallel_kde(sampled_heights, **kwargs):\\n    with ProcessPoolExecutor() as p:\\n        futs = [p.submit(kde_ne, h.reshape(-1), **kwargs) for h in sampled_heights]\\n        return [(f.result()[0], f.result()[1]) for f in futs]\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from collections import Counter\n",
    "from scipy.signal import convolve\n",
    "from xsmc.supporting.kde_ne import *\n",
    "\n",
    "\n",
    "def parallel_kde(sampled_heights, **kwargs):\n",
    "    with ProcessPoolExecutor() as p:\n",
    "        futs = [p.submit(kde_ne, h.reshape(-1), **kwargs) for h in sampled_heights]\n",
    "        return [(f.result()[0], f.result()[1]) for f in futs]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Constant effective population size\n",
    "The simplest case. First we check the estimator on \"perfect\" data, that is i.i.d. samples from the true distribution:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 8;\n",
       "                var nbb_unformatted_code = \"de = [msp.PopulationParametersChange(time=0, initial_size=1e4)]\";\n",
       "                var nbb_formatted_code = \"de = [msp.PopulationParametersChange(time=0, initial_size=1e4)]\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "de = [msp.PopulationParametersChange(time=0, initial_size=1e4)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Perfect data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Verify the estimator on \"perfect\" data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1000.0, 100000.0)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2020-10-22 17:02:57,282 WARNING matplotlib.font_manager MainThread findfont: Font family ['sans-serif'] not found. Falling back to DejaVu Sans.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 9;\n",
       "                var nbb_unformatted_code = \"true_data = np.array(\\n    [\\n        next(sim.trees()).get_time(2)\\n        for sim in msp.simulate(\\n            num_replicates=10000, demographic_events=de, sample_size=2\\n        )\\n    ]\\n)\\nx, y = kde_ne(true_data)\\nplt.plot(x, y / 2, label=\\\"Fitted\\\")\\nplt.plot(plt.xlim(), [1e4] * 2, \\\"--\\\", color=\\\"darkgrey\\\", label=\\\"Truth\\\")\\nplt.xscale(\\\"log\\\")\\nplt.yscale(\\\"log\\\")\\nplt.legend()\\nplt.ylim(1e3, 1e5)\";\n",
       "                var nbb_formatted_code = \"true_data = np.array(\\n    [\\n        next(sim.trees()).get_time(2)\\n        for sim in msp.simulate(\\n            num_replicates=10000, demographic_events=de, sample_size=2\\n        )\\n    ]\\n)\\nx, y = kde_ne(true_data)\\nplt.plot(x, y / 2, label=\\\"Fitted\\\")\\nplt.plot(plt.xlim(), [1e4] * 2, \\\"--\\\", color=\\\"darkgrey\\\", label=\\\"Truth\\\")\\nplt.xscale(\\\"log\\\")\\nplt.yscale(\\\"log\\\")\\nplt.legend()\\nplt.ylim(1e3, 1e5)\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "true_data = np.array(\n",
    "    [\n",
    "        next(sim.trees()).get_time(2)\n",
    "        for sim in msp.simulate(\n",
    "            num_replicates=10000, demographic_events=de, sample_size=2\n",
    "        )\n",
    "    ]\n",
    ")\n",
    "x, y = kde_ne(true_data)\n",
    "plt.plot(x, y / 2, label=\"Fitted\")\n",
    "plt.plot(plt.xlim(), [1e4] * 2, \"--\", color=\"darkgrey\", label=\"Truth\")\n",
    "plt.xscale(\"log\")\n",
    "plt.yscale(\"log\")\n",
    "plt.legend()\n",
    "plt.ylim(1e3, 1e5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### XSMC \n",
    "Next we simulate data and sample from the posterior instead."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "25"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 10;\n",
       "                var nbb_unformatted_code = \"data = sim_data(de)\\nlen(data)\";\n",
       "                var nbb_formatted_code = \"data = sim_data(de)\\nlen(data)\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "data = sim_data(de)\n",
    "len(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sampled_heights = parallel_sample(data)\n",
    "sampled_heights.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lines_xsmc = parallel_kde(sampled_heights)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Diagnostic\n",
    "q = np.linspace(0, 1.0, 100)\n",
    "plt.plot(np.quantile(sampled_heights.reshape(-1), q), np.quantile(true_data, q))\n",
    "plt.plot(plt.xlim(), plt.xlim())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### PSMC"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "psmc_out = run_psmc(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_psmc = np.geomspace(1e2, 1e5, 100)\n",
    "lines_psmc = [(x_psmc, r(x_psmc)) for r in psmc_out]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Combined plot for paper"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "truth = ([1e2, 1e6], [1e4, 1e4])\n",
    "fig, axs = plt.subplots(ncols=3, figsize=(12, 4.5), sharex=True, sharey=True, dpi=150)\n",
    "plot_combined(lines_psmc, lines_xsmc, truth, axs[0])\n",
    "# a.legend()\n",
    "axs[0].set_xlim(1e2, 1e5)\n",
    "axs[0].set_ylim(1e3, 1e6)\n",
    "axs[0].set_title(\"Constant\")\n",
    "fig.add_subplot(111, frameon=False)\n",
    "plt.tick_params(labelcolor=\"none\", top=False, bottom=False, left=False, right=False)\n",
    "# plt.xlabel(\"common X\")\n",
    "# plt.ylabel(\"common Y\")\n",
    "plt.xlabel(\"Generations\")\n",
    "plt.ylabel(\"$N_e$\")\n",
    "plt.tight_layout(pad=1.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Recent growth"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Perfect data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "de = [\n",
    "    msp.PopulationParametersChange(time=0, initial_size=1e6),\n",
    "    msp.PopulationParametersChange(time=1e3, initial_size=5e3),\n",
    "    msp.PopulationParametersChange(time=2e3, initial_size=2e4),\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "true_data = np.array(\n",
    "    [\n",
    "        next(sim.trees()).get_time(2)\n",
    "        for sim in msp.simulate(\n",
    "            num_replicates=10000, demographic_events=de, sample_size=2, Ne=1\n",
    "        )\n",
    "    ]\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x, y = kde_ne(true_data)\n",
    "plt.plot(x[::50], y[::50] / 2)  # downsample the curves to make plotting faster\n",
    "truth = ([0, 1e3, 2e3, 1e5], [1e6, 5e3, 2e4, 2e4])\n",
    "\n",
    "\n",
    "plt.plot(\n",
    "    *truth, \"--\", color=\"darkgrey\", label=\"Truth\", drawstyle=\"steps-post\",\n",
    ")\n",
    "plt.xscale(\"log\")\n",
    "plt.yscale(\"log\")\n",
    "plt.legend()\n",
    "plt.xlim(1e2, 1e5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### XSMC"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = sim_data(de)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sampled_heights = parallel_sample(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lines_xsmc = parallel_kde(sampled_heights)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### PSMC"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "psmc_out = run_psmc(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lines_psmc = [(x_psmc, r(x_psmc)) for r in psmc_out]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Combined plot for paper"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plot_combined(lines_psmc, lines_xsmc, truth, axs[1])\n",
    "axs[1].set_title(\"Growth\")\n",
    "fig"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Zigzag"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import stdpopsim\n",
    "\n",
    "species = stdpopsim.get_species(\"HomSap\")\n",
    "model = species.get_demographic_model(\"Zigzag_1S14\")\n",
    "de = [\n",
    "    msp.PopulationParametersChange(time=0, initial_size=14312)\n",
    "] + model.demographic_events"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Perfect data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "true_data = np.array(\n",
    "    [\n",
    "        next(sim.trees()).get_time(2)\n",
    "        for sim in msp.simulate(\n",
    "            num_replicates=10000, demographic_events=de, sample_size=2,\n",
    "        )\n",
    "    ]\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x, y = kde_ne(true_data)\n",
    "plt.plot(x[::50], y[::50] / 2)  # downsample the curves to make plotting faster\n",
    "\n",
    "f = plot_de(de, 14312)\n",
    "x_zz = np.geomspace(1e2, 1e6, 1000)\n",
    "truth = (x_zz, f(x_zz))\n",
    "\n",
    "\n",
    "plt.plot(\n",
    "    *truth, \"--\", color=\"darkgrey\", label=\"Truth\", drawstyle=\"steps-post\",\n",
    ")\n",
    "plt.xscale(\"log\")\n",
    "plt.yscale(\"log\")\n",
    "plt.legend()\n",
    "plt.xlim(1e2, 1e5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### XSMC"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = sim_data(de, recombination_rate=1e-9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sampled_heights = parallel_sample(data, rho_over_theta=1e-9 / mu)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lines_xsmc = parallel_kde(sampled_heights)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### PSMC"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "psmc_out = run_psmc(data, rho_over_theta=1e-9 / mu)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lines_psmc = [(x_psmc, r(x_psmc)) for r in psmc_out]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Combined plot for paper"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/terhorst/opt/py37/lib/python3.7/site-packages/numpy/lib/nanfunctions.py:1392: RuntimeWarning: All-NaN slice encountered\n",
      "  overwrite_input, interpolation)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1800x675 with 4 Axes>"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 38;\n",
       "                var nbb_unformatted_code = \"plot_combined(lines_psmc, lines_xsmc, truth, axs[2])\\naxs[2].set_title(\\\"Zigzag\\\")\\nfig\";\n",
       "                var nbb_formatted_code = \"plot_combined(lines_psmc, lines_xsmc, truth, axs[2])\\naxs[2].set_title(\\\"Zigzag\\\")\\nfig\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_combined(lines_psmc, lines_xsmc, truth, axs[2])\n",
    "axs[2].set_title(\"Zigzag\")\n",
    "fig"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f1da126bcd0>"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 42;\n",
       "                var nbb_unformatted_code = \"axs[0].legend()\";\n",
       "                var nbb_formatted_code = \"axs[0].legend()\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "axs[0].legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "            setTimeout(function() {\n",
       "                var nbb_cell_id = 40;\n",
       "                var nbb_unformatted_code = \"fig.savefig(os.path.join(PAPER_ROOT, \\\"figures\\\", \\\"xsmc_psmc.pdf\\\"))\";\n",
       "                var nbb_formatted_code = \"fig.savefig(os.path.join(PAPER_ROOT, \\\"figures\\\", \\\"xsmc_psmc.pdf\\\"))\";\n",
       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
       "                        }\n",
       "                        break;\n",
       "                    }\n",
       "                }\n",
       "            }, 500);\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig.savefig(os.path.join(PAPER_ROOT, \"figures\", \"xsmc_psmc.pdf\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Additional diagnostics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = np.linspace(4, 12, 32)\n",
    "for d in np.array(sampled_heights)[..., 0], true_data:\n",
    "    plt.hist(np.log(d).reshape(-1), bins=b, density=True, alpha=0.5)"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Edit 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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}