diff --git a/docs/source/.ipynb_checkpoints/annotated_tutorial_i-checkpoint.ipynb b/docs/source/.ipynb_checkpoints/annotated_tutorial_i-checkpoint.ipynb new file mode 100644 index 000000000..56e94a773 --- /dev/null +++ b/docs/source/.ipynb_checkpoints/annotated_tutorial_i-checkpoint.ipynb @@ -0,0 +1,1938 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Causal probabilistic programming without tears" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Despite the tremendous progress over the last several decades in reducing causal inference to statistical practice, the \\\"causal revolution\\\" proclaimed by Judea Pearl and others remains incomplete, with a sprawling and fragmented literature inaccessible to non-experts and still somewhat isolated from cutting-edge machine learning research and software tools.\n", + "\n", + "Probabilistic programming languages are promising substrates for bridging this gap thanks to the close correspondence between their operational semantics and the field’s standard mathematical formalism of structural causal models. \n", + "\n", + "In this tutorial, we elaborate on this idea with three key observations inspiring ChiRho's design and outline a causal Bayesian workflow for using ChiRho to answer causal questions." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Outline\n", + "- [Introduction](#causal-probabilistic-programming-without-tears)\n", + "- [Outline](#outline)\n", + "- [Observation 1: Causal Models are Probabilistic Programs](#observation-1:-causal-models-are-probabilistic-programs)\n", + " - [Defining a Causal Model](#defining-a-causal-model)\n", + " - [Simulating Observational Data](#simulating-observational-data-with-fixed-parameters)\n", + " - [Applying an Intervention](#applying-an-intervention)\n", + " - [Simulating Interventional Data](#simulating-interventional-data-with-fixed-parameters)\n", + " - [Transforming Causal Models using ChiRho](#transforming-causal-models-using-ChiRho---do)\n", + "- [Observation 2: Causal Uncertainty is Probabilistic Uncertainty](#observation-2:-causal-uncertainty-is-probabilistic-uncertainty)\n", + " - [Adding Uncertainty over Model Parameters](#adding-uncertainty-over-model-parameters)\n", + " - [Simulating Observational Data with Uncertain Parameters](#simulating-observational-data-with-uncertain-parameters)\n", + " - [Simulating Interventional Data with Uncertain Parameters](#simulating-interventional-data-with-uncertain-parameters)\n", + " - [Adding Uncertainty over Model Structure](#adding-uncertainty-over-model-structure)\n", + " - [Simulating Observational Data with Uncertain Structure and Parameters](#simulating-observational-data-with-uncertain-structure-and-parameters)\n", + " - [Simulating Interventional Data with Uncertain Structure and Parameters](#simulating-interventional-data-with-uncertain-structure-and-parameters)\n", + "- [Observation 3: Causal Inference is Probabilistic Inference](#observation-3:-causal-inference-is-probabilistic-inference)\n", + " - [Automatically Constructing Counterfactual Worlds](#automatically-constructing-counterfactual-worlds---twinworldcounterfactual)\n", + " - [Generating Synthetic Data](#generating-synthetic-data)\n", + " - [Conditioning the Causal Model on Observational Data](#conditioning-the-causal-model-on-observational-data)\n", + " - [Using Variational Inference for Bayesian Causal Inference](#using-variational-inference-for-bayesian-causal-inference)\n", + " - [Simulating Interventional Data from the Approximate Posterior](#simulating-interventional-data-from-the-approximate-posterior)\n", + "- [Recap](#recap)\n", + "- [Causal Bayesian Workflow](#a-causal-bayesian-workflow)\n", + "- [References](#references)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Observation 1: causal models are probabilistic programs" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Probabilistic programmers typically think of their code as defining a probability distribution over a set of variables, but programs often contain more information than just the joint distributions they induce. In practice, when we write probabilistic programs in languages such as Pyro we often bring to bear knowledge of causal relationships between variables, and implicitly, how changes to one variable would propagate to changes in others.\n", + "\n", + "Formally, a causal model specifies a *family* of probability distributions, indexed by a set of *interventions*. This set always includes a trivial *identity intervention*, which maps to the usual (acausal) joint distribution over random variables induced by simply executing the program. However, for other interventions the resulting joint distributions can differ significantly, as we'll see later throughout this tutorial.\n", + "\n", + "Somewhat less formally, causal models using these (nontrivial) interventions are useful when we want to represent hypothetical changes to a domain, such as a policy that encourages people to stop smoking. To ground this out a bit more concretely, consider the following Pyro program describing a causal model relating three random variables, *stress*, *smokes*, and *cancer*.\n", + "\n", + "**Note:** Later we'll see how to think of interventions as program transformations. ChiRho defaults to the trivial *identity intervention* if none are applied explicitly. The result of applying this identity intervention to a causal model is sometimes called an *observational model* or *factual model*." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Defining a Causal Model" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import pyro\n", + "from pyro.distributions import Bernoulli\n", + "\n", + "smoke_test = ('CI' in os.environ)\n", + "num_samples = 1000 if not smoke_test else 10\n", + "num_iterations = 1000 if not smoke_test else 10\n", + "n_individuals = 10000 if not smoke_test else 10\n", + "\n", + "def causal_model(stress_pt, smokes_cpt, cancer_cpt):\n", + " stress = pyro.sample(\"stress\", Bernoulli(stress_pt))\n", + " smokes = pyro.sample(\"smokes\", Bernoulli(smokes_cpt[stress.long()]))\n", + " cancer = pyro.sample(\"cancer\", Bernoulli(cancer_cpt[stress.long(), smokes.long()]))\n", + " # For now we only return smokes because we need to return a single value for the predictive handler.\n", + " # We need to return smokes because the trace address for `smokes` does not include the interventions.\n", + " # TODO: address this in the future.\n", + " return smokes\n", + " # return stress, smokes, cancer" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Our `causal_model` takes as input three sets of parameters, here just marginal and conditional probability tables, and returns a sample from the joint distribution over a single individual's *stress*, *smokes*, and *cancer* attributes. For now, let's just choose some parameters by hand, but later we'll see how we can place priors over these parameters to express broader uncertainty and enable Bayesian causal inference. " + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "image/svg+xml": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "stress\n", + "\n", + "stress\n", + "\n", + "\n", + "\n", + "smokes\n", + "\n", + "smokes\n", + "\n", + "\n", + "\n", + "stress->smokes\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "cancer\n", + "\n", + "cancer\n", + "\n", + "\n", + "\n", + "stress->cancer\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "smokes->cancer\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import torch\n", + "\n", + "stress_pt = torch.tensor([0.5])\n", + "smokes_cpt = torch.tensor([0.2, 0.8])\n", + "cancer_cpt = torch.tensor([[0.1, 0.15], \n", + " [0.8, 0.85]])\n", + "\n", + "pyro.render_model(causal_model, (stress_pt, smokes_cpt, cancer_cpt))" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Simulating Observational Data with Fixed Parameters" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Fortunately, all causal models written in ChiRho compose freely with the probabilistic programming tooling in Pyro. Without belaboring the details, Pyro provides support for probabilistic modeling and inference with a set of composable *effect handlers*, which can be thought of as context managers that provide nonstandard interpretation of `pyro.sample` statements in Pyro programs. For more background on Pyro and its use of effect handlers, see https://pyro.ai/examples/intro_long.html and https://pyro.ai/examples/effect_handlers.html. Perhaps not surprisingly, ChiRho's main capabilities also make heavy use of similar effect handlers.\n", + "\n", + "As an example, let's use Pyro's `plate` effect handler to repeatedly sample from the `causal_model` to approximate the joint distribution for all of the attributes. " + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch.Size([10000])\n" + ] + } + ], + "source": [ + "def population_causal_model(n_individuals, stress_pt, smokes_cpt, cancer_cpt):\n", + " with pyro.plate(\"individuals\", n_individuals, dim=-1):\n", + " return causal_model(stress_pt, smokes_cpt, cancer_cpt)\n", + "\n", + "\n", + "\n", + "smokes_obs = population_causal_model(n_individuals, stress_pt, smokes_cpt, cancer_cpt)\n", + "# stress_obs, smokes_obs, cancer_obs = population_causal_model(n_individuals, stress_pt, smokes_cpt, cancer_cpt)\n", + "\n", + "print(smokes_obs.shape)\n", + "# print(stress_obs.shape, smokes_obs.shape, cancer_obs.shape)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's pretend for a moment that we're only interested in the relationship between whether individuals smoke and how likely they are to get cancer. To understand this relationship a bit better, we can simulate observations from our model." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[Text(0.5, 1.0, 'Observational Data - Fixed Parameters')]" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkQAAAHFCAYAAAAT5Oa6AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABNmklEQVR4nO3de1xUdf4/8NfIZbgII5dmBhKQvCCKmWKLaK4XFCQRjQzNIt3My5oaq2aRqdDXpKxV+0GauiYmGtaudnUpFC8ZoohhXtCvthCojIjiIIrD7fP7oy9nHcEbAjN4Xs/H4zwens95nzOfzzADL89VIYQQICIiIpKxNqbuABEREZGpMRARERGR7DEQERERkewxEBEREZHsMRARERGR7DEQERERkewxEBEREZHsMRARERGR7DEQERERkewxEJFZyczMxHPPPQc3NzdYW1tDq9VizJgx2L9/f73a2NhYKBQKlJSUmKCnLWPlypVISkqq156fnw+FQtHgMlOo+1nca13dZGdnh/bt2yMkJAQJCQm4evVqo/uQkZGB2NhYXLlypdHbaAodOnQwGuPNU3l5OSZOnIgOHTq0eL+SkpKgUCiQn59/x7pbf0bW1tbw9vbGa6+9ZvL3trmdOHECsbGxd32P6OHEQERmIyEhAf3798fZs2exdOlS7NixAx9++CHOnTuHp556ComJiabuYou7XSByc3PD/v37MWLEiJbvVBNITU3F/v37kZqaig8//BCenp6YN28eunfvjiNHjjRqmxkZGYiLizOLP9r9+/fH/v376012dnZYsGABtm3bZuou3lXdz+j777/H6NGjkZCQgNDQUDzMT3s6ceIE4uLiGIhkytLUHSACgJ9//hnR0dF4+umnsW3bNlha/vejOW7cODzzzDN47bXX0KtXL/Tv39+EPW1YRUUFbG1tW+z1lEol+vbt22Kv19T8/f3h6uoqzY8bNw4zZszAwIEDER4ejv/93/+FUqk0YQ8fTLt27W778+nYsWML96Zxbv4ZDRs2DJcuXcLGjRuRkZHxQN9BIQRu3LjRot8XU7t+/Trs7OxM3Q26C+4hIrMQHx8PhUKBVatWGYUhALC0tMTKlSuhUCjw3nvv1Vu3sLAQERERcHR0hEqlwosvvoiLFy8a1aSnp2PQoEFwcXGBra0tPD098eyzz+L69etSTWVlJRYvXoyuXbtCqVTikUcewV/+8pd62+rQoQPCwsKwdetW9OrVCzY2NoiLi0OvXr0wYMCAev2rqanBo48+ioiICKktLi4OAQEBcHZ2hqOjI3r37o1169YZ/e+7Q4cOOH78OPbs2SMdvqg71HK7Q2b79u1DUFAQHBwcYGdnh379+uH77783qqk7dLJr1y789a9/haurK1xcXBAREYHz588b1W7ZsgXBwcFwc3ODra0tfH198eabb+LatWv1xvmgevbsifnz56OgoABbtmyR2tPS0jBq1Ci0b98eNjY26NSpE6ZOnWp0qDQ2Nhavv/46AMDb21t6v3bv3t3i47ibWw+ZpaSkQKFQ1NsDumjRIlhYWCAtLU1qO3ToEMLDw+Hs7AwbGxv06tULX3zxRb3XyMzMRP/+/WFjYwN3d3fExMSgqqrqgfpdF/B+//133LhxA3PmzMETTzwBlUoFZ2dnBAYG4uuvv663nkKhwIwZM/DJJ5/A19cXSqUSGzZsAHBv3wPgv9+57777Dr169ZJ+ht999x2APz7Tvr6+sLe3x5/+9CccOnSoXj/u9t4lJSXhueeeAwAMHjxY+gzd/B3bsWMHgoKC4OjoCDs7O/Tv3x87d+40ep26Q46HDx/GmDFj4OTkJIXg//znPxg3bhzc3d2hVCqh0WgQFBSEnJyc+/xpUHPgHiIyuZqaGuzatQt9+vRB+/btG6zx8PCAv78/0tPTUVNTAwsLC2nZM888g8jISEybNg3Hjx/HggULcOLECRw4cABWVlbIz8/HiBEjMGDAAHz66ado164dzp07h9TUVFRWVsLOzg61tbUYNWoUfvrpJ8ybNw/9+vXD77//jkWLFmHQoEE4dOiQ0f9oDx8+jNzcXLz99tvw9vaGvb093N3d8dprr+H06dPo3LmzVPvjjz/i/Pnz+Mtf/iK15efnY+rUqfD09ATwxx+wmTNn4ty5c1i4cCEAYNu2bRgzZgxUKhVWrlwJAHfca7Jnzx4MGzYMjz/+ONatWwelUomVK1di5MiR+PzzzzF27Fij+ldeeQUjRozA5s2bUVhYiNdffx0vvvgi0tPTpZrTp0/j6aefRnR0NOzt7XHy5Em8//77OHjwoFFdUwkPD8e8efOwd+9evPTSSwCA3377DYGBgXjllVegUqmQn5+PZcuW4amnnsLRo0dhZWWFV155BZcvX0ZCQgK2bt0KNzc3AEC3bt1MMg4hBKqrq43a2rRpgzZt6v8fdNy4cdizZw/mzJmDvn37ok+fPkhPT8fixYvx1ltvYdiwYQCAXbt2Yfjw4QgICMAnn3wClUqFlJQUjB07FtevX8fEiRMB/HHYJygoCB06dEBSUhLs7OywcuVKbN68+YHGdObMGQDAI488AoPBgMuXL2Pu3Ll49NFHUVlZiR07diAiIgLr16+XfnZ1vvrqK/z0009YuHAhtFot1Go1gHv7HtQ5cuQIYmJiMH/+fKhUKsTFxSEiIgIxMTHYuXMnlixZAoVCgTfeeANhYWHIy8uTvrP38t6NGDECS5YswVtvvYWPP/4YvXv3BvDfPXrJycl46aWXMGrUKGzYsAFWVlZYvXo1QkJC8MMPPyAoKMiovxERERg3bhymTZsmBe+nn34aNTU1WLp0KTw9PVFSUoKMjAyzOMxLAASRiel0OgFAjBs37o51Y8eOFQDEhQsXhBBCLFq0SAAQf/vb34zqNm3aJACI5ORkIYQQ//znPwUAkZOTc9ttf/755wKA+Ne//mXUnpWVJQCIlStXSm1eXl7CwsJCnDp1yqi2pKREWFtbi7feesuoPTIyUmg0GlFVVdXga9fU1IiqqirxzjvvCBcXF1FbWyst6969uxg4cGC9dfLy8gQAsX79eqmtb9++Qq1Wi6tXr0pt1dXVws/PT7Rv317a7vr16wUAMX36dKNtLl26VAAQRUVFDfaztrZWVFVViT179ggA4siRI9Kyup/F3dTVXbx4scHlFRUVAoAIDQ29Yx9+//13AUB8/fXX0rIPPvhAABB5eXl37MOdxtEUvLy8BIB60/z584UQQkyYMEF4eXkZrXPjxg3Rq1cv4e3tLU6cOCE0Go0YOHCgqK6ulmq6du0qevXqVe9zFBYWJtzc3ERNTY0Q4o/via2trdDpdFJNdXW16Nq16z29P3U/I51OJ6qqqkRpaalITk4Wtra2wsPDQ1RUVNRbp7q6WlRVVYlJkyaJXr16GS0DIFQqlbh8+fIdX/dO3wMvLy9ha2srzp49K7Xl5OQIAMLNzU1cu3ZNav/qq68EAPHNN99Ibff63n355ZcCgNi1a5dR3bVr14Szs7MYOXJkvT737NlT/OlPf6r3/i1cuNCotqSkRAAQK1asuOP7QKbDQ2bUaoj/241+69VML7zwgtF8ZGQkLC0tsWvXLgDAE088AWtra0yZMgUbNmzAf/7zn3rb/u6779CuXTuMHDkS1dXV0vTEE09Aq9VKh17qPP744+jSpYtRm4uLC0aOHIkNGzagtrYWAFBaWoqvv/4aL730ktGhwPT0dAwdOhQqlQoWFhawsrLCwoULcenSJRQXF9/3e3Pt2jUcOHAAY8aMQdu2baV2CwsLREVF4ezZszh16pTROuHh4fXGBPxxSKTOf/7zH4wfPx5arVbq58CBAwEAubm5993PuxENnLBbXFyMadOmwcPDA5aWlrCysoKXl9d99eFBxnHz56G6uvqeTip+6qmnkJWVZTRNnz79tvVKpRJffPEFLl26hN69e0MIgc8//1zaE3rmzBmcPHlS+qzf3J+nn34aRUVF0s93165dCAoKgkajkbZvYWFRbw/h3Wi1WlhZWcHJyQkvvvgievfujdTUVNjY2AAAvvzyS/Tv3x9t27aVfi7r1q1r8P0cMmQInJyc6rXfz/fgiSeewKOPPirN+/r6AgAGDRpkdH5OXXvd5/h+3rvbycjIwOXLlzFhwgSj9WtrazF8+HBkZWXVO/z67LPPGs07OzujY8eO+OCDD7Bs2TL88ssv0u8JMg8MRGRyrq6usLOzQ15e3h3r8vPzYWdnB2dnZ6N2rVZrNG9paQkXFxdcunQJwB+7vHfs2AG1Wo1XX30VHTt2RMeOHfHRRx9J61y4cAFXrlyBtbU1rKysjCadTlfv0v66QzK3evnll3Hu3DnpvI/PP/8cBoNBOpwBAAcPHkRwcDAAYO3atfj555+RlZWF+fPnA/jjBO37VVpaCiFEg/1yd3cHAOn9qOPi4mI0X3c4ru71y8vLMWDAABw4cACLFy/G7t27kZWVha1btza6n3dT90esrs+1tbUIDg7G1q1bMW/ePOzcuRMHDx5EZmbmPffhQcdx6+eh7vyXO1GpVOjTp4/RVDem2+nUqRMGDBiAGzdu4IUXXjD6WV64cAEAMHfu3Hr9qQtadZ/RS5cu1ftOAPW/J3ezY8cOZGVlIScnByUlJdi3b590CHLr1q2IjIzEo48+iuTkZOzfvx9ZWVl4+eWXcePGjXrbauhzeb/fg1u/99bW1ndsr+vH/bx3t1O3jTFjxtTbxvvvvw8hBC5fvnzHMSsUCuzcuRMhISFYunQpevfujUceeQSzZs16oNtNUNPhOURkchYWFhg8eDBSU1Nx9uzZBs8jOnv2LLKzsxEaGmp0/hAA6HQ6o/85VldX49KlS0Z/8AcMGIABAwagpqYGhw4dQkJCAqKjo6HRaDBu3DjpxOLU1NQG++jg4GA0f7t77oSEhMDd3R3r169HSEgI1q9fj4CAAOkPCfDHSbRWVlb47rvvpP9tA3+cZ9FYTk5OaNOmDYqKiuotqztR+uaruu5Feno6zp8/j927d0t7UwA06/kO33zzDYA//tcPAMeOHcORI0eQlJSECRMmSHV157PciwcdR1ZWltG8t7f3Pb/2/fjHP/6B77//Hn/605+QmJiIsWPHIiAgAMB/f3YxMTFGJ+ffzMfHB8AfQVen09Vb3lDbnfTs2fO2n5nk5GR4e3tjy5YtRt8Fg8HQYH1D35fm+B405H7eu7ttIyEh4bZXD968Rw5oeMxeXl5Yt24dAOB///d/8cUXXyA2NhaVlZX45JNP7jwQanYMRGQWYmJi8O9//xvTp0/Htm3bjEJPTU0N/vrXv0IIgZiYmHrrbtq0Cf7+/tL8F198gerqaumP6s0sLCwQEBCArl27YtOmTTh8+DDGjRuHsLAwpKSkoKamRvoj1Bh1h6hWrFiBn376CYcOHcLq1auNahQKBSwtLY3GWFFRgY0bN9bbnlKpvKe9IPb29ggICMDWrVvx4YcfSieT1tbWIjk5Ge3bt693iO9u6n6h33oi963jaSpHjhzBkiVL0KFDB0RGRt53H27dw1XnQcfRp0+fe6p7EEePHsWsWbPw0ksvYe3atejXrx/Gjh2LX375BU5OTvDx8UHnzp2l9+hOBg8ejG+++QYXLlyQ/kjX1NQYXbn3oOpu2HjzH32dTtfgVWZ32sa9fg8exP28d7f7DPXv3x/t2rXDiRMnMGPGjCbpV5cuXfD222/jX//6Fw4fPtwk26QHw0BEZqF///5YsWIFoqOj8dRTT2HGjBnw9PREQUEBPv74Yxw4cAArVqxAv3796q27detWWFpaYtiwYdJVZj179pT+qH7yySdIT0/HiBEj4OnpiRs3buDTTz8FAAwdOhTAH1f6bNq0CU8//TRee+01/OlPf4KVlRXOnj2LXbt2YdSoUXjmmWfuaSwvv/wy3n//fYwfPx62trb1zt0YMWIEli1bhvHjx2PKlCm4dOkSPvzwwwavIOvRowdSUlKwZcsWPPbYY7CxsUGPHj0afN34+HgMGzYMgwcPxty5c2FtbY2VK1fi2LFj+Pzzz+/pTtI369evH5ycnDBt2jQsWrQIVlZW2LRpU6NvnHiz7OxsqFQqVFVV4fz589i5cyc2btwItVqNb7/9Vjrs0bVrV3Ts2BFvvvkmhBBwdnbGt99+a3Qpep269+Wjjz7ChAkTYGVlBR8fn2YdR1O4du0aIiMj4e3tjZUrV8La2hpffPEFevfujb/85S/SHpPVq1cjNDQUISEhmDhxIh599FFcvnwZubm5OHz4ML788ksAwNtvv41vvvkGQ4YMwcKFC2FnZ4ePP/64SW8xUHfbienTp2PMmDEoLCzE//zP/8DNzQ2nT5++p23cz/fgQd3re+fn5wcAWLNmDRwcHGBjYwNvb2+4uLggISEBEyZMwOXLlzFmzBio1WpcvHgRR44cwcWLF7Fq1ao79uHXX3/FjBkz8Nxzz6Fz586wtrZGeno6fv31V7z55ptNPmZqBNOdz01U3/79+8WYMWOERqMRlpaWQq1Wi4iICJGRkVGvtu5qjuzsbDFy5EjRtm1b4eDgIJ5//nnpSrS6bT7zzDPCy8tLKJVK4eLiIgYOHGh0FYoQQlRVVYkPP/xQ9OzZU9jY2Ii2bduKrl27iqlTp4rTp09LdV5eXmLEiBF3HEe/fv0EAPHCCy80uPzTTz8VPj4+QqlUiscee0zEx8eLdevW1bsKKD8/XwQHBwsHBwcBQLo6qaGrzIQQ4qeffhJDhgwR9vb2wtbWVvTt21d8++23RjV1V5llZWUZte/ataveFTYZGRkiMDBQ2NnZiUceeUS88sor4vDhw/Ve+36vMqublEqlcHNzE8HBweKjjz4SZWVl9dY5ceKEGDZsmHBwcBBOTk7iueeeEwUFBQKAWLRokVFtTEyMcHd3F23atDEay72Ooync7fNx61VmL774orCzsxPHjx83qqu74mn58uVS25EjR0RkZKRQq9XCyspKaLVaMWTIEPHJJ58Yrfvzzz+Lvn37CqVSKbRarXj99dfFmjVr7usqs9tdCVjnvffeEx06dBBKpVL4+vqKtWvXNvg5ACBeffXVBrdxr9+D272nDW277rvxwQcfGLXf63u3YsUK4e3tLSwsLOp9Pvbs2SNGjBghnJ2dhZWVlXj00UfFiBEjxJdffnnX9+/ChQti4sSJomvXrsLe3l60bdtWPP7442L58uVGVxOS6SiEeIjvw05ERER0D3iVGREREckeAxERERHJHgMRERERyR4DEREREcme2QSiuqedR0dHS21CCMTGxsLd3R22trYYNGgQjh8/brSewWDAzJkz4erqCnt7e4SHh+Ps2bNGNaWlpYiKioJKpYJKpUJUVBQfpkdEREQSswhEWVlZWLNmjfQspTpLly7FsmXLkJiYiKysLGi1WgwbNszoNufR0dHYtm0bUlJSsG/fPpSXlyMsLAw1NTVSzfjx45GTk4PU1FSkpqYiJycHUVFRLTY+IiIiMm8mv+y+vLwcvXv3xsqVK7F48WI88cQTWLFiBYQQcHd3R3R0NN544w0Af+wN0mg0eP/99zF16lTo9Xo88sgj2Lhxo3Tzu/Pnz8PDwwPbt29HSEgIcnNz0a1bN2RmZkp3IM7MzERgYCBOnjx511u216mtrcX58+fh4OBw3ze4IyIiItMQQuDq1atwd3dHmzZ32A9kwnsgCSGEeOmll0R0dLQQQoiBAweK1157TQghxG+//SYAiMOHDxvVh4eHi5deekkIIcTOnTsFAHH58mWjmscff1wsXLhQCCHEunXrhEqlqve6KpVKfPrpp/fcz8LCQqMbynHixIkTJ06cWs9UWFh4x7/zJn10R0pKCg4fPlzv4YnAfx9EeOsD8zQajfREbJ1OB2trazg5OdWrqVtfp9NBrVbX275arb7jww4NBoPRgwrF/+1IKywshKOj470Mj4iIiEysrKwMHh4e9R7SfSuTBaLCwkK89tpr+PHHH42edHyrWw9PCSHuesjq1pqG6u+2nfj4eMTFxdVrd3R0ZCAiIiJqZe6WHUx2UnV2djaKi4vh7+8PS0tLWFpaYs+ePfh//+//wdLSUtozdOtenOLiYmmZVqtFZWUlSktL71hz4cKFeq9/8eLFenufbhYTEwO9Xi9NhYWFDzReIiIiMl8mC0RBQUE4evQocnJypKlPnz544YUXkJOTg8ceewxardboqdaVlZXYs2eP9MRzf39/WFlZGdUUFRXh2LFjUk1gYCD0ej0OHjwo1Rw4cAB6vb7BJ6fXUSqV0t4g7hUiIiJ6uJnskJmDgwP8/PyM2uzt7eHi4iK1R0dHY8mSJejcuTM6d+6MJUuWwM7ODuPHjwcAqFQqTJo0CXPmzIGLiwucnZ0xd+5c9OjRA0OHDgUA+Pr6Yvjw4Zg8eTJWr14NAJgyZQrCwsLu+QozIiIieriZ9KTqu5k3bx4qKiowffp0lJaWIiAgAD/++KPRiVHLly+HpaUlIiMjUVFRgaCgICQlJcHCwkKq2bRpE2bNmoXg4GAAQHh4OBITE1t8PERERGSeTH4fotairKwMKpUKer2eh8+IiIhaiXv9+20Wd6omIiIiMiUGIiIiIpI9BiIiIiKSPQYiIiIikj0GIiIiIpI9BiIiIiKSPQYiIiIikj0GIiIiIpI9BiIiIiKSPbN+dIdcFBQUoKSkxNTdkBVXV1d4enqauhtERGQmGIhMrKCgAF27+qKi4rqpuyIrtrZ2OHkyl6GIiIgAMBCZXElJCSoqriPg5UVwdOtg6u7IQllRPg58GoeSkhIGIiIiAsBAZDYc3TrA2dPH1N0gIiKSJZ5UTURERLLHQERERESyx0BEREREssdARERERLLHQERERESyx0BEREREssdARERERLLHQERERESyx0BEREREssdARERERLLHQERERESyx0BEREREssdARERERLLHQERERESyx0BEREREssdARERERLLHQERERESyx0BEREREssdARERERLLHQERERESyx0BEREREssdARERERLJnacoXX7VqFVatWoX8/HwAQPfu3bFw4UKEhoYCACZOnIgNGzYYrRMQEIDMzExp3mAwYO7cufj8889RUVGBoKAgrFy5Eu3bt5dqSktLMWvWLHzzzTcAgPDwcCQkJKBdu3bNO0AiImqVCgoKUFJSYupuyIqrqys8PT1N9vomDUTt27fHe++9h06dOgEANmzYgFGjRuGXX35B9+7dAQDDhw/H+vXrpXWsra2NthEdHY1vv/0WKSkpcHFxwZw5cxAWFobs7GxYWFgAAMaPH4+zZ88iNTUVADBlyhRERUXh22+/bYlhEhFRK1JQUADfrj64XnHD1F2RFTtbG+SePGWyUGTSQDRy5Eij+XfffRerVq1CZmamFIiUSiW0Wm2D6+v1eqxbtw4bN27E0KFDAQDJycnw8PDAjh07EBISgtzcXKSmpiIzMxMBAQEAgLVr1yIwMBCnTp2Cj49PM46QiIham5KSElyvuIHkKU/A162tqbsjC7lF5XhxTQ5KSkrkGYhuVlNTgy+//BLXrl1DYGCg1L57926o1Wq0a9cOAwcOxLvvvgu1Wg0AyM7ORlVVFYKDg6V6d3d3+Pn5ISMjAyEhIdi/fz9UKpUUhgCgb9++UKlUyMjIYCAiIqIG+bq1Re8OKlN3g1qIyQPR0aNHERgYiBs3bqBt27bYtm0bunXrBgAIDQ3Fc889By8vL+Tl5WHBggUYMmQIsrOzoVQqodPpYG1tDScnJ6NtajQa6HQ6AIBOp5MC1M3UarVU0xCDwQCDwSDNl5WVNcVwiYiIyAyZPBD5+PggJycHV65cwb/+9S9MmDABe/bsQbdu3TB27Fipzs/PD3369IGXlxe+//57RERE3HabQggoFApp/uZ/367mVvHx8YiLi2vkqIiIiKg1Mfll99bW1ujUqRP69OmD+Ph49OzZEx999FGDtW5ubvDy8sLp06cBAFqtFpWVlSgtLTWqKy4uhkajkWouXLhQb1sXL16UahoSExMDvV4vTYWFhY0dIhEREZk5kweiWwkhjA5V3ezSpUsoLCyEm5sbAMDf3x9WVlZIS0uTaoqKinDs2DH069cPABAYGAi9Xo+DBw9KNQcOHIBer5dqGqJUKuHo6Gg0ERER0cPJpIfM3nrrLYSGhsLDwwNXr15FSkoKdu/ejdTUVJSXlyM2NhbPPvss3NzckJ+fj7feeguurq545plnAAAqlQqTJk3CnDlz4OLiAmdnZ8ydOxc9evSQrjrz9fXF8OHDMXnyZKxevRrAH5fdh4WF8YRqIiIiAmDiQHThwgVERUWhqKgIKpUKjz/+OFJTUzFs2DBUVFTg6NGj+Oyzz3DlyhW4ublh8ODB2LJlCxwcHKRtLF++HJaWloiMjJRuzJiUlCTdgwgANm3ahFmzZklXo4WHhyMxMbHFx0tERETmyaSBaN26dbddZmtrix9++OGu27CxsUFCQgISEhJuW+Ps7Izk5ORG9ZGIiIgefmZ3DhERERFRS2MgIiIiItljICIiIiLZYyAiIiIi2WMgIiIiItljICIiIiLZYyAiIiIi2WMgIiIiItljICIiIiLZYyAiIiIi2WMgIiIiItljICIiIiLZYyAiIiIi2WMgIiIiItljICIiIiLZYyAiIiIi2WMgIiIiItljICIiIiLZYyAiIiIi2WMgIiIiItljICIiIiLZYyAiIiIi2WMgIiIiItljICIiIiLZYyAiIiIi2WMgIiIiItljICIiIiLZYyAiIiIi2WMgIiIiItljICIiIiLZYyAiIiIi2WMgIiIiItljICIiIiLZYyAiIiIi2WMgIiIiItkzaSBatWoVHn/8cTg6OsLR0RGBgYH497//LS0XQiA2Nhbu7u6wtbXFoEGDcPz4caNtGAwGzJw5E66urrC3t0d4eDjOnj1rVFNaWoqoqCioVCqoVCpERUXhypUrLTFEIiIiagVMGojat2+P9957D4cOHcKhQ4cwZMgQjBo1Sgo9S5cuxbJly5CYmIisrCxotVoMGzYMV69elbYRHR2Nbdu2ISUlBfv27UN5eTnCwsJQU1Mj1YwfPx45OTlITU1FamoqcnJyEBUV1eLjJSIiIvNkacoXHzlypNH8u+++i1WrViEzMxPdunXDihUrMH/+fERERAAANmzYAI1Gg82bN2Pq1KnQ6/VYt24dNm7ciKFDhwIAkpOT4eHhgR07diAkJAS5ublITU1FZmYmAgICAABr165FYGAgTp06BR8fn5YdNBEREZkdszmHqKamBikpKbh27RoCAwORl5cHnU6H4OBgqUapVGLgwIHIyMgAAGRnZ6Oqqsqoxt3dHX5+flLN/v37oVKppDAEAH379oVKpZJqiIiISN5MuocIAI4ePYrAwEDcuHEDbdu2xbZt29CtWzcprGg0GqN6jUaD33//HQCg0+lgbW0NJyenejU6nU6qUavV9V5XrVZLNQ0xGAwwGAzSfFlZWeMGSERERGbP5HuIfHx8kJOTg8zMTPz1r3/FhAkTcOLECWm5QqEwqhdC1Gu71a01DdXfbTvx8fHSSdgqlQoeHh73OiQiIiJqZUweiKytrdGpUyf06dMH8fHx6NmzJz766CNotVoAqLcXp7i4WNprpNVqUVlZidLS0jvWXLhwod7rXrx4sd7ep5vFxMRAr9dLU2Fh4QONk4iIiMyXyQPRrYQQMBgM8Pb2hlarRVpamrSssrISe/bsQb9+/QAA/v7+sLKyMqopKirCsWPHpJrAwEDo9XocPHhQqjlw4AD0er1U0xClUindDqBuIiIiooeTSc8heuuttxAaGgoPDw9cvXoVKSkp2L17N1JTU6FQKBAdHY0lS5agc+fO6Ny5M5YsWQI7OzuMHz8eAKBSqTBp0iTMmTMHLi4ucHZ2xty5c9GjRw/pqjNfX18MHz4ckydPxurVqwEAU6ZMQVhYGK8wIyIiIgAmDkQXLlxAVFQUioqKoFKp8PjjjyM1NRXDhg0DAMybNw8VFRWYPn06SktLERAQgB9//BEODg7SNpYvXw5LS0tERkaioqICQUFBSEpKgoWFhVSzadMmzJo1S7oaLTw8HImJiS07WCIiIjJbJg1E69atu+NyhUKB2NhYxMbG3rbGxsYGCQkJSEhIuG2Ns7MzkpOTG9tNIiIiesiZ3TlERERERC2NgYiIiIhkj4GIiIiIZI+BiIiIiGSPgYiIiIhkj4GIiIiIZI+BiIiIiGSPgYiIiIhkj4GIiIiIZI+BiIiIiGSPgYiIiIhkj4GIiIiIZI+BiIiIiGSPgYiIiIhkj4GIiIiIZI+BiIiIiGSPgYiIiIhkj4GIiIiIZI+BiIiIiGSPgYiIiIhkj4GIiIiIZI+BiIiIiGSPgYiIiIhkj4GIiIiIZI+BiIiIiGSPgYiIiIhkj4GIiIiIZI+BiIiIiGSPgYiIiIhkj4GIiIiIZI+BiIiIiGSPgYiIiIhkj4GIiIiIZI+BiIiIiGSPgYiIiIhkz6SBKD4+Hk8++SQcHBygVqsxevRonDp1yqhm4sSJUCgURlPfvn2NagwGA2bOnAlXV1fY29sjPDwcZ8+eNaopLS1FVFQUVCoVVCoVoqKicOXKleYeIhEREbUCJg1Ee/bswauvvorMzEykpaWhuroawcHBuHbtmlHd8OHDUVRUJE3bt283Wh4dHY1t27YhJSUF+/btQ3l5OcLCwlBTUyPVjB8/Hjk5OUhNTUVqaipycnIQFRXVIuMkIiIi82ZpyhdPTU01ml+/fj3UajWys7Px5z//WWpXKpXQarUNbkOv12PdunXYuHEjhg4dCgBITk6Gh4cHduzYgZCQEOTm5iI1NRWZmZkICAgAAKxduxaBgYE4deoUfHx8mmmERERE1BqY1TlEer0eAODs7GzUvnv3bqjVanTp0gWTJ09GcXGxtCw7OxtVVVUIDg6W2tzd3eHn54eMjAwAwP79+6FSqaQwBAB9+/aFSqWSaoiIiEi+TLqH6GZCCMyePRtPPfUU/Pz8pPbQ0FA899xz8PLyQl5eHhYsWIAhQ4YgOzsbSqUSOp0O1tbWcHJyMtqeRqOBTqcDAOh0OqjV6nqvqVarpZpbGQwGGAwGab6srKwphklERERmyGwC0YwZM/Drr79i3759Ru1jx46V/u3n54c+ffrAy8sL33//PSIiIm67PSEEFAqFNH/zv29Xc7P4+HjExcXd7zCIiIioFTKLQ2YzZ87EN998g127dqF9+/Z3rHVzc4OXlxdOnz4NANBqtaisrERpaalRXXFxMTQajVRz4cKFetu6ePGiVHOrmJgY6PV6aSosLGzM0IiIiKgVMGkgEkJgxowZ2Lp1K9LT0+Ht7X3XdS5duoTCwkK4ubkBAPz9/WFlZYW0tDSppqioCMeOHUO/fv0AAIGBgdDr9Th48KBUc+DAAej1eqnmVkqlEo6OjkYTERERPZxMesjs1VdfxebNm/H111/DwcFBOp9HpVLB1tYW5eXliI2NxbPPPgs3Nzfk5+fjrbfegqurK5555hmpdtKkSZgzZw5cXFzg7OyMuXPnokePHtJVZ76+vhg+fDgmT56M1atXAwCmTJmCsLAwXmFGREREpg1Eq1atAgAMGjTIqH39+vWYOHEiLCwscPToUXz22We4cuUK3NzcMHjwYGzZsgUODg5S/fLly2FpaYnIyEhUVFQgKCgISUlJsLCwkGo2bdqEWbNmSVejhYeHIzExsfkHSURERGbPpIFICHHH5ba2tvjhhx/uuh0bGxskJCQgISHhtjXOzs5ITk6+7z4SERHRw88sTqomIiIiMiUGIiIiIpI9BiIiIiKSPQYiIiIikj0GIiIiIpI9BiIiIiKSPQYiIiIikj0GIiIiIpI9BiIiIiKSPQYiIiIikj0GIiIiIpI9BiIiIiKSPQYiIiIikj0GIiIiIpI9BiIiIiKSPQYiIiIikj0GIiIiIpI9BiIiIiKSPQYiIiIikj0GIiIiIpI9BiIiIiKSvUYFosceewyXLl2q137lyhU89thjD9wpIiIiopbUqECUn5+Pmpqaeu0GgwHnzp174E4RERERtSTL+yn+5ptvpH//8MMPUKlU0nxNTQ127tyJDh06NFnniIiIiFrCfQWi0aNHAwAUCgUmTJhgtMzKygodOnTA3//+9ybrHBEREVFLuK9AVFtbCwDw9vZGVlYWXF1dm6VTRERERC3pvgJRnby8vKbuBxEREZHJNCoQAcDOnTuxc+dOFBcXS3uO6nz66acP3DEiIiKiltKoQBQXF4d33nkHffr0gZubGxQKRVP3i4iIiKjFNCoQffLJJ0hKSkJUVFRT94eIiIioxTXqPkSVlZXo169fU/eFiIiIyCQaFYheeeUVbN68uan7QkRERGQSjTpkduPGDaxZswY7duzA448/DisrK6Ply5Yta5LOEREREbWERgWiX3/9FU888QQA4NixY0bLeII1ERERtTaNCkS7du1q6n4QERERmUyjziFqKvHx8XjyySfh4OAAtVqN0aNH49SpU0Y1QgjExsbC3d0dtra2GDRoEI4fP25UYzAYMHPmTLi6usLe3h7h4eE4e/asUU1paSmioqKgUqmgUqkQFRWFK1euNPcQiYiIqBVo1B6iwYMH3/HQWHp6+j1tZ8+ePXj11Vfx5JNPorq6GvPnz0dwcDBOnDgBe3t7AMDSpUuxbNkyJCUloUuXLli8eDGGDRuGU6dOwcHBAQAQHR2Nb7/9FikpKXBxccGcOXMQFhaG7OxsWFhYAADGjx+Ps2fPIjU1FQAwZcoUREVF4dtvv23MW0BEREQPkUYForrzh+pUVVUhJycHx44dq/fQ1zupCyd11q9fD7VajezsbPz5z3+GEAIrVqzA/PnzERERAQDYsGEDNBoNNm/ejKlTp0Kv12PdunXYuHEjhg4dCgBITk6Gh4cHduzYgZCQEOTm5iI1NRWZmZkICAgAAKxduxaBgYE4deoUfHx8GvM2EBER0UOiUYFo+fLlDbbHxsaivLy80Z3R6/UAAGdnZwB/PDNNp9MhODhYqlEqlRg4cCAyMjIwdepUZGdno6qqyqjG3d0dfn5+yMjIQEhICPbv3w+VSiWFIQDo27cvVCoVMjIyGIiIiIhkrknPIXrxxRcb/RwzIQRmz56Np556Cn5+fgAAnU4HANBoNEa1Go1GWqbT6WBtbQ0nJ6c71qjV6nqvqVarpZpbGQwGlJWVGU1ERET0cGrSQLR//37Y2Ng0at0ZM2bg119/xeeff15v2a3nKwkh7np5/601DdXfaTvx8fHSCdgqlQoeHh73MgwiIiJqhRp1yKzufJ46QggUFRXh0KFDWLBgwX1vb+bMmfjmm2+wd+9etG/fXmrXarUA/tjD4+bmJrUXFxdLe420Wi0qKytRWlpqtJeouLhYeryIVqvFhQsX6r3uxYsX6+19qhMTE4PZs2dL82VlZQxFRERED6lG7SG6ec+JSqWCs7MzBg0ahO3bt2PRokX3vB0hBGbMmIGtW7ciPT0d3t7eRsu9vb2h1WqRlpYmtVVWVmLPnj1S2PH394eVlZVRTVFREY4dOybVBAYGQq/X4+DBg1LNgQMHoNfrb/tMNqVSCUdHR6OJiIiIHk6N2kO0fv36JnnxV199FZs3b8bXX38NBwcH6XwelUoFW1tbKBQKREdHY8mSJejcuTM6d+6MJUuWwM7ODuPHj5dqJ02ahDlz5sDFxQXOzs6YO3cuevToIV115uvri+HDh2Py5MlYvXo1gD8uuw8LC+MJ1URERNS4QFQnOzsbubm5UCgU6NatG3r16nVf669atQoAMGjQIKP29evXY+LEiQCAefPmoaKiAtOnT0dpaSkCAgLw448/SvcgAv646s3S0hKRkZGoqKhAUFAQkpKSpHsQAcCmTZswa9Ys6Wq08PBwJCYmNmLURERE9LBpVCAqLi7GuHHjsHv3brRr1w5CCOj1egwePBgpKSl45JFH7mk7Qoi71igUCsTGxiI2Nva2NTY2NkhISEBCQsJta5ydnZGcnHxP/SIiIiJ5adQ5RDNnzkRZWRmOHz+Oy5cvo7S0FMeOHUNZWRlmzZrV1H0kIiIialaN2kOUmpqKHTt2wNfXV2rr1q0bPv74Y6MbJBIRERG1Bo3aQ1RbWwsrK6t67VZWVqitrX3gThERERG1pEYFoiFDhuC1117D+fPnpbZz587hb3/7G4KCgpqsc0REREQtoVGBKDExEVevXkWHDh3QsWNHdOrUCd7e3rh69eodT2wmIiIiMkeNOofIw8MDhw8fRlpaGk6ePAkhBLp16ybd94eIiIioNbmvPUTp6eno1q2b9KDTYcOGYebMmZg1axaefPJJdO/eHT/99FOzdJSIiIioudxXIFqxYgUmT57c4GMsVCoVpk6dimXLljVZ54iIiIhawn0FoiNHjmD48OG3XR4cHIzs7OwH7hQRERFRS7qvQHThwoUGL7evY2lpiYsXLz5wp4iIiIha0n0FokcffRRHjx697fJff/0Vbm5uD9wpIiIiopZ0X4Ho6aefxsKFC3Hjxo16yyoqKrBo0SKEhYU1WeeIiIiIWsJ9XXb/9ttvY+vWrejSpQtmzJgBHx8fKBQK5Obm4uOPP0ZNTQ3mz5/fXH0lIiIiahb3FYg0Gg0yMjLw17/+FTExMdLT6hUKBUJCQrBy5UpoNJpm6SgRERFRc7nvGzN6eXlh+/btKC0txZkzZyCEQOfOneHk5NQc/SMiIiJqdo26UzUAODk54cknn2zKvhARERGZRKOeZUZERET0MGEgIiIiItljICIiIiLZYyAiIiIi2WMgIiIiItljICIiIiLZYyAiIiIi2WMgIiIiItljICIiIiLZYyAiIiIi2WMgIiIiItljICIiIiLZYyAiIiIi2WMgIiIiItljICIiIiLZYyAiIiIi2WMgIiIiItljICIiIiLZYyAiIiIi2TNpINq7dy9GjhwJd3d3KBQKfPXVV0bLJ06cCIVCYTT17dvXqMZgMGDmzJlwdXWFvb09wsPDcfbsWaOa0tJSREVFQaVSQaVSISoqCleuXGnm0REREVFrYdJAdO3aNfTs2ROJiYm3rRk+fDiKioqkafv27UbLo6OjsW3bNqSkpGDfvn0oLy9HWFgYampqpJrx48cjJycHqampSE1NRU5ODqKiopptXERERNS6WJryxUNDQxEaGnrHGqVSCa1W2+AyvV6PdevWYePGjRg6dCgAIDk5GR4eHtixYwdCQkKQm5uL1NRUZGZmIiAgAACwdu1aBAYG4tSpU/Dx8WnaQREREVGrY/bnEO3evRtqtRpdunTB5MmTUVxcLC3Lzs5GVVUVgoODpTZ3d3f4+fkhIyMDALB//36oVCopDAFA3759oVKppBoiIiKSN5PuIbqb0NBQPPfcc/Dy8kJeXh4WLFiAIUOGIDs7G0qlEjqdDtbW1nBycjJaT6PRQKfTAQB0Oh3UanW9bavVaqmmIQaDAQaDQZovKytrolERERGRuTHrQDR27Fjp335+fujTpw+8vLzw/fffIyIi4rbrCSGgUCik+Zv/fbuaW8XHxyMuLq6RPSciIqLWxOwPmd3Mzc0NXl5eOH36NABAq9WisrISpaWlRnXFxcXQaDRSzYULF+pt6+LFi1JNQ2JiYqDX66WpsLCwCUdCRERE5qRVBaJLly6hsLAQbm5uAAB/f39YWVkhLS1NqikqKsKxY8fQr18/AEBgYCD0ej0OHjwo1Rw4cAB6vV6qaYhSqYSjo6PRRERERA8nkx4yKy8vx5kzZ6T5vLw85OTkwNnZGc7OzoiNjcWzzz4LNzc35Ofn46233oKrqyueeeYZAIBKpcKkSZMwZ84cuLi4wNnZGXPnzkWPHj2kq858fX0xfPhwTJ48GatXrwYATJkyBWFhYbzCjIhajYKCApSUlJi6G7KQm5tr6i6QCZg0EB06dAiDBw+W5mfPng0AmDBhAlatWoWjR4/is88+w5UrV+Dm5obBgwdjy5YtcHBwkNZZvnw5LC0tERkZiYqKCgQFBSEpKQkWFhZSzaZNmzBr1izparTw8PA73vuIiMicFBQUoGtXX1RUXDd1V2REgSL9DQAqU3eEWohJA9GgQYMghLjt8h9++OGu27CxsUFCQgISEhJuW+Ps7Izk5ORG9ZGIyNRKSkpQUXEdAS8vgqNbB1N356F3Me8kcja/jyvXq03dFWpBZn2VGRER/ZejWwc4e/JQf3OruMY9cXLUqk6qJiIiImoODEREREQkewxEREREJHsMRERERCR7DEREREQkewxEREREJHsMRERERCR7DEREREQkewxEREREJHsMRERERCR7DEREREQkewxEREREJHsMRERERCR7DEREREQkewxEREREJHsMRERERCR7DEREREQkewxEREREJHsMRERERCR7DEREREQkewxEREREJHuWpu4Akank5uaauguy4urqCk9PT1N3g4ioQQxEJDtVhkoAwIsvvmjinsiLna0Nck+eYigiIrPEQESyU11dDQD4n4gueLqH2sS9kYfconK8uCYHJSUlDEREZJYYiEi2vF3t0LuDytTdICIiM8CTqomIiEj2GIiIiIhI9hiIiIiISPYYiIiIiEj2GIiIiIhI9hiIiIiISPYYiIiIiEj2GIiIiIhI9hiIiIiISPZMGoj27t2LkSNHwt3dHQqFAl999ZXRciEEYmNj4e7uDltbWwwaNAjHjx83qjEYDJg5cyZcXV1hb2+P8PBwnD171qimtLQUUVFRUKlUUKlUiIqKwpUrV5p5dERERNRamDQQXbt2DT179kRiYmKDy5cuXYply5YhMTERWVlZ0Gq1GDZsGK5evSrVREdHY9u2bUhJScG+fftQXl6OsLAw1NTUSDXjx49HTk4OUlNTkZqaipycHERFRTX7+IiIiKh1MOmzzEJDQxEaGtrgMiEEVqxYgfnz5yMiIgIAsGHDBmg0GmzevBlTp06FXq/HunXrsHHjRgwdOhQAkJycDA8PD+zYsQMhISHIzc1FamoqMjMzERAQAABYu3YtAgMDcerUKfj4+LTMYImIiMhsme05RHl5edDpdAgODpbalEolBg4ciIyMDABAdnY2qqqqjGrc3d3h5+cn1ezfvx8qlUoKQwDQt29fqFQqqYaIiIjkzWyfdq/T6QAAGo3GqF2j0eD333+XaqytreHk5FSvpm59nU4HtVpdb/tqtVqqaYjBYIDBYJDmy8rKGjcQIiIiMntmu4eojkKhMJoXQtRru9WtNQ3V32078fHx0knYKpUKHh4e99lzIiIiai3MNhBptVoAqLcXp7i4WNprpNVqUVlZidLS0jvWXLhwod72L168WG/v081iYmKg1+ulqbCw8IHGQ0RERObLbAORt7c3tFot0tLSpLbKykrs2bMH/fr1AwD4+/vDysrKqKaoqAjHjh2TagIDA6HX63Hw4EGp5sCBA9Dr9VJNQ5RKJRwdHY0mIiIiejiZ9Byi8vJynDlzRprPy8tDTk4OnJ2d4enpiejoaCxZsgSdO3dG586dsWTJEtjZ2WH8+PEAAJVKhUmTJmHOnDlwcXGBs7Mz5s6dix49ekhXnfn6+mL48OGYPHkyVq9eDQCYMmUKwsLCeIUZERERATBxIDp06BAGDx4szc+ePRsAMGHCBCQlJWHevHmoqKjA9OnTUVpaioCAAPz4449wcHCQ1lm+fDksLS0RGRmJiooKBAUFISkpCRYWFlLNpk2bMGvWLOlqtPDw8Nve+4iIiIjkx6SBaNCgQRBC3Ha5QqFAbGwsYmNjb1tjY2ODhIQEJCQk3LbG2dkZycnJD9JVIiIieoiZ7TlERERERC2FgYiIiIhkj4GIiIiIZI+BiIiIiGSPgYiIiIhkj4GIiIiIZI+BiIiIiGSPgYiIiIhkj4GIiIiIZI+BiIiIiGSPgYiIiIhkz6TPMiMiup2amhpUVVWZuhvNwsrKyugB1ERkegxERGRWhBDQ6XS4cuWKqbvSrNq1awetVguFQmHqrhARGIiIyMzUhSG1Wg07O7uHLjAIIXD9+nUUFxcDANzc3EzcIyICGIiIyIzU1NRIYcjFxcXU3Wk2tra2AIDi4mKo1WoePiMyAzypmojMRt05Q3Z2dibuSfOrG+PDep4UUWvDQEREZudhO0zWEDmMkag1YSAiIiIi2WMgIiIiItljICIiIiLZYyAiImpGlZWVpu4CEd0DBiIialVqa2vx/vvvo1OnTlAqlfD09MS7774LAHjjjTfQpUsX2NnZ4bHHHsOCBQuMruKKjY3FE088gY0bN6JDhw5QqVQYN24crl69ek/bB4Bz585h7NixcHJygouLC0aNGoX8/Hxp+cSJEzF69GjEx8fD3d0dXbp0af43hYgeGO9DREStSkxMDNauXYvly5fjqaeeQlFREU6ePAkAcHBwQFJSEtzd3XH06FFMnjwZDg4OmDdvnrT+b7/9hq+++grfffcdSktLERkZiffee08KPXfa/vXr1zF48GAMGDAAe/fuhaWlJRYvXozhw4fj119/hbW1NQBg586dcHR0RFpaGoQQLfwOEVFjMBARUatx9epVfPTRR0hMTMSECRMAAB07dsRTTz0FAHj77bel2g4dOmDOnDnYsmWLUSCqra1FUlISHBwcAABRUVHYuXMn3n333btuPyUlBW3atME//vEP6bL59evXo127dti9ezeCg4MBAPb29vjHP/4hBSQiMn8MRETUauTm5sJgMCAoKKjB5f/85z+xYsUKnDlzBuXl5aiuroajo6NRTYcOHaQwBPzx6Iy6x2jcbfvZ2dk4c+aM0foAcOPGDfz222/SfI8ePRiGiFoZBiIiajXqHnnRkMzMTIwbNw5xcXEICQmBSqVCSkoK/v73vxvVWVlZGc0rFArU1tbedfvAH3uX/P39sWnTpnrLHnnkEenf9vb2dx0LEZkXnlRNRK1G586dYWtri507d9Zb9vPPP8PLywvz589Hnz590LlzZ/z+++9Ntn0A6N27N06fPg21Wo1OnToZTSqVqlFjIiLzwD1ERNRq2NjY4I033sC8efNgbW2N/v374+LFizh+/Dg6deqEgoICpKSk4Mknn8T333+Pbdu2Ndn2J02ahBdeeAEffPABRo0ahXfeeQft27dHQUEBtm7ditdffx3t27dvppETUXNjICKiVmXBggWwtLTEwoULcf78ebi5uWHatGmYNGkS/va3v2HGjBkwGAwYMWIEFixYgNjY2CbZPvDHA1n37t2LN954AxEREbh69SoeffRRBAUF1TtXiYhaFwYiImpV2rRpg/nz52P+/Pn1li1duhRLly41aouOjpb+HRsbWy8gRUdHG9XcafsAoNVqsWHDhtv2Lykp6a5jICLzw3OIiIiISPYYiIiIiEj2GIiIiIhI9hiIiIiISPYYiIiIiEj2zDoQxcbGQqFQGE1arVZaLoRAbGws3N3dYWtri0GDBuH48eNG2zAYDJg5cyZcXV1hb2+P8PBwnD17tqWHQkRERGbMrAMRAHTv3h1FRUXSdPToUWnZ0qVLsWzZMiQmJiIrKwtarRbDhg3D1atXpZro6Ghs27YNKSkp2LdvH8rLyxEWFoaamhpTDIeIiIjMkNnfh8jS0tJor1AdIQRWrFiB+fPnIyIiAgCwYcMGaDQabN68GVOnToVer8e6deuwceNGDB06FACQnJwMDw8P7NixAyEhIS06FiIiIjJPZr+H6PTp03B3d4e3tzfGjRuH//znPwCAvLw86HQ6BAcHS7VKpRIDBw5ERkYGgD+eTF1VVWVU4+7uDj8/P6mGiIiIyKz3EAUEBOCzzz5Dly5dcOHCBSxevBj9+vXD8ePHodPpAAAajcZoHY1GIz3QUafTwdraGk5OTvVq6ta/HYPBAIPBIM2XlZU1xZCIqJEKCgpQUlLSYq/n6uoKT0/P+15v5cqV+OCDD1BUVITu3btjxYoVGDBgQDP0kIiaklkHotDQUOnfPXr0QGBgIDp27IgNGzagb9++AACFQmG0jhCiXtut7qUmPj4ecXFxjew5ETWlgoICdO3qi4qK6y32mra2djh5Mve+QtGWLVsQHR2NlStXon///li9ejVCQ0Nx4sSJRoUrImo5Zh2IbmVvb48ePXrg9OnTGD16NIA/9gK5ublJNcXFxdJeI61Wi8rKSpSWlhrtJSouLka/fv3u+FoxMTGYPXu2NF9WVgYPD48mHA0R3auSkhJUVFxHwMuL4OjWodlfr6woHwc+jUNJScl9BZlly5Zh0qRJeOWVVwAAK1aswA8//IBVq1YhPj6+ubpLRE2gVQUig8GA3NxcDBgwAN7e3tBqtUhLS0OvXr0AAJWVldizZw/ef/99AIC/vz+srKyQlpaGyMhIAEBRURGOHTtW7wGQt1IqlVAqlc07ICK6L45uHeDs6WPqbjSosrIS2dnZePPNN43ag4ODec4iUStg1oFo7ty5GDlyJDw9PVFcXIzFixejrKwMEyZMgEKhQHR0NJYsWYLOnTujc+fOWLJkCezs7DB+/HgAgEqlwqRJkzBnzhy4uLjA2dkZc+fORY8ePaSrzoiImkJJSQlqamoaPK/xbucsEpHpmXUgOnv2LJ5//nmUlJTgkUceQd++fZGZmQkvLy8AwLx581BRUYHp06ejtLQUAQEB+PHHH+Hg4CBtY/ny5bC0tERkZCQqKioQFBSEpKQkWFhYmGpYRPQQa8x5jURkemYdiFJSUu64XKFQIDY2FrGxsbetsbGxQUJCAhISEpq4d0RE/+Xq6goLC4t6e4NuPq+RiMyX2d+HiIioNbC2toa/vz/S0tKM2tPS0u56EQcRmZ5Z7yEiImpNZs+ejaioKPTp0weBgYFYs2YNCgoKMG3aNFN3jYjugoGIiFqNsqJ8s36dsWPH4tKlS3jnnXdQVFQEPz8/bN++XTrvkYjMFwMREZk9V1dX2Nra4cCnLXezVFtbO7i6ut73etOnT8f06dOboUdE1JwYiIjI7Hl6euLkydxW8egOImqdGIiIqFXw9PRkQCGiZsOrzIiIiEj2GIiIiIhI9hiIiIiISPYYiIiIiEj2GIiIiIhI9hiIiIiISPYYiIiIiEj2GIiIiIhI9nhjRiJqFQoKCsz6TtV79+7FBx98gOzsbBQVFWHbtm0YPXp083WQiJoUAxERmb2CggL4dvXB9YobLfaadrY2yD156p5D0bVr19CzZ0/85S9/wbPPPtvMvSOipsZARERmr6SkBNcrbiB5yhPwdWvb7K+XW1SOF9fkoKSk5J4DUWhoKEJDQ5u5Z0TUXBiIiKjV8HVri94dVKbuBhE9hHhSNREREckeAxERERHJHgMRERERyR4DEREREckeT6omImoC5eXlOHPmjDSfl5eHnJwcODs739f9jIjINBiIiKjVyC0qN9vXOXToEAYPHizNz549GwAwYcIEJCUlNVXXiKiZMBARkdlzdXWFna0NXlyT02KvaWdrA1dX13uuHzRoEIQQzdgjImpODEREZPY8PT2Re/KUWT+6g4haNwYiImoVPD09GVCIqNnwKjMiIiKSPQYiIiIikj0GIiIiIpI9BiIiMjtyuFpLDmMkak0YiIjIbFhZWQEArl+/buKeNL+6MdaNmYhMi1eZEZHZsLCwQLt27VBcXAwAsLOzg0KhMHGvmpYQAtevX0dxcTHatWsHCwsLU3eJiMBARERmRqvVAoAUih5W7dq1k8ZKRKbHQEREZkWhUMDNzQ1qtRpVVVWm7k6zsLKy4p4hIjMjq0C0cuVKfPDBBygqKkL37t2xYsUKDBgwwNTdIqIGWFhYMDQQUYuRzUnVW7ZsQXR0NObPn49ffvkFAwYMQGhoKAoKCkzdNSIiIjIx2QSiZcuWYdKkSXjllVfg6+uLFStWwMPDA6tWrTJ114iIiMjEZBGIKisrkZ2djeDgYKP24OBgZGRkmKhXREREZC5kcQ5RSUkJampqoNFojNo1Gg10Ol2D6xgMBhgMBmler9cDAMrKypq0b+Xl5QCAy7+fQrWhokm3TQ3TnzsNAMgtuoq9py6ZuDfycEp3DcAfn/em/g7JAX9PtCz+jmh5zfk7om57d70ZqpCBc+fOCQAiIyPDqH3x4sXCx8enwXUWLVokAHDixIkTJ06cHoKpsLDwjllBFnuIXF1dYWFhUW9vUHFxcb29RnViYmIwe/Zsab62thaXL1+Gi4vLQ3ejOLkpKyuDh4cHCgsL4ejoaOruEJGZ4e+Ih4sQAlevXoW7u/sd62QRiKytreHv74+0tDQ888wzUntaWhpGjRrV4DpKpRJKpdKorV27ds3ZTWphjo6O/GVHRLfF3xEPD5VKddcaWQQiAJg9ezaioqLQp08fBAYGYs2aNSgoKMC0adNM3TUiIiIyMdkEorFjx+LSpUt45513UFRUBD8/P2zfvh1eXl6m7hoRERGZmGwCEQBMnz4d06dPN3U3yMSUSiUWLVpU75AoERHA3xFypRDibtehERERET3cZHFjRiIiIqI7YSAiIiIi2WMgIiIiItljICIiIiLZYyAi2Vm5ciW8vb1hY2MDf39//PTTT6buEhGZib1792LkyJFwd3eHQqHAV199ZeouUQthICJZ2bJlC6KjozF//nz88ssvGDBgAEJDQ1FQUGDqrhGRGbh27Rp69uyJxMREU3eFWhgvuydZCQgIQO/evbFq1SqpzdfXF6NHj0Z8fLwJe0ZE5kahUGDbtm0YPXq0qbtCLYB7iEg2KisrkZ2djeDgYKP24OBgZGRkmKhXRERkDhiISDZKSkpQU1MDjUZj1K7RaKDT6UzUKyIiMgcMRCQ7CoXCaF4IUa+NiIjkhYGIZMPV1RUWFhb19gYVFxfX22tERETywkBEsmFtbQ1/f3+kpaUZtaelpaFfv34m6hUREZkDWT3tnmj27NmIiopCnz59EBgYiDVr1qCgoADTpk0zddeIyAyUl5fjzJkz0nxeXh5ycnLg7OwMT09PE/aMmhsvuyfZWblyJZYuXYqioiL4+flh+fLl+POf/2zqbhGRGdi9ezcGDx5cr33ChAlISkpq+Q5Ri2EgIiIiItnjOUREREQkewxEREREJHsMRERERCR7DEREREQkewxEREREJHsMRERERCR7DEREREQkewxERES3mDhxIkaPHm3qbhBRC2IgIiIiItljICIiIiLZYyAiIrP3z3/+Ez169ICtrS1cXFwwdOhQXLt2TTq0tWTJEmg0GrRr1w5xcXGorq7G66+/DmdnZ7Rv3x6ffvqp0faOHj2KIUOGSNubMmUKysvLb/v62dnZUKvVePfddwEAer0eU6ZMgVqthqOjI4YMGYIjR45I9UeOHMHgwYPh4OAAR0dH+Pv749ChQ83z5hBRk2AgIiKzVlRUhOeffx4vv/wycnNzsXv3bkRERKDuMYzp6ek4f/489u7di2XLliE2NhZhYWFwcnLCgQMHMG3aNEybNg2FhYUAgOvXr2P48OFwcnJCVlYWvvzyS+zYsQMzZsxo8PV3796NoKAgxMXFYf78+RBCYMSIEdDpdNi+fTuys7PRu3dvBAUF4fLlywCAF154Ae3bt0dWVhays7Px5ptvwsrKqmXeMCJqHEFEZMays7MFAJGfn19v2YQJE4SXl5eoqamR2nx8fMSAAQOk+erqamFvby8+//xzIYQQa9asEU5OTqK8vFyq+f7770WbNm2ETqeTtjtq1Cjx1VdfCQcHB7F582apdufOncLR0VHcuHHDqC8dO3YUq1evFkII4eDgIJKSkppg9ETUUriHiIjMWs+ePREUFIQePXrgueeew9q1a1FaWiot7969O9q0+e+vMo1Ggx49ekjzFhYWcHFxQXFxMQAgNzcXPXv2hL29vVTTv39/1NbW4tSpU1LbgQMH8Oyzz2LDhg14/vnnpfbs7GyUl5fDxcUFbdu2laa8vDz89ttvAIDZs2fjlVdewdChQ/Hee+9J7URkvhiIiMisWVhYIC0tDf/+97/RrVs3JCQkwMfHB3l5eQBQ71CUQqFosK22thYAIISAQqFo8LVubu/YsSO6du2KTz/9FJWVlVJ7bW0t3NzckJOTYzSdOnUKr7/+OgAgNjYWx48fx4gRI5Ceno5u3bph27ZtD/5mEFGzYSAiIrOnUCjQv39/xMXF4ZdffoG1tXWjA0a3bt2Qk5ODa9euSW0///wz2rRpgy5dukhtrq6uSE9Px2+//YaxY8eiqqoKANC7d2/odDpYWlqiU6dORpOrq6u0fpcuXfC3v/0NP/74IyIiIrB+/fpGjp6IWgIDERGZtQMHDmDJkiU4dOgQCgoKsHXrVly8eBG+vr6N2t4LL7wAGxsbTJgwAceOHcOuXbswc+ZMREVFQaPRGNWq1Wqkp6fj5MmTeP7551FdXY2hQ4ciMDAQo0ePxg8//ID8/HxkZGTg7bffxqFDh1BRUYEZM2Zg9+7d+P333/Hzzz8jKyur0f0lopbBQEREZs3R0RF79+7F008/jS5duuDtt9/G3//+d4SGhjZqe3Z2dvjhhx9w+fJlPPnkkxgzZgyCgoKQmJjYYL1Wq0V6ejqOHj2KF154AbW1tdi+fTv+/Oc/4+WXX0aXLl0wbtw45OfnQ6PRwMLCApcuXcJLL72ELl26IDIyEqGhoYiLi3uQt4GImplCiP+7dpWIiIhIpriHiIiIiGSPgYiIiIhkj4GIiIiIZI+BiIiIiGSPgYiIiIhkj4GIiIiIZI+BiIiIiGSPgYiIiIhkj4GIiIiIZI+BiIiIiGSPgYiIiIhkj4GIiIiIZO//A/nGDii6Qbc3AAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "import pandas as pd\n", + "\n", + "def visualize_proportions_single(prediction, title):\n", + " # TODO: Make this prettier\n", + " cancer = prediction['cancer'][0]\n", + " smokes = prediction['_RETURN'][0]\n", + "\n", + " data = torch.concat((smokes.reshape(-1, 1), \n", + " cancer.reshape(-1, 1)), axis=-1)\n", + " frame = pd.DataFrame(data.numpy(),\n", + " columns=[\"smokes\", \"cancer\"]).astype(\n", + " \"category\").replace({0:\"0\", 1:\"1\"})\n", + " \n", + " return sns.histplot(x='smokes', hue='cancer', multiple=\"dodge\", shrink=0.7, data=frame).set(title=title)\n", + "\n", + "predictive_fixed = pyro.infer.Predictive(population_causal_model, num_samples=1000, return_sites=(\"cancer\", \"_RETURN\"))\n", + "prediction_fixed = predictive_fixed(n_individuals, stress_pt, smokes_cpt, cancer_cpt)\n", + "\n", + "visualize_proportions_single(prediction_fixed, \"Observational Data - Fixed Parameters\")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As we can see clearly from this simulation, individuals who smoke are much more likely to get cancer than individuals who don't. Of the ~5,000 simulated individuals who smoke ~3600 got cancer, roughly 72% of the smokers. Of the remaining ~5,000 simulated individuals who did not smoke only ~1,200 individuals got cancer, a much lower 24% of the smoking population.\n", + "\n", + "We can also approximate our uncertainty in this conclusion by repeating the process a number of times, each time calculating the proportions of individuals with cancer for smokers and non-smokers." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def visualize_proportions_multiple(prediction, title, position = (0.6, 1)):\n", + " # TODO: make these violin plots with individual data points.\n", + " cancer = prediction['cancer']\n", + " smokes = prediction['_RETURN']\n", + "\n", + " cancer_and_smokes = cancer * smokes\n", + " cancer_given_smokes = cancer_and_smokes.sum(1) / smokes.sum(1)\n", + " cancer_and_not_smokes = cancer * (1 - smokes)\n", + " cancer_given_not_smokes = cancer_and_not_smokes.sum(1) / (1 - smokes).sum(1)\n", + " # TODO: make the smoothing kernel sharper.\n", + " ax = sns.kdeplot(data=cancer_given_not_smokes.detach().numpy(), label=\"Doesn't Smoke\", legend=True)\n", + " sns.kdeplot(data=cancer_given_smokes.detach().numpy(), label=\"Smokes\", ax=ax, legend=True)\n", + " ax.legend(loc='upper left', bbox_to_anchor=position)\n", + " ax.set(xlabel='Proportion of Individuals w/ Cancer', ylabel='Density', title=title, xlim=(0, 1))\n", + " return ax\n", + "\n", + "visualize_proportions_multiple(prediction_fixed, \"Observational Data - Fixed Parameters\")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As we can see clearly, even when simulating many times our model tells us that individuals who smoke are consistently much more likely to get cancer than individuals who don't. In fact, since our model together with the chosen probability tables describe a unique joint distribution over individual attributes, we're only approximating an answer that we could've straightforwardly obtained by hand. Let $c, s, t$ stand for the presence of cancer, smoking and stress, respectively. $P(t \\vert s) = \\frac{P(s\\vert t)P(t)}{P(s)}= .8$, and $P(t\\vert \\neg s ) = \\frac{P(\\neg s \\vert t)P(t)}{P(\\neg s)} = .2$. Then, $P(c\\vert s) = P(c\\vert t, s ) \\times P(t \\vert s) + P(c\\vert t, s) \\times P(\\neg t\\vert s) =.71$, and analogously $P(c\\vert \\neg s) = .24$, which are modes of the empirical distributions shown above. The variance here is only due to the fact that we are simulating a finite population." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "So far we have a program that describes the distribution over data given model parameters. Somewhat more abstractly, we can imagine this process of simulating from a model as we've done above with the following (somewhat cartoonish) diagram. Here, each point in \"model space\" or \"parameter space\" induces a joint distribution over data." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![fig1](figures/Conditional_Distribution_of_Data.png)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Applying an Intervention" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Simulating from our `causal_model` is certainly interesting and informative, but it doesn't exactly tell us what we're interested in. We want to know to what extent smoking *causes* cancer, not just whether smoking is associated with cancer. To answer this question, we can instead sample from a modified version of our model in which individuals are forced to smoke or not smoke, regardless of their level of stress. We can represent these kinds of modifications as **interventions**, and implement them in ChiRho as a special kind of program transformation. Later we'll see how ChiRho helps to automate the application of these kinds of interventions, but to build some intuition let's first walk through what these new programs would look like if we built them by hand instead.\n", + "\n", + "Consider the following new Pyro program; `forced_smokes_model`, which closely resembles our original `causal_model` except in how the *smokes* attribute is assigned. Specifically, we've replaced the expression `smokes = pyro.sample(\"smokes\", Bernoulli(smokes_cpt[stress]))` with the expressions `smokes = pyro.deterministic(\"smokes\", smokes_assignment)`, where `smokes_assignment` is now an argument." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "def forced_smokes_model(stress_pt, smokes_cpt, cancer_cpt, smokes_assignment):\n", + " stress = pyro.sample(\"stress\", Bernoulli(stress_pt))\n", + " # smokes no longer depends on stress.\n", + " smokes = pyro.deterministic(\"smokes\", smokes_assignment)\n", + " cancer = pyro.sample(\"cancer\", Bernoulli(cancer_cpt[stress.int(), smokes.int()]))\n", + " # For now we only return smokes because we need to return a single value for the predictive handler.\n", + " # We need to return smokes because the trace address for `smokes` does not include the interventions.\n", + " # TODO: address this in the future.\n", + " return smokes\n", + " # return stress, smokes, cancer\n", + "\n", + "def population_forced_smokes_model(n_individuals, stress_pt, smokes_cpt, cancer_cpt):\n", + " # Let's imagine that we force half the people to always smoke and half to never smoke.\n", + " smokes_assignment = torch.tensor([0., 1.]).repeat(n_individuals // 2)\n", + " with pyro.plate(\"individuals\", n_individuals, dim=-1):\n", + " return forced_smokes_model(stress_pt, smokes_cpt, cancer_cpt, smokes_assignment)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Simulating Interventional Data with Fixed Parameters" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's visualize a simulation from these new programs (compare this to the previous visualization based on the original simulation). First, one run on a barplot, then the proportions obtained in multiple (1k) runs using a kernel density estimate." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[Text(0.5, 1.0, 'Intervened Data - Fixed Parameters')]" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkQAAAHFCAYAAAAT5Oa6AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA/WUlEQVR4nO3df3zOdf////thvzfbwTb7hdkqdhKpJE0J0VghqbdKLUo6JfoIdZ5OdRoVlTP0JipnrFDUecHZTxrCeeZHrBQaZzppqq0Zsxkz+/H8/tF3r3eHza+17Th43a6Xy+ty8Xq+Hsfr9Xgdx8zd63g9j8NhjDECAACwsQbubgAAAMDdCEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CES4oKWlpcnhcGjbtm3n/djjx48rNTVV69atq/3GLnCpqalyOBxnrRsyZIgcDoe1BAUFKS4uTv369dOCBQtUUlJS4x4+/vhjpaam1vjxteW35/fbJTw8XJLUrVs3devWrd77qulr5Ofnp4SEBE2cOFEnTpyoh07dZ+PGjUpNTdWRI0fc3QouAN7ubgBwl+PHj2vSpEmS5JZ/0C4WAQEBWrt2rSSpuLhYBw4c0CeffKJhw4bppZde0sqVK9WsWbPz3u/HH3+sV155xSNC0Z133qmxY8e6jPn4+EiS5syZ446WzstvX6P8/Hy98847mjx5snbv3q2lS5e6ubu6s3HjRk2aNElDhgxRo0aN3N0OPByBCKhlpaWlcjgc8va2x1+vBg0a6LrrrnMZu//++/XAAw+oT58+uvPOO7V582Y3dVc7IiMjq5xjpTZt2tRzN+fv1NcoOTlZ+/fv17vvvqvp06eradOmNd53eXm5ysrK5OfnVxutXhCOHz+uwMBAd7eBWsZbZrjoDBkyRA0bNtTevXt1yy23qGHDhmrevLnGjh1rvYWzf/9+NWnSRJI0adIk6+2EIUOGWPv57rvvNGjQIEVERMjPz0+tW7fWK6+84nKsdevWyeFwaOHChRo7dqyaNm0qPz8/7dq1Sw6HQ2+88UaV/j755BM5HA69//77NTrWO++8owkTJigmJkYhISHq2bOn9uzZU+U4q1evVo8ePRQSEqLAwEBdf/31WrNmTZW6jz76SFdeeaX8/PwUHx+vv/3tb+f+ZJ9BUlKShg0bpi1btmjDhg3W+NKlS5WUlKTo6GgFBASodevW+vOf/6xjx45ZNUOGDLHO/7dv9+zfv1+S9Morr+jGG29URESEgoKC1K5dO7344osqLS2tld7Px6lvmT3//PNq0KCBPvjgA5e6IUOGKDAwUDt27LDG3PkaVQakH374QQcPHtSIESPUpk0bNWzYUBEREbrpppv0r3/9y+Ux+/fvl8Ph0Isvvqhnn31W8fHx8vPz02effaYTJ05o7NixuvLKK+V0OhUaGqrExET985//rHJsh8OhkSNHasGCBUpISFBAQICuueYabd68WcYYTZs2TfHx8WrYsKFuuukm7d27t8o+zvbcpaam6oknnpAkxcfHWz9Dv32LfOnSpUpMTFRQUJAaNmyoXr166auvvnI5TuXvkx07digpKUnBwcHq0aOHJOmrr75Snz59rL+3MTExuvXWW/Xjjz/W7EWBexngArZgwQIjyWzdutUaGzx4sPH19TWtW7c2f/vb38zq1avNX//6V+NwOMykSZOMMcacOHHCrFy50kgyQ4cONZs2bTKbNm0ye/fuNcYYs2vXLuN0Ok27du3MW2+9ZT799FMzduxY06BBA5Oammod67PPPjOSTNOmTc2dd95p3n//ffPhhx+aQ4cOmauuuspcf/31VXoeOHCgiYiIMKWlpTU6VlxcnLn33nvNRx99ZN555x0TGxtrWrZsacrKyqzahQsXGofDYfr372+WLVtmPvjgA9OnTx/j5eVlVq9ebdWtXr3aeHl5mRtuuMEsW7bMvPfee6Zjx44mNjbWnMuvh8GDB5ugoKDTbq98jp955hlr7JlnnjEzZswwH330kVm3bp159dVXTXx8vOnevbtVs3fvXnPnnXcaSdZrs2nTJnPixAljjDGPP/64mTt3rlm5cqVZu3atmTFjhgkPDzcPPPDAWXs+X5LMiBEjTGlpqctSUVFhjDGma9eupmvXrlZ9RUWFueWWW0zjxo3N/v37jTHGzJ8/30gyf//73606d79Gt99+u5Fk/vOf/5jdu3ebRx55xCxZssSsW7fOfPjhh2bo0KGmQYMG5rPPPrMes2/fPuvnvXv37uYf//iH+fTTT82+ffvMkSNHzJAhQ8zChQvN2rVrzcqVK824ceNMgwYNzJtvvlnlOW3RooXp3LmzWbZsmVm+fLlp1aqVCQ0NNY8//ri57bbbzIcffmgWL15sIiMjzRVXXGE93+f63B04cMCMGjXKSDLLli2zfoYKCgqMMcY899xzxuFwmAcffNB8+OGHZtmyZSYxMdEEBQWZXbt2uTx/Pj4+Ji4uzkydOtWsWbPGrFq1yhQVFZmwsDBzzTXXmHfffdesX7/eLF261AwfPtx8++23Z31d4HkIRLignS4QSTLvvvuuS+0tt9xiEhISrPWDBw8aSWbixIlV9turVy/TrFkz65dnpZEjRxp/f39z+PBhY8z/hZQbb7yxyj7+93//10gye/bsscYOHz5s/Pz8zNixY2t8rFtuucWl7t1337WCgzHGHDt2zISGhpq+ffu61JWXl5v27duba6+91hrr1KmTiYmJMcXFxdZYYWGhCQ0NrZVAlJmZaSSZRx55pNrtFRUVprS01Kxfv95IMl9//bW17dFHHz2nHsrLy01paal56623jJeXl/V81RZJ1S7z5s0zxlQNRMYYk5eXZ5o1a2auvfZa8+WXX5rAwEBz3333Wdvd8RpVBrmDBw+al19+2TgcDtOxY8dqH1NWVmZKS0tNjx49zO23326NVwaiSy+91Jw8efKMx63cx9ChQ81VV13lsk2SiYqKMkVFRdbYihUrjCRz5ZVXuoSfmTNnGknmm2++Mcac33M3bdo0I8ns27fPpTYrK8t4e3ubUaNGuYwfPXrUREVFmYEDB1pjlb9P5s+f71K7bds2I8msWLHijM8DLhy8ZYaLksPhUN++fV3GrrjiCv3www9nfeyJEye0Zs0a3X777QoMDFRZWZm13HLLLTpx4kSVe2LuuOOOKvu599575efnp7S0NGvsnXfeUUlJiR544IEaH6tfv35VzkuSdW4bN27U4cOHNXjwYJf9VVRUqHfv3tq6dauOHTumY8eOaevWrRowYID8/f2t/QUHB1d57mrKGFNl7L///a8GDRqkqKgoeXl5ycfHR127dpUkZWZmntN+v/rqK/Xr109hYWHWPu6//36Vl5frP//5zxkf+9vnpKysrNoeTzVw4EBt3brVZenfv/9p68PCwrR06VJ9+eWX6ty5s2JjY/Xqq69a2+v7NTp27Jh8fHzk4+OjJk2aaPTo0UpOTtby5cutmldffVVXX321/P395e3tLR8fH61Zs6ba16Rfv37WTeW/9d577+n6669Xw4YNrX288cYb1e6je/fuCgoKstZbt24t6df7m347e65y/Hx/vs9k1apVKisr0/333++yD39/f3Xt2rXamaen/h2/7LLL1LhxY/3pT3/Sq6++qm+//faMx4Tns8ddn7CdwMBAl39AJMnPz++cphkfOnRIZWVlmjVrlmbNmlVtTV5enst6dHR0lZrQ0FD169dPb731lp555hl5eXkpLS1N1157rS6//PIaHyssLKzKeUm/zvCSpF9++UXSrzOjTufw4cNyOByqqKhQVFRUle3VjdVE5T9iMTExkqSioiJ16dJF/v7+evbZZ9WqVSsFBgbqwIEDGjBggHUOZ5KVlaUuXbooISFBL7/8suLi4uTv768vvvhCjz766Bn3sX//fsXHx7uMffbZZ2edZdikSRNdc801Z+3ttzp16qTLL79cX3/9tR555BGXf/zr+zUKCAiw7uPy8/NTixYtFBISYm2fPn26xo4dq+HDh+uZZ55ReHi4vLy89PTTT1cbZqr7eV+2bJkGDhyo//mf/9ETTzyhqKgoeXt7a+7cuZo/f36V+tDQUJd1X1/fM45X/t091+fut8/3qSr30bFjx2q3N2jgeq0gMDDQ5fmSJKfTqfXr1+u5557TX/7yF+Xn5ys6OlrDhg3TU089VW1ghGcjEAGnaNy4sby8vJSSkqJHH3202ppT/1E93efBPPDAA3rvvfeUnp6u2NhYbd26VXPnzv1dxzqbys/HmTVr1mlnRkVGRlqz4XJycqpsr26sJipvHK8MHGvXrtXPP/+sdevWWVeFJJ3X58SsWLFCx44d07Jly9SiRQtrfPv27Wd9bExMjLZu3eoylpCQcM7HPh8TJ07Ujh071KFDB/31r39Vnz59dMkll0iq/9eoQYMGZwx0ixYtUrdu3Vx+NiXp6NGj1dZX9/O+aNEixcfHa+nSpS7bf89nUVXnXJ+7c9nHP/7xD5efodM53d/vdu3aacmSJTLG6JtvvlFaWpomT56sgIAA/fnPfz7rfuFZCESwrVOvrFQKDAxU9+7d9dVXX+mKK66w/odaE0lJSWratKkWLFig2NhY+fv765577qmTY1W6/vrr1ahRI3377bcaOXLkaet8fX117bXXatmyZZo2bZp1Re3o0aNVZkjVRHp6uv7+97+rc+fOuuGGGyT93z8sp07Rfu2116o8/revT0BAgDVe3T6MMZo3b95Ze/L19T3vKz01kZ6erqlTp+qpp57S6NGjdeWVV+quu+7S559/Ll9fX495jSpVfmDjb33zzTfatGmTmjdvfs778PX1dQkPOTk51c4y+z3O9bmTTv93vFevXvL29tb3339f7dvd58vhcKh9+/aaMWOG0tLS9OWXX/7ufaL+EYhgW8HBwWrRooX++c9/qkePHgoNDVV4eLji4uL08ssv64YbblCXLl30yCOPKC4uTkePHtXevXv1wQcfWB9ydzZeXl66//77NX36dIWEhGjAgAFyOp0uNbV1rEoNGzbUrFmzNHjwYB0+fFh33nmnIiIidPDgQX399dc6ePCgdSXgmWeeUe/evXXzzTdr7NixKi8v1wsvvKCgoCAdPnz4nI5XUVFh3edUUlKirKwsffLJJ3r33XfVunVrvfvuu1Zt586d1bhxYw0fPlwTJ06Uj4+PFi9erK+//rrKftu1aydJeuGFF5ScnCwvLy9dccUVuvnmm+Xr66t77rlHTz75pE6cOKG5c+cqPz//vJ6nupKdna377rtPXbt21cSJE9WgQQMtXbpUN954o5588knNnDmz3l+js+nTp4+eeeYZTZw4UV27dtWePXs0efJkxcfHq6ys7Jz3sWzZMo0YMUJ33nmnDhw4oGeeeUbR0dH67rvvaqVP6fx+vit/hl5++WUNHjxYPj4+SkhIUFxcnCZPnqwJEybov//9r3r37q3GjRvrl19+0RdffKGgoCDrQ1tP58MPP9ScOXPUv39/XXLJJTLGaNmyZTpy5IhuvvnmWjtf1CO33tIN/E6nm2VW3cyniRMnVpmVs3r1anPVVVcZPz8/I8kMHjzY2rZv3z7z4IMPmqZNmxofHx/TpEkT07lzZ/Pss89aNZUzv957773T9vif//zHmpmUnp5ebc3vOVblzJ8FCxa4jK9fv97ceuutJjQ01Pj4+JimTZuaW2+9tcrj33//fXPFFVcYX19fExsba55//vlqn6vqVM7AqVwCAgJMbGys6du3r5k/f74pKSmp8piNGzeaxMREExgYaJo0aWIeeugh8+WXX1Y5h5KSEvPQQw+ZJk2aGIfD4TJb6IMPPjDt27c3/v7+pmnTpuaJJ54wn3zyiZHkMk28Nkgyjz766Gm3/3aWWVlZmenatauJjIw02dnZLnWVM56WL19ujdXXa3SmmYDG/Ppcjxs3zjRt2tT4+/ubq6++2qxYscIMHjzYtGjRwqqr/FmbNm1atft5/vnnTVxcnPHz8zOtW7c28+bNq7bP6p7T0+37dD/35/rcjR8/3sTExJgGDRpU+flYsWKF6d69uwkJCTF+fn6mRYsW5s4773T52IPTPX+7d+8299xzj7n00ktNQECAcTqd5tprrzVpaWnVPjfwfA5jzmGKBQAAwEWMafcAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2+GDGc1RRUaGff/5ZwcHBp/0YdwAA4FmMMTp69KhiYmKqfE/dbxGIztHPP/98zh9hDwAAPMuBAwfUrFmz024nEJ2j4OBgSb8+oad+6zEAAPBMhYWFat68ufXv+OkQiM5R5dtkISEhBCIAAC4wZ7vdhZuqAQCA7RGIAACA7RGIAACA7RGIAACA7RGIAACA7RGIAACA7RGIAACA7RGIAACA7RGIAACA7RGIAACA7RGIAACA7RGIAACA7RGIAACA7RGIAACA7Xm7uwFIWVlZysvLc3cbthIeHq7Y2Fh3twEA8BAEIjfLysrSH/7QWsXFx93diq0EBARq9+5MQhEAQBKByO3y8vJUXHxcnR6cqJDoOHe3YwuF2fu1Zf4k5eXlEYgAAJIIRB4jJDpOobEJ7m4DAABb4qZqAABgewQiAABgewQiAABgewQiAABgewQiAABgewQiAABgewQiAABgewQiAABgewQiAABgewQiAABgewQiAABgewQiAABgewQiAABgewQiAABgewQiAABgewQiAABgewQiAABgewQiAABgewQiAABgewQiAABge97ubgAAcHZZWVnKy8tzdxu2ER4ertjYWHe3gXpEIAIAD5eVlaU//KG1iouPu7sV2wgICNTu3ZmEIhtxayCaOnWqli1bpt27dysgIECdO3fWCy+8oISEBKtmyJAhevPNN10e16lTJ23evNlaLykp0bhx4/TOO++ouLhYPXr00Jw5c9SsWTOrJj8/X4899pjef/99SVK/fv00a9YsNWrUqG5PEgB+p7y8PBUXH1enBycqJDrO3e1c9Aqz92vL/EnKy8sjENmIWwPR+vXr9eijj6pjx44qKyvThAkTlJSUpG+//VZBQUFWXe/evbVgwQJr3dfX12U/o0eP1gcffKAlS5YoLCxMY8eOVZ8+fZSRkSEvLy9J0qBBg/Tjjz9q5cqVkqSHH35YKSkp+uCDD+rhTAHg9wuJjlNobMLZCwGcN7cGospwUmnBggWKiIhQRkaGbrzxRmvcz89PUVFR1e6joKBAb7zxhhYuXKiePXtKkhYtWqTmzZtr9erV6tWrlzIzM7Vy5Upt3rxZnTp1kiTNmzdPiYmJ2rNnj8sVKQAAYD8eNcusoKBAkhQaGuoyvm7dOkVERKhVq1YaNmyYcnNzrW0ZGRkqLS1VUlKSNRYTE6O2bdtq48aNkqRNmzbJ6XRaYUiSrrvuOjmdTqvmVCUlJSosLHRZAADAxcljApExRmPGjNENN9ygtm3bWuPJyclavHix1q5dq5deeklbt27VTTfdpJKSEklSTk6OfH191bhxY5f9RUZGKicnx6qJiIiocsyIiAir5lRTp06V0+m0lubNm9fWqQIAAA/jMbPMRo4cqW+++Ub//ve/Xcbvuusu689t27bVNddcoxYtWuijjz7SgAEDTrs/Y4wcDoe1/ts/n67mt8aPH68xY8ZY64WFhYQiAAAuUh5xhWjUqFF6//339dlnn7nMDKtOdHS0WrRooe+++06SFBUVpZMnTyo/P9+lLjc3V5GRkVbNL7/8UmVfBw8etGpO5efnp5CQEJcFAABcnNwaiIwxGjlypJYtW6a1a9cqPj7+rI85dOiQDhw4oOjoaElShw4d5OPjo/T0dKsmOztbO3fuVOfOnSVJiYmJKigo0BdffGHVbNmyRQUFBVYNAACwL7e+Zfboo4/q7bff1j//+U8FBwdb9/M4nU4FBASoqKhIqampuuOOOxQdHa39+/frL3/5i8LDw3X77bdbtUOHDtXYsWMVFham0NBQjRs3Tu3atbNmnbVu3Vq9e/fWsGHD9Nprr0n6ddp9nz59mGEGAKhWZmamu1uwFXd/OrhbA9HcuXMlSd26dXMZX7BggYYMGSIvLy/t2LFDb731lo4cOaLo6Gh1795dS5cuVXBwsFU/Y8YMeXt7a+DAgdYHM6alpVmfQSRJixcv1mOPPWbNRuvXr59mz55d9ycJALiglJaclCTdd999bu7EXgID/JW5e4/bQpFbA5Ex5ozbAwICtGrVqrPux9/fX7NmzdKsWbNOWxMaGqpFixadd48AAHspKyuTJD0zoJVuaVd1hjJqX2Z2ke57fbtbPx3cY2aZAQDgSeLDA3V1nNPdbaCeeMQsMwAAAHciEAEAANsjEAEAANsjEAEAANsjEAEAANsjEAEAANsjEAEAANsjEAEAANsjEAEAANsjEAEAANsjEAEAANsjEAEAANsjEAEAANsjEAEAANsjEAEAANsjEAEAANsjEAEAANsjEAEAANsjEAEAANsjEAEAANvzdncDgLtkZma6uwVbCQ8PV2xsrLvbAIBqEYhgO6UlJyVJ9913n5s7sZfAAH9l7t5DKALgkQhEsJ2ysjJJ0jMDWumWdhFu7sYeMrOLdN/r25WXl0cgAuCRCESwrfjwQF0d53R3GwAAD8BN1QAAwPYIRAAAwPYIRAAAwPYIRAAAwPYIRAAAwPYIRAAAwPYIRAAAwPYIRAAAwPYIRAAAwPYIRAAAwPYIRAAAwPYIRAAAwPYIRAAAwPYIRAAAwPYIRAAAwPYIRAAAwPYIRAAAwPYIRAAAwPYIRAAAwPYIRAAAwPYIRAAAwPYIRAAAwPYIRAAAwPYIRAAAwPYIRAAAwPYIRAAAwPYIRAAAwPYIRAAAwPbcGoimTp2qjh07Kjg4WBEREerfv7/27NnjUmOMUWpqqmJiYhQQEKBu3bpp165dLjUlJSUaNWqUwsPDFRQUpH79+unHH390qcnPz1dKSoqcTqecTqdSUlJ05MiRuj5FAABwAXBrIFq/fr0effRRbd68Wenp6SorK1NSUpKOHTtm1bz44ouaPn26Zs+era1btyoqKko333yzjh49atWMHj1ay5cv15IlS/Tvf/9bRUVF6tOnj8rLy62aQYMGafv27Vq5cqVWrlyp7du3KyUlpV7PFwAAeCZvdx585cqVLusLFixQRESEMjIydOONN8oYo5kzZ2rChAkaMGCAJOnNN99UZGSk3n77bf3xj39UQUGB3njjDS1cuFA9e/aUJC1atEjNmzfX6tWr1atXL2VmZmrlypXavHmzOnXqJEmaN2+eEhMTtWfPHiUkJNTviQMAAI/iUfcQFRQUSJJCQ0MlSfv27VNOTo6SkpKsGj8/P3Xt2lUbN26UJGVkZKi0tNSlJiYmRm3btrVqNm3aJKfTaYUhSbruuuvkdDqtmlOVlJSosLDQZQEAABcnjwlExhiNGTNGN9xwg9q2bStJysnJkSRFRka61EZGRlrbcnJy5Ovrq8aNG5+xJiIiosoxIyIirJpTTZ061brfyOl0qnnz5r/vBAEAgMfymEA0cuRIffPNN3rnnXeqbHM4HC7rxpgqY6c6taa6+jPtZ/z48SooKLCWAwcOnMtpAACAC5BHBKJRo0bp/fff12effaZmzZpZ41FRUZJU5SpObm6uddUoKipKJ0+eVH5+/hlrfvnllyrHPXjwYJWrT5X8/PwUEhLisgAAgIuTWwORMUYjR47UsmXLtHbtWsXHx7tsj4+PV1RUlNLT062xkydPav369ercubMkqUOHDvLx8XGpyc7O1s6dO62axMREFRQU6IsvvrBqtmzZooKCAqsGAADYl1tnmT366KN6++239c9//lPBwcHWlSCn06mAgAA5HA6NHj1aU6ZMUcuWLdWyZUtNmTJFgYGBGjRokFU7dOhQjR07VmFhYQoNDdW4cePUrl07a9ZZ69at1bt3bw0bNkyvvfaaJOnhhx9Wnz59mGEGAADcG4jmzp0rSerWrZvL+IIFCzRkyBBJ0pNPPqni4mKNGDFC+fn56tSpkz799FMFBwdb9TNmzJC3t7cGDhyo4uJi9ejRQ2lpafLy8rJqFi9erMcee8yajdavXz/Nnj27bk8QAABcENwaiIwxZ61xOBxKTU1VamrqaWv8/f01a9YszZo167Q1oaGhWrRoUU3aBAAAFzmPuKkaAADAnQhEAADA9ghEAADA9ghEAADA9ghEAADA9ghEAADA9ghEAADA9ghEAADA9ghEAADA9ghEAADA9ghEAADA9ghEAADA9ghEAADA9ghEAADA9ghEAADA9ghEAADA9ghEAADA9ghEAADA9ghEAADA9ghEAADA9ghEAADA9ghEAADA9ghEAADA9ghEAADA9ghEAADA9ghEAADA9ghEAADA9ghEAADA9ghEAADA9ghEAADA9ghEAADA9ghEAADA9ghEAADA9ghEAADA9ghEAADA9ghEAADA9ghEAADA9ghEAADA9ghEAADA9ghEAADA9ghEAADA9ghEAADA9ghEAADA9ghEAADA9ghEAADA9ghEAADA9ghEAADA9ghEAADA9ghEAADA9moUiC655BIdOnSoyviRI0d0ySWX/O6mAAAA6lONAtH+/ftVXl5eZbykpEQ//fTT724KAACgPnmfT/H7779v/XnVqlVyOp3Wenl5udasWaO4uLhaaw4AAKA+nFcg6t+/vyTJ4XBo8ODBLtt8fHwUFxenl156qdaaAwAAqA/nFYgqKiokSfHx8dq6davCw8PrpCkAAID6VKN7iPbt21crYWjDhg3q27evYmJi5HA4tGLFCpftQ4YMkcPhcFmuu+46l5qSkhKNGjVK4eHhCgoKUr9+/fTjjz+61OTn5yslJUVOp1NOp1MpKSk6cuTI7+4fAABcHM7rCtFvrVmzRmvWrFFubq515ajS/Pnzz2kfx44dU/v27fXAAw/ojjvuqLamd+/eWrBggbXu6+vrsn306NH64IMPtGTJEoWFhWns2LHq06ePMjIy5OXlJUkaNGiQfvzxR61cuVKS9PDDDyslJUUffPDBOZ8vAAC4eNUoEE2aNEmTJ0/WNddco+joaDkcjhodPDk5WcnJyWes8fPzU1RUVLXbCgoK9MYbb2jhwoXq2bOnJGnRokVq3ry5Vq9erV69eikzM1MrV67U5s2b1alTJ0nSvHnzlJiYqD179ighIaFGvQMAgItHjQLRq6++qrS0NKWkpNR2P1WsW7dOERERatSokbp27arnnntOERERkqSMjAyVlpYqKSnJqo+JiVHbtm21ceNG9erVS5s2bZLT6bTCkCRdd911cjqd2rhx42kDUUlJiUpKSqz1wsLCOjpDAADgbjW6h+jkyZPq3LlzbfdSRXJyshYvXqy1a9fqpZde0tatW3XTTTdZQSUnJ0e+vr5q3Lixy+MiIyOVk5Nj1VQGqN+KiIiwaqozdepU654jp9Op5s2b1+KZAQAAT1KjQPTQQw/p7bffru1eqrjrrrt06623qm3bturbt68++eQT/ec//9FHH310xscZY1zexqvuLb1Ta041fvx4FRQUWMuBAwdqfiIAAMCj1egtsxMnTuj111/X6tWrdcUVV8jHx8dl+/Tp02uluVNFR0erRYsW+u677yRJUVFROnnypPLz812uEuXm5lpXsKKiovTLL79U2dfBgwcVGRl52mP5+fnJz8+vls8AAAB4ohpdIfrmm2905ZVXqkGDBtq5c6e++uora9m+fXstt/h/Dh06pAMHDig6OlqS1KFDB/n4+Cg9Pd2qyc7O1s6dO61AlJiYqIKCAn3xxRdWzZYtW1RQUFAvb/sBAADPV6MrRJ999lmtHLyoqEh79+611vft26ft27crNDRUoaGhSk1N1R133KHo6Gjt379ff/nLXxQeHq7bb79dkuR0OjV06FCNHTtWYWFhCg0N1bhx49SuXTtr1lnr1q3Vu3dvDRs2TK+99pqkX6fd9+nThxlmAABA0u/4HKLasG3bNnXv3t1aHzNmjCRp8ODBmjt3rnbs2KG33npLR44cUXR0tLp3766lS5cqODjYesyMGTPk7e2tgQMHqri4WD169FBaWpr1GUSStHjxYj322GPWbLR+/fpp9uzZ9XSWAADA09UoEHXv3v2MNySvXbv2nPbTrVs3GWNOu33VqlVn3Ye/v79mzZqlWbNmnbYmNDRUixYtOqeeAACA/dQoEF155ZUu66Wlpdq+fbt27txZ5UtfAQAAPF2NAtGMGTOqHU9NTVVRUdHvaggAAKC+1WiW2encd9995/w9ZgAAAJ6iVgPRpk2b5O/vX5u7BAAAqHM1estswIABLuvGGGVnZ2vbtm16+umna6UxAACA+lKjQOR0Ol3WGzRooISEBE2ePNnli1YBAAAuBDUKRAsWLKjtPgAAANzmd30wY0ZGhjIzM+VwONSmTRtdddVVtdUXAABAvalRIMrNzdXdd9+tdevWqVGjRjLGqKCgQN27d9eSJUvUpEmT2u4TAACgztRoltmoUaNUWFioXbt26fDhw8rPz9fOnTtVWFioxx57rLZ7BAAAqFM1ukK0cuVKrV69Wq1bt7bG2rRpo1deeYWbqgEAwAWnRleIKioq5OPjU2Xcx8dHFRUVv7spAACA+lSjQHTTTTfp//2//6eff/7ZGvvpp5/0+OOPq0ePHrXWHAAAQH2oUSCaPXu2jh49qri4OF166aW67LLLFB8fr6NHj57xW+cBAAA8UY3uIWrevLm+/PJLpaena/fu3TLGqE2bNurZs2dt9wcAAFDnzusK0dq1a9WmTRsVFhZKkm6++WaNGjVKjz32mDp27KjLL79c//rXv+qkUQAAgLpyXoFo5syZGjZsmEJCQqpsczqd+uMf/6jp06fXWnMAAAD14bwC0ddff63evXufdntSUpIyMjJ+d1MAAAD16bwC0S+//FLtdPtK3t7eOnjw4O9uCgAAoD6dVyBq2rSpduzYcdrt33zzjaKjo393UwAAAPXpvALRLbfcor/+9a86ceJElW3FxcWaOHGi+vTpU2vNAQAA1Ifzmnb/1FNPadmyZWrVqpVGjhyphIQEORwOZWZm6pVXXlF5ebkmTJhQV70CAADUifMKRJGRkdq4caMeeeQRjR8/XsYYSZLD4VCvXr00Z84cRUZG1kmjAAAAdeW8P5ixRYsW+vjjj5Wfn6+9e/fKGKOWLVuqcePGddEfAABAnavRJ1VLUuPGjdWxY8fa7AUAAMAtavRdZgAAABcTAhEAALA9AhEAALA9AhEAALA9AhEAALA9AhEAALA9AhEAALA9AhEAALA9AhEAALA9AhEAALA9AhEAALA9AhEAALA9AhEAALA9AhEAALA9AhEAALA9AhEAALA9AhEAALA9AhEAALA9AhEAALA9AhEAALA9AhEAALA9AhEAALA9AhEAALA9AhEAALA9AhEAALA9AhEAALA9AhEAALA9AhEAALA9twaiDRs2qG/fvoqJiZHD4dCKFStcthtjlJqaqpiYGAUEBKhbt27atWuXS01JSYlGjRql8PBwBQUFqV+/fvrxxx9davLz85WSkiKn0ymn06mUlBQdOXKkjs8OAABcKNwaiI4dO6b27dtr9uzZ1W5/8cUXNX36dM2ePVtbt25VVFSUbr75Zh09etSqGT16tJYvX64lS5bo3//+t4qKitSnTx+Vl5dbNYMGDdL27du1cuVKrVy5Utu3b1dKSkqdnx8AALgweLvz4MnJyUpOTq52mzFGM2fO1IQJEzRgwABJ0ptvvqnIyEi9/fbb+uMf/6iCggK98cYbWrhwoXr27ClJWrRokZo3b67Vq1erV69eyszM1MqVK7V582Z16tRJkjRv3jwlJiZqz549SkhIqJ+TBQAAHstj7yHat2+fcnJylJSUZI35+fmpa9eu2rhxoyQpIyNDpaWlLjUxMTFq27atVbNp0yY5nU4rDEnSddddJ6fTadUAAAB7c+sVojPJycmRJEVGRrqMR0ZG6ocffrBqfH191bhx4yo1lY/PyclRRERElf1HRERYNdUpKSlRSUmJtV5YWFizEwEAAB7PY68QVXI4HC7rxpgqY6c6taa6+rPtZ+rUqdZN2E6nU82bNz/PzgEAwIXCYwNRVFSUJFW5ipObm2tdNYqKitLJkyeVn59/xppffvmlyv4PHjxY5erTb40fP14FBQXWcuDAgd91PgAAwHN5bCCKj49XVFSU0tPTrbGTJ09q/fr16ty5sySpQ4cO8vHxcanJzs7Wzp07rZrExEQVFBToiy++sGq2bNmigoICq6Y6fn5+CgkJcVkAAMDFya33EBUVFWnv3r3W+r59+7R9+3aFhoYqNjZWo0eP1pQpU9SyZUu1bNlSU6ZMUWBgoAYNGiRJcjqdGjp0qMaOHauwsDCFhoZq3LhxateunTXrrHXr1urdu7eGDRum1157TZL08MMPq0+fPswwAwAAktwciLZt26bu3btb62PGjJEkDR48WGlpaXryySdVXFysESNGKD8/X506ddKnn36q4OBg6zEzZsyQt7e3Bg4cqOLiYvXo0UNpaWny8vKyahYvXqzHHnvMmo3Wr1+/0372EQAAsB+3BqJu3brJGHPa7Q6HQ6mpqUpNTT1tjb+/v2bNmqVZs2adtiY0NFSLFi36Pa0CAICLmMfeQwQAAFBfCEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2vN3dAABUp7y8XKWlpe5uo074+PjIy8vL3W0A+A0CEQCPYoxRTk6Ojhw54u5W6lSjRo0UFRUlh8Ph7lYAiEAEwMNUhqGIiAgFBgZedIHBGKPjx48rNzdXkhQdHe3mjgBIBCIAHqS8vNwKQ2FhYe5up84EBARIknJzcxUREcHbZ4AH4KZqAB6j8p6hwMBAN3dS9yrP8WK9Twq40BCIAHici+1tsurY4RyBC4lHB6LU1FQ5HA6XJSoqytpujFFqaqpiYmIUEBCgbt26adeuXS77KCkp0ahRoxQeHq6goCD169dPP/74Y32fCgAA8GAeHYgk6fLLL1d2dra17Nixw9r24osvavr06Zo9e7a2bt2qqKgo3XzzzTp69KhVM3r0aC1fvlxLlizRv//9bxUVFalPnz4qLy93x+kAAAAP5PE3VXt7e7tcFapkjNHMmTM1YcIEDRgwQJL05ptvKjIyUm+//bb++Mc/qqCgQG+88YYWLlyonj17SpIWLVqk5s2ba/Xq1erVq1e9ngsAAPBMHn+F6LvvvlNMTIzi4+N1991367///a8kad++fcrJyVFSUpJV6+fnp65du2rjxo2SpIyMDJWWlrrUxMTEqG3btlbN6ZSUlKiwsNBlAYDzdfLkSXe3AOAceHQg6tSpk9566y2tWrVK8+bNU05Ojjp37qxDhw4pJydHkhQZGenymMjISGtbTk6OfH191bhx49PWnM7UqVPldDqtpXnz5rV4ZgBqqqKiQi+88IIuu+wy+fn5KTY2Vs8995wk6U9/+pNatWqlwMBAXXLJJXr66addZnGlpqbqyiuv1MKFCxUXFyen06m7777b5W32M+1fkn766Sfdddddaty4scLCwnTbbbdp//791vYhQ4aof//+mjp1qmJiYtSqVau6f1IA/G4e/ZZZcnKy9ed27dopMTFRl156qd58801dd911kqrO1DDGnHX2xrnUjB8/XmPGjLHWCwsLCUWABxg/frzmzZunGTNm6IYbblB2drZ2794tSQoODlZaWppiYmK0Y8cODRs2TMHBwXryySetx3///fdasWKFPvzwQ+Xn52vgwIF6/vnnrdBzpv0fP35c3bt3V5cuXbRhwwZ5e3vr2WefVe/evfXNN9/I19dXkrRmzRqFhIQoPT1dxph6foYA1IRHB6JTBQUFqV27dvruu+/Uv39/Sb9eBfrtJ73m5uZaV42ioqJ08uRJ5efnu1wlys3NVefOnc94LD8/P/n5+dX+SQCosaNHj+rll1/W7NmzNXjwYEnSpZdeqhtuuEGS9NRTT1m1cXFxGjt2rJYuXeoSiCoqKpSWlqbg4GBJUkpKitasWaPnnnvurPtfsmSJGjRooL///e/Wf6oWLFigRo0aad26ddbb80FBQfr73/9uBSQAns+j3zI7VUlJiTIzMxUdHa34+HhFRUUpPT3d2n7y5EmtX7/eCjsdOnSQj4+PS012drZ27tx51kAEwPNkZmaqpKREPXr0qHb7P/7xD91www2KiopSw4YN9fTTTysrK8ulJi4uzgpD0q9fnVH5NRpn239GRob27t2r4OBgNWzYUA0bNlRoaKhOnDih77//3qpr164dYQi4wHj0FaJx48apb9++io2NVW5urp599lkVFhZq8ODBcjgcGj16tKZMmaKWLVuqZcuWmjJligIDAzVo0CBJktPp1NChQzV27FiFhYUpNDRU48aNU7t27axZZwAuHJVfeVGdzZs36+6779akSZPUq1cvOZ1OLVmyRC+99JJLnY+Pj8u6w+FQRUXFWfcv/Xp1qUOHDlq8eHGVbU2aNLH+HBQUdNZzAeBZPDoQ/fjjj7rnnnuUl5enJk2a6LrrrtPmzZvVokULSdKTTz6p4uJijRgxQvn5+erUqZM+/fRTl//9zZgxQ97e3ho4cKCKi4vVo0cPpaWl8d1BwAWoZcuWCggI0Jo1a/TQQw+5bPv888/VokULTZgwwRr74Ycfam3/knT11Vdr6dKlioiIUEhISM1OAoBH8uhAtGTJkjNudzgcSk1NVWpq6mlr/P39NWvWLM2aNauWuwNQ3/z9/fWnP/1JTz75pHx9fXX99dfr4MGD2rVrly677DJlZWVpyZIl6tixoz766CMtX7681vY/dOhQ3XvvvZo2bZpuu+02TZ48Wc2aNVNWVpaWLVumJ554Qs2aNaujMwdQ1zw6EAHAqZ5++ml5e3vrr3/9q37++WdFR0dr+PDhGjp0qB5//HGNHDlSJSUluvXWW/X000+f8T9M57N/6dcvZN2wYYP+9Kc/acCAATp69KiaNm2qHj16cMUIuMARiABcUBo0aKAJEya4vDVW6cUXX9SLL77oMjZ69Gjrz9VdUR49erRLzZn2L/06e/XNN988bX9paWlnPQcAnueCmmUGAABQFwhEAADA9ghEAADA9ghEAADA9ghEAADA9ghEAADA9ghEAADA9ghEAADA9ghEAADA9vikagAXhKysLOXl5dXb8cLDwxUbG3vej5szZ46mTZum7OxsXX755Zo5c6a6dOlSBx0CqE0EIgAeLysrS3/4Q2sVFx+vt2MGBARq9+7M8wpFS5cu1ejRozVnzhxdf/31eu2115ScnKxvv/22RuEKQP0hEAHweHl5eSouPq5OD05USHRcnR+vMHu/tsyfpLy8vPMKMtOnT9fQoUP10EMPSZJmzpypVatWae7cuZo6dWpdtQugFhCIAFwwQqLjFBqb4O42qnXy5EllZGToz3/+s8t4UlKSNm7c6KauAJwrbqoGgFqQl5en8vJyRUZGuoxHRkYqJyfHTV0BOFcEIgCoRQ6Hw2XdGFNlDIDnIRABQC0IDw+Xl5dXlatBubm5Va4aAfA8BCIAqAW+vr7q0KGD0tPTXcbT09PVuXNnN3UF4FxxUzUA1JIxY8YoJSVF11xzjRITE/X6668rKytLw4cPd3drAM6CQATgglGYvd+jj3PXXXfp0KFDmjx5srKzs9W2bVt9/PHHatGiRe02CKDWEYgAeLzw8HAFBARqy/xJ9XbMgIBAhYeHn/fjRowYoREjRtRBRwDqEoEIgMeLjY3V7t2ZF8RXdwC4MBGIAFwQYmNjCSgA6gyzzAAAgO0RiAAAgO0RiAAAgO0RiAAAgO0RiAAAgO0RiAAAgO0RiAAAgO0RiAAAgO3xwYwALghZWVke/UnVGzZs0LRp05SRkaHs7GwtX75c/fv3r7sGAdQqAhEAj5eVlaXWf0jQ8eIT9XbMwAB/Ze7ec86h6NixY2rfvr0eeOAB3XHHHXXcHYDaRiAC4PHy8vJ0vPiEFj18pVpHN6zz42VmF+m+17crLy/vnANRcnKykpOT67gzAHWFQATggtE6uqGujnO6uw0AFyFuqgYAALZHIAIAALZHIAIAALZHIAIAALbHTdUAUAuKioq0d+9ea33fvn3avn27QkNDz+vzjAC4B4EIwAUjM7vIY4+zbds2de/e3VofM2aMJGnw4MFKS0urrdYA1BECEQCPFx4ersAAf933+vZ6O2ZggL/Cw8PPub5bt24yxtRhRwDqEoEIgMeLjY1V5u49Hv3VHQAubAQiABeE2NhYAgqAOsMsMwAAYHsEIgAAYHsEIgAAYHsEIgAexw6ztexwjsCFhEAEwGP4+PhIko4fP+7mTupe5TlWnjMA92KWGQCP4eXlpUaNGik3N1eSFBgYKIfD4eauapcxRsePH1dubq4aNWokLy8vd7cEQAQiAB4mKipKkqxQdLFq1KiRda4A3I9ABMCjOBwORUdHKyIiQqWlpe5up074+PhwZQjwMLYKRHPmzNG0adOUnZ2tyy+/XDNnzlSXLl3c3RaAanh5eREaANQb29xUvXTpUo0ePVoTJkzQV199pS5duig5OVlZWVnubg0AALiZbQLR9OnTNXToUD300ENq3bq1Zs6cqebNm2vu3Lnubg0AALiZLQLRyZMnlZGRoaSkJJfxpKQkbdy40U1dAQAAT2GLe4jy8vJUXl6uyMhIl/HIyEjl5ORU+5iSkhKVlJRY6wUFBZKkwsLCWu2tqKhIknT4hz0qKymu1X2jegU/fSdJysw+qg17Drm5G3vYk3NM0q8/77X9d8gO+D1Rv/gdUf/q8ndE5f7O+mGoxgZ++uknI8ls3LjRZfzZZ581CQkJ1T5m4sSJRhILCwsLCwvLRbAcOHDgjFnBFleIwsPD5eXlVeVqUG5ubpWrRpXGjx+vMWPGWOsVFRU6fPiwwsLCLroPirObwsJCNW/eXAcOHFBISIi72wHgYfgdcXExxujo0aOKiYk5Y50tApGvr686dOig9PR03X777dZ4enq6brvttmof4+fnJz8/P5exRo0a1WWbqGchISH8sgNwWvyOuHg4nc6z1tgiEEnSmDFjlJKSomuuuUaJiYl6/fXXlZWVpeHDh7u7NQAA4Ga2CUR33XWXDh06pMmTJys7O1tt27bVxx9/rBYtWri7NQAA4Ga2CUSSNGLECI0YMcLdbcDN/Pz8NHHixCpviQKAxO8Iu3IYc7Z5aAAAABc3W3wwIwAAwJkQiAAAgO0RiAAAgO0RiAAAgO0RiGA7c+bMUXx8vPz9/dWhQwf961//cndLADzEhg0b1LdvX8XExMjhcGjFihXubgn1hEAEW1m6dKlGjx6tCRMm6KuvvlKXLl2UnJysrKwsd7cGwAMcO3ZM7du31+zZs93dCuoZ0+5hK506ddLVV1+tuXPnWmOtW7dW//79NXXqVDd2BsDTOBwOLV++XP3793d3K6gHXCGCbZw8eVIZGRlKSkpyGU9KStLGjRvd1BUAwBMQiGAbeXl5Ki8vV2RkpMt4ZGSkcnJy3NQVAMATEIhgOw6Hw2XdGFNlDABgLwQi2EZ4eLi8vLyqXA3Kzc2tctUIAGAvBCLYhq+vrzp06KD09HSX8fT0dHXu3NlNXQEAPIGtvu0eGDNmjFJSUnTNNdcoMTFRr7/+urKysjR8+HB3twbAAxQVFWnv3r3W+r59+7R9+3aFhoYqNjbWjZ2hrjHtHrYzZ84cvfjii8rOzlbbtm01Y8YM3Xjjje5uC4AHWLdunbp3715lfPDgwUpLS6v/hlBvCEQAAMD2uIcIAADYHoEIAADYHoEIAADYHoEIAADYHoEIAADYHoEIAADYHoEIAADYHoEIAE4xZMgQ9e/f391tAKhHBCIAAGB7BCIAAGB7BCIAHu8f//iH2rVrp4CAAIWFhalnz546duyY9dbWlClTFBkZqUaNGmnSpEkqKyvTE088odDQUDVr1kzz58932d+OHTt00003Wft7+OGHVVRUdNrjZ2RkKCIiQs8995wkqaCgQA8//LAiIiIUEhKim266SV9//bVV//XXX6t79+4KDg5WSEiIOnTooG3bttXNkwOgVhCIAHi07Oxs3XPPPXrwwQeVmZmpdevWacCAAar8Gsa1a9fq559/1oYNGzR9+nSlpqaqT58+aty4sbZs2aLhw4dr+PDhOnDggCTp+PHj6t27txo3bqytW7fqvffe0+rVqzVy5Mhqj79u3Tr16NFDkyZN0oQJE2SM0a233qqcnBx9/PHHysjI0NVXX60ePXro8OHDkqR7771XzZo109atW5WRkaE///nP8vHxqZ8nDEDNGADwYBkZGUaS2b9/f5VtgwcPNi1atDDl5eXWWEJCgunSpYu1XlZWZoKCgsw777xjjDHm9ddfN40bNzZFRUVWzUcffWQaNGhgcnJyrP3edtttZsWKFSY4ONi8/fbbVu2aNWtMSEiIOXHihEsvl156qXnttdeMMcYEBwebtLS0Wjh7APWFK0QAPFr79u3Vo0cPtWvXTv/zP/+jefPmKT8/39p++eWXq0GD//tVFhkZqXbt2lnrXl5eCgsLU25uriQpMzNT7du3V1BQkFVz/fXXq6KiQnv27LHGtmzZojvuuENvvvmm7rnnHms8IyNDRUVFCgsLU8OGDa1l3759+v777yVJY8aM0UMPPaSePXvq+eeft8YBeC4CEQCP5uXlpfT0dH3yySdq06aNZs2apYSEBO3bt0+SqrwV5XA4qh2rqKiQJBlj5HA4qj3Wb8cvvfRS/eEPf9D8+fN18uRJa7yiokLR0dHavn27y7Jnzx498cQTkqTU1FTt2rVLt956q9auXas2bdpo+fLlv//JAFBnCEQAPJ7D4dD111+vSZMm6auvvpKvr2+NA0abNm20fft2HTt2zBr7/PPP1aBBA7Vq1coaCw8P19q1a/X999/rrrvuUmlpqSTp6quvVk5Ojry9vXXZZZe5LOHh4dbjW7Vqpccff1yffvqpBgwYoAULFtTw7AHUBwIRAI+2ZcsWTZkyRdu2bVNWVpaWLVumgwcPqnXr1jXa37333it/f38NHjxYO3fu1GeffaZRo0YpJSVFkZGRLrURERFau3atdu/erXvuuUdlZWXq2bOnEhMT1b9/f61atUr79+/Xxo0b9dRTT2nbtm0qLi7WyJEjtW7dOv3www/6/PPPtXXr1hr3C6B+EIgAeLSQkBBt2LBBt9xyi1q1aqWnnnpKL730kpKTk2u0v8DAQK1atUqHDx9Wx44ddeedd6pHjx6aPXt2tfVRUVFau3atduzYoXvvvVcVFRX6+OOPdeONN+rBBx9Uq1atdPfdd2v//v2KjIyUl5eXDh06pPvvv1+tWrXSwIEDlZycrEmTJv2epwFAHXMY8//PXQUAALAprhABAADbIxABAADbIxABAADbIxABAADbIxABAADbIxABAADbIxABAADbIxABAADbIxABAADbIxABAADbIxABAADbIxABAADb+/8AeHLLlCmsd/IAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "predictive_int_fixed = pyro.infer.Predictive(population_forced_smokes_model, num_samples=num_samples, return_sites=(\"cancer\", \"_RETURN\"))\n", + "prediction_int_fixed = predictive_int_fixed(n_individuals, stress_pt, smokes_cpt, cancer_cpt)\n", + "\n", + "visualize_proportions_single(prediction_int_fixed, \"Intervened Data - Fixed Parameters\")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAj4AAAHFCAYAAADyj/PrAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABroElEQVR4nO3dd3hU1dYG8HdKMklIgVASSoDQexcElAQpIkgRlHqponjRD1CQIgqhCMK9csGG6MUEvKCgUhSlREoAEaVKi4AYipAQ6SE9mf39MTknM5mSmTMn/f09T57AmTPn7MmEZLHW2ntrhBACRERERGWAtqgHQERERFRYGPgQERFRmcHAh4iIiMoMBj5ERERUZjDwISIiojKDgQ8RERGVGQx8iIiIqMxg4ENERERlBgMfIiIiKjMY+JDboqKioNFocPToUZefm5KSgoiICOzbt0/9gRWx9evXY/ny5TYf02g0iIiIKNTx2CO9f5cvX3bqPOnDy8sLwcHB6Nq1KxYvXozExETFYzh37hwiIiLyHUNBCw8Pt3iN5h9nzpxBREQENBpNoY9r37590Gg0+f47yfse6fV61KhRA2PHjsX169cLZ7BF5MaNG4iIiMDJkyeLeihUzOmLegBUtqWkpGDevHkATL90SpP169fjzJkzmDJlitVjP//8M2rUqFH4g1JBZGQkGjVqhMzMTCQmJuLgwYNYsmQJ/v3vf2PDhg3o3r27y9c8d+4c5s2bh/DwcNSuXVv9QbugTp06WLdundXxunXrYvz48ejVq1cRjMo10nuUmpqK/fv3Y/HixYiJicHp06dRrly5oh5egbhx4wbmzZuH2rVro1WrVkU9HCrGGPhQqZSZmSn/j7c4evTRR4t6CIo1a9YM7dq1k/8+aNAgvPrqq3jssccwcOBAXLx4EUFBQUU4Qvd4e3vbfX9q1KhRIgJW8/eoa9euyM7OxoIFC7BlyxaMGDHCrWunpqbC29tbjWGWCKmpqfDy8iqSTB8VDJa6qECMGTMGvr6++OOPP9C7d2/4+voiJCQEU6dORXp6OgDg8uXLqFy5MgBg3rx5cnp+zJgx8nUuXryI4cOHo0qVKjAYDGjcuDE+/PBDi3tJZYDPP/8cU6dORfXq1WEwGHD27FloNBqsXr3aanzbt2+HRqPBt99+q+heX3zxBWbPno1q1arB398f3bt3x/nz5+XzwsPD8f333+PKlSsWpQeJrVLXmTNn0L9/f1SoUAFeXl5o1aoV1qxZo+j+ABAdHY3+/fujRo0a8PLyQr169TBhwgTcunXL3tumWM2aNfHuu+8iKSkJq1atko8fPXoUQ4cORe3ateHt7Y3atWtj2LBhuHLlinxOVFQUnnvuOQCmX9LS1yoqKqrQX0d+8pa6Dh48CA8PD0ybNs3iPKnkZP6958z3FwD8/vvv6NWrF3x8fFCpUiW89NJLSEpKcmvcUiAnfd3nzZuHDh06IDAwEP7+/mjTpg1Wr16NvHtW165dG08//TQ2bdqE1q1bw8vLS87Qfvjhh+jSpQuqVKmCcuXKoXnz5li6dCkyMzMtrhEeHo5mzZrh559/RqdOneTvg8jISADA999/jzZt2sDHxwfNmzfHjh07rMaf39du3759eOSRRwAAY8eOlb+HzP+NHT16FP369UNgYCC8vLzQunVrbNy40eI+0vu2a9cujBs3DpUrV4aPjw/S09Px999/48UXX0RISAgMBgMqV66Mzp0748cff1TyllARKp7/HaZSITMzE/369cPzzz+PqVOnYv/+/ViwYAECAgIwZ84cVK1aFTt27ECvXr3w/PPPY/z48QAgB0Pnzp1Dp06d5F+qwcHB2LlzJyZNmoRbt25h7ty5FvebNWsWOnbsiI8//hharRYhISFo3bo1IiMj8fzzz1ucGxUVhSpVqqB3796K7vXGG2+gc+fO+O9//4sHDx5gxowZ6Nu3L2JjY6HT6fDRRx/hxRdfxKVLl7B58+Z8v1bnz59Hp06dUKVKFbz33nuoWLEi/ve//2HMmDG4efMmpk+f7tL9AeDSpUvo2LEjxo8fj4CAAFy+fBnLli3DY489htOnT8PDw8OFdzN/vXv3hk6nw/79++Vjly9fRsOGDTF06FAEBgYiPj4eK1euxCOPPIJz586hUqVK6NOnDxYtWoQ33ngDH374Idq0aQPAVFoqitcBAFlZWRZ/12q10Gqt/5/42GOPYeHChZg5cya6dOmCfv364ezZs3j55Zfxj3/8Q/6+c/b76+bNmwgLC4OHhwc++ugjBAUFYd26dXjllVfcej1//PEHgNx/W5cvX8aECRNQs2ZNAMDhw4fxf//3f7h+/TrmzJlj8dzjx48jNjYWb775JkJDQ+VS2aVLlzB8+HCEhobC09MTv/32G95++238/vvv+OyzzyyukZCQgLFjx2L69OmoUaMG3n//fYwbNw7Xrl3D119/jTfeeAMBAQGYP38+BgwYgD///BPVqlVz+mvXpk0bREZGYuzYsXjzzTfRp08fAJCzc3v37kWvXr3QoUMHfPzxxwgICMCXX36JIUOGICUlxeI/WwAwbtw49OnTB59//jmSk5Ph4eGBkSNH4vjx43j77bfRoEED3Lt3D8ePH8ft27fdem+oCAgiN0VGRgoA4siRI/Kx0aNHCwBi48aNFuf27t1bNGzYUP7733//LQCIuXPnWl33ySefFDVq1BD379+3OP7KK68ILy8vcefOHSGEEHv37hUARJcuXayu8d577wkA4vz58/KxO3fuCIPBIKZOnar4Xr1797Y4b+PGjQKA+Pnnn+Vjffr0EbVq1bIakxDC6jUPHTpUGAwGcfXqVYvznnrqKeHj4yPu3bvn8v3NGY1GkZmZKa5cuSIAiK1bt8qPSe9fXFyczefmPc/8fc4rKChING7c2O7jWVlZ4uHDh6JcuXJixYoV8vGvvvpKABB79+51OAZHr0MNYWFhAoDVx4gRI4QQQsydO1fk/bFpNBpF7969Rfny5cWZM2dEkyZNRKNGjcTDhw/lc5z9/poxY4bQaDTi5MmTFuf16NHDqa+P9B4dPnxYZGZmiqSkJLFt2zZRuXJl4efnJxISEqyek52dLTIzM8X8+fNFxYoVhdFolB+rVauW0Ol0Fv9+bJGusXbtWqHT6eTXI0Tu1/To0aPysdu3bwudTie8vb3F9evX5eMnT54UAMR7770nH3P2a3fkyBEBQERGRlqNr1GjRqJ169YiMzPT4vjTTz8tqlatKrKzsy2+fqNGjbK6hq+vr5gyZYrDrwOVDCx1UYHRaDTo27evxbEWLVpYlDnsSUtLw+7du/HMM8/Ax8cHWVlZ8kfv3r2RlpaGw4cPWzxn0KBBVtcZMWIEDAaDXDYBgC+++ALp6ekYO3as4nv169fP6nUBcOq12bJnzx5069YNISEhFsfHjBmDlJQU/Pzzzy7fPzExES+99BJCQkKg1+vh4eGBWrVqAQBiY2MVjTM/Ik+p5OHDh5gxYwbq1asHvV4PvV4PX19fJCcnOz0Gd15Hdna2xftpNBrzvV/dunVx5MgRi48FCxbYPV+j0WDt2rXw8/NDu3btEBcXh40bN8qZEVe+v/bu3YumTZuiZcuWFvcYPnx4vuM29+ijj8LDwwN+fn54+umnERwcjO3bt8u9V3v27EH37t0REBAAnU4HDw8PzJkzB7dv37aandeiRQs0aNDA6h4nTpxAv379ULFiRfkao0aNQnZ2Ni5cuGBxbtWqVdG2bVv574GBgahSpQpatWolZ3YAoHHjxgByv4+V/NvM648//sDvv/8u9zblvUZ8fLxVmdjWz5L27dsjKioKCxcuxOHDh61KelRyMPChAuPj4wMvLy+LYwaDAWlpafk+9/bt28jKysL7778PDw8Piw+pPJW3x6Nq1apW1wkMDES/fv2wdu1aZGdnAzCVudq3b4+mTZsqvlfFihWtXhdgaoRU4vbt2zbHL/1SyJtOz+/+RqMRPXv2xKZNmzB9+nTs3r0bv/76q/xLQuk4HUlOTsbt27ctfpENHz4cH3zwAcaPH4+dO3fi119/xZEjR1C5cmWnxuDu66hbt67F+zl//vx87+nl5YV27dpZfISGhjp8TsWKFdGvXz+kpaWhV69eaN68ufyYK99ft2/fRnBwsNX1bR1zZO3atThy5AhOnDiBGzdu4NSpU+jcuTMA4Ndff0XPnj0BAJ9++il++uknHDlyBLNnzwZg/TW19X159epVPP7447h+/TpWrFiBAwcO4MiRI3LfTd5rBAYGWl3D09PT6rinpycAyD8jlPzbzOvmzZsAgGnTplldY+LEiTavYes1b9iwAaNHj8Z///tfdOzYEYGBgRg1ahQSEhIc3p+KH/b4ULFUoUIF6HQ6jBw5Ei+//LLNc/L+MrI362Ls2LH46quvEB0djZo1a+LIkSNYuXKlW/dSW8WKFREfH291/MaNGwCASpUquXS9M2fO4LfffkNUVBRGjx4tH5d6PQrC999/j+zsbHlZgvv372Pbtm2YO3cuZs6cKZ+Xnp6OO3fuOHVNd1/Hd999JzfTA7AIytQUHR2NlStXon379ti8eTO++eYbOWvgyvdXxYoVbf4idfWXa+PGjS1m3pn78ssv4eHhgW3btln8x2TLli02z7f172rLli1ITk7Gpk2b5OwbANXX0FHj36b0b2fWrFkYOHCgzXMaNmxo8Xdbr7lSpUpYvnw5li9fjqtXr+Lbb7/FzJkzkZiYaLMhm4ovBj5UpOxlSnx8fNC1a1ecOHECLVq0kP8nqETPnj1RvXp1REZGombNmvDy8sKwYcMK5F7mDAaD05mVbt26YfPmzbhx44bFL+e1a9fCx8fH5env0g9u6esrMZ9xpaarV69i2rRpCAgIwIQJE+QxCCGsxvDf//5Xzr5J7H0fuPs6zDMvBSU+Ph7/+Mc/EBYWhujoaAwcOBDPP/882rRpg9DQUJe+v7p27YqlS5fit99+syh3rV+/XrXxSss8SE3wgOnr/vnnn7t0DcDyfRFC4NNPP1VtnIBr/zbtfQ81bNgQ9evXx2+//YZFixapMq6aNWvilVdewe7du/HTTz+pck0qPAx8qEj5+fmhVq1a2Lp1K7p164bAwEBUqlQJtWvXxooVK/DYY4/h8ccfxz//+U/Url0bSUlJ+OOPP/Ddd99hz549Tt1Dp9Nh1KhRWLZsGfz9/TFw4EAEBARYnKPWvcw1b94cmzZtwsqVK9G2bVtotVq7/wufO3cutm3bhq5du2LOnDkIDAzEunXr8P3332Pp0qVW481Po0aNULduXcycORNCCAQGBuK7775DdHS0y68jrzNnzsg9EomJiThw4AAiIyOh0+mwefNmeeaQv78/unTpgn/961/yexoTE4PVq1ejfPnyFtds1qwZAOCTTz6Bn58fvLy8EBoaWqCvQw3Z2dkYNmwYNBoN1q9fD51Oh6ioKLRq1QpDhgzBwYMH4enp6fT315QpU/DZZ5+hT58+WLhwoTyr6/fff1dtzH369MGyZcswfPhwvPjii7h9+zb+/e9/WwWXjvTo0QOenp4YNmwYpk+fjrS0NKxcuRJ3795VbZwSZ792devWhbe3N9atW4fGjRvD19cX1apVQ7Vq1bBq1So89dRTePLJJzFmzBhUr14dd+7cQWxsLI4fP46vvvrK4Rju37+Prl27Yvjw4WjUqBH8/Pxw5MgR7Nixw24WiYqxIm2tplLB3qyucuXKWZ1ra1bMjz/+KFq3bi0MBoMAIEaPHi0/FhcXJ8aNGyeqV68uPDw8ROXKlUWnTp3EwoUL5XOkmU5fffWV3TFeuHBBnqETHR1t8xx37hUXF2c1o+TOnTvi2WefFeXLlxcajcbidcPGTLbTp0+Lvn37ioCAAOHp6SlatmxpNUPFlfufO3dO9OjRQ/j5+YkKFSqI5557Tly9etXq3q7O6pI+PD09RZUqVURYWJhYtGiRSExMtHrOX3/9JQYNGiQqVKgg/Pz8RK9evcSZM2dErVq1LN5nIYRYvny5CA0NFTqdzuK1OPs61BAWFiaaNm1q9/G837+zZ88WWq1W7N692+K8Q4cOCb1eLyZPniwfc+b7S4jc1+vl5SUCAwPF888/L7Zu3erSrC5HM++EEOKzzz4TDRs2FAaDQdSpU0csXrxYrF692ur7oFatWqJPnz42r/Hdd9+Jli1bCi8vL1G9enXx+uuvi+3bt1uN097X1N61AYiXX37Z4pizX7svvvhCNGrUSHh4eFh9f/z2229i8ODBokqVKsLDw0MEBweLJ554Qnz88cfyOfa+fmlpaeKll14SLVq0EP7+/sLb21s0bNhQzJ07VyQnJ9v8+lDxpREizzQMIiIiolKKs7qIiIiozGDgQ0RERGUGAx8iIiIqMxj4EBERUZnBwIeIiIjKDAY+REREVGaU+gUMjUYjbty4AT8/P7tbGhAREVHxIoRAUlISqlWrBq1WvTxNqQ98bty4YbXjNREREZUM165dQ40aNVS7XqkPfPz8/ACYvnD+/v5FPBoiIiJyxoMHDxASEiL/HldLqQ98pPKWv78/Ax8iIqISRu02FTY3ExERUZnBwIeIiIjKDAY+REREVGaU+h4fIqLSwGg0IiMjo6iHQaWQh4cHdDpdUQ+j0DDwISIq5jIyMhAXFwej0VjUQ6FSqnz58ggODi4T690x8CEiKsaEEIiPj4dOp0NISIiqC7kRCSGQkpKCxMREAEDVqlWLeEQFj4EPEVExlpWVhZSUFFSrVg0+Pj5FPRwqhby9vQEAiYmJqFKlSqkve/G/DkRExVh2djYAwNPTs4hHQqWZFFRnZmYW8UgKHgMfIqISoCz0XlDRKUvfXwx8iIiIqMxg4ENERFTCjBkzBgMGDCjqYZRIDHyIiEh1Y8aMgUajgUajgYeHB4KCgtCjRw989tlnxXJavkajweXLlwEA+/btg0ajwb179/J93qpVq9CyZUuUK1cO5cuXR+vWrbFkyZKCHSy5hYEPEREViF69eiE+Ph6XL1/G9u3b0bVrV0yePBlPP/00srKyinp4blu9ejVee+01TJo0Cb/99ht++uknTJ8+HQ8fPizqoZEDDHyIqEA8SMvEsSt3IYQo6qFQETEYDAgODkb16tXRpk0bvPHGG9i6dSu2b9+OqKgo+byrV6+if//+8PX1hb+/PwYPHoybN29aXOu7775D27Zt4eXlhTp16mDevHkWwVNERARq1qwJg8GAatWqYdKkSfJjtWvXxqJFizBu3Dj4+fmhZs2a+OSTT2yO+fLly+jatSsAoEKFCtBoNBgzZozNc7/77jsMHjwYzz//POrVq4emTZti2LBhWLBggXyOVJJatGgRgoKCUL58eXnsr7/+OgIDA1GjRg189tlnFtc+ffo0nnjiCXh7e6NixYp48cUXHQZUx44dQ5UqVfD2228DAO7fv48XX3wRVapUgb+/P5544gn89ttvdp9fljDwIaICMePrUxi08hA2Hb9e1EMpVYQQSMnIKpIPNYLYJ554Ai1btsSmTZvk1zNgwADcuXMHMTExiI6OxqVLlzBkyBD5OTt37sQ//vEPTJo0CefOncOqVasQFRUl/5L/+uuv8Z///AerVq3CxYsXsWXLFjRv3tzivu+++y7atWuHEydOYOLEifjnP/+J33//3Wp8ISEh+OabbwAA58+fR3x8PFasWGHztQQHB+Pw4cO4cuWKw9e8Z88e3LhxA/v378eyZcsQERGBp59+GhUqVMAvv/yCl156CS+99BKuXbsGAEhJSUGvXr1QoUIFHDlyBF999RV+/PFHvPLKKzavv2/fPnTr1g3z5s3D7NmzIYRAnz59kJCQgB9++AHHjh1DmzZt0K1bN9y5c8fhWMsCLmBIRAVi+5kEAMDqg3EY1LZGEY+m9EjNzEaTOTuL5N7n5j8JH0/3f200atQIp06dAgD8+OOPOHXqFOLi4hASEgIA+Pzzz9G0aVMcOXIEjzzyCN5++23MnDkTo0ePBgDUqVMHCxYswPTp0zF37lxcvXoVwcHB6N69Ozw8PFCzZk20b9/e4p69e/fGxIkTAQAzZszAf/7zH+zbtw+NGjUCAIugLjAwEABQpUoVlC9f3u7rmDt3LgYOHIjatWujQYMG6NixI3r37o1nn33WYoXtwMBAvPfee9BqtWjYsCGWLl2KlJQUvPHGGwCAWbNm4Z133sFPP/2EoUOHYt26dUhNTcXatWtRrlw5AMAHH3yAvn37YsmSJQgKCpKvvXXrVowcORKrVq3CsGHDAAB79+7F6dOnkZiYCIPBAAD497//jS1btuDrr7/Giy++6MrbVeow40NEqjP/JXIvhRtrkiUhhLxuTGxsLEJCQuSgBwCaNGmC8uXLIzY2FoCpjDN//nz4+vrKHy+88ALi4+ORkpKC5557DqmpqahTpw5eeOEFbN682aqHqEWLFvKfNRoNgoOD5W0alKpatSp+/vlnnD59GpMmTUJmZiZGjx6NXr16WTRwN23a1CIQCgoKsshI6XQ6VKxYUR5PbGys3DAt6dy5M4xGI86fPy8f++WXXzBo0CCsWbNGDnqkr9fDhw9RsWJFi69ZXFwcLl265NZrLg2Y8SEi1T1ILfmNq8WVt4cO5+Y/WWT3VkNsbCxCQ0MBWAZB5syPG41GzJs3DwMHDrQ6z8vLCyEhITh//jyio6Px448/YuLEifjXv/6FmJgYeHh4AID8WaLRaFSbXdasWTM0a9YML7/8Mg4ePIjHH38cMTExcq+QrXs7Go+9r4l0nqRu3bqoWLEiPvvsM/Tp00de3dtoNKJq1arYt2+f1fMdZbDKCgY+RKS6vx+my39OSmcQpCaNRqNKuamo7NmzB6dPn8arr74KwJTduXr1Kq5duyZnfc6dO4f79++jcePGAIA2bdrg/PnzqFevnt3rent7o1+/fujXrx9efvllNGrUCKdPn0abNm1cHqMUQEjbhbiiSZMmAIDk5GSXn2t+jTVr1iA5OVnO+vz000/QarVo0KCBfF6lSpWwadMmhIeHY8iQIdi4cSM8PDzQpk0bJCQkQK/Xo3bt2orHUVqx1EVEqjMvbyWlZSEjq/it20IFLz09HQkJCbh+/TqOHz+ORYsWoX///nj66acxatQoAED37t3RokULjBgxAsePH8evv/6KUaNGISwsDO3atQMAzJkzB2vXrkVERATOnj2L2NhYbNiwAW+++SYAICoqCqtXr8aZM2fw559/4vPPP4e3tzdq1aqlaNy1atWCRqPBtm3b8Pfff9udTfXPf/4TCxYswE8//YQrV67g8OHDGDVqFCpXroyOHTsqujcAjBgxAl5eXhg9ejTOnDmDvXv34v/+7/8wcuRIi/4ewNSHtGfPHvz+++8YNmwYsrKy0L17d3Ts2BEDBgzAzp07cfnyZRw6dAhvvvkmjh49qnhcpQUDHyJSXVqmZaBzJ5l9PmXRjh07ULVqVdSuXRu9evXC3r178d5772Hr1q3yDuAajQZbtmxBhQoV0KVLF3Tv3h116tTBhg0b5Os8+eST2LZtG6Kjo/HII4/g0UcfxbJly+TApnz58vj000/RuXNntGjRArt378Z3332HihUrKhp39erVMW/ePMycORNBQUF2Z1N1794dhw8fxnPPPYcGDRpg0KBB8PLywu7duxXfGzBtGLpz507cuXMHjzzyCJ599ll069YNH3zwgc3zg4OD5UzaiBEjYDQa8cMPP6BLly4YN24cGjRogKFDh+Ly5ctWgVNZpBGlfJGNBw8eICAgAPfv34e/v39RD4eoTPjx3E2MX5v7P8sfX+uCelX8inBEJVdaWhri4uIQGhoKLy+voh4OlVLF8fusoH5/M+NDRKpLy7LsjUhKY58PERUPDHyISHV5S10MfIiouGDgQ0SqS8u0zPg85MwuIiomGPgQkeqsAh9mfIiomGDgQ0SqS88zfZ1r+RBRccHAh4hUx4wPERVXDHyISHXWPT6ZRTQSIiJLDHyISHXSrC5pWyE2NxNRccHAh4hUJ2V8An1Mex6lZri+5xERUUFg4ENEqkvLaW4u72PagTo1k4EPFR5pGwwiWxj4EJHqpIxPBSnjk8lNSsuixMRETJgwATVr1oTBYEBwcDCefPJJ/Pzzz0U9NCrD9EU9ACIqfdLzZHzSWOoqkwYNGoTMzEysWbMGderUwc2bN7F7927cuXOnqIdGZRgzPkSkusycwMffi6WusurevXs4ePAglixZgq5du6JWrVpo3749Zs2ahT59+gAwlaRWrVqFp59+Gj4+PmjcuDF+/vln/PHHHwgPD0e5cuXQsWNHXLp0yeLaK1euRN26deHp6YmGDRvi888/dziW+fPnIygoCCdPngQAHDp0CF26dIG3tzdCQkIwadIkJCcny+d/9NFHqF+/Pry8vBAUFIRnn31W3S8OFSkGPkSkuiyjKfDx8zIllfNObyc3CAFkJBfNhxBOD9PX1xe+vr7YsmUL0tPT7Z63YMECjBo1CidPnkSjRo0wfPhwTJgwAbNmzcLRo0cBAK+88op8/ubNmzF58mRMnToVZ86cwYQJEzB27Fjs3bvXxpdKYPLkyVi9ejUOHjyIVq1a4fTp03jyyScxcOBAnDp1Chs2bMDBgwflexw9ehSTJk3C/Pnzcf78eezYsQNdunRx+nVT8acRwoXv5BKooLa1JyL7Bnz4E05eu4dXutbDB3v/QI0K3jg444miHlaJlJaWhri4OISGhsLLy8sUgCyqVjSDeeMG4FnO6dO/+eYbvPDCC0hNTUWbNm0QFhaGoUOHokWLFgBMGZ8333wTCxYsAAAcPnwYHTt2xOrVqzFu3DgAwJdffomxY8ciNTUVANC5c2c0bdoUn3zyiXyfwYMHIzk5Gd9//7183a+++gpbt27F0aNHER0djRo1agAARo0aBW9vb6xatUp+/sGDBxEWFobk5GT88MMPGDt2LP766y/4+fm58cUqWay+z4qBgvr9XaQZn4iICGg0GouP4OBg+XEhBCIiIlCtWjV4e3sjPDwcZ8+eLcIRE5EzMrNzSl3ezPiUZYMGDcKNGzfw7bff4sknn8S+ffvQpk0bREVFyedIQRAABAUFAQCaN29ucSwtLQ0PHjwAAMTGxqJz584W9+ncuTNiY2Mtjr366qv4+eefceDAATnoAYBjx44hKipKzkj5+vriySefhNFoRFxcHHr06IFatWqhTp06GDlyJNatW4eUlBTVviZU9Iq8ublp06b48ccf5b/rdDr5z0uXLsWyZcsQFRWFBg0aYOHChejRowfOnz9fpiJxopImK9uUSPaTenzY3KweDx9T5qWo7u0iLy8v9OjRAz169MCcOXMwfvx4zJ07F2PGjDFd0sNDPleTs+KlrWNGo9HqmEQIYXWsR48e+OKLL7Bz506MGDFCPm40GjFhwgRMmjTJaqw1a9aEp6cnjh8/jn379mHXrl2YM2cOIiIicOTIEZQvX97l10/FT5EHPnq93iLLIxFCYPny5Zg9ezYGDhwIAFizZg2CgoKwfv16TJgwobCHSkROysz5JeVrMP2ISc3MtvnLiRTQaFwqNxU3TZo0cWuNncaNG+PgwYMYNWqUfOzQoUNo3LixxXn9+vVD3759MXz4cOh0OgwdOhQA0KZNG5w9exb16tWzew+9Xo/u3buje/fumDt3LsqXL489e/bIv4uoZCvywOfixYuoVq0aDAYDOnTogEWLFqFOnTqIi4tDQkICevbsKZ9rMBgQFhaGQ4cO2Q180tPTLRrppPQoERWe3IyP6UeMUQAZ2UYY9DpHT6NS5Pbt23juuecwbtw4tGjRAn5+fjh69CiWLl2K/v37K77u66+/jsGDB6NNmzbo1q0bvvvuO2zatMmiciB55pln8Pnnn2PkyJHQ6/V49tlnMWPGDDz66KN4+eWX8cILL6BcuXKIjY1FdHQ03n//fWzbtg1//vknunTpggoVKuCHH36A0WhEw4YN3flyUDFSpIFPhw4dsHbtWjRo0AA3b97EwoUL0alTJ5w9exYJCQkAcmu+kqCgIFy5csXuNRcvXox58+YV6LiJyLHcHp/ckkVaZgEEPnf+BLbPAGo/DnS2Ll1Q0fH19UWHDh3wn//8B5cuXUJmZiZCQkLwwgsv4I033lB83QEDBmDFihX417/+hUmTJiE0NBSRkZEIDw+3ef6zzz4Lo9GIkSNHQqvVYuDAgYiJicHs2bPx+OOPQwiBunXrYsiQIQCA8uXLY9OmTYiIiEBaWhrq16+PL774Ak2bNlU8ZipeitWsruTkZNStWxfTp0/Ho48+is6dO+PGjRuoWrWqfM4LL7yAa9euYceOHTavYSvjExISwlldRIWo3cIfcethOrZPfhx93z+ILKPAL290Q5C/yrNF1vQF4vab/jw9DvAJVPf6xUBxnG1DpU9x/D4rlbO68ipXrhyaN2+Oixcvyn0/UuZHkpiYaJUFMmcwGODv72/xQUSFS1rHx0OngZeHKcujeoNz8q3coAcAbv+h7vWJqFQqVoFPeno6YmNjUbVqVYSGhiI4OBjR0dHy4xkZGYiJiUGnTp2KcJRElB+px0ev1eYGPmpPab9x0vLvD66re30iKpWKtMdn2rRp6Nu3L2rWrInExEQsXLgQDx48wOjRo6HRaDBlyhQsWrQI9evXR/369bFo0SL4+Phg+PDhRTlsIspHRk6Pj4deC29P0/+vUtTO+Ny/avn3B0U0xZuISpQiDXz++usvDBs2DLdu3ULlypXx6KOP4vDhw6hVqxYAYPr06UhNTcXEiRNx9+5ddOjQAbt27eIaPkTFXJYU+Gg1ckNzRpbKO7Tfz5PhSeMMTiLKX5EGPl9++aXDxzUaDSIiIhAREVE4AyIitxmNAsacKRN6nRaeOlPGR8oCqSZvaSvjobrXL2aK0TwUKoXK0vdXserxIaKSL9NshV29TgNPfU7go3bGJyne9DmwjulzepK61y8mpNXsMzIyingkVJpJ23KYr5pdWhX5AoZEVLpkZuf+z9FTpy24wCftvulzQIhpPZ9SmvHR6/Xw8fHB33//DQ8PD2i1/P8qqUcIgZSUFCQmJqJ8+fIW20aVVgx8iEhVWWYlLb1WA4MU+GSr3NwsBz45G1Cml87AR6PRoGrVqoiLi3O4eCuRO8qXL29z+6jSiIEPEanKPOOj02pye3xUz/jkNDP7VzN9LqUZHwDw9PRE/fr1We6iAuHh4VEmMj0SBj5EpCrzxQs1mgLq8REiN+Pjm7OgaVa6/fNLAa1WW2xW1CUqyVgsJiJVZWaZMj4eOZkeKfBJVzPwyUoDjJmmP5erZPqcXboDHyJSBwMfIlKVNKtLr9UAQMFMZ5fX7NEAPhVNf8xiGYiI8sfAh4hUJW1XkTfjo2qpSypzGfwBfU75hxkfInICAx8iUlVmTmZHr8vJ+BRE4CM1Mht8AV3OuiPM+BCRExj4EJGqpMCnQDM+WWmmz3ovQGcw/TmbgQ8R5Y+BDxGpKstoWeoyFESPT2aq6bOHN6Bn4ENEzmPgQ0Sqkktd2gIsdUkZHw9vQOeZc4w9PkSUPwY+RKQqqblZX5ClLinjo/cyy/ikm9b3ISJygIEPEalKyvh46iyns6cXVKlLZ7apYnamevcgolKJgQ8RqSrTKuOTs7t4gZW6DLnH2edDRPlg4ENEqsrKu4BhgZa6zJqbAQY+RJQvBj5EpKq8Cxh65JS8Mguk1OUFaHWAJmeDRTY4E1E+GPgQkaoysnM3KTV9Nv2YycpWsfE4yyzjA1g2OBMROcDAh4hUlXdWl1TykvbwUkWmWY8PYDalnaUuInKMgQ8RqUrq8SmUjE/ewIcZHyLKBwMfIlKVPKtLa/rxosvJ+EgrOqtzE7N1fIDcUhczPkSUDwY+RKSqvHt1SZuVZhXUOj4AoNWbPhuz1LsHEZVKDHyISFVZ9pqb1cz4ZOXt8clZxJCBDxHlg4EPEakqdwFDU+AjNzcXRMZHKnXJGR+u3ExEjjHwISJV5S5gKK3jUxDNzXkyPix1EZGTGPgQkark6ew5mZ4CaW6WVmiWtquQAp9sBj5E5BgDHyJSVd69uqRenyw11/GRNiOVenvY40NETmLgQ0SqyruOj1TyUrXUJWd8ctbvYY8PETmJgQ8RqUoqaUkBj74g9uqSA5+cTI82Z68uY7Z69yCiUomBDxGpSprOri/I6ex5S11aD8vjRER2MPAhIlXl7s5u2dycbRQQQqXgx26piz0+ROQYAx8iUlVmnlKXhzb3x4xqWR8545MT+MjNzcz4EJFjDHyISFV5V26WSl6mx9TO+LDHh4hcw8CHiFSVdzq7eeCTqdaU9rwZHy2nsxORcxj4EJGqclduzmluNi91qZHxMWYDIiezk7fHh83NRJQPBj5EpKrc5mbTjxetVoOcGEidRQzNgxt5AUM2NxORcxj4EJGqMvNMZwdUXsRQ6u8BOKuLiFzGwIeIVJV3AUMgNwhSJ/Axy/ho86zjw8CHiPLBwIeIVJV3VheQ2++jSnOzlPHR6AApuGKPDxE5iYEPEakq76wuwGz1ZjVLXVKZC2CPDxE5jYEPEalK3qRUa5bxUXOH9rxT2QH2+BCR0xj4EJGqsmxkfAqkuVma0QWwx4eInMbAh4hUJfXxWMzqUjXjY6PUxR4fInISAx8iUpW8jo/ZrC5po1J1FjDMyeqYZ3zY40NETmLgQ0Sqym1utp7Vla3G7uyOMj4MfIgoHwx8iEhVcnOzWeCj1eQEPmrszs7Ah4jcwMCHiFQlNzfbKHWpE/hIs7psNDezx4eI8sHAh4hUJW1ZodNal7qMBVbq0pk+M+NDRPlg4ENEqpK2rPAwm86uVbO52dZ0dh2nsxORcxj4EJFqhBByOcu8uVmnUTPjY6vUxR4fInIOAx8iUk2mWUbH1nT2bBWW8bFd6mKPDxE5h4EPEanGvHnZIuOjLegFDKUen2z3r09EpRoDHyJSjfnu67YCnwIrdbHHh4icxMCHiFSTlU+pS53mZkeblLLURUSOFZvAZ/HixdBoNJgyZYp8TAiBiIgIVKtWDd7e3ggPD8fZs2eLbpBE5FBWThOPVpM7kwtQu7mZm5QSkXLFIvA5cuQIPvnkE7Ro0cLi+NKlS7Fs2TJ88MEHOHLkCIKDg9GjRw8kJSUV0UiJyJFMo/XO7IDazc22Mj45PT7ZDHyIyLEiD3wePnyIESNG4NNPP0WFChXk40IILF++HLNnz8bAgQPRrFkzrFmzBikpKVi/fn0RjpiI7JEyPh5m2R7APPApoOZm9vgQkZOKPPB5+eWX0adPH3Tv3t3ieFxcHBISEtCzZ0/5mMFgQFhYGA4dOlTYwyQiJ+RuUGr5o0Wr6pYVtkpd7PEhIufoi/LmX375JY4fP44jR45YPZaQkAAACAoKsjgeFBSEK1eu2L1meno60tPT5b8/ePBApdESUX5sbVAKmO/OrsJNpFKXlj0+ROS6Isv4XLt2DZMnT8b//vc/eHl52T1Po7H8ASqEsDpmbvHixQgICJA/QkJCVBszETlma4NSILe5ucBKXezxISInFVngc+zYMSQmJqJt27bQ6/XQ6/WIiYnBe++9B71eL2d6pMyPJDEx0SoLZG7WrFm4f/++/HHt2rUCfR1ElEvaoFSfJ+OjLZCVm7mODxG5rshKXd26dcPp06ctjo0dOxaNGjXCjBkzUKdOHQQHByM6OhqtW7cGAGRkZCAmJgZLliyxe12DwQCDwVCgYyci22xtUAqovTs71/EhIuWKLPDx8/NDs2bNLI6VK1cOFStWlI9PmTIFixYtQv369VG/fn0sWrQIPj4+GD58eFEMmYjyIWd8tLYzPqosYGh0FPhwywoicqxIm5vzM336dKSmpmLixIm4e/cuOnTogF27dsHPz6+oh0ZENmTZmdUl9/gU2AKGOT/KuEkpEeWjWAU++/bts/i7RqNBREQEIiIiimQ8ROQae7O61F3Hx0bGR+7xYeBDRI4V+To+RFR6yOv42F3AUIWb2JzVZdbcrEZWiYhKLQY+RKQae6WugmluNp/VZZa85swuInKAgQ8RqcZeqUvV5mZHGR+AfT5E5BADHyJSTUaWKfDxtNPcXGC7s5v/mX0+ROQAAx8iUk2GtEmp3d3ZC6jUZZHxYamLiOxj4ENEqpEzPnrbgU+WqpuUmpe6tIAm557M+BCRAwx8iEg10gKGVqUuqbm5oAIfIDfrwx4fInKAgQ8RqaZwMj45pSzzUpf535nxISIHGPgQkWrsBj4F0tycN+Mjrd7MHh8iso+BDxGpJiPb9ialWlWbm+0EPsz4EJETGPgQkWrsZXz0BT2rC2CPDxE5hYEPEakmI9u0O3qhZHy0eXt8pB3aWeoiIvsY+BCRajKzTIGNwV7Gx90eHyFyS1mc1UVECjDwISLVZNibzq5RKeNjns0x358LYI8PETmFgQ8RqSZ35Wbbe3W5HfiYZ3PylrqY8SEiJzDwISLV5DY36yyOq7Y7u9TfA9iY1cUeHyLKHwMfIlKNFPgU2O7sFqUuZnyIyHUMfIhINfKWFXYWMHS7uVkKajQ6QGMZXLHHh4icwcCHiFQjZXzyzupSbXd2o501fACu3ExETmHgQ0SqyW1uLqDAJ9vOVHaAGR8icgoDHyJSTX4rN7vf3JwT1Gj11o+xx4eInMDAh4hUYy/jo15zs4NSlzyri4EPEdnHwIeIVFPgu7PLGR9bPT5Sxoc9PkRkHwMfIlJNpr2Vm1Xv8bGV8WGPDxHlj4EPEanGbsanUGZ1SRmfDOvHiIhyMPAhItVk5vTwWGd8TJ9VW8fHVqlLx+nsRJQ/Bj5EpBp55WarjI/p76ptUpp3g1IgNxhiqYuIHGDgQ0SqEEIU/O7sUhnL0To+nM5ORA4w8CEiVWSaTVXP2+OjlUpdajU325zVxU1KiSh/DHyISBVStgewP6vL7ensjkpdzPgQkRMY+BCRKqT+HsD+ys1ZBVnqYo8PETmBgQ8RqUJaw0eryc3wSLSq9fg4M6uLgQ8R2cfAh4hUIc/o0ln/WJFLXaqt4+NoVhd7fIjIPgY+RKQKqYyVt78HMFvA0O11fHKCGpsZH/b4EFH+GPgQkSqkUlfeNXwANbesYI8PEbmHgQ8RqUIqdenz9PcAKq7j46jUxZWbicgJDHyISBVyxsdGqUsrT2c3LXSomKNSFzM+ROQEBj5EpAq5x8dGqcs8C+RW1sfRJqVS+Ys9PkTkAAMfIlJFpjyry7rUpTUPfNzK+HDLCiJyDwMfIlJFhoNSl9TjAwBGo9XDzpNLXbZ6fKSMT7obNyCi0o6BDxGpQtqrS+9gOjvgZsbHqVJXhvLrE1Gpx8CHiFSRJe/MbmNWl3ngk+1OqcvRys0sdRFR/hj4EJEqnC11udfj4yDjozfknMOMDxHZx8CHiFQhlbocTWcHCmNWFwMfIrKPgQ8RqSJ3HR/rUheQO6XdrcCHpS4ichMDHyJShaMFDIHcrI8609kdZHyyOKuLiOxTFPjExcWpPQ4iKuEclbqA3D4ft3Zol3Ze5wKGRKSQosCnXr166Nq1K/73v/8hLS1N7TERUQmUX8an4Etd7PEhovwpCnx+++03tG7dGlOnTkVwcDAmTJiAX3/9Ve2xEVEJ4mjlZiC31JVVGM3N7pTTiKhUUxT4NGvWDMuWLcP169cRGRmJhIQEPPbYY2jatCmWLVuGv//+W+1xElExl1/GRydvVFpA09nlYwIwZiu/BxGVam41N+v1ejzzzDPYuHEjlixZgkuXLmHatGmoUaMGRo0ahfj4eLXGSUTFXKbRcY+PVlNIpS6A21YQkV1uBT5Hjx7FxIkTUbVqVSxbtgzTpk3DpUuXsGfPHly/fh39+/dXa5xEVMzJpS59AU5nd1TqkhYwBNjnQ0R22djpL3/Lli1DZGQkzp8/j969e2Pt2rXo3bs3tFpTHBUaGopVq1ahUaNGqg6WiIqvTHnLCselLvcyPg42KTU/xpldRGSHosBn5cqVGDduHMaOHYvg4GCb59SsWROrV692a3BEVHJkSJuUau2t42P6rM46Pp7Wj2k0puPZGcz4EJFdikpd0dHRmDFjhlXQI4TA1atXAQCenp4YPXq0w+usXLkSLVq0gL+/P/z9/dGxY0ds377d4noRERGoVq0avL29ER4ejrNnzyoZMhEVMGmTUvulLtOPG/fW8XFQ6gI4pZ2I8qUo8Klbty5u3bpldfzOnTsIDQ11+jo1atTAO++8g6NHj+Lo0aN44okn0L9/fzm4Wbp0KZYtW4YPPvgAR44cQXBwMHr06IGkpCQlwyaiApRfqUvarsut6eyOSl1AbkCUxcCHiGxTFPgIO6nqhw8fwsvLy+nr9O3bF71790aDBg3QoEEDvP322/D19cXhw4chhMDy5csxe/ZsDBw4EM2aNcOaNWuQkpKC9evXKxk2ERWgfFdu1qqxcnN+GR/u0E5EjrnU4/Paa68BADQaDebMmQMfHx/5sezsbPzyyy9o1aqVooFkZ2fjq6++QnJyMjp27Ii4uDgkJCSgZ8+e8jkGgwFhYWE4dOgQJkyYoOg+RFQwMnIyPnp7Cxhq1Nyry0aPj/lxNjcTkR0uBT4nTpwAYMr4nD59Gp6euT98PD090bJlS0ybNs2lAZw+fRodO3ZEWloafH19sXnzZjRp0gSHDh0CAAQFBVmcHxQUhCtXrti9Xnp6OtLTc9fwePDggUvjISJlsvLbskKnwsrNzpa6mPEhIjtcCnz27t0LABg7dixWrFgBf39/twfQsGFDnDx5Evfu3cM333yD0aNHIyYmRn5co7H836MQwuqYucWLF2PevHluj4uIXCOVuuxOZ1dlk1I2NxORexT1+ERGRqoS9ACmTFG9evXQrl07LF68GC1btsSKFSvkGWMJCQkW5ycmJlplgczNmjUL9+/flz+uXbumyjiJyLGMfDI+WlXW8cmn1KVn4ENEjjmd8Rk4cCCioqLg7++PgQMHOjx306ZNigckhEB6ejpCQ0MRHByM6OhotG7dGgCQkZGBmJgYLFmyxO7zDQYDDAaD3ceJqGBk5tPjo3d3ry6jERCme9jcsgJgxoeI8uV04BMQECCXmAICAlS5+RtvvIGnnnoKISEhSEpKwpdffol9+/Zhx44d0Gg0mDJlChYtWoT69eujfv36WLRoEXx8fDB8+HBV7k9E6snKp9QlNTcr7vExmjUs6+z1+DDwISLHnA58IiMjbf7ZHTdv3sTIkSMRHx+PgIAAtGjRAjt27ECPHj0AANOnT0dqaiomTpyIu3fvokOHDti1axf8/PxUuT8RqcfZ3dkVl7rMZ2rZzfh4WJ9LRGRG0ZYVqampEELI09mvXLkiz8Yyn36en/y2tNBoNIiIiEBERISSYRJRIcrt8bFd6tK5W+oyz+LkO52dGR8isk1Rc3P//v2xdu1aAMC9e/fQvn17vPvuu+jfvz9Wrlyp6gCJqGSQMz56xxkfqSTmMmNW7p+1OtvnSIFPVrrtx4mozFMU+Bw/fhyPP/44AODrr79GcHAwrly5grVr1+K9995TdYBEVDJIAY2HnU1K5ensijM+OeUrrYdpQ1KbN+EChkTkmKLAJyUlRe6z2bVrFwYOHAitVotHH33U4eKCRFR6ZeazSWnudHaFN8hvDR+ApS4iypeiwKdevXrYsmULrl27hp07d8p9PYmJiaqt70NEJUtGVj4rN2vd3LIi25nAhys3E5FjigKfOXPmYNq0aahduzY6dOiAjh07AjBlf6Q1d4iobMlv5WY546M05WNe6rKHpS4iyoeiWV3PPvssHnvsMcTHx6Nly5by8W7duuGZZ55RbXBEVHJkGR0vYKiTNylVeANnSl16aXd2NjcTkW2KAh8ACA4OlreVkLRv397tARFRySOEkDM++ZW6FO/VJW9Q6kypixkfIrJNUeCTnJyMd955B7t370ZiYiKMRsvU9Z9//qnK4IioZMg0S+Pkt1eX4pWb5X262NxMRMopCnzGjx+PmJgYjBw5ElWrVnW4WzoRlX6ZZn07+e7OrnivLs7qIiL3KQp8tm/fju+//x6dO3dWezxEVAKZBz72enzc3p2dzc1EpAJFs7oqVKiAwMBAtcdCRCWUealL6uXJS69W4ONMxocrNxORHYoCnwULFmDOnDlISUlRezxEVAJJGR9PndZu6dvtTUqdKnVxHR8ickxRqevdd9/FpUuXEBQUhNq1a8PDw/IH0fHjx1UZHBGVDJn5bFAKAFqNSgsYstRFRG5QFPgMGDBA5WEQUUmW3walQG7vj+Lp7NImpToHP7bY3ExE+VAU+MydO1ftcRBRCSb1+OjtbFAK5GZ83J/O7mn/HD0DHyJyTFGPDwDcu3cP//3vfzFr1izcuXMHgKnEdf36ddUGR0QlQ26Pj/1SlzTLvXBmdTHwISLbFGV8Tp06he7duyMgIACXL1/GCy+8gMDAQGzevBlXrlzB2rVr1R4nERVjzpS63F/Hh6UuInKfoozPa6+9hjFjxuDixYvw8vKSjz/11FPYv3+/aoMjopIhI8vxdhUAoMspgxVsxodbVhCRY4oCnyNHjmDChAlWx6tXr46EhAS3B0VEJYu8QamdNXwANUpdTvT4MONDRPlQFPh4eXnhwYMHVsfPnz+PypUruz0oIipZ5B4fB6Uut1dultfxcVTqknZnZ+BDRLYpCnz69++P+fPnIzPT9INIo9Hg6tWrmDlzJgYNGqTqAImo+HOm1CWv3Kx4HR8XdmfPYuBDRLYpCnz+/e9/4++//0aVKlWQmpqKsLAw1KtXD35+fnj77bfVHiMRFXMuLWDodsaHpS4iUk7RrC5/f38cPHgQe/fuxbFjx2A0GtGmTRt0795d7fERUQkg9fg4bm52d68uqcfHmVldbG4mIttcDnyMRiOioqKwadMmXL58GRqNBqGhoQgODoYQwu4+PURUemU6NavLzensrpS6mPEhIjtcKnUJIdCvXz+MHz8e169fR/PmzdG0aVNcuXIFY8aMwTPPPFNQ4ySiYizDiVJXoWxSqmdzMxE55lLGJyoqCvv378fu3bvRtWtXi8f27NmDAQMGYO3atRg1apSqgySi4i23xyf/BQzdL3U5sXKzyAaM2YBWp+xeRFRquZTx+eKLL/DGG29YBT0A8MQTT2DmzJlYt26daoMjopIhK2evLk8HgY/b09ldKXUBzPoQkU0uBT6nTp1Cr1697D7+1FNP4bfffnN7UERUskilLr2DUlfudHaFN3Gm1GU+44uBDxHZ4FLgc+fOHQQFBdl9PCgoCHfv3nV7UERUsjhV6pIzPkZlN3Flk1Lz84mIzLgU+GRnZ0Ovt98WpNPpkJWV5fagiKhkcSbwcXsdn2wnMj4aTW5gxIwPEdngUnOzEAJjxoyBwWCw+Xh6eroqgyKikkXu8XG0O7s0nV1hwsepUhdgyvoYM4Es/jwiImsuBT6jR4/O9xzO6CIqe+QeH4eblJoeyyrIUhdgCowywVIXEdnkUuATGRlZUOMgohLMpensipubc8rojlZuBrhtBRE5pGivLiIic9LKzc6Vutxdx8fBXl2A2SKGLHURkTUGPkTktkxjIazc7GypS5uTEcrmRAsissbAh4jclplTv9JrC3CTUrm5Ob9Sl4fl+UREZhj4EJHbMrNyMj4OSl3ydHbFm5RKgU8+pS55OjsDHyKyxsCHiNwmNTd7OlHqUt7j4+ysrpyMkJGlLiKyxsCHiNyW4cLKzVkFuTs7wIwPETnEwIeI3CYtYOgo8JEan7Oy3VzHJ98FDNnjQ0T2MfAhIrflruNjv9QlBUWZhTari4EPEVlj4ENEbnNmAUMpKMpUmvFxessKlrqIyD4GPkTktgwnSl3SVPcspUs3O13qypn1xVIXEdnAwIeI3JblRMZH727Gh6UuIlIBAx8icpszPT6eOUGRolldQrhe6uJ0diKygYEPEbkt05lSV85j2Ubh+lo+5kEMp7MTkRsY+BCR25xZx0dvlg2S9vZymnkQk+8ChpzOTkT2MfAhIrdJPT6eegfT2c328XK5wVnamR1wIuPDTUqJyD4GPkTkNmc2KTXv/3E58DEvdTHjQ0RuYOBDRG6TS10ONimVtqwwP99pUqlLowMcBFcAzHp8MhyfR0RlEgMfInKbM7O6NBpN7rYVLvf45AQx+ZW5gNxNStncTEQ2MPAhIrdkGwVETuXK00FzM+DGIoZSqUtanNARLaezE5F9DHyIyC3mCxI6mtVletyU8VFc6pIalx3hlhVE5AADHyJyi3kQo3dQ6gJyAyPFs7qcKXVp2dxMRPYVaeCzePFiPPLII/Dz80OVKlUwYMAAnD9/3uIcIQQiIiJQrVo1eHt7Izw8HGfPni2iERNRXplZZhmffBqPFW9bIa/a7ESpS874sNRFRNaKNPCJiYnByy+/jMOHDyM6OhpZWVno2bMnkpOT5XOWLl2KZcuW4YMPPsCRI0cQHByMHj16ICkpqQhHTkQSaQsKvVYDrdZxxkfu8XF15WYpiHGl1MWMDxHZ4MRPkYKzY8cOi79HRkaiSpUqOHbsGLp06QIhBJYvX47Zs2dj4MCBAIA1a9YgKCgI69evx4QJE4pi2ERkJiMr/1WbJZ45091dzvgoKXWxx4eIbChWPT73798HAAQGBgIA4uLikJCQgJ49e8rnGAwGhIWF4dChQ0UyRiKyJAUx+fX3AKaskPlznOZSqSvn/3Oc1UVENhRpxsecEAKvvfYaHnvsMTRr1gwAkJCQAAAICgqyODcoKAhXrlyxeZ309HSkp6fLf3/w4EEBjZiIgNxVm/Obyg7kblTqenOzC6UuZnyIyIFik/F55ZVXcOrUKXzxxRdWj2k0lv+TFEJYHZMsXrwYAQEB8kdISEiBjJeITDKd2KBUUjgLGHLlZiKyr1gEPv/3f/+Hb7/9Fnv37kWNGjXk48HBwQByMz+SxMREqyyQZNasWbh//778ce3atYIbOBG5VOqSgqOMLFcXMHSh1KVlqYuI7CvSwEcIgVdeeQWbNm3Cnj17EBoaavF4aGgogoODER0dLR/LyMhATEwMOnXqZPOaBoMB/v7+Fh9EVHDkUpeDfbokUo+P6xkfBbO6WOoiIhuKtMfn5Zdfxvr167F161b4+fnJmZ2AgAB4e3tDo9FgypQpWLRoEerXr4/69etj0aJF8PHxwfDhw4ty6ESUQ8r4ONPjI2V8CmVWF6ezE5ENRRr4rFy5EgAQHh5ucTwyMhJjxowBAEyfPh2pqamYOHEi7t69iw4dOmDXrl3w8/Mr5NESkS0ZLvT4yNPZC7LUxYwPETlQpIGPEPn/8NNoNIiIiEBERETBD4iIXJaZlf/O7BIpK5RekHt1sceHiBwoFs3NRFRyST0+rmR8MrIUBj5OzerytHwOEZEZBj5E5Ba5x8eJ5mbFgY+SUhd7fIjIBgY+ROQWJT0+6VnZrt1Eam52pdTFTUqJyAYGPkTkltwFDPPv8TEoLnXlBDGuLGDIjA8R2cDAh4jcomST0gItdWm5cjMR2cfAh4jc4so6PgZp5Wal6/i4tIAhS11EZI2BDxG5pXBmdblQ6pKns7PURUTWGPgQkVvkUpfeiXV8CnNWF6ezE5ENDHyIyC2u7M4uL2DocsZHKnW5sGWFyAacWCSViMoWBj5E5BaXenw8dACUBD5SqcuZHh+zc5j1IaI8GPgQkVtc2Z3dU2lzs5JZXebPIyLKwcCHiNyiZAHDDMULGLqwjg/AjA8RWWHgQ0RuySyMdXxcKXVZZHw4pZ2ILDHwISK3uLJysxz4uLyOT7rps86Q/7laLaDR5TyPGR8issTAh4jc4kqPj7SAYXqmi4FPVk7go3ci8AHMprRz9WYissTAh4jcoqjHR+nKzc40NwO55S6WuogoDwY+ROQWV9bxMehNJSiXe3xczvhIO7Sz1EVElhj4EJFbFPX4KF3A0OWMDwMfIrLEwIeI3JKZldPjU5CzuhT3+DDwISJLDHyIyC1KenzSXe7xcWEBQ8Bso1L2+BCRJQY+ROQWudTlysrNWUYIV/bRkqezOxn4MONDRHYw8CEityjp8QFcnNnlaqmLPT5EZAcDHyJyi7yOj1OzuswCH1f6fFxtbpZndbHURUSWGPgQkVsyXNmyQqcw8HG5uTknQGLGh4jyYOBDRG5xpblZq9XIJTGnS13GbEDkbGrqzJYVQG6piys3E1EeDHyIyC1Sj4+nPv8eH8CywdkpUrYHAPRsbiYi9zDwISK3uLI7O6BgLZ9ss8DH6YwPp7MTkW0MfIjILVJzs6uBT7rTGR+zcpWUyckPMz5EZAcDHyJSTAjhUo8PkLtfl9OBjzyjywBonCuncTo7EdnDwIeIFMsy5i5C6Mx0dkBJqSsn8HF2RhfA6exEZBcDHyJSLNNsZpanEys3A2bNzc7O6pKam50tcwHM+BCRXQx8iEgxaYNSwLmVmwE3mpudbWwG2ONDRHYx8CEixaSsjUYD6LQFFPhIzc3OTmUHzGZ1MfAhIksMfIhIsUyzxmaNk43HBnlWV7ZzN3Er48MeHyKyxMCHiBSTFy90srEZyA18Cjbjw5Wbicg2Bj5EpJgrO7NL5FKXs83N7mR8WOoiojwY+BCRYhlZri1eCCjYskLRdHaWuojINgY+RKRYpouLFwJurNysU1DqYsaHiPJg4ENEiuVuUOp64OPydHZFGR8GPkRkiYEPESmWoaTHR+filhXyAoZKprOz1EVElhj4EJFirm5QChTWlhXM+BCRbQx8iEixzCzXe3zk6ezZTq7jk5lq+qz3cn5g7PEhIjsY+BCRYhkK1vFxfeXmNNNnD2/nByZvUsrAh4gsMfAhIsXkWV1653t8XF7A0K2MD3t8iMgSAx8iUixDQanL5QUMFWV8chqhuXIzEeXBwIeIFFPU3JxzbnqmsxmfnMDHleZmaXuLLAY+RGSJgQ8RKaZkry7XMz5SqcuVjE9OkCStAURElIOBDxEppmSvLoPexXV8pIyPhws9PlI/kFQmIyLKwcCHiBTLcGPLCudndSnI+LDURUR2MPAhIsUyczYpLdAtK5RkfFjqIiI7GPgQkWKKNinVFUKPj9QIncXAh4gsMfAhIsUKZZNSRT0+DHyIyDYGPkSkmJJNSqUFDNOznNyywp2MD9fxIaI8GPgQkWJKSl2ur9zsRo8PZ3URUR5FGvjs378fffv2RbVq1aDRaLBlyxaLx4UQiIiIQLVq1eDt7Y3w8HCcPXu2aAZLRFak5ubiN6srJ/AxZgFGJ+9DRGVCkQY+ycnJaNmyJT744AObjy9duhTLli3DBx98gCNHjiA4OBg9evRAUlJSIY+UiGwplAUM3enxATizi4gs6Ivy5k899RSeeuopm48JIbB8+XLMnj0bAwcOBACsWbMGQUFBWL9+PSZMmFCYQyUiG5T0+EhBUma2gNEooNU6eK7RmBu4KFm5GTCVu1zZ54uISrVi2+MTFxeHhIQE9OzZUz5mMBgQFhaGQ4cOFeHIiEiSuzu76xkfwImsj3mPjks9Ph5m12CDMxHlKtKMjyMJCQkAgKCgIIvjQUFBuHLlit3npaenIz09N7X94MGDghkgESnbpNQs8EnPMsLLQ2f/ZPPAx5WMj0Zj2rYiK42lLiKyUGwzPhKNxjINLoSwOmZu8eLFCAgIkD9CQkIKeohEZZbUoOxSj4/Zufk2OGfmNDZr9YDOxf+n6biWDxFZK7aBT3BwMIDczI8kMTHRKgtkbtasWbh//778ce3atQIdJ1FZJq3FY3Ch1KXRaOSsT75r+UgZH1eyPRIuYkhENhTbwCc0NBTBwcGIjo6Wj2VkZCAmJgadOnWy+zyDwQB/f3+LDyIqGNIO6wYP136UeDk7pT1LwYwuiZ77dRGRtSLt8Xn48CH++OMP+e9xcXE4efIkAgMDUbNmTUyZMgWLFi1C/fr1Ub9+fSxatAg+Pj4YPnx4EY6aiCS5pS4HfTo2GDx0QFqWHDjZlelGxkcn7dDOwIeIchVp4HP06FF07dpV/vtrr70GABg9ejSioqIwffp0pKamYuLEibh79y46dOiAXbt2wc/Pr6iGTERmlGZ8pNJYWmZ+pa6cHh9FGZ+c5zDwISIzRRr4hIeHQwhh93GNRoOIiAhEREQU3qCIyGlSxseVHh/z853P+CgJfJjxISJrxbbHh4iKP6k52ZXd2QHAoNflPD+/Hh8p46Ok1MUeHyKyxsCHiBRLz5QyPq71+HjllMbS8yt1uZXxkWZ1cQFDIsrFwIeIFEuX9upSmPFJK8iMj547tBORNQY+RKSIEEJ5j09hZnxY6iIiMwx8iEgR8322Cqy5WY0eH5a6iMgMAx8iUsQ8aCmw5mY542NwfJ4tLHURkQ0MfIhIEamxGXBtry7ArLk53y0rcjI+7mxZkc2MDxHlYuBDRIpkmDU2O9o42Ba5uTnTyYyPkgUMuUkpEdnAwIeIFJEak13t7zF/TsFmfLiAIRFZY+BDRIpIGR9X1/ABzGd1FWDGR5oJxlldRGSGgQ8RKZK7eKGSjI+zzc0pps8ePi7fI3eTUjY3E1EuBj5EpEi6wjV8ABeam90JfKTnZDLwIaJcDHyISBFp8UJXp7IDZhmffEtdOT0+ngoCH+k5UvBERAQGPkSkkJStKdDm5oxk02d3Mj7SNYiIwMCHiBRyK+Pj4eTKzVLGx61SV6rrzyWiUouBDxEpkpoznd3LQ8GsLldLXUoCH5a6iMgGBj5EpEhKhinw8fF0PfBxvrk5p0ylpMfHg4EPEVlj4ENEiqTKgY/e5ec6v3KzG5uUyj0+DHyIKBcDHyJSJDkjCwDgrSDjIzU3pznK+BiNZtPZy7l8D3jmPIcZHyIyw8CHiBSRMj7lFAQ+UrAklctsMl94UFHGJ+c5DHyIyAwDHyJSRApavBWUusrlPCfVUeBjHrC4U+oyZgFZ3KGdiEwY+BCRIlKpS0lzs/Sc5IwsCCFsnyQFPnovQOv6PeRSF5DbJE1EZR4DHyJSxJ1Sl4/BlPERwsFaPlJTspJsDwDoPABtTjaKa/kQUQ4GPkSkiDulLm+ztX+S07Nsn+ROY7NEei5ndhFRDgY+RKRIihulLp1WI6/lY7fBOdPNjA9gtoghS11EZMLAh4gUcWcBQ9Pz9BbXseLOBqUSeWYXS11EZMLAh4gUkUpU5Qyul7qA3HKXlDmy4s4GpRK51MWMDxGZMPAhIkXupWYCAMp7eyh6fjlDPmv5uLNPl4T7dRFRHgx8iMhlRqPA/ZzAJ8BHWeDjnW+pS8r4uNHjIz2Xzc1ElIOBDxG5LCktC9LyOwFKMz6e+ZS65B4fN2Z1GfxNn9MfKL8GEZUqDHyIyGX3Uk0rIft46uQNR13lk9+2Fe6u4wMAXgGmz2n3lV+DiEoVBj5E5LK7KaYyVwUfT8XXkGZ15b+Ojxs9Pgx8iCgPBj5E5LJ7KaaMj9IyF5Cb8bG7X1d6kumzwU/xPeBV3vQ57Z7yaxBRqcLAh4hcdjcn8CmvsLEZMMv4FGjgw4wPEVli4ENELku4nw4ACPL3UnyN3IyPnVKXHPj4K74HvMubPjPwIaIcDHyIyGU3H6QBcC/wkRY+TLLX4yPNxGLGh4hUxMCHiFyWG/gYFF/D3zsn8EnLL/BxI+PDwIeI8mDgQ0QukwKfYDcyPv5epv6gpLRM2ydIpS4vFQKf1HvKr0FEpQoDHyJy2c0HOT0+AW4EPjkzwh6k2sn4pKlR6iqfc617gNFOEzURlSkMfIjIJUajUKXHx9/LVOp6YCvjI4Q6s7rKVQKgAYQRSLmj/DpEVGow8CEil9xJyUCWUUCjAar4udPjI2V8bAQ+WemAMee4Oz0+Og/Ap6Lpzw8TlF+HiEoNBj5E5JKE+6ZsT8VyBnjolP8I8fPKndVlNArLB6VsDwB4+iq+h+lGwabPD2+6dx0iKhUY+BCRSxKT3J/RBeQ2NwsBPMy7lo80C8vgD2jd/DHlW8X0+WGie9cholKBgQ8RuURavNCdGV0A4OWhg6fe9CPIakp7yi3TZ59At+4BAPANMn1mxoeIwMCHiFwUfz8VABDsxowuiZT1serzSZYCn0pu30PO+CSxx4eIGPgQkYv+umsKfGpUcGPX9BzSIobWgc/fps/lVAh8ytcyfb572f1rEVGJx8CHiFzy190UAECNCt5uX0vO+NgtdakQ+ATWMX2+86f71yKiEo+BDxG5JDfj437gE5AzpV3a7V2WfNv0uVxFt+8hBz53L3MRQyJi4ENEzsvIMiIhZ/FCNUpdlXPWAbr1MN3ygQfXTZ/9qrl9DwTUALQeQHYG8OCG+9cjohKNgQ8ROS3+fiqEAAx6LSr5erp9PSnw+TspT+Bz/5rpc/kQt+8BrQ6oUNv05zuX3L8eEZVoDHyIyGmXb5v6e0ICfaDRaNy+XmVfU+CTmDfwuZcT+ASoEPgAQKUGps+Jsepcj4hKLAY+ROS0izdNKyrXr+Lmaso5bGZ80h/mNjerkfEBgODmps8Jp9W5HhGVWAx8iMhpl/5+CACop1LgI+31dcs88Ek8Z/rsGwx4V1DlPqjawvQ5/pQ61yOiEouBDxE57eJNdQMfKeNz80EahMjZr0vKygQ3U+UepmvlZHz+jjVtgEpEZVaJCHw++ugjhIaGwsvLC23btsWBAweKekhEZU5WthHn4h8AABoG+6lyzWrlvaHVAMkZ2fhbmtkVt9/0uXpbVe4BwNQr5FUeMGYBN8+qd10iKnGKfeCzYcMGTJkyBbNnz8aJEyfw+OOP46mnnsLVq1eLemhEZcqFmw+RkpENX4Me9auoE/h4eehQq2I5AAKJx78HDn0AXNhperB+T1XuAQDQaICaj5r+LAVWRFQmFfvAZ9myZXj++ecxfvx4NG7cGMuXL0dISAhWrlxZ1EMjKlN++sPUcNy6ZnnotO7P6JI0quKNt/WfodneccCu2UBWqqk0Va2NavcAANR9wvT5YrS61yWiEqVYBz4ZGRk4duwYeva0/J9fz549cejQoSIaFVHZkpFlxMGLtxB16DIAoGeTIHUufPcycPprzLn7Bkbod8MIDe4Fd4JoMQQYsg7QqvzjqUEvQKMFrhwEfv6IW1gQlVH6oh6AI7du3UJ2djaCgix/0AYFBSEhwfZOy+np6UhPz21evH//PgDgwYMHBTdQolLs3I37GL7qMACgip8nutXzV+ff094PgCOfoByAm/DE9IwXcDr7Uewb3tX0uNr/ZnUVgIaDgd++AL6dCTx6Deg6S917EJFqpJ8z8sQHlRTrwEeSd6E0IYTdxdMWL16MefPmWR0PCVFpPRCiMuwagOoLCurq7wAAAhYW1PVt3e+dwroZESl0+/ZtBAQEqHa9Yh34VKpUCTqdziq7k5iYaJUFksyaNQuvvfaa/Pd79+6hVq1auHr1qqpfOHLdgwcPEBISgmvXrsHf37+oh1Om8b0oXvh+FB98L4qP+/fvo2bNmggMDFT1usU68PH09ETbtm0RHR2NZ555Rj4eHR2N/v3723yOwWCAwWCwOh4QEMBv4mLC39+f70UxwfeieOH7UXzwvSg+tCr3+xXrwAcAXnvtNYwcORLt2rVDx44d8cknn+Dq1at46aWXinpoREREVMIU+8BnyJAhuH37NubPn4/4+Hg0a9YMP/zwA2rVqlXUQyMiIqISptgHPgAwceJETJw4UdFzDQYD5s6da7P8RYWL70XxwfeieOH7UXzwvSg+Cuq90Ai154kRERERFVPFegFDIiIiIjUx8CEiIqIyg4EPERERlRkMfIiIiKjMKBWBz0cffYTQ0FB4eXmhbdu2OHDggMPzY2Ji0LZtW3h5eaFOnTr4+OOPC2mkpZ8r78WmTZvQo0cPVK5cGf7+/ujYsSN27txZiKMt3Vz9dyH56aefoNfr0apVq4IdYBni6nuRnp6O2bNno1atWjAYDKhbty4+++yzQhpt6efq+7Fu3Tq0bNkSPj4+qFq1KsaOHYvbt28X0mhLr/3796Nv376oVq0aNBoNtmzZku9zVPn9LUq4L7/8Unh4eIhPP/1UnDt3TkyePFmUK1dOXLlyxeb5f/75p/Dx8RGTJ08W586dE59++qnw8PAQX3/9dSGPvPRx9b2YPHmyWLJkifj111/FhQsXxKxZs4SHh4c4fvx4IY+89HH1vZDcu3dP1KlTR/Ts2VO0bNmycAZbyil5L/r16yc6dOggoqOjRVxcnPjll1/ETz/9VIijLr1cfT8OHDggtFqtWLFihfjzzz/FgQMHRNOmTcWAAQMKeeSlzw8//CBmz54tvvnmGwFAbN682eH5av3+LvGBT/v27cVLL71kcaxRo0Zi5syZNs+fPn26aNSokcWxCRMmiEcffbTAxlhWuPpe2NKkSRMxb948tYdW5ih9L4YMGSLefPNNMXfuXAY+KnH1vdi+fbsICAgQt2/fLozhlTmuvh//+te/RJ06dSyOvffee6JGjRoFNsayyJnAR63f3yW61JWRkYFjx46hZ8+eFsd79uyJQ4cO2XzOzz//bHX+k08+iaNHjyIzM7PAxlraKXkv8jIajUhKSlJ9Q7qyRul7ERkZiUuXLmHu3LkFPcQyQ8l78e2336Jdu3ZYunQpqlevjgYNGmDatGlITU0tjCGXakrej06dOuGvv/7CDz/8ACEEbt68ia+//hp9+vQpjCGTGbV+f5eIlZvtuXXrFrKzs612ag8KCrLa0V2SkJBg8/ysrCzcunULVatWLbDxlmZK3ou83n33XSQnJ2Pw4MEFMcQyQ8l7cfHiRcycORMHDhyAXl+ifywUK0reiz///BMHDx6El5cXNm/ejFu3bmHixIm4c+cO+3zcpOT96NSpE9atW4chQ4YgLS0NWVlZ6NevH95///3CGDKZUev3d4nO+Eg0Go3F34UQVsfyO9/WcXKdq++F5IsvvkBERAQ2bNiAKlWqFNTwyhRn34vs7GwMHz4c8+bNQ4MGDQpreGWKK/8ujEYjNBoN1q1bh/bt26N3795YtmwZoqKimPVRiSvvx7lz5zBp0iTMmTMHx44dw44dOxAXF8eNsouIGr+/S/R/7SpVqgSdTmcVqScmJlpFhZLg4GCb5+v1elSsWLHAxlraKXkvJBs2bMDzzz+Pr776Ct27dy/IYZYJrr4XSUlJOHr0KE6cOIFXXnkFgOmXrxACer0eu3btwhNPPFEoYy9tlPy7qFq1KqpXr46AgAD5WOPGjSGEwF9//YX69esX6JhLMyXvx+LFi9G5c2e8/vrrAIAWLVqgXLlyePzxx7Fw4UJWCQqRWr+/S3TGx9PTE23btkV0dLTF8ejoaHTq1Mnmczp27Gh1/q5du9CuXTt4eHgU2FhLOyXvBWDK9IwZMwbr169nzVwlrr4X/v7+OH36NE6ePCl/vPTSS2jYsCFOnjyJDh06FNbQSx0l/y46d+6MGzdu4OHDh/KxCxcuQKvVokaNGgU63tJOyfuRkpICrdbyV6VOpwOQm22gwqHa72+XWqGLIWlq4urVq8W5c+fElClTRLly5cTly5eFEELMnDlTjBw5Uj5fmg736quvinPnzonVq1dzOrtKXH0v1q9fL/R6vfjwww9FfHy8/HHv3r2iegmlhqvvRV6c1aUeV9+LpKQkUaNGDfHss8+Ks2fPipiYGFG/fn0xfvz4onoJpYqr70dkZKTQ6/Xio48+EpcuXRIHDx4U7dq1E+3bty+ql1BqJCUliRMnTogTJ04IAGLZsmXixIkT8tICBfX7u8QHPkII8eGHH4patWoJT09P0aZNGxETEyM/Nnr0aBEWFmZx/r59+0Tr1q2Fp6enqF27tli5cmUhj7j0cuW9CAsLEwCsPkaPHl34Ay+FXP13YY6Bj7pcfS9iY2NF9+7dhbe3t6hRo4Z47bXXREpKSiGPuvRy9f147733RJMmTYS3t7eoWrWqGDFihPjrr78KedSlz969ex3+Diio398aIZirIyIiorKhRPf4EBEREbmCgQ8RERGVGQx8iIiIqMxg4ENERERlBgMfIiIiKjMY+BAREVGZwcCHiIiIygwGPkQlSO3atbF8+fKiHgZSUlIwaNAg+Pv7Q6PR4N69ewV2r/DwcEyZMkX+u6tfg7zPt6Ugvq5jxozBgAEDVL0mEbmPgQ+VemPGjIFGo4FGo4GHhwfq1KmDadOmITk5uaiHZldUVBTKly9vdfzIkSN48cUXC39AeaxZswYHDhzAoUOHEB8fb7GhpsTea3CXq1+DTZs2YcGCBaqPozgKDw/Hxx9/bPfxP/74A2PHjkWNGjVgMBgQGhqKYcOG4ejRo4U4SqKiVaJ3ZydyVq9evRAZGYnMzEwcOHAA48ePR3JyMlauXGl1bmZmZpFuWJuZmWn3scqVKxfiSOy7dOkSGjdujGbNmhX6vV39GgQGBhbQSIqXO3fu4NChQ1i3bp3Nx48ePYpu3bqhWbNmWLVqFRo1aoSkpCRs3boVU6dORUxMTCGP2HkZGRnw9PQs6mFQKcGMD5UJBoMBwcHBCAkJwfDhwzFixAhs2bIFABAREYFWrVrhs88+Q506dWAwGCCEwNWrV9G/f3/4+vrC398fgwcPxs2bN+VrSs9btWoVQkJC4OPjg+eee86i7GM0GjF//nz5f9itWrXCjh075McvX74MjUaDjRs3Ijw8HF5eXvjf//6HsWPH4v79+3KmKiIiAoB1ScbZMX7++eeoXbs2AgICMHToUCQlJTn8en3zzTdo2rQpDAYDateujXfffVd+LDw8HO+++y72798PjUaD8PBwp94DZ8aSnJyMUaNGwdfXF1WrVrW4r8T8azBs2DAMHTrU4vHMzExUqlQJkZGR8njNS12JiYno27cvvL29ERoaahUoSO/JyZMn5WP37t2DRqPBvn37AADZ2dl4/vnnERoaCm9vbzRs2BArVqxw+Pq//vprNG/eHN7e3qhYsSK6d+9uN+vYtm1bi9c+YMAA6PV6PHjwAACQkJAAjUaD8+fPy+d8//33aNmyJapXr251PSEExowZg/r16+PAgQPo06cP6tati1atWmHu3LnYunWrfO6MGTPQoEED+Pj4oE6dOnjrrbcsgnFn3kej0YglS5agXr16MBgMqFmzJt5++2358evXr2PIkCGoUKECKlasiP79++Py5cvy41KZcPHixahWrRoaNGjg8GtL5AoGPlQmeXt7W/ww/+OPP7Bx40Z888038i+8AQMG4M6dO4iJiUF0dDQuXbqEIUOGWFxHet53332HHTt24OTJk3j55Zflx1esWIF3330X//73v3Hq1Ck8+eST6NevHy5evGhxnRkzZmDSpEmIjY1Ft27dsHz5cvj7+yM+Ph7x8fGYNm2a1WsQQjg1xkuXLmHLli3Ytm0btm3bhpiYGLzzzjt2vzbHjh3D4MGDMXToUJw+fRoRERF46623EBUVBcBUOnrhhRfQsWNHxMfHY9OmTU59zZ0Zy+uvv469e/di8+bN2LVrF/bt24djx47Zvd6IESPw7bff4uHDh/KxnTt3Ijk5GYMGDbL5nDFjxuDy5cvYs2cPvv76a3z00UdITEx0+jUApl/sNWrUwMaNG3Hu3DnMmTMHb7zxBjZu3Gjz/Pj4eAwbNgzjxo1DbGws9u3bh4EDB8LeVonh4eFykCWEwIEDB1ChQgUcPHgQALB3714EBwejYcOG8nO+/fZb9O/f3+b1Tp48ibNnz2Lq1KnQaq1/7JuXJP38/BAVFYVz585hxYoV+PTTT/Gf//zH4vz83sdZs2ZhyZIleOutt3Du3DmsX78eQUFBAEz9YV27doWvry/279+PgwcPwtfXF7169UJGRoZ8jd27dyM2NhbR0dHYtm2bzddFpIg7O6sSlQSjR48W/fv3l//+yy+/iIoVK4rBgwcLIUw7kXt4eIjExET5nF27dgmdTieuXr0qHzt79qwAIH799Vf5eTqdTly7dk0+Z/v27UKr1Yr4+HghhBDVqlUTb7/9tsV4HnnkETFx4kQhhBBxcXECgFi+fLnFOZGRkSIgIMDqtdSqVUv85z//cWmMPj4+4sGDB/I5r7/+uujQoYPdr9fw4cNFjx49LI69/vrrokmTJvLfJ0+e7HB3d1uvIb+xJCUlCU9PT/Hll1/Kj9++fVt4e3uLyZMn2/waZGRkiEqVKom1a9fKjw8bNkw899xz8t/DwsLk558/f14AEIcPH5Yfj42NFQDka0rvyYkTJ+Rz7t69KwCIvXv32n29EydOFIMGDZL/bv59d+zYMQFAXL582e7zzX377bciICBAZGdni5MnT4rKlSuLV199Vbz++utCCCFefPFFMWTIEPn8tLQ04efnJ06dOmXzehs2bBAAxPHjx526v7mlS5eKtm3byn/P73188OCBMBgM4tNPP7V5vdWrV4uGDRsKo9EoH0tPTxfe3t5i586dQgjT1y4oKEikp6e7PF6i/DDjQ2XCtm3b4OvrCy8vL3Ts2BFdunTB+++/Lz9eq1Yti96R2NhYhISEICQkRD7WpEkTlC9fHrGxsfKxmjVrokaNGvLfO3bsCKPRiPPnz+PBgwe4ceMGOnfubDGWzp07W1wDANq1a+fya3J2jLVr14afn5/896pVqzrMcMTGxtoc88WLF5Gdne3yOM05GsulS5eQkZGBjh07yo8HBgZaZDXy8vDwwHPPPSeXq5KTk7F161aMGDHC5vmxsbHQ6/UWX+9GjRopasL++OOP0a5dO1SuXBm+vr749NNPcfXqVZvntmzZEt26dUPz5s3x3HPP4dNPP8Xdu3ftXrtLly5ISkrCiRMnEBMTg7CwMHTt2lXuw9m3bx/CwsLk8/fs2YOKFSuiefPmNq8ncjJLGo0m39f19ddf47HHHkNwcDB8fX3x1ltvWb0uR+9jbGws0tPT0a1bN5vXP3bsGP744w/4+fnB19cXvr6+CAwMRFpaGi5duiSf17x5c/b1UIFg4ENlQteuXXHy5EmcP38eaWlp2LRpE6pUqSI/Xq5cOYvzhRA2f0nYOy6RHjM/J+/5tq6R9/7OcHaMeRu1NRoNjEajS9cVdkoyrnI0FqX3GDFiBH788UckJiZiy5Yt8PLywlNPPWXzXGcCAKkUZD6evA3nGzduxKuvvopx48Zh165dOHnyJMaOHWtRqjGn0+kQHR2N7du3o0mTJnj//ffRsGFDxMXF2Tw/ICAArVq1wr59+xATE4Pw8HA8/vjjOHnyJC5evIgLFy5Y9FY5KnMBkHtk8gbceR0+fBhDhw7FU089hW3btuHEiROYPXu21ety9D56e3s7vIfRaETbtm1x8uRJi48LFy5g+PDh8nlK/k0QOYOBD5UJ5cqVQ7169VCrVi2nZmw1adIEV69exbVr1+Rj586dw/3799G4cWP52NWrV3Hjxg357z///DO0Wi0aNGgAf39/VKtWTe7LkBw6dMjiGrZ4enrmm11xdoyuatKkic0xN2jQADqdTvF181OvXj14eHjg8OHD8rG7d+/iwoULDp/XqVMnhISEYMOGDVi3bh2ee+45u5mCxo0bIysry2L69vnz5y0a0qXMX3x8vHzMvNEZAA4cOIBOnTph4sSJaN26NerVq2eRrbBFo9Ggc+fOmDdvHk6cOAFPT09s3rzZ7vnh4eHYu3cv9u/fj/DwcJQvXx5NmjTBwoULUaVKFfk9FkLgu+++Q79+/exeq1WrVmjSpAneffddm0Gv9Pp/+ukn1KpVC7Nnz0a7du1Qv359XLlyxeHryqt+/frw9vbG7t27bT7epk0bXLx4EVWqVEG9evUsPmwti0CkNgY+RDZ0794dLVq0wIgRI3D8+HH8+uuvGDVqFMLCwizKJF5eXhg9ejR+++03HDhwAJMmTcLgwYMRHBwMwNSsu2TJEmzYsAHnz5/HzJkzcfLkSUyePNnh/WvXro2HDx9i9+7duHXrFlJSUhSP0VVTp07F7t27sWDBAly4cAFr1qzBBx98YLPBWk2+vr54/vnn8frrr2P37t04c+YMxowZY7MZ15xGo8Hw4cPx8ccfIzo6Gv/4xz/sntuwYUP06tULL7zwAn755RccO3YM48ePt8hSeHt749FHH8U777yDc+fOYf/+/XjzzTctrlOvXj0cPXoUO3fuxIULF/DWW2/hyJEjdu/7yy+/YNGiRTh69CiuXr2KTZs24e+//3YYoIaHh2PHjh3QaDRo0qSJfGzdunUWZa5jx44hOTkZXbp0cfg1ioyMxIULF9ClSxf88MMP+PPPP3Hq1Cm8/fbbcraoXr16uHr1Kr788ktcunQJ7733nsPgzBYvLy/MmDED06dPx9q1a3Hp0iUcPnwYq1evBmDK0FWqVAn9+/fHgQMHEBcXh5iYGEyePBl//fWXS/ciUoKBD5ENGo0GW7ZsQYUKFdClSxd0794dderUwYYNGyzOq1evHgYOHIjevXujZ8+eaNasGT766CP58UmTJmHq1KmYOnUqmjdvjh07duDbb79F/fr1Hd6/U6dOeOmllzBkyBBUrlwZS5cuVTxGV7Vp0wYbN27El19+iWbNmmHOnDmYP38+xowZ49Z1nfGvf/0LXbp0Qb9+/dC9e3c89thjaNu2bb7PGzFiBM6dO4fq1atb9SflFRkZiZCQEISFhWHgwIF48cUXLcqeAPDZZ58hMzMT7dq1w+TJk7Fw4UKLx1966SUMHDgQQ4YMQYcOHXD79m1MnDjR7j39/f2xf/9+9O7dGw0aNMCbb76Jd999125JDoAcyISFhcmlubCwMGRnZ1sEPlu3bkWfPn2g1ztelq19+/Y4evQo6tatixdeeAGNGzdGv379cPbsWXl5gP79++PVV1/FK6+8glatWuHQoUN46623HF7XlrfeegtTp07FnDlz0LhxYwwZMkTuAfLx8cH+/ftRs2ZNDBw4EI0bN8a4ceOQmpoKf39/l+9F5CqNUKt4T1TGREREYMuWLVZlEKLC1KJFC7z55psYPHhwUQ+FqERgxoeIqITKyMjAoEGDHGaOiMgSt6wgIiqhPD09MXfu3KIeBlGJwlIXERERlRksdREREVGZwcCHiIiIygwGPkRERFRmMPAhIiKiMoOBDxEREZUZDHyIiIiozGDgQ0RERGUGAx8iIiIqMxj4EBERUZnx/4+7qFqExsxOAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "visualize_proportions_multiple(prediction_int_fixed, \"Interventional Data - Fixed Parameters\")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Using our intervened model we can clearly see that changing the mechanism by which individuals choose whether or not to smoke dramatically changes the joint distribution between smoking and cancer. In our observational model, individuals who smoke are much more likely to get cancer than those who don't smoke. However, in our modified model in which individuals are either forced to smoke or forced not no smoke, the dependence between smoking and cancer nearly disapears.\n", + "\n", + "The phenomenon we're observing in this (contrived) example is known as confounding. Here, the reason we see a statistical dependency between smoking and cancer in our original `causal_model` without any interventions is because of the individuals' stress. Given the parameters we happened to choose, individuals who are stressed are more likely to smoke and stress causes an increase in cancer. The confounding effect of stress dissapears in our intervened program, as stress no longer influences whether individuals smoke or not.\n", + "\n", + "In causal inference settings we often wish to answer a specific scientific or policy question using our causal models. For example, we may be interested in the **Average Treatment Effect** (ATE), the average difference in the proportion of individuals with cancer between individuals who were forced to smoke and those who were forced to not smoke. This ATE quantity can be expressed as a function of the population of individuals' attributes after applying an intervention." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def visualize_ATE(prediction, title, position=(0.6, 1)):\n", + " \n", + " cancer = prediction['cancer']\n", + " smokes = prediction['_RETURN']\n", + "\n", + " cancer_and_smokes = cancer * smokes\n", + " cancer_given_smokes = cancer_and_smokes.sum(1) / smokes.sum(1)\n", + " cancer_and_not_smokes = cancer * (1 - smokes)\n", + " cancer_given_not_smokes = cancer_and_not_smokes.sum(1) / (1 - smokes).sum(1)\n", + "\n", + " ate = cancer_given_smokes - cancer_given_not_smokes\n", + "\n", + " ax = sns.kdeplot(data=ate.detach().numpy())\n", + " ax.set(xlabel='Average Treatment Effect (ATE)', ylabel='Density', title=title)\n", + " return ax\n", + "\n", + "visualize_ATE(prediction_int_fixed, \"Interventional Data - Fixed Parameters\")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Note:** Just as in the observational setting above, the expectation of the proportion of individuals with cancer in this interventional setting also has a closed-form analytic solution that we can easily compute by hand. This is the case here because (i) the structure of our `causal_model` is isomorphic to a causal graphical model, and thus Pearl's backdoor adjustment formula applies, and (ii) all attributes ($stress$, $smokes$, $cancer$) are discrete. In more complicated examples this will not be the case. Using Pearl's $do$ notation (see Pearl, 2009), we have $P(c\\vert do(s)) = P(c\\vert s, t)P(t) + P(c\\vert s, \\neg t) P(\\neg t) = 0.5$, and anologously $P(c\\vert do(\\neg s)) = .45$. Therefore, we have that $ATE \\equiv E[P(c\\vert do(s))] - E[P(c\\vert do(\\neq s))] = 0.5 - 0.45 = 0.05$, which is again consistent with our answer above." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Transforming Causal Models using ChiRho - `do`" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "So far, we've accomplished some limited form of causal reasoning by manually rewriting our original program, replacing the mechanism for how individuals choose to smoke directly in Pyro's syntax, and then simulating from the new programs. In fact, even though we called our program a `causal_model`, we haven't seen anything that we couldn't already do in an ordinary probabilistic programming language. \n", + "\n", + "This manual approach is perfectly reasonable in simple scenarios where we have a single model and a single \"thought experiment\" we want to explore. However, as we'll see throughout these tutorials and examples, reasoning about cause and effect can often involve much more complicated compositions of program transformations. For example, in our [Mediation Analysis](mediation.ipynb) example we'll need to simulate multiple counterfactual models simultaneously, with intervention assignments in one model that depend on simulated outcomes in another. \n", + "\n", + "One of the key insights behind ChiRho (and borrowed from Pearl's structural formalism \\[Pearl 2009\\]) is that an intervention can be represented as model agnostic program transformation, that is, a function $I: \\mathcal{P} \\rightarrow \\mathcal{P}$, where $\\mathcal{P}$ is the space of programs in our language. In ChiRho, and in many formalisms for causal models, we'll assume that models satisfy a kind of locality-preserving property known as autonomy \\[Aldrich 1989\\]. This autonomy property implies that interventions can be accurately represented as an alteration of a small number of model components, and all other model components (and the causal relationships among them) remain unchanged.\n", + "\n", + "In that vein, ChiRho addresses the complexity of causal reasoning by automating a number of probabilistic program transformations; including interventions, construction of parallel counterfactual worlds, and (as we'll see in subsequent tutorials) automatic reparameterization for counterfactual or \"what if\" reasoning. \n", + "\n", + "For example, instead of rewriting the code by hand, we can implement our `forced_smokes_model` succinctly as follows using ChiRho's `do` program transformation. As the name implies, this special function `do` operates very similarly to the $do$ operator used with structural causal models and causal graphical models. Here, `do` takes as input a probabilistic program and a dictionary describing the intervention assignment and returns a transformed probabilistic program with the intervention applied." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "from chirho.interventional.handlers import do\n", + "\n", + "def forced_smokes_model(stress_pt, smokes_cpt, cancer_cpt, smokes_assignment):\n", + " transformed_model = do(causal_model, {\"smokes\": smokes_assignment})\n", + " return transformed_model(stress_pt, smokes_cpt, cancer_cpt)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Just as with our manual implementation of the `forced_smokes_model`, models constructed using ChiRho's `do` transformation are probabilistic programs in Pyro, and can thus freely compose with all of Pyro's effect handlers. For example, we can again use an `plate` effect handler to sample from a population of individuals by calling our `forced_smokes_model` in the context of a Pyro `plate`." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([0., 1., 0., ..., 1., 0., 1.])" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def population_forced_smokes_model(n_individuals, stress_pt, smokes_cpt, cancer_cpt):\n", + " # Let's imagine that we force half the people to always smoke and half to never smoke.\n", + " smokes_assignment = torch.tensor([0., 1.]).repeat(n_individuals // 2)\n", + " with pyro.plate(\"individuals\", n_individuals, dim=-1):\n", + " return forced_smokes_model(stress_pt, smokes_cpt, cancer_cpt, smokes_assignment)\n", + "\n", + "population_forced_smokes_model(n_individuals, stress_pt, smokes_cpt, cancer_cpt)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To recap, so far we've constructed a causal model describing how data is generated in the actual world we can observe, which we called `causal_model`, and transformed our causal model to represent our thought experiments, or interventions, resulting in the `forced_smokes_model` program. Then, we sampled from our original and transformed models to generate simulated outcomes, and finally summarized the simulated outcomes yielding an answer to our causal query. Again, this process can be viewed somewhat abstractly as follows:" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![fig2](figures/Interventional_Conditional.png)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this section, we've seen that a probabilistic program specifies a causal model by:\n", + " 1. specifying a \"default\" or \"observational\" joint distribution over the variables of interest according to the usual semantics of probabilistic programming languages, and\n", + " 2. encoding the information necessary for determining the new joint distribution under an arbitrary intervention (program transformation)---to apply the transformation and derive the new joint distribution." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Observation 2: causal uncertainty is probabilistic uncertainty\n", + "\n", + "We've shown how to define a causal model as a probabilistic program, and how to use ChiRho's intervention program transformations, `do`, to answer causal questions. However, in doing so we made a few very strong assumptions.\n", + "\n", + "1. We assumed that we knew the **parameters** of our causal model exactly, i.e. we asserted *how much* variables causally affect which other variables.\n", + "2. We assumed that we knew the **structure** of our causal model exactly, i.e. we asserted *which* variables causally affect which other variables.\n", + "\n", + "In this section, we'll show how we can use ChiRho to substantially relax these assumptions, representing broad uncertainty over causal structure and parameters. Simply put, we can introduce uncertainty over causal model parameters the same way we would write any other Bayesian hierarchical model, by composing a prior distribution over parameters with our original causal model." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Adding Uncertainty over Model Parameters" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/svg+xml": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "cluster_individuals\n", + "\n", + "individuals\n", + "\n", + "\n", + "\n", + "stress_pt\n", + "\n", + "stress_pt\n", + "\n", + "\n", + "\n", + "stress\n", + "\n", + "stress\n", + "\n", + "\n", + "\n", + "stress_pt->stress\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "smokes_cpt\n", + "\n", + "smokes_cpt\n", + "\n", + "\n", + "\n", + "smokes\n", + "\n", + "smokes\n", + "\n", + "\n", + "\n", + "smokes_cpt->smokes\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "cancer_cpt\n", + "\n", + "cancer_cpt\n", + "\n", + "\n", + "\n", + "cancer\n", + "\n", + "cancer\n", + "\n", + "\n", + "\n", + "cancer_cpt->cancer\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "stress->smokes\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "stress->cancer\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "smokes->cancer\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from pyro.distributions import Beta\n", + "\n", + "def parameter_prior():\n", + "\n", + " stress_pt = pyro.sample(\"stress_pt\", Beta(1., 1.))\n", + " smokes_cpt = pyro.sample(\"smokes_cpt\", Beta(torch.ones(2), torch.ones(2)).to_event(1))\n", + " cancer_cpt = pyro.sample(\"cancer_cpt\", Beta(torch.ones(2, 2), torch.ones(2, 2)).to_event(2)) \n", + "\n", + " return stress_pt, smokes_cpt, cancer_cpt\n", + "\n", + "def bayesian_population_causal_model(n_individuals):\n", + " stress_pt, smokes_cpt, cancer_cpt = parameter_prior()\n", + " return population_causal_model(n_individuals, stress_pt, smokes_cpt, cancer_cpt)\n", + "\n", + "pyro.render_model(bayesian_population_causal_model, (n_individuals,))" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Simulating Observational Data with Uncertain Parameters" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We have now reached a stage where seeing what the observational or an interventional distribution downstream analytically becomes cumbersome (and it is impossible in more complex cases). But again, by sampling multiple times from the model, sampling 'n_individuals' and calculating the proportions of cancer in two groups each time, we can approximate how our new uncertainty about the parameters propagates to uncertainty about the relationship between smoking and cancer." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "predictive_bayesian = pyro.infer.Predictive(bayesian_population_causal_model, num_samples=num_samples, return_sites=(\"cancer\", \"_RETURN\"))\n", + "prediction_bayesian = predictive_bayesian(n_individuals)\n", + "visualize_proportions_multiple(prediction_bayesian, \"Observational Data - Uncertain Parameters\")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We see that our uniform uncertainty about the parameters propagates downstream, resulting in broad uncertainty about the observed relationship between smoking and cancer." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Simulating Interventional Data with Uncertain Parameters" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Earlier we showed how to extend the `population_causal_model` to the `bayesian_population_causal_model` by simply sampling from the prior over parameters and then calling `population_causal_model` with the sampled parameters. Perhaps not surprisingly, we can also apply this simple recipe with our `population_forced_smokes_model` to construct a `bayesian_population_forced_smokes_model` which also incorporates uncertainty over parameters.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "def bayesian_population_forced_smokes_model(n_individuals):\n", + " stress_pt, smokes_cpt, cancer_cpt = parameter_prior()\n", + " return population_forced_smokes_model(n_individuals, stress_pt, smokes_cpt, cancer_cpt)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkIAAAHFCAYAAAAe+pb9AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAACjlElEQVR4nOzdd3gUVffA8e9ueu+NFBJ66KH3XgQEFFAQpWPvXfT9AWLhtfFiA1EpgoqIAipVivQaeu8hkEIgIb3vzu+PSQIxCaRsSTmf59knk9nZuWeTTfbsnXvP1SiKoiCEEEIIUQNpzR2AEEIIIYS5SCIkhBBCiBpLEiEhhBBC1FiSCAkhhBCixpJESAghhBA1liRCQgghhKixJBESQgghRI0liZAQQgghaixJhIQQQghRY0kiJABYtGgRGo2G8PDwMj82PT2d6dOns3XrVsMHZmY///wzs2fPLvY+jUbD9OnTTRpPSfJ/fxEREaU6Lv9ma2uLr68vPXv2ZObMmcTFxZU7hlOnTjF9+vR7xmBswcHB3H///cXeFx4ejkajYdGiRaYNqozmzJlT4RiDg4MZP368QeKBoq8dS0tLAgICmDBhAlFRUQZrpzKKjo5m+vTpHDlyxNyhCCOwNHcAoupLT0/n3XffBaBHjx7mDcbAfv75Z06cOMFLL71U5L49e/YQEBBg+qAMYOHChTRq1IicnBzi4uLYuXMnH330EZ9++inLli2jT58+ZT7nqVOnePfdd+nRowfBwcGGD7oGmTNnDp6enhVKZFauXImzs7PhgsqT/9rJyMhg+/btzJw5k23btnH8+HEcHBwM3l5lEB0dzbvvvktwcDAtW7Y0dzjCwCQREpVWTk5OwSfPyqhDhw7mDqHcmjZtSps2bQq+Hz58OC+//DJdunRh2LBhnD9/Hh8fHzNGWDOlp6djb29vkHOFhYUZ5Dz/dudrp2fPnuh0Ot577z1WrVrFo48+WqFzZ2RkYGdnZ4gwq4SMjAxsbW3RaDTmDqVGk0tjokTjx4/H0dGRCxcuMHDgQBwdHQkMDOTVV18lKysLgIiICLy8vAB49913C7rN7/wke/78eUaPHo23tzc2NjaEhoby9ddfF2pr69ataDQalixZwquvvoq/vz82NjacPHkSjUbD/Pnzi8S3bt06NBoNf/75Z7naWrp0Ke+88w61atXC2dmZPn36cPbs2YLjevTowZo1a7hy5UqhSwL5irs0duLECYYOHYqbmxu2tra0bNmSH374oVztA2zcuJGhQ4cSEBCAra0t9erV48knn+TmzZsl/drKLSgoiM8++4yUlBTmzZtXsD88PJxRo0YRHByMnZ0dwcHBPPLII1y5cqXgmEWLFvHQQw8B6ptj/s8q//KOKZ9HWZXmdZ4vKyuLGTNmEBoaiq2tLR4eHvTs2ZPdu3cXHKMoCnPmzKFly5bY2dnh5ubGiBEjuHTpUqFz9ejRg6ZNm7J9+3Y6deqEvb09EydOJDg4mJMnT7Jt27aCn2N+D1tmZiavvvoqLVu2xMXFBXd3dzp27Mgff/xR5Hn9+9JYWV53ZZH/gSD/9fDuu+/Svn173N3dcXZ2plWrVsyfP59/r++dfwlzxYoVhIWFYWtrW9Cz/PXXX9OtWze8vb1xcHCgWbNmfPzxx+Tk5BT7M9yzZw+dOnUqeH0uXLgQgDVr1tCqVSvs7e1p1qwZ69evLxL/vf5nbN26lbZt2wIwYcKEgt/JnX/74eHhDBkyBHd3d2xtbQkLC+PXX38t1E7+pcW///6biRMn4uXlhb29PVlZWdy4cYMnnniCwMBAbGxs8PLyonPnzmzatKk8vxJRRpXzo7aoNHJychgyZAiTJk3i1VdfZfv27bz33nu4uLgwdepU/Pz8WL9+Pffddx+TJk1i8uTJAAXJ0alTp+jUqVPBm6yvry8bNmzghRde4ObNm0ybNq1Qe1OmTKFjx4588803aLVaAgMDCQsLY+HChUyaNKnQsYsWLcLb25uBAweWq623336bzp078/3335OcnMybb77J4MGDOX36NBYWFsyZM4cnnniCixcvsnLlynv+rM6ePUunTp3w9vbmiy++wMPDgx9//JHx48dz/fp13njjjTK1D3Dx4kU6duzI5MmTcXFxISIiglmzZtGlSxeOHz+OlZVVGX6b9zZw4EAsLCzYvn17wb6IiAgaNmzIqFGjcHd3JyYmhrlz59K2bVtOnTqFp6cngwYN4sMPP+Ttt9/m66+/plWrVgDUrVvXLM+jrO71OgfIzc1lwIAB7Nixg5deeolevXqRm5vL3r17iYyMpFOnTgA8+eSTLFq0iBdeeIGPPvqIhIQEZsyYQadOnTh69GihnraYmBgee+wx3njjDT788EO0Wi1vvvkmI0aMwMXFhTlz5gBgY2MDqIlYQkICr732Gv7+/mRnZ7Np0yaGDRvGwoULGTt27D2fa2led2Vx4cIF4PbffEREBE8++SRBQUEA7N27l+eff56oqKiCn2W+Q4cOcfr0af7zn/8QEhJScGnt4sWLjB49mpCQEKytrTl69CgffPABZ86cYcGCBYXOERsby4QJE3jjjTcICAjgyy+/ZOLEiVy9epXffvuNt99+GxcXF2bMmMEDDzzApUuXqFWrFlC6/xmtWrVi4cKFTJgwgf/85z8MGjQIoOCy+D///MN9991H+/bt+eabb3BxceGXX35h5MiRpKenF7m8OXHiRAYNGsSSJUtIS0vDysqKMWPGcOjQIT744AMaNGhAYmIihw4dIj4+vsy/D1EOihCKoixcuFABlAMHDhTsGzdunAIov/76a6FjBw4cqDRs2LDg+xs3biiAMm3atCLn7d+/vxIQEKAkJSUV2v/cc88ptra2SkJCgqIoivLPP/8ogNKtW7ci5/jiiy8UQDl79mzBvoSEBMXGxkZ59dVXy93WwIEDCx3366+/KoCyZ8+egn2DBg1SateuXSQmRVGKPOdRo0YpNjY2SmRkZKHjBgwYoNjb2yuJiYllbv9Oer1eycnJUa5cuaIAyh9//FFwX/7v7/Lly8U+9t/H3fl7/jcfHx8lNDS0xPtzc3OV1NRUxcHBQfn8888L9i9fvlwBlH/++eeuMdzteRhC7dq1lUGDBhV734EDBxRAWbhwYcG+0r7OFy9erADKd999V2Lbe/bsUQDls88+K7T/6tWrip2dnfLGG28U7OvevbsCKJs3by5yniZNmijdu3e/29NUFEX9XeTk5CiTJk1SwsLCCt1Xu3ZtZdy4cQXfl/d1ly//tbN3714lJydHSUlJUVavXq14eXkpTk5OSmxsbJHH6HQ6JScnR5kxY4bi4eGh6PX6QvFZWFgU+rsuTv45Fi9erFhYWBT8HSvK7Z9heHh4wb74+HjFwsJCsbOzU6Kiogr2HzlyRAGUL774omBfaf9nFPe6ydeoUSMlLCxMycnJKbT//vvvV/z8/BSdTlfo5zd27Ngi53B0dFReeumlu/4chPHIpTFxVxqNhsGDBxfa17x580KXRUqSmZnJ5s2befDBB7G3tyc3N7fgNnDgQDIzM9m7d2+hxwwfPrzIeR599FFsbGwKzaJZunQpWVlZTJgwodxtDRkypMjzAkr13IqzZcsWevfuTWBgYKH948ePJz09nT179pS5/bi4OJ566ikCAwOxtLTEysqK2rVrA3D69OlyxXkvyr8uYaSmpvLmm29Sr149LC0tsbS0xNHRkbS0tFLHUJHnodPpCv0+9Xp9+Z7YXZTmdb5u3TpsbW2ZOHFiiedZvXo1Go2Gxx57rFDMvr6+tGjRosjMSjc3N3r16lWmWJcvX07nzp1xdHQs+FnOnz+/1L+Lir7uO3TogJWVFU5OTtx///34+vqybt26gp6uLVu20KdPH1xcXLCwsMDKyoqpU6cSHx9fZFZi8+bNadCgQZE2Dh8+zJAhQ/Dw8Cg4x9ixY9HpdJw7d67QsX5+frRu3brge3d3d7y9vWnZsmVBzw9AaGhooedZnv8Z/3bhwgXOnDlTMDbq3+eIiYkpctmxuP9x7dq1Y9GiRbz//vvs3bu3yCVAYVySCIm7sre3x9bWttA+GxsbMjMz7/nY+Ph4cnNz+fLLL7Gysip0y7+c9e8xIn5+fkXO4+7uzpAhQ1i8eDE6nQ5QL4u1a9eOJk2alLstDw+PIs8L1AGM5REfH19s/Pn/jP/dzX2v9vV6Pf369WPFihW88cYbbN68mf379xf8cy5vnHeTlpZGfHx8oTeQ0aNH89VXXzF58mQ2bNjA/v37OXDgAF5eXqWKoaLPo27duoV+nzNmzLjr8ZaWlgWvk3/Lzc0FKHIprjSv8xs3blCrVi202pL/bV6/fh1FUfDx8SnyOty7d2+pXu93s2LFCh5++GH8/f358ccf2bNnDwcOHGDixIml+puEir/uFy9ezIEDBzh8+DDR0dEcO3aMzp07A7B//3769esHwHfffceuXbs4cOAA77zzTrFtFPf8IyMj6dq1K1FRUXz++efs2LGDAwcOFIzb+fc53N3di5zD2tq6yH5ra2uAgp9Tef5n/Nv169cBeO2114qc45lnnin2HMU952XLljFu3Di+//57OnbsiLu7O2PHjiU2Nvau7QvDkDFCwmjc3NywsLBgzJgxPPvss8UeExISUuj7kmZPTJgwgeXLl7Nx40aCgoI4cOAAc+fOrVBbhubh4UFMTEyR/dHR0QB4enqW6XwnTpzg6NGjLFq0iHHjxhXszx+TYQxr1qxBp9MVlEFISkpi9erVTJs2jbfeeqvguPyxKqVR0efx119/FRq0fGeSVhwfH58S69rk7y/PjDgvLy927tyJXq8vMRny9PREo9GwY8eOggTjTv/eV9bZQj/++CMhISEsW7as0GP/PajbmEJDQwvNOLzTL7/8gpWVFatXry6UWK5atarY44t7/qtWrSItLY0VK1YU9BoCBq/hY4j/Gfl/01OmTGHYsGHFHtOwYcNC3xf3nD09PZk9ezazZ88mMjKSP//8k7feeou4uLhiB3gLw5JESFRYSZ8o7e3t6dmzJ4cPH6Z58+YFn8jKo1+/fvj7+7Nw4UKCgoKwtbXlkUceMUpbd7KxsSn1J+XevXuzcuVKoqOjC71ZL168GHt7+zJPt8//h/nvN887Z3QZUmRkJK+99houLi48+eSTBTEoilIkhu+//75Ir0tJr4OKPo9mzZqV/kkAffr04b333uPUqVM0bty40H2//vorjo6OtG/fvkznBBgwYABLly5l0aJFJV4eu//++/nvf/9LVFQUDz/8cJnbyFfS606j0WBtbV3ozTQ2NrbYWWPmkF/u4s5B1xkZGSxZsqRM54DCrxdFUfjuu+8MFyhl+59R0mu7YcOG1K9fn6NHj/Lhhx8aJK6goCCee+45Nm/ezK5duwxyTnF3kgiJCnNycqJ27dr88ccf9O7dG3d3dzw9PQkODubzzz+nS5cudO3alaeffprg4GBSUlK4cOECf/31F1u2bClVGxYWFowdO5ZZs2bh7OzMsGHDcHFxKXSModq6U7NmzVixYgVz586ldevWaLXaEj8NT5s2jdWrV9OzZ0+mTp2Ku7s7P/30E2vWrOHjjz8uEu+9NGrUiLp16/LWW2+hKAru7u789ddfbNy4sczP499OnDhRMJYhLi6OHTt2sHDhQiwsLFi5cmXBDCBnZ2e6devGJ598UvA73bZtG/Pnz8fV1bXQOZs2bQrAt99+i5OTE7a2toSEhBj1eRTnxRdfZPHixfTo0YO3336bZs2acevWLZYtW8Zvv/3GrFmzcHJyKvN5H3nkERYuXMhTTz3F2bNn6dmzJ3q9nn379hEaGsqoUaPo3LkzTzzxBBMmTCA8PJxu3brh4OBATEwMO3fupFmzZjz99NP3bKtZs2b88ssvLFu2jDp16mBra0uzZs0Kpps/88wzjBgxgqtXr/Lee+/h5+fH+fPny/PjMqhBgwYxa9YsRo8ezRNPPEF8fDyffvppsb1jJenbty/W1tY88sgjvPHGG2RmZjJ37lxu3bpl8HhL+z+jbt262NnZ8dNPPxEaGoqjoyO1atWiVq1azJs3jwEDBtC/f3/Gjx+Pv78/CQkJnD59mkOHDrF8+fK7xpCUlETPnj0ZPXo0jRo1wsnJiQMHDrB+/foSe5mEgZlzpLaoPEqaNebg4FDk2GnTpin/fuls2rRJCQsLU2xsbBSg0GyVy5cvKxMnTlT8/f0VKysrxcvLS+nUqZPy/vvvFxyTP6Nl+fLlJcZ47tw5BVAAZePGjcUeU5G2Ll++XGRmSEJCgjJixAjF1dVV0Wg0hZ43xcyUO378uDJ48GDFxcVFsba2Vlq0aFFkpklZ2j916pTSt29fxcnJSXFzc1MeeughJTIyskjbZZ01ln+ztrZWvL29le7duysffvihEhcXV+Qx165dU4YPH664ubkpTk5Oyn333aecOHGiyKwkRVGU2bNnKyEhIYqFhUWh51La52EosbGxytNPP60EBQUplpaWipOTk9KlS5diX19leZ1nZGQoU6dOVerXr69YW1srHh4eSq9evZTdu3cXOm7BggVK+/btFQcHB8XOzk6pW7euMnbs2EKzm7p37640adKk2PgjIiKUfv36KU5OTgpQaObif//7XyU4OFixsbFRQkNDle+++67YWEuaNVaa111xSjPjMP+5N2zYULGxsVHq1KmjzJw5U5k/f36R1+fdZvf99ddfSosWLRRbW1vF399fef3115V169YVmZVY0s+wpHMDyrPPPltoX2n+ZyiKoixdulRp1KiRYmVlVeR1e/ToUeXhhx9WvL29FSsrK8XX11fp1auX8s033xQcU9LPLzMzU3nqqaeU5s2bK87OzoqdnZ3SsGFDZdq0aUpaWlqxPx9hWBpF+dcUESGEEEKIGkJmjQkhhBCixpJESAghhBA1liRCQgghhKixJBESQgghRI0liZAQQgghaixJhIQQQghRY9W4gop6vZ7o6GicnJzKXN5eCCGEEOahKAopKSn3XPOvrGpcIhQdHV1kdXAhhBBCVA1Xr14lICDAYOercYlQfmn9q1ev4uzsbOZohBBCCFEaycnJBAYGlmuJnLsxayK0fft2PvnkEw4ePEhMTAwrV67kgQceKNVjd+3aRffu3WnatGmZViXOvxzm7OwsiZAQQghRxRh6WItZB0unpaXRokULvvrqqzI9LikpibFjx9K7d28jRSaEEEKImsCsPUIDBgxgwIABZX7ck08+yejRo7GwsGDVqlWGD0wIIYQQNUKVmz6/cOFCLl68yLRp00p1fFZWFsnJyYVuQgghhBBQxQZLnz9/nrfeeosdO3ZgaVm60GfOnMm7775r5MiEEML0dDodOTk55g5DVDNWVlZYWFiYOwyTqTKJkE6nY/To0bz77rs0aNCg1I+bMmUKr7zySsH3+aPOhRCiqlIUhdjYWBITE80diqimXF1d8fX1rRH19qpMIpSSkkJ4eDiHDx/mueeeA9TiiIqiYGlpyd9//02vXr2KPM7GxgYbGxtThyuEEEaTnwR5e3tjb29fI96shGkoikJ6ejpxcXEA+Pn5mTki46syiZCzszPHjx8vtG/OnDls2bKF3377jZCQEDNFJoQQpqPT6QqSIA8PD3OHI6ohOzs7AOLi4vD29q72l8nMmgilpqZy4cKFgu8vX77MkSNHcHd3JygoiClTphAVFcXixYvRarU0bdq00OO9vb2xtbUtsl8IIaqr/DFB9vb2Zo5EVGf5r6+cnBxJhIwpPDycnj17FnyfP5Zn3LhxLFq0iJiYGCIjI80VnhBCVFpyOUwYU016fWkURVHMHYQpJScn4+LiQlJSklSWFkJUOZmZmVy+fJmQkBBsbW3NHY6opirj68xY799Vro6QEEIIIQobP358qZeoEoVJIiSEEMLoxo8fj0ajQaPRYGVlhY+PD3379mXBggXo9Xpzh1eERqMhIiICgK1bt6LRaEpVrmDevHm0aNECBwcHXF1dCQsL46OPPjJusKJCJBESQghhEvfddx8xMTFERESwbt06evbsyYsvvsj9999Pbm6uucOrsPnz5/PKK6/wwgsvcPToUXbt2sUbb7xBamqquUMTdyGJkBA1iaJAegLEnYEru+HiFji7Hk79CWfXwYXNELELYo5CUhTkZJo7YlGN2NjY4Ovri7+/P61ateLtt9/mjz/+YN26dSxatKjguMjISIYOHYqjoyPOzs48/PDDXL9+vdC5/vrrL1q3bo2trS116tTh3XffLZRMTZ8+naCgIGxsbKhVqxYvvPBCwX3BwcF8+OGHTJw4EScnJ4KCgvj222+LjTkiIqJgUo+bmxsajYbx48cXe+xff/3Fww8/zKRJk6hXrx5NmjThkUce4b333is4Jv8S1ocffoiPjw+urq4Fsb/++uu4u7sTEBDAggULCp37+PHj9OrVCzs7Ozw8PHjiiSfummAdPHgQb29vPvjgA0BdrPyJJ57A29sbZ2dnevXqxdGjR0t8fE1SZeoICSHKKOkaRO6F6yfhxhn1lngV9GVcksHaCdxqg1uwenMPAbcQddu1NljIvxFzUxSFjBydydu1s7Ko8OyiXr160aJFC1asWMHkyZNRFIUHHngABwcHtm3bRm5uLs888wwjR45k69atAGzYsIHHHnuML774gq5du3Lx4kWeeOIJAKZNm8Zvv/3G//73P3755ReaNGlCbGxskTf9zz77jPfee4+3336b3377jaeffppu3brRqFGjQscFBgby+++/M3z4cM6ePYuzs3NBnZ1/8/X1Zdu2bVy5coXatWuX+Jy3bNlCQEAA27dvZ9euXUyaNIk9e/bQrVs39u3bx7Jly3jqqafo27cvgYGBpKenc99999GhQwcOHDhAXFwckydP5rnnniuUQObbunUrDzzwADNnzuTpp59GURQGDRqEu7s7a9euxcXFhXnz5tG7d2/OnTuHu7t7GX5j1Y/MGhOiusjJhAub4Nw6iNgJtyJKPtbWFew9wNIWLK3Bwhr0uZCbBbmZkJUC6fHqvruxsAGvhuDbDHyagm9T9at9zf7HakzFzeZJz86l8dQNJo/l1Iz+2FuXLhEeP348iYmJrFq1qsh9o0aN4tixY5w6dYqNGzcyYMAALl++XLAc0qlTp2jSpAn79++nbdu2dOvWjQEDBjBlypSCc/z444+88cYbREdHM2vWLObNm8eJEyewsrIq0l5wcDBdu3ZlyZIlgJpI+vr68u677/LUU08VOX7r1q307NmTW7du4erqWuJzjImJYdiwYezdu5cGDRrQsWNHBg4cyIgRI9BqtQU/h61bt3Lp0qWCfY0aNcLb25vt27cDatFMFxcXvv/+e0aNGsV3333Hm2++ydWrV3FwcABg7dq1DB48mOjoaHx8fAp+vhMmTGDMmDHMmzePRx55BFATrwcffJC4uLhCKy3Uq1ePN954oyCJvFNNmjUmH+WEqMr0evXy1rFl6qWt7JTb92m04NcC/FqCdyh4NVJ7cxx9wLIUy84oCmQlQ0os3LoCty5DwmU1wbqV9zU3E2KPqbc7OQeAX3O1bb8WUKslOPka7GmL6kVRlIKepdOnTxMYGFhoTcjGjRvj6urK6dOnadu2LQcPHuTAgQMFl31ATR4yMzNJT0/noYceYvbs2dSpU4f77ruPgQMHMnjw4EKLdTdv3rxgW6PR4OvrW7CsRHn5+fmxZ88eTpw4wbZt29i9ezfjxo3j+++/Z/369QWJT5MmTQq2AXx8fAoVBrawsMDDw6MgntOnTxcMwM7XuXNn9Ho9Z8+excfHB4B9+/axevVqli9fzoMPPlhw7MGDB0lNTS1SiTwjI4OLFy9W6DlXB5IICVEVZSbD0aWwbx4k3PGPzDkAGg+BOj0hqAPYVuBTk0YDti7qzath0fv1ekiMgNgTcP1E3tfjkBgJydfU29m1t4939CmcGPm1AGd/tR1RIXZWFpya0d8s7RrC6dOnC5ZJujMputOd+/V6Pe+++y7Dhg0rcpytrS2BgYGcPXuWjRs3smnTJp555hk++eQTtm3bVtBD9O+eIo1GY7DZa02bNqVp06Y8++yz7Ny5k65du7Jt27aCsUbFtX23eEr6meQfl69u3bp4eHiwYMECBg0ahLW1NaD+vPz8/AouLd7pbj1cNYUkQkJUJVmpsHcO7P5S7a0BsHGBFqOg2QjwbwNaE82B0GrBvY56azzk9v7MJDUpij0G0UfUgdc3z0LqdTi/Qb3ls/csnBj5tQTXIEmOykij0ZT6ElVls2XLFo4fP87LL78MqL0/kZGRXL16tdClsaSkJEJDQwFo1aoVZ8+epV69eiWe187OjiFDhjBkyBCeffZZGjVqxPHjx2nVqlWZY8xPKHS6so/Daty4MQBpaWllfuyd5/jhhx9IS0sr6BXatWsXWq2WBg0aFBzn6enJihUr6NGjByNHjuTXX3/FysqKVq1aERsbi6WlJcHBweWOo7qqmn85QtQ0uVkQvhC2fwLpN9V9ng2g/ZPQfBTYOJo3vjvZukBwZ/WWLztNHbSdnxjFHIG40+pzubhZveWzc1OTIt9m4NlQfZ6e9WXcUTWQlZVFbGwsOp2O69evs379embOnMn999/P2LFjAejTpw/Nmzfn0UcfZfbs2QWDpbt3706bNm0AmDp1Kvfffz+BgYE89NBDaLVajh07xvHjx3n//fdZtGgROp2O9u3bY29vz5IlS7Czs7vrAOa7qV27NhqNhtWrVzNw4EDs7OxwdCz6N/f0009Tq1YtevXqRUBAADExMbz//vt4eXnRsWPHcv/cHn30UaZNm8a4ceOYPn06N27c4Pnnn2fMmDEFl8XyeXt7s2XLFnr27MkjjzzCL7/8Qp8+fejYsSMPPPAAH330EQ0bNiQ6Opq1a9fywAMPFPxcaypJhISo7K7shr9ehJvn1O/d60Kvd6Dxg6br/akoawcIbKfe8uVkqslRzJG821G4fgoybsGlrertTvYe4FFfTYrcgtXLai7+6lfnWmBV/EweUXmsX78ePz8/LC0tcXNzo0WLFnzxxReMGzeuYMyMRqNh1apVPP/883Tr1g2tVst9993Hl19+WXCe/v37s3r1ambMmMHHH3+MlZUVjRo1YvLkyYB6uee///0vr7zyCjqdjmbNmvHXX38VGSNTWv7+/rz77ru89dZbTJgwgbFjxxY7W6tPnz4sWLCAuXPnEh8fj6enJx07dmTz5s3lbhvUBVA3bNjAiy++SNu2bbG3t2f48OHMmjWr2ON9fX3ZsmULPXr04NFHH+Xnn39m7dq1vPPOO0ycOJEbN27g6+tLt27diiRSNZHMGhOissq4BRunwqHF6vcOXtDzHQh7DCyKzoSpFnKz1J6imCNqknTzPMRfgKSr936snbuaFNm7qzc7N3WfnZv6va2r2nNm46SWBMjftrKvUpfiKuNsHlH9VMbXmcwaE6Imubwdfn8cUmPV71uNg77vqm/q1ZmljTpeqFbLwvuz0yD+IsSfV5OjxKvqYOykKEiOgpx0yEhQb2Wl0RZOjKzzvto4quOvHL3Ugd6OPurMt/yv1g73PrcQotKTREiIykSXC9s+UscCoYBHPRjyJdTuZO7IzMvaIW86fvOi9ykKZCaqSVFKjFo5OyNB7VFLz/uacUs9JitVrZGUnfcVBRQ9ZCWpt7KwdVV/P5711a++zdSxTaUoE6DXK6Rm55KamUtqVi46vYKFVoNWo8HO2gJPR2tsLA0zI0sIcXeSCAlRWaRch+XjIHKP+n3YYzDgY+l5uBeNJu8ymJta0LG09Hq1Jyk/Kcq/ZafmJUzJ6i01Tq2llHpdTbRSrkNuhppYRYWrtzs5+qAEtCHVtx2X7VtyQhfIxfgsriakE5ucSWxSJjdSs7jXoARXeyt8nW1p6OtEM38Xmvq70CLAlapzEU+IqkESISEqg5ijsPQR9TKPtRMMnq1OhxfGo9XmXf5yLFuxx/xCk4lXIf4CadFnSLt2EssbJ3BNj0Cbeh3NmTU4nVlDcyBYsWe7vjm3dC25pm9JArfHNlhqNTjaWmKp1aBXQKdXSM/OJUenkJieQ2J6DmdiU/jjSDQAtlZaBjfxYlSoDbm6yrdiuxBVkSRCQtxFSmYOCWnZxKdlk5Seg42VFhc7K1zsrPBysjHM5YvTq2HF42rvhEd9GL0MPOpW/LzCoHJ0ei7dSON0TDKnY5I5FZPG6RhHbqY2A5oBYEsWjTVXaKM9SwftGdpanMVZk879Fnu532IvChrS/Dqib/Ig1s0ewMbZq0ihPEVRk6C4lCyiEtM5GZXMiegkjl5NIjY5k90Xb9IvyJtLN9NwywJPRxvsrOUymhDlJbPGhLjDpRup7LpwkwMRtzh45RZRiRklHmtloaGBjxPNA9RLFj0beePjXMbZFXu+hg1vq9t1esJDi8DOtdzxC8NIysjhVHRyQdJzOjaZc9dTyc4t2guj0UCIhwOhfs408nWivo8jdbwcqe1hj40WiDoI5zbA+b8LL0WisYD6fSFsDDTof8+ZgIqicCommR2no2nkmImbjz8aS7XQn6ONJT7OtjjYyGdbYRg1adaYJEKixkvLymXNsRiWhV/l4JVbRe63t7bA3cEaFzsrsnL1JGXkkJSRU+RNUaOB1kFu3NfUl6Et/fFyust6XooCW2eqA6MB2k6G+z6SldzNID07l5PRyRy9msjxqCSOXUvi8s3iqwA72ljSyNeJUD/nvJsTDX2dSl/V+dYVOLkSTvxeOCly8IawR6Ht42ptpLvIf4Py8Q8kNUdDUkYuCuq/cRc7K/xcbLGWgdaigiQRqsYkERL50rNz+X7HZb7dfonULHWVdQuthg513GkX7EGbYDeaB7jgZFv0k7qiKEQlZnAi741zz6V4DkcmFtxvbaHl/uZ+TOgcQrMAl38/WO0F2jtH/b7Xf6Dra1Wqlk1VdiMli32X49l7KZ7wiFucu56Cvpj/ggFudgUJT+O8W4CbHVqtgX5PN87B4SXqmnFpN9R9Wkto/AB0fAb8Wxf7sH+/QWXn6olLySQhLRtQCxJ6O9ng7WRT4vpUQtyLJELVmCRCQqdXWB5+lVkbzxGXkgVAsIc9D7cNZESrALzLenkrT0xSBhtOxLLqSDRHriYW7G8f4s5r/RvSNthdnam0+sXbRRIHfALtn6joUxJ3cSMli72X4gtuF28U7e3xcbaheYArzf1daB6ofnVzsDZNgLocOLdeXUA3Ysft/UEdocMz0GgQaG/38JT0BpWRrSM6KYO0vKTe3tqSQDc7bAy0MKqoWSQRqsYkEarZIm6m8eKyIxzNS1QC3e14o38jBjXzM9wnfeDo1UQW7rrMmuMx5OjUP7EeDTz5zPFHPE4tVov4Df0aWo42WJtCpSgKJ6OT2Xw6js1nrnPsWuH6QBoNNPJ1pkMdd9qHuBMW5Fb2sV3GEn0E9s5VL53pc9R9rrWh43PQagxY2d31DUpRFJIycohKzECnV9BqNNRytcPN3qpG9w5pNBpWrlzJAw88YO5QqoyalAjJgARRIyiKwvKD15j+50nSs3U42VryUp8GPNYhyCiF61oEujJ7VBhvDmjEl1susOxAJJ0ufY6H5Rr0aEgb8BVOkgQZjKIonI5JYfWxaFYfiyEyIb3Q/aF+znSs46Fe9gxxx9XeRL09ZVWrJQybB32mw4HvIHwBJF6Bda/D9o+h47PQbEyJD9doNLjaW2NvbcnVW+mkZeVy7VY6GdnW+LnaoTVzMhQXF8f//d//sW7dOq5fv16w3tj06dMrtCipEBUhiZCo9tKzc3n9t2OsORYDqJeq/jeyJbVcjb9Ip5+LHR8+2Iw3rH/H9cAaAKbkTGbdWk9e10Uwun1tLAzYE1XTxKdmsfJwFL+GX+Xc9dSC/bZWWrrW96JPqDc9G3nj7VQ5PtGWmrMf9J6qjh078hPs+gKSImHTdDj0K3T9n1qFvATWllrqeDpwIyWL2ORM4tOyycrVE+Ruj6WF+RbqHT58ODk5Ofzwww/UqVOH69evs3nzZhISyrE0ihAGUkWWrhaifG6kZPHIt3tZcywGS62GN+9rxM+PdzBJElRg37e4HvgfAJHtp3LceyjJmbn83x8nGTZ3N+evp5gulmpAURT2XornmZ8O0mHmZt5fc5pz11OxttTSv4kPXz4SxqH/68t3Y9swsm1Q1UuC7mRtD+0ehxcOwQPfgGcDyE6BzKS8xWijQJdd7EM1Gg3ezrYEezig1WhIzcrl4o1UsnJ0Jn4SqsTERHbu3MlHH31Ez549qV27Nu3atWPKlCkMGjSoIOZ58+Zx//33Y29vT2hoKHv27OHChQv06NEDBwcHOnbsyMWLFwude+7cudStWxdra2saNmzIkiVL7hrLjBkz8PHx4ciRIwDs3r2bbt26YWdnR2BgIC+88AJpabfHks2ZM4f69etja2uLj48PI0ZIsdPqRMYIiWrrQlwK4xce4NqtDNzsrfhubBvaBLubNogza+CXRwEFev4Hur+OTq/w874rfLzhLCmZuVhbaHmpb32e6FrHrJ/WK7vMHB1/Holm4e4ITsckF+xvHuDCw20CGdKyFs7FzPCrVvQ6Mk+t53K6PSG+LthaagAN2LmrFbItiy/ZkJGjIzI+nWydHkutlmAPe8MUYbSyL/Vsx9zcXNzc3Jg8eTL//e9/sbEpGqtGo8Hf359Zs2bRsmVL3nzzTY4cOUKdOnV44403CAoKYuLEibi6urJu3ToAVq5cyciRI5k9ezZ9+vRh9erVvPHGG2zcuJGePXsWnHflypUMHTqUl156iVWrVrFp0ybq16/P8ePH6dSpE++99x6DBg3ixo0bPPfcc7Ro0YKFCxcSHh5Ohw4dWLJkCZ06dSIhIYEdO3bwwgsvVPznV4nVpDFCkgiJaunI1UTGLdhPUkYOtT3sWTShHSGeJl6z61o4LLpfXZeq9Xi4f3ahN43YpEymrDjGP2fVqdMtAlz49KEW1PdxMm2clVxmjo6f90Uyb/tFriers/xsrbQ8GBbAmA61aVyrZv0dF7xB1fLCNicBstMgJwMWDjB9MG9Hl2ktvN9//53HH3+cjIwMWrVqRffu3Rk1ahTNm6uL6Wo0Gv7zn//w3nvvAbB37146duzI/PnzmThxIgC//PILEyZMICNDLXbauXNnmjRpwrffflvQzsMPP0xaWhpr1qwpOO/y5cv5448/CA8PZ+PGjQQEBAAwduxY7OzsmDdvXsHjd+7cSffu3UlLS2Pt2rVMmDCBa9eu4eRUc/42a1IiJB8/RbVzIiqJMfP3kZSRQ1iQKyue7mT6JCjhMvw8Uk2C6veDgZ8V+eTs62LLgvFt+fShFjjZWnL0WhKDvtjJnK0XZB0p1LFd322/RJeP/mHG6lNcT87C19mWtwY0Yu+U3swc1qzGJUGF2Diql8o86oNN1XiDHj58ONHR0fz555/079+frVu30qpVKxYtWlRwTH5SBODj4wNAs2bNCu3LzMwkOVntFTx9+jSdO3cu1E7nzp05ffp0oX0vv/wye/bsYceOHQVJEMDBgwdZtGgRjo6OBbf+/fuj1+u5fPkyffv2pXbt2tSpU4cxY8bw008/kZ5eeDC+qNpksLSoVk7HJPPY/H2kZObSNtiNHya2K33VX0PJSlEXUE2/Cb7NYcTCEitGazQaRrQOoEs9T95eeZwtZ+L4eP1Z1p+I5bMa2juUmpXL4j0RfL/jckGRQH9XO57pWZcRrQOMMsuvSrNxBJ+m8NoFSItTxw/ls3IAB0+wdSlIxHV6hSsJ6owyrUZDsId9+ZfmsLIv80NsbW3p27cvffv2ZerUqUyePJlp06Yxfvx49ZRWty9v5k/5L26fXq8vsi+foihF9vXt25elS5eyYcMGHn300YL9er2eJ598sthLXUFBQVhbW3Po0CG2bt3K33//zdSpU5k+fToHDhzA1dW1zM9fVD6SCIlq40JcCo99v4/E9BxaBrqyYHxb0ydBej2sfApunAZHXxj9q/pGdQ++LrbMH9eGFYeiePevkxy7lsSgL3fyWr8GTOpSp0bMLMvM0bF4TwRztl4kMV2toRPkbs9zPevxYCt/rGT8VMk0GnD0Um85GZAaBxm3AH1ecpQI9h5g546FtTXBvg5ExKeRmpVLRArUsbHBztR/K3kaN27MqlWryv340NBQdu7cydixYwv27d69m9DQ0ELHDRkyhMGDBzN69GgsLCwYNWoUAK1ateLkyZPUq1evxDYsLS3p06cPffr0Ydq0abi6urJlyxaGDRtW7rhF5SGJkKgW4lIyGTt/P/Fp2TTzd+GHie2KXRrD6HZ8BmdWg4U1jPxRnQZdShqNhuGtA+hS35M3fz/G1rM3+HDtGTaeus6nD7WgtoeJL++ZiE6vsOLQNf638RzRSZkA1PF04Lle9RjSopYMIC8rKztwqw3OtSDtptozqcuGlBj1ZuOM1t6d2u7ORMRnkJady+Wb6dTxcsDWiFWo4+Pjeeihh5g4cSLNmzfHycmJ8PBwPv74Y4YOHVru877++us8/PDDtGrVit69e/PXX3+xYsUKNm3aVOTYBx98kCVLljBmzBgsLS0ZMWIEb775Jh06dODZZ5/l8ccfx8HBgdOnT7Nx40a+/PJLVq9ezaVLl+jWrRtubm6sXbsWvV5Pw4YNK/LjEJWIJEKiysvM0fH44oNEJ2VSx9OBxRPb4WJnhiTo7Dr45wN1e+CnENi2XKfxcbZl4fi2/Bp+lRl/neJAxC3um72DtweF8lj7oGpTIVhRFLacieOj9WcKagD5udjyct8GDG8VUCN6wYzKwkpNxB191B6h9HjIToWsZMhKxkKjJcTGhVi9LQm5Nly+mUZdL0esLY2TeDo6OtK+fXv+97//cfHiRXJycggMDOTxxx/n7bffLvd5H3jgAT7//HM++eQTXnjhBUJCQli4cCE9evQo9vgRI0ag1+sZM2YMWq2WYcOGsW3bNt555x26du2KoijUrVuXkSNHAuDq6sqKFSuYPn06mZmZ1K9fn6VLl9KkSZNyxywqF5k1Jqo0vV7h+V8Os+ZYDK72Vqx8prPpB0YD3IqAb7pBVpK6kvygzwxy2qsJ6bz+21H2XlILznWt78lHw5ubtg6SERy8couP1p1hf4T6vFzsrHi2Z13Gdgw2aq9EdVCh2Tw5mZARDxmJheoP6dGQptiSoXXAw90dC+vST4sX1VNNmjUmPUKiSpu96RxrjsVgZaHhm8damycJys2G5RPUJCigHdz3X4OdOtDdnp8nd+CHPRF8tP4MO87fpN//tvPmfQ15tH1tg66PZgpnY1P4ZMNZNp2+DoCNpZYJnUN4untdXOyreQ2gysDKFqz8wamWOu0+MxEyk9DqsnHSZOCkZED8TRSNFo2VvToY2soWLO3UGkVaSVJF9SOJkKiyNp66zhdbLgDwwYPN6FDHwzyBbJoG0YfA1hVGLFAvSRiQVqthQucQujfw4rXlRzkUmcj//XGSVUeimTmsGQ2qwMyyyPh0/rfpHKuORKEooNXAQ60DealvffxcqnbvVpWk0aiD+G0cwdkfcrPISU8kMzURe7KwQK9eRstO/dfjLNTxbxZWoLVUEyONhXo+TV5xx39/Lal9NOriw/k3C0v1nBoZEyZMSxIhUSVdu5XOa8uPAjChczAPtwk0TyCnV8PeOer2g9+Aq/HiqOPlyPKnOvHj3it8vP4MB6/cYtAXOxjfKZjne9evlFWV41Iy+WrLBZbujyRHp16FH9TMj1f6NaCu171n0wkT0GjAyhYrF18ybTw4dTMNGyUbX1sdzlY6dRZabiboc0HRqbWxcjOMF4/WUk22LG3zerDyeqakN0oYiSRCosrJztXz3M+HScrIoUWAC1MGhN77QcaQeBX+eEbd7vgcNDR+ZV8LrYZxnYLp29iHqX+cZNPp63y34zIrDkXxWv+GPNwmsFIMMo5LzuT7nZdZsucKGXlrW3Wt78kb/RvRLMDFzNGJkjjZWuHvZs+1WxCRCUH29ri6WKt36nXquCJdjvpV0an79DpADwqgKLe31R152/nf30FRQNHn3XRqogXqV30u5KRDQb6lUZMhGyewc1VnxglhIJIIiSrnkw1nOHI1EWdbS74a3cpos1zuSq+HVU+rxev8W0PvaSZtvparHd+Pa8M/Z+J4b80pLt1IY8qK4yzYeZkXetdnYDM/syREkfHpzNt+keUHr5Gdqxa8axnoyhv3NaRTXU+Tx1OdGWuei7uDNZk5Om6mZnHtVgY2llq1xpDWArR2xktCFEVNgHQ5oMtSe6FyMtWxTPocyElTb6mx6pglezew8yixWKmomJo0j0peQaJK+edMHN/tuAzAJw+1INC97JVtDWLv1xCxQ/2UOuw7sLQ2Sxg9G3nTuZ4ni/dE8MXm85yPS+X5pYf5YvN5nu1ZjwHNfI1eiVmvV9hx4SaLd0ew5Wwc+f8/W9d249medenZ0LvaTPmvDPKrLKenp2NnZ5ykxM/FlqxcPSmZOUTEp1PP29H4BS01GnXskYUVcMfftaKoPVBZKeoHj6wU9dJccgakxIK9p1pI0sI8f4PVVf4yIndW9a6uZPq8qDJupWXTb/Z2bqRkMaFzMNMGm6mOx/WT8G0P9Z/z/bOhzQTzxPEvSRk5LNoVwfydl0jOVC8zeDhY81CbQEa3CyLIw7BJ44W4VP46Gs0fR6KIiL+99lK3Bl4806Mu7UPcJQEykpiYGBITE/H29sbe3t4oP+dcvZ6r8Rlk63TYWVkQ4G6PtjL8PnW5ajKUcQt0mXk7NWDnpi4nopXP9xWhKArp6enExcXh6uqKn1/pi8Iam6w+byCSCFVdLyw9zJ9Ho6nr5cCaF7qap95MbhZ82xPiTkKD++CRXypdvZXkzBx+2BXBT/siiU3OLNjf1N+Z3o186BPqQ5NazmWeep+RrePglVvsuXSTLWducDomueA+JxtLRrRRV4OvI4OgjU5RFGJjY0lMTDRqOzk6PTdSstAr4GBjgZt9Jet1yclUy1bkZqnfay3A1g2szdRTXI24urri6+tbqT7MVMtEaPv27XzyySccPHiQmJgYVq5cyQMPPFDi8StWrGDu3LkcOXKErKwsmjRpwvTp0+nfv3+p25REqGpadzyGp386hFYDK57pTMtAV/MEsnEa7Jqtdsc/swccvc0TRynk6vRsORPHj/si2XH+Bnf+pTtYWxDq50yTWs7U8XLE1d4KV3trHG0sycrRkZ6tIy07l6sJ6Vy8kcalG6mcjkkhW3d7oUtLrYZuDbwY3MKPfo19y79wpyg3nU5HTk6OUdvYdzmet1ceBwWe61WfB8P8jdpeuUTuhe2fQOIV9fuAdtBneqX++6zMrKyssLCofLP0qmVBxbS0NFq0aMGECRMYPnz4PY/fvn07ffv25cMPP8TV1ZWFCxcyePBg9u3bR1hYmAkiFuZwMzWLd1adAOCZHvXMlwRFHYLdX6jbQ76o9P9kLS209GviS78mvtxMzWLLmTg2n77OjvM3ScvWEX7lFuFXbpXpnH4utnSs40HHuh70CfXBzaGS9RDUMBYWFkZ/w+oe6s+4G5l8uPYM//nrLLW9XOhUr5INfG/QA+p0hF1fwI5P4czvELkNhn8HdXuZOzpRyVWaS2MajeaePULFadKkCSNHjmTq1KmlOl56hKqeZ346yNrjsTTydeLP57qYZ5ZYbrY6LijuJDQdASPmmz4GA8nV6bl0M42T0UmcjEomOimDW2k53ErPJi07F1tLC+ytLbCztqCWix11vR2p4+lAIz9ngj2MMx5FVG6KovDKr0dZeTgKV3sr/ny2i8HHnBlM/EX4dRxcPw5ooPub0P0NqUNUDVTLHqGK0uv1pKSk4O7uXuIxWVlZZGVlFXyfnJxc4rGi8tly5jprj8diodXw2cMtzJMEAeycpSZB9p4w4GPzxGAglhZaGvg40cDHiQelI1WUgkajYeawZly6mcbRq4k8sSScFc90wt66Er6FeNSFyRth/VtwcBFs+y9cPwHD56sFGoX4lypdy/yzzz4jLS2Nhx9+uMRjZs6ciYuLS8EtMNBMFYhFmWVk65j6x0kAJnUJoUktMxXiiz2hjj8AGPgJOJhpKQ8hzMjWyoJ5j7XG09GGM7EpvP7bscpba8bKDgZ/Dg/OU6fVn1kNPw5Xp98L8S9VNhFaunQp06dPZ9myZXh7lzxWY8qUKSQlJRXcrl69asIoRUV8seU8125lUMvFlhd71zdPEHod/PmcWuit0f3Q5EHzxCFEJeDrYsvcx1phqdWw5lgM87ZfMndId9diFDy2Amyc4cpOWDhIrT0kxB2qZCK0bNkyJk2axK+//kqfPn3ueqyNjQ3Ozs6FbqLyOxubwnd5/2TfHdrUfDOSDsyH6MNg4wKDPqt0U+WFMLW2we5MG6LW8Pp4/Rm2n7th5ojuIaQrjF8DDt7quKGFAyE1ztxRiUqkyiVCS5cuZfz48fz8888MGjTI3OEII1AUhf+sOk6uXqFvYx/6NvYxTyDJMbB5hrrdZyo4+ZonDiEqmcfaBzGyTSB6BZ5fepgr8WnmDunu/JrDpA3gEgQJF2HJMMhINHdUopIwayKUmprKkSNHOHLkCACXL1/myJEjREZGAuplrbFjxxYcv3TpUsaOHctnn31Ghw4diI2NJTY2lqQkue5bnfxxJJoDEbewt7Zg+hAzVY8G2DAFslPAvw20nmi+OISoZDQaDTMeaELLQFeSMnJ4cslB0rNzzR3W3bnXgbGrbvcM/fywuo6ZqPHMmgiFh4cTFhZWUAPolVdeISwsrGAqfExMTEFSBDBv3jxyc3N59tln8fPzK7i9+OKLZolfGF56di7/XXcGgGd71sPf1UyrTJ/fBCdXgkYL9/8PtFWu81QIo7KxtOCbx1rj5VQFBk/n86gLY1aCrQtc3QfLxqiLvIoardLUETIVqSNUuf1v4zk+33wef1c7Nr/a3TzLaORkwJwOcCsCOjwL931o+hiEqCLCIxJ45Lu95OgU3ryvEU/3qGvukO7t6n5YPBRy0qHtZHX8n6j0jPX+LR9zRaURnZjBvO0XAXh7YKh5kiBQq9PeigCnWtBzinliEKKKaBPsXrAA8scbzrCtsg+eBghsByMWABo48D2ELzR3RMKMJBESlcZ/150hM0dPu2B3BjYz08DkxEi1eCJA/w/Axsk8cQhRhTzaPohRbQNRFHj+50OVf/A0QMMB0Os/6vba1+DKbvPGI8xGEiFRKRy8cos/j0aj0cDUwY3Nt4zD3/+B3Eyo3UVqBglRShqNhneHNiEsyJXkzFyeWHyQtKxKPngaoOur6t+5PlcdL5QodeZqIkmEhNkpisJ/150G4KHWATT1N1MF6Uvb4NQf6gDpAR9JzSAhyuDOwdNnr6fw+m9HK//gaY0Ghn4Nvs0g/Sb8Pgl0VSCBEwYliZAwuy1n4jgQcQsbSy2v9G1oniB0ObDuTXW77WTwbWqeOISownycbfnmsVZYWWhYezyWzzefN3dI92btACN/VKtPX913ezkdUWNIIiTMSqdX+Gi9Ol1+QucQfF3MtChi+AK4cRrs3KGHDJAWorxa13bnvaHqB4nZm86z6nCUmSMqBbdgtUwGwPaP4coes4YjTEsSIWFWKw9Hce56Ks62ljzd3UzTbjNuwdaZ6nav/4C9u3niEKKaGNUuiCe71QHgjd+OER6RYOaISqHZCGjxCCh6WPG4+n9B1AiSCAmzyczR8b+N5wB4pmc9XOytzBPI9k/Vf3pejaDVOPPEIEQ18+Z9jejX2IdsnZ4nlhwkMj7d3CHd28BPwC0Ekq7C6lfMHY0wEUmEhNn8uPcKUYkZ+DrbMr5TsHmCSLgE++ap2/0+AAszLe4qRDWj1WqYPaolzfxdSEjLZsKi/SRlVPIqzjZOMGI+aCzg5Ao4vdrcEQkTkERImEV6di5zt6rFE1/qU998xRM3TQd9DtTtBfX7mCcGIaope2tLvh/XBj8XWy7eSOOZnw6So9ObO6y7828NnfOWbVrzqizOWgNIIiTMYvGeK8SnZVPbw54RrQPME0Tk3tvT5fu9b54YhKjmfJxtmT+uLQ7WFuy6EM//rTpR+afVd38TPOpBaixs/D9zRyOMTBIhYXKpWbnM26b2Br3Qqz6WFmZ4GSoKbHhH3Q57DHzMuMq9ENVc41rOfDk6DK0GfjlwlW+3XzJ3SHdnZQtDvlS3Dy2GS1vNGo4wLkmEhMn9sDuCW+k5hHg6MLRlLfMEcWYNRIWDlT30fMc8MQhRg/Rq5MN/BjUGYOa6M/x+8JqZI7qH2p3UmmIAf74A2VVgsLcoF0mEhEmlZObw3Q710+ALveuZpzdIr4MteZfCOjwNTmZa10yIGmZC52AmdQkB4I3fj7Hx1HUzR3QPvaeBcwAkXoFds80djTASSYSESS3aFUFieg51vBwY0sLfPEEcX64WT7R1gU7PmycGIWogjUbDOwNDGd4qAJ1e4dmfD7H3Ury5wyqZrbO6+DLAztlwK8Kc0QgjkURImExKZg7f77wMwIu962OhNcNaXrnZ8M+H6nbnl8DOzfQxCFGDabUaPhrejD6hPmTn6nn8h3BORCWZO6ySNR4KId1Al3V7XKGoViQREiazZO8VkjJyqOvlwP3NzTQ26NAPaje3ow+0f8o8MQhRw1laaPlqdBjtQ9xJycpl3IL9XLqRau6wiqfRwICP1dpCZ1bDhc3mjkgYmCRCwiQysnXM36H2Bj3bs555eoOy024vqNjtdbC2N30MQggAbK0s+G5cG5rUciY+LZsx8/cTk5Rh7rCK5x0K7Z9Ut9e9qfYsi2pDEiFhEssORBKflk2Amx2DW5ipN2jfPEi9Dq61ZSkNISoBZ1srfpjYjhBPB6ISMxg7fz+30ippktHjLXDwgvjzsP9bc0cjDEgSIWF02bl65uXVDXmqe12szDFTLCPx9qyPnm+DpbXpYxBCFOHpaMOSSe3wdbblfFwqYxbsIzG9EiZDti7Qe6q6vf0TWZS1GpFESBjdysPXiEnKxNvJxnxVpHd/AZlJ4BUKzR4yTwxCiGIFuNnz4+R2eDhYcyIqmcfm7yMpvRKuS9byUfV/SGYi7PyfuaMRBiKJkDCqXJ2+YE2xJ7rVMc+aYinXYe9cdbvXf0BrpnXNhBAlquftxNInOlTuZEhrAX2mq9t7v4GkSl4UUpSKJELCqNaeiCUiPh1XeyseaRdkniB2fAY56eDfBhoNMk8MQoh7auDjxM+Pq8nQ8agkxizYV/lWrG/QH2p3VqfT55fiEFWaJELCaBRFKVhTbHynYBxsLE0fxK0rEL5A3e49VZ0KK4SotBr6qsmQu4M1x64lMWZ+JUuGNBroO0PdPvIzXD9p3nhEhUkiJIxm98V4TkYnY2dlwbiOweYJYvsnoM+BOj2gTnfzxCCEKBM1GWpfkAyNrWzJUEAbaPwAoMCmd80djaggSYSE0eTPFHu4TQBuDmaYpXXrChxdqm7LwqpCVCmNfJ35aXJ73OytOHotibEL9leuZKj3VLXI4vkNcC3c3NGICpBESBjF6Zhktp+7gVYDk7vWMU8QO2eBPhfq9ITAduaJQQhRbqF+zvz8eAc1GbqayGPfV6Kp9R51ocUj6raMFarSJBESRvFdXm/QgGZ+BLqboYJz4lU4/JO63f1N07cvhDCI/GTIPW8A9SPf7SM+NcvcYam6vQZaS7i4GSL3mTsaUU6SCAmDi07M4M+j0QA82c1MvUG7Zqtjg4K7Qu2O5olBCGEQoX7O/PJEBzwdbTgdk8wj3+0lLiXT3GGBewi0HK1ub5VeoapKEiFhcAt2XiZXr9CxjgfNA1xNH0BSFBxarG73eMv07QshDK6BjxPLnuyAj7MN566nMurbvVxPrgTJUNe8XqFLW+HKbnNHI8pBEiFhUKlZuSw7cBVQCyiaxa7PQZet1voI7mKeGIQQBlfXy5Ffn+yIv6sdl26kMXLeHqITzbxQq1ttCBujbstYoSpJEiFhUL8fvEZKVi51vBzo3sDL9AGkxMLBRep29zdM374QwqhqezjwyxMdCHS3IyI+nYfn7eFqQrp5g+r6KlhYQ8QOuLLHvLGIMpNESBiMXq+waHcEABM6BaPVmqF44a7P1YqvgR0gROoGCVEdBbrbs+yJjgR72HPtVgYj5+0h4maa+QJyDbw9g2znLPPFIcpFEiFhMNvO3eDyzTScbC0Z1soMi6umXL9dRbr7G1JFWohqrJarHcue7EhdLweikzIZ+e0eLt5INV9AnV8EjRbO/w0xx8wXhygzSYSEwSzM6w0a2SbQPMtp7PkScjPVNcXq9jJ9+0IIk/JxtuWXJzrSwMeR68lZjJy3l3PXU8wTjEddaPKgui0r01cpkggJg7gQl1pQQHFcp2DTB5B6Aw7MV7e7vym9QULUEF5ONix9vAOhfs7cTM1i1Ld7ORtrpmSoyyvq11OrIP6ieWIQZSaJkDCIRbsvA9An1Mc8BRT3fKWuMF8rDOr3NX37Qgiz8XC0Yenj7Wnm70JCWjaPfr/PPJfJfJtC/f6g6NVaZqJKkERIVFhSeg6/H4wCYHznYNMHkJ4A+79Tt6U3SIgaydXemh8ntadxXs/Q6O/2ciXeDAOou+b1Ch1ZCsnRpm9flJkkQqLCloVHkpGjo5GvEx3reJg+gP3fQk4a+DSDBveZvn0hRKXgYm/FkkntCsYMjf5uH9dumXhqfVAHtYaZPgf2zjFt26JcJBESFaLTK/yw+woAEzoHozF1b0x2Guz7Rt3u+rL0BglRw3k42vDj5PbU8XQgKjGDR7/fR2ySiStQd35R/XrwB8hMNm3boswkERIVsvHUdaISM3Czt2JoS3/TB3BoMWTcArcQCB1q+vaFEJWOt5MtPz3enkB3O67EpzP6+73cSDHhQq31+oJnA8hKhsNLTNeuKBezJkLbt29n8ODB1KpVC41Gw6pVq+75mG3bttG6dWtsbW2pU6cO33zzjfEDFSVauEsdJP1IuyBsrSxM23huNuz+St3u/CJYmGHKvhCiUvJzsePnyR2o5WLLpRtpPPb9PhLSsk3TuFYLHZ9Vt/fOBV2uadoV5WLWRCgtLY0WLVrw1Vdfler4y5cvM3DgQLp27crhw4d5++23eeGFF/j999+NHKkozsnoJPZdTsBCq2FMx9qmD+DEb5B8DRx9bld1FUKIPIHu9vz8eAe8nWw4ez2FsQv2kZploqSk+Uiw94Skq+p0elFpmTURGjBgAO+//z7Dhg0r1fHffPMNQUFBzJ49m9DQUCZPnszEiRP59NNPjRypKM4PeQUUBzT1xc/FzrSN6/Wwc7a63eEZsLI1bftCiCoh2NOBnx/vgIeDNSeiknlqyUGyc/XGb9jKDtpOVrf3fAWKYvw2RblUqTFCe/bsoV+/foX29e/fn/DwcHJycop9TFZWFsnJyYVuouLiU7NYdUSdGjrBHFPmz62Dm2fBxgXaTDR9+0KIKqOetyMLJ7TF3tqCnRdu8tryo+j1JkhM2k4GCxuIPgxXdhu/PVEuVSoRio2NxcfHp9A+Hx8fcnNzuXnzZrGPmTlzJi4uLgW3wMBAU4Ra7f1y4CrZuXqaB7jQKsjNtI0rCuzIW9iw7SSwdTZt+0KIKqd5gCvfPNYaS62GP49G8/6a0yjG7qVx9IIWo9TtPV8bty1RblUqEQKKTM/OfyGXNG17ypQpJCUlFdyuXr1q9BirO51eYen+SADGdjTDlPmInRAVrn7S6vC0adsWQlRZ3Rp48elDLQBYsOsy83deNn6j+YOmz66FWxHGb0+UWZVKhHx9fYmNjS20Ly4uDktLSzw8ii/kZ2Njg7Ozc6GbqJjt525w7VYGLnZW3N/cz/QB5C9oGPYYOHqbvn0hRJX1QJg/bw9sBMAHa0+z6dR14zbo1RDq9ASU2xXwRaVSpRKhjh07snHjxkL7/v77b9q0aYOVlZWZoqp5ftqnFlAc0TrA9FPmY47Cxc2g0UKn503bthCiWni8ax0eaReEosALvxzmRFSScRts/5T69fAStQisqFTMmgilpqZy5MgRjhw5AqjT448cOUJkpHrZZcqUKYwdO7bg+KeeeoorV67wyiuvcPr0aRYsWMD8+fN57bXXzBF+jRSVmMGWM3EAjG4fZPoA8meKNRkG7iGmb18IUeVpNBpmDG1C1/qepGfrmPTDAWKSMozXYP2+4BYMmUlw7FfjtSPKxayJUHh4OGFhYYSFhQHwyiuvEBYWxtSpUwGIiYkpSIoAQkJCWLt2LVu3bqVly5a89957fPHFFwwfPtws8ddEv+yPRK9Ap7oe1PVyNG3j8Rdv1+Po8rJp2xZCVCtWFlq+Gt2K+t7qumRPLD5IZo7OOI1pLaDdE+r2vnkylb6S0ShGHzZfuSQnJ+Pi4kJSUpKMFyqjHJ2eTv/dwo2ULL4e3YpBph4f9NdLcHAh1O8Hjy43bdtCiGrpakI6g7/aSWJ6DsNa+fPZQy2MMwEkIxFmhUJOOoz7C0K6Gb6Nas5Y799VaoyQMK9Np65zIyULT0cb+jb2ufcDDCklFo78pG5Lb5AQwkAC3e35enQrtBpYcSiKhbsijNOQnevtCvj75hmnDVEukgiJUvsxb5D0qLaBWFua+KWzdy7osiGwPQR1NG3bQohqrXM9T94eGAqoM8l2Xyy+Ll2F5V8eO7sWEiPvfqwwGUmERKlcupHKrgvxaDQwqp2Ji1JmJkH4AnW7y8tg6rpFQohqb1KXEB4M80enV3ju58PGGTzt3Ui9JKbo4eAPhj+/KBdJhESp5BdQ7NXQmwA3e9M2fuB7yEoGr1Co39+0bQshagSNRsPMYc1oUsuZhLRsnv/5MDk6I6xJ1maS+vXQYsjNNvz5RZlJIiTuKTNHx/KD1wB4tIOJp8znZKiXxQC6vARaeckKIYzD1sqCOY+2wsnGkvArt/hkw1nDN9JoEDj6QlocnPnL8OcXZSbvKuKe1h6PITE9B39XO7o3MHEl5yM/QdoNcAmCplImQQhhXLU9HPjkoeYAfLv9En+fjL3HI8rIwgpa5dXHO7DAsOcW5SKJkLinn/apl8VGtw/CQmvC8Tm6XNj1hbrd6Xn1H4gQQhjZfU39mNhZLdj62vKjXE1IN2wDrcep1fGv7IS4M4Y9tygzSYTEXZ2OSebglVtYajU81CbAtI2fWgWJV8DeQ11XTAghTOStAY1oGehKcmYuLy87Qq4hxwu5BECDAep2uPQKmZskQuKu8tcV69/EF28nW9M1rCi3F1dt/zRYm3iAthCiRrO21PLlI2EF44W++ueCYRtomzdo+uhSWX/MzCQREiVKy8pl1eFowAyDpC9sgusnwNoR2k02bdtCCIFabPH9B5sC8MXm8xyISDDcyev0BLcQdUbsid8Nd15RZpIIiRKtPhZNalYudTwd6FjHw7SN5/cGtR4Pdm6mbVsIIfIMbenPsFb+6BV46ZcjJGXkGObEWi20maBuH1psmHOKcpFESJTolwNXARjZNtA4a++UJHIfXNkFWivo+Kzp2hVCiGLMGNqUIHd7ohIzmPrHCcOduMUjoLWEawfg+inDnVeUiSRColhnY1M4HJmIpVbDsFYmHiSd3xvUYhQ41zJt20II8S+ONpZ8PqolWg38cSSatcdjDHRib2hwn7p9eIlhzinKTBIhUaxleb1BfUJ98HKyMV3D10/BuXWABjq/aLp2hRDiLsKC3HimRz0A/rPqBDdSsgxz4lbj1K9Hl0Kugc4pykQSIVFEVq6OFYfVStIjTb2u2K7P1a+Nh4BnfdO2LYQQd/FC7/o08nUiIS2bt1ceR1GUip+0Xm9wqgUZt+DM6oqfT5SZJEKiiL9PXicxPQc/F1u61fcyXcOJkXB8ubrd+SXTtSuEEKVgbanlfyNbYmWhYeOp66w4FFXxk2otbtdJOySXx8xBEiFRxK/h6mWxh1oHmLaS9O6vQNFBnR7g38p07QohRCmF+jnzUp8GAEz/6yTXkzMrftKwxwANXPoHbkVU/HyiTCQREoVcTUhnx/mbaDTwUBsTXhZLu3l7CmmXl03XrhBClNGT3erQIsCFlMxc/rPqRMUvkbnVVj8AAhz+qcLxibKRREgUsjyvN6hLPU8C3U1YzXnfPMjNgFphENLddO0KIUQZWVpo+WhE84JLZGsMMYus1Rj16+EfQa+r+PlEqUkiJAro9Aq/hucNkm5rwt6grBTY/6263eVlMGXNIiGEKIdGvs4Fs8im/XGSW2nZFTzh/Wrx2JRouLDZABGK0pJESBTYfu4GscmZuNlb0bexj+kaPvgDZCaCRz31n4EQQlQBz/SsSwMfR+LTsnlvdQULIlraqAUWAQ79UPHgRKlJIiQK/HIgEoBhrQKwsbQwTaO5WbDnK3W784vqDAohhKgCbCwt+Gh4czQaWHE4iq1n4yp2wrC8y2Pn1kNqBc8lSk0SIQFAXEomm0+rf3gmvSx2dCmkxICzPzQfZbp2hRDCAMKC3JjQKQSA//vjBJk5FRjf49MYAtqCPlf93yhMQhIhAcCKQ1Hk6hVaBbnSwMfJNI3qcmHnbHW70/NgaW2adoUQwoBe6dcAPxdbriZk8OWW8xU7Waux6tdDi8EQBRvFPUkiJFAUpWBJjVFtg0zX8KlVcOsy2Hvc/uMXQogqxtHGkmmDmwDw7fZLnL+eUv6TNXkQrBwg/gJE7jFQhOJuJBES7L+cwOWbaThYWzCouZ9pGtXrYcdn6naHp8HawTTtCiGEEfRv4kOfUG9ydArvrKxAbSEbJ2g6TN3Or60mjEoSIVHQGzSkZS0cbCxN0+j5DRB3CqydoO3jpmlTCCGMRKPRMH1IE+ysLNgfkcDyg9fKf7L8hVhProLMJIPEJ0omiVANl5KZw9oTajGwh01VSVpRYPun6na7yWDnapp2hRDCiALc7Hm5r7pY9EfrzpCUkVPOE7UBz4ZqkdmTqwwXoCiWJEI13NrjMWTm6Knr5UDLQFfTNBqxA6LCwdIWOjxjmjaFEMIExncKoa6XA/Fp2XyxuZwDpzUaaJlXU0hmjxmdJEI13O8H1dWTR7QORGOqis75Y4NajQVHb9O0KYQQJmBtqS0YOP3D7ojyD5xuPhI0WnXAdMIlA0Yo/k0SoRos4mYa+yMS0GrgwTB/0zR67SBc2gpaS3XKvBBCVDPdGnjRt7EPuXqFd/86Vb6B0861bi/EevQXg8YnCpNEqAZbcUgdzNe1vhe+LramaXTnLPVr85HgasKp+kIIYUL/N6gx1pZadl64yd+nrpfvJC1Gq1+PLlVn2gqjkESohtLrFX4/lH9ZLMA0jcadhjOrAQ10fsk0bQohhBkEedjzeFe14vT7a06Vr+J0o0HqzNrESIjcbeAIRT5JhGqovZfiiUrMwMnW0nQLrO78n/q18RDwamCaNoUQwkye6VEPX2e14vT3O8oxzsfaHpo8oG4fkUHTxiKJUA31W16Ni8EtamFrZYKFTm9FwPHf1O0urxi/PSGEMDMHG0umDGwEwNf/XCQ6MaPsJ2mZd3ns1CrITjNccKKAJEI1UGpWLutOxAImvCy2YxYoOqjbG2q1NE2bQghhZkNa1KJtsBsZOTpmrjtT9hMEdQS3YMhOhdOrDR6fkESoRlp7PIaMHB11vBwIM0XtoMRIOPKTut39DeO3J4QQlUR+xWmtBv46Gs2+S/FlPQG0yK8p9LPhAxSSCNVE+ZfFRrQOME3toB2fgT5XnQoa1MH47QkhRCXSpJYLo9qps2Sn/3UKnb6M0+lbjFK/XtoGSRVYukMUSxKhGuZKfBr7L6u1g4aFmeCyWOJVOJzfG/SW8dsTQohK6LV+DXG2teR0TDK/hl8t24PdgqF2Z0CBY8uMEV6NJolQDZM/Zb5zPU/T1A7aOQv0ORDSDWp3NH57QghRCbk7WPNiH3W27P82niM9O7dsJ8i/PHZkqbpeozAYSYRqEL1e4fc7LosZXdI1OLRE3ZbeICFEDTemQ22C3O2JS8ni+x2Xy/bgxkPB0g7iz0PUQeMEWEOZPRGaM2cOISEh2Nra0rp1a3bs2HHX43/66SdatGiBvb09fn5+TJgwgfj4Mg4+q6H2XU5QawfZWNK/ia/xG9yR1xsU3BWCOxu/PSGEqMSsLbW83r8hAPO2XeRGSlbpH2zrDKGD1e0jMmjakMyaCC1btoyXXnqJd955h8OHD9O1a1cGDBhAZGRkscfv3LmTsWPHMmnSJE6ePMny5cs5cOAAkydPNnHkVVP+IOn7TVE7KCkKDuf1BvWQ3iAhhAAY1MyPFgEupGXryr46ff6K9Cd+h9wyJFHirsyaCM2aNYtJkyYxefJkQkNDmT17NoGBgcydO7fY4/fu3UtwcDAvvPACISEhdOnShSeffJLw8HATR171pGXlsu5EDGCiy2I7/we6bKjdBYK7GL89IYSoArRaDW8NCAXg5/2RXLyRWvoHh3QHp1qQmQhn1xknwBrIbIlQdnY2Bw8epF+/foX29+vXj927i19TpVOnTly7do21a9eiKArXr1/nt99+Y9CgQSW2k5WVRXJycqFbTbT2eAzp2TpCPB1oFeRq3MaSouDQD+p2jzeN25YQQlQxHet60LuRNzq9wifrz5b+gVqL21Ppj8qSG4ZSrkTo8uUyDvIqxs2bN9HpdPj4FF7nysfHh9jY2GIf06lTJ3766SdGjhyJtbU1vr6+uLq68uWXX5bYzsyZM3FxcSm4BQYGVjj2qsiktYN2zc7rDeqsjg8SQghRyJsDGqHVwPqTsRy8klD6B+bPHruwCdJkfKwhlCsRqlevHj179uTHH38kMzOzQgH8+01ZUZQS36hPnTrFCy+8wNSpUzl48CDr16/n8uXLPPXUUyWef8qUKSQlJRXcrl4tY/2GauBqQjr7Lieg0cCDYf7GbSw5Bg7m9QZ1f1OtiiqEEKKQBj5OPNxG/WD+4dozKKWdEu/VAPxaqEVqT64wYoQ1R7kSoaNHjxIWFsarr76Kr68vTz75JPv37y/TOTw9PbGwsCjS+xMXF1eklyjfzJkz6dy5M6+//jrNmzenf//+zJkzhwULFhATE1PsY2xsbHB2di50q2l+P6T2BnWp50ktVzvjNrZrNuiy1PVxQroZty0hhKjCXu7bAFsrLQev3GLDyeulf2DzkerXY78aJ7AaplyJUNOmTZk1axZRUVEsXLiQ2NhYunTpQpMmTZg1axY3bty45zmsra1p3bo1GzduLLR/48aNdOrUqdjHpKeno9UWDtnCQp39VOpsuobR65WCRMjog6SToyF8obotvUFCCHFXPs62PN61DgAfrz9Djk5fugc2HQ4aLVzbDwmXjBhhzVChwdKWlpY8+OCD/Prrr3z00UdcvHiR1157jYCAAMaOHVtiL02+V155he+//54FCxZw+vRpXn75ZSIjIwsudU2ZMoWxY8cWHD948GBWrFjB3LlzuXTpErt27eKFF16gXbt21KpVqyJPpdraH5HA1QS1dlC/xkauHbTto9u9QXV6GLctIYSoBp7oVgcPB2su3UzjlwOlHLrh5Hv7f+zx34wWW01RoUQoPDycZ555Bj8/P2bNmsVrr73GxYsX2bJlC1FRUQwdOvSujx85ciSzZ89mxowZtGzZku3bt7N27Vpq164NQExMTKGaQuPHj2fWrFl89dVXNG3alIceeoiGDRuyYoVcJy1J/iDpQc39sLM2Yu2g+Iu3q0j3nia9QUIIUQpOtla82Kc+AJ9vOkdaVimX3mj2sPr12DJZcqOCNEo5rinNmjWLhQsXcvbsWQYOHMjkyZMZOHBgoctWFy5coFGjRuTmlnE9FSNLTk7GxcWFpKSkaj9eKC0rl7YfbCI9W8dvT3WkTbC78Rr7bRKc+A3q94NHlxuvHSGEqGZydHr6zNrGlfh03rivIc/0qHfvB2WlwCf1ITcDHt8C/q2NH6iZGev9u1w9QnPnzmX06NFERkayatUq7r///iJjd4KCgpg/f75BghTls/5ELOnZOoI97Gld2814DcUeV5MggF7/MV47QghRDVlZaHkpr1do3rZLJGfm3PtBNk7QKK+GngyarpByJUIbN27kzTffxNe38JgTRVEKLmVZW1szbty4ikcoys1ktYO2vK9+bTJMndYphBCiTIa08KeetyNJGTnML+2CrPmzx078DrrKdfWlKilXIlS3bl1u3rxZZH9CQgIhISEVDkpU3NWEdPZcildrB7Uy4myxyH1wbj1oLKDnO8ZrRwghqjELrYZX+jYAYP7Oy9xKy773g+r2BHsPSLsBl7YaN8BqrFyJUEnDilJTU7G1ta1QQMIwVhyKAqBTXQ/8jVU7SFFg8wx1O+xR8CzFdW0hhBDFuq+JL439nEnNyuWb7Rfv/QALK3UqPaiDpkW5WJbl4FdeeQVQq0FPnToVe3v7gvt0Oh379u2jZcuWBg1QlJ1er/DbIXUaplFrB13cAld2goWNWjdICCFEuWm1Gl7r34CJi8L5YXcEk7qE4O10j86F5iNh/7dwZjVkpYKNo2mCrUbKlAgdPnwYUHuEjh8/jrW1dcF91tbWtGjRgtdee82wEYoyO5BXO8jRxpL+TYxUO+jO3qC2k8HFBCvaCyFENdezoTdhQa4cjkxkzj8XmT6kyd0f4N8a3ELg1mU4uxaaP2yaQKuRMiVC//zzDwATJkzg888/r/bTz6uq/ErSg5r5YW9dpl9x6Z3+E2KOgLUjdH3FOG0IIUQNo9FoeK1fQx79fh8/74vk8W517j68QaNRe4W2/Ve9PCaJUJmVa4zQwoULJQmqpNKzc1lzTK3oPaKNkXppdLm3Z4p1fBYcPI3TjhBC1ECd6nrQoY472To9X205f+8H5Cc/F7dAapxxg6uGSt1dMGzYMBYtWoSzszPDhg2767FS6dl81p+IJS1bR20Pe9oYq3bQsV/g5jmwc1MTISGEEAaj0Wh4tV9DHvpmD7+GX+PJbnUJ9nQo+QEedcG/DUSFw4kV0OEp0wVbDZS6R8jFxaWgFo2Li8tdb8J88msHDW9lpNpB2enwz4fqdpdXwFZ+30IIYWhtg93p3sALnV7hi81l6BWS2WNlVq4lNqqy6rzExrVb6XT5SB3HtfPNngS42d/jEeWw/RP1sphLIDwXDlZSLkEIIYzh+LUkBn+1E40G/n6pG/V9nEo+OPUGfNYQFJ36v9mzvukCNZFKtcRGRkYG6enpBd9fuXKF2bNn8/fffxssMFF2K++oHWSUJCjlOuycrW73niZJkBBCGFGzABf6N/FBUWD2pnv0Cjl6Qb3e6rYsuVEm5UqEhg4dyuLFiwFITEykXbt2fPbZZwwdOpS5c+caNEBROoqi8Nuh20tqGMXWDyE7FWq1ul3ESwghhNG81EetNr32RAznr6fc/eD8JTeO/yor0pdBuRKhQ4cO0bVrVwB+++03fH19uXLlCosXL+aLL74waICidMKv3OJKfDoO1hbc19QItYOun4JDavJL/w9BW66XjhBCiDII9XMu6BX66p8Ldz+44QCwcoBbEXDtgEniqw7K9W6Wnp6Ok5N6rfLvv/9m2LBhaLVaOnTowJUrVwwaoCid38Lzagc1N1LtoI3/B4oeQgdD7Y6GP78QQohiPd9LHe/z19FoLt1ILflAawf1fzTIoOkyKFciVK9ePVatWsXVq1fZsGED/fr1AyAuLq7aDUCuCtKzc1lzXK0dNNwYC6xe2AwXNoHWCvq8a/jzCyGEKFFTfxd6N/JGr8DX/9xjDbL82WMnVoAux/jBVQPlSoSmTp3Ka6+9RnBwMO3bt6djR7WH4O+//yYsLMygAYp723AyltSsXILc7Wkb7G7Yk+t18Pf/qdvtHlfrVQghhDCp53urvUKrjkQRGZ9e8oEh3cHRBzIS1A+x4p7KlQiNGDGCyMhIwsPDWb9+fcH+3r1787///c9gwYnS+f2gOltseKsAtFoD1w468hPEnVTrBXV73bDnFkIIUSotA13plldXaM7Wu4wVsrCUFenLqNwjXn19fQkLC0N7x6DZdu3a0ahRI4MEJkonKjGDXRdvAjCslb9hT56VenspjW5vgL2Be5uEEEKU2ou96wFq4dxrt+7SK5R/eezsWshMNkFkVVu5EqG0tDT+7//+j06dOlGvXj3q1KlT6CZMZ+WhaygKdKzjQaC7gWsH7f4CUq+DW7B6WUwIIYTZtK7tTud6HuTqFeZuvctYIb+W4NkAcjPhzGqTxVdVlWt60eTJk9m2bRtjxozBz8/POEs5iHtSFOX2khqGrh2UHA278koh9HkXLG0Me34hhBBl9nyv+uy6EM/y8Gs816sefi7FrEyv0UCzh+Gf9+HoL9BytOkDrULKlQitW7eONWvW0LlzZ0PHI8rg4JVbRMSnY29twQBD1w76+/8gNwMC20PjoYY9txBCiHLpUMeDdiHu7L+cwLxtl5g+pEnxBzYboSZCl7dDcgw4+5k20CqkXJfG3NzccHeX8SLmlt8bNLCZHw42BqwddHkHnPgN0MCAj9RPF0IIISqFF/NmkC3dH0lccmbxB7mHqB9kUeDE76YLrgoqVyL03nvvMXXq1ELrjQnTysjWseaYWjvIoEtq6HJgbd7ssDYToJaUQxBCiMqkU10PWgW5kpWr59vtl0o+sNlD6tfjsvbY3ZQrEfrss8/YsGEDPj4+NGvWjFatWhW6CeP7+1QsKVm5BLrb0c6QtYP2fwc3ToOdO/T6P8OdVwghhEFoNBpeyOsV+nHfFW6mZhV/YJNhoLWEmKNw46wJI6xaynU95YEHHjBwGKKsCgZJG7J2UMp12DpT3e4zTabLCyFEJdW9gRctAlw4ei2Jhbsu83r/YkrXOHhAvT5wbr26In1v+XBbnHIlQtOmTTN0HKIMohMz2HlBrR1k0CU1Nk6FrGR1dfmwsYY7rxBCCIPSaDQ807MeTy45yOI9V3iqe12cbK2KHtjsITUROr4cev1HxnwWo9wFFRMTE/n++++ZMmUKCQkJgLoqfVRUlMGCE8VbeTgKRYH2Ie6Gqx10ZQ8c+wXQwKBPZXV5IYSo5PqG+lDXy4GUzFx+3hdZ/EENB4K1IyRegav7TRtgFVGud7tjx47RoEEDPvroIz799FMSExMBWLlyJVOmTDFkfOJfFEXh97zLYgYbJK3LhbWvqdutxoJ/a8OcVwghhNFotRqe6q6u//j9zstk5uiKHmRtf3tFehk0XaxyJUKvvPIK48eP5/z589ja2hbsHzBgANu3bzdYcKKoQ5GJXLqZhr21BQObGaguRPh8uH4C7Nygt1z2FEKIqmJoS3/8XGy5kZLFysMlXJHJnz0mK9IXq1yJ0IEDB3jyySeL7Pf39yc2NrbCQYmS5Q+SHtDUQLWDUuNgywfqdq//UwfXCSGEqBKsLbVM7qoubTVv20V0eqXoQSHdwcFbVqQvQbkSIVtbW5KTiy7kdvbsWby8vCoclCheZo6O1UejARje2kALrG6aDllJ4NcCWo83zDmFEEKYzKi2gbjaWxERn866EzFFD7hzRXq5PFZEuRKhoUOHMmPGDHJy1C42jUZDZGQkb731FsOHDzdogOK2DSfV2kH+rnZ0CDFAz83V/XDkJ3V74Gegtaj4OYUQQpiUg40l4zoGAzB360UUpZheofwV6c+shawU0wVXBZQrEfr000+5ceMG3t7eZGRk0L17d+rVq4eTkxMffPCBoWMUee5cYLXCtYP0Oljzqrod9hgEtq1gdEIIIcxlXKdg7KwsOBmdzI7zN4seUCsMPOqpa0ielhXp71SuQSbOzs7s3LmTf/75h4MHD6LX62nVqhV9+vQxdHwiT2xSJrsKagcZ4LJY+AKIPQa2Lurq8kIIIaosdwdrRrULZOGuCOZuvUi3Bv8appK/Iv3WD9XLYy0fMU+glVCZEyG9Xs+iRYtYsWIFERERaDQaQkJC8PX1RVEUNFKsyShWHL6GXoF2Ie7U9nCo2MnSbsKW99TtXv8HDp4VD1AIIYRZTe5ahyV7rrDnUjyHI28RFuRW+IDmD6mJ0KWt6koCTj5mibOyKdOlMUVRGDJkCJMnTyYqKopmzZrRpEkTrly5wvjx43nwwQeNFWeNpihKwWUxg9QO2jQdMpPApxm0nlDx8wkhhDA7f1c7hrZUrxh8s+1i0QPc60BAW1D0cHKFiaOrvMqUCC1atIjt27ezefNmDh8+zNKlS/nll184evQomzZtYsuWLSxevNhYsdZYh68mculGGnZWBqgddC0cDi9Rtwd9qs4mEEIIUS081V2dSr/h5HUuxBUzKLpZ3qDpY8tMGFXlVqZEaOnSpbz99tv07NmzyH29evXirbfe4qeffjJYcEK1PDy/dpAvjhWpHXTnAOkWj0BQBwNEJ4QQorKo7+NEv8bqJa952y4VPaDJg6CxgOjDcPOCiaOrnMqUCB07doz77ruvxPsHDBjA0aNHKxyUuC0j+3btoBFtKnhZ7NBiiDkCNs7Qd0bFgxNCCFHpPNVDXXZj5eEoYpMyC9/p6AX1eqvbUlMIKGMilJCQgI9PyYOrfHx8uHXrVoWDErf9fUqtHRTgVsHaQekJsDlvdljPt8HR2zABCiGEqFRaBbnRLtidXL3Cot0RRQ+48/JYcTWHapgyJUI6nQ5Ly5IvzVhYWJCbm1umAObMmUNISAi2tra0bt2aHTt23PX4rKws3nnnHWrXro2NjQ1169ZlwYIFZWqzKsm/LDa8VQVrB22eARm3wLsJtH3cQNEJIYSojB7vpo4V+mnfFVKz/vW+3GggWDnArQh13GgNV6YBJ4qiMH78eGxsbIq9Pysrq0yNL1u2jJdeeok5c+bQuXNn5s2bx4ABAzh16hRBQUHFPubhhx/m+vXrzJ8/n3r16hEXF1fm5KuqiErMYNdFtXZQhWaLRR2Cg4vU7YGfyABpIYSo5no38qaOpwOXbqbx64GrTOwScvtOawdoNEi9NHb81xpfULdMPULjxo3D29sbFxeXYm/e3t6MHTu21OebNWsWkyZNYvLkyYSGhjJ79mwCAwOZO3duscevX7+ebdu2sXbtWvr06UNwcDDt2rWjU6dOZXkaVcaKg9dQFOhYx4NAd/vynUSvh7WvA4raHRrc2aAxCiGEqHy0Wg2TuqrJz/ydl8nV6Qsf0Hyk+lVWpC9bj9DChQsN1nB2djYHDx7krbfeKrS/X79+7N69u9jH/Pnnn7Rp04aPP/6YJUuW4ODgwJAhQ3jvvfews7Mr9jFZWVmFeqqKWyy2MlIUhd8OGaB20JEfISocrJ2g33sGik4IIURlN7xVAJ/9fY6oxAzWn4zl/ua1bt9Zpwc4eEHaDbj4DzToZ7Y4za1ca40Zws2bN9HpdEUGX/v4+BAbG1vsYy5dusTOnTs5ceIEK1euZPbs2fz22288++yzJbYzc+bMQr1WgYGBBn0exrL/cgJX4tNxtLFkQDPf8p0kPUEtngjQ4y1wKud5hBBCVDm2VhaM6VAbgO+2Xyq8GKuFJTQZpm7X8NljZkuE8v17SY67LdOh1+vRaDT89NNPtGvXjoEDBzJr1iwWLVpERkZGsY+ZMmUKSUlJBberV68a/DkYQ34l6UHN/LC3LueYnn8+gPR48AqF9k8aMDohhBBVwZiOtbG21HL0WhIHIv41qzv/8tiZNZCVavrgKgmzJUKenp5YWFgU6f2Ji4srcYq+n58f/v7+uLi4FOwLDQ1FURSuXbtW7GNsbGxwdnYudKvs0rJyWXM8BqhA7aCYo+rCqpA3QNrKQNEJIYSoKjwdbRjeSn0f+Xb7vwos+rdSl93ISYeza80QXeVgtkTI2tqa1q1bs3HjxkL7N27cWOLg586dOxMdHU1q6u3M9dy5c2i1WgICDLAGVyWx9ngM6dk6gj3saVPb7d4P+De9Hta8pq4n03Q4hHQ1fJBCCCGqhEl5M8Y2n7nOxRt39Pzkr0gPNXrJDbNeGnvllVf4/vvvWbBgAadPn+bll18mMjKSp556ClAva905C2306NF4eHgwYcIETp06xfbt23n99deZOHFiiYOlq6I7F1gt6TLhXR1dCtf2g7Uj9HvfwNEJIYSoSup5O9In1BtFUWeQFdI8LxG6+A+k3jB9cJWAWROhkSNHMnv2bGbMmEHLli3Zvn07a9eupXZtdXBXTEwMkZGRBcc7OjqyceNGEhMTadOmDY8++iiDBw/miy++MNdTMLjI+HT2XU5Ao4FhrcrRy5WRCBunqtvd3wDnWnc9XAghRPU3uataYPH3g9eIT72j5p9HXfBvDYquxq5Ir1GUmlVfOzk5GRcXF5KSkirleKFZG8/xxebzdK3vyZJJ7ct+grVvwP554NkAntoFltaGD1IIIUSVoigKQ7/exbFrSbzUpz4v9Wlw+86938D6N8G/DTy+2XxB3oOx3r/NPmtM3KbXK/x+sAK1g2JPwIHv1O2Bn0gSJIQQAlBnaOf3Ci3Zc4XMHN3tO5sOU1ekjwqH+ItmitB8JBGqRPZciicqMQMnW0v6NyljzR9FgbV5A6QbP6AWyxJCCCHyDGzqi7+rHfFp2aw4FHX7Dkfv2+8Zx5ebJTZzkkSoEskfJD2kRS1srSzK9uDjyyFyD1jZQ/8PjBCdEEKIqszSQsuEzsEALNh1uXCBxfyaQsd+rXEr0ksiVEkkZ+aw7kRe7aCyXhbLSr09QLrrq+BSfUoJCCGEMJyRbQNxtLHkQlwqO87fvH1Ho0HqB+mEixB9yHwBmoEkQpXEmmMxZOboqeftSMtA17I9eMdnkBIDbiHQ8TmjxCeEEKLqc7K1KviwvWDXHVPpbRyh4UB1+1jNWnJDEqFKIv+y2ENlrR0UfxH2fKVu9/8QrGyNEJ0QQojqYnynYDQa2Hr2RuECiwUr0v8OulzzBGcGkghVAhdvpHLwyi0stBoeDPMv24M3vAO6bKjbGxoOME6AQgghqo1gTwd6N/IGYNGuiNt31O0J9h7qivSXt5olNnOQRKgSyO8N6t7AC2/nMvTonN8E59aB1hLu+69aLl0IIYS4h4md1WU3fjt4jaT0HHWnhdXtFemP1ZzZY5IImZlOr7Di0O3LYqWWmw3r31K32z8FXg3ufrwQQgiRp2NdDxr6OJGRo2NZ+O0VHAqW3Dj9F2SnmSc4E5NEyMx2nL/B9eQsXO2t6BXqXfoH7p8H8efBwUtdSkMIIYQoJY1Gw8QuwQD8sPsKuTq9ekdAW3ALhpw0OLvObPGZkiRCZrY877LYAy39sbEsZe2glOuw9SN1u890sHUxTnBCCCGqraEt/XGztyIqMYNNp6+rOwutSF8zZo9JImRGSek5bDypvvjKVDto8wzIToFaraDFaCNFJ4QQojqztbLg0fbqIucLdkbcviP/8tiFTZB2s+gDqxlJhMxo1ZEosnV6Gvk60aRWKReQu3YQjvyobg/8BLTyKxRCCFE+YzrWxlKrYX9EAieiktSdnvXBr2XeivQrzRqfKci7qJkoisIvB64CMKptYOlqB+n1sC5vPFCL0RDQxogRCiGEqO58nG0Z1NwP+FeBxTuX3KjmJBEykxNRyZyOScbaUssDpa0ddHKFujqwtSP0mWbcAIUQQtQIE/Km0q8+GkNcSqa6s+lw0Gjh2n5IuGTG6IxPEiEzyZ+u2L+JL6721vd+QE4mbHpX3e7yEjiVcXV6IYQQohgtA10JC3IlW6fnp715U+mdfG6vSF/NawpJImQGGdk6/jgSDaiXxUpl3zeQFAlOtaDDs0aMTgghRE2TX2Dxp31XyMrVqTtbPKJ+Pbq0Wq9IL4mQGaw7EUNKZi6B7nZ0rONx7wekxasLqwL0ngrW9sYNUAghRI1yX1NffJ1tuZmazV9HY9SdjQapQzFuXYar+8wboBFJImQGy/IGST/UOhCtthSDpLf9F7KSwbf57QFsQgghhIFYWWgZ20mdSr9w12UURQFrB2g8VD3gyM9mjM64JBEyscs309h3OQGtppS1g26eh/AF6na/92W6vBBCCKN4pG0QtlZaTkYncyDilroz//LYyVWQk2G22IxJ3lVN7NdwtTeoWwMvarna3fsBG6eBPhca3Ad1uhs5OiGEEDWVm4M1D4apH9AX7MybSl+7M7gEQVZStV1yQxIhE8rV6fk9b0mNkW1KMUg6YiecXQMaC+g7w8jRCSGEqOkmdA4G4O9TsVxNSFevQrTIG5JxdKn5AjMiSYRMaOvZG8SlZOHhYE3vUJ+7H6zXw4Z31O3W48GrodHjE0IIUbM18HGia31P9Aos3hOh7mw+Sv16YbO61mU1I4mQCeVXkh7Wyh9ry3v86I8vh5gjYO0EPaYYPzghhBCC271Cvxy4SlpWLnjWU1elV3Tqe1M1I4mQicQlZ/LP2TgARt6rdlBOhrqwKkDXl8HRy8jRCSGEEKoeDbwJ8XQgJTOX3w+pwzlu1xT6xXyBGYkkQiby26Fr6PQKrWu7Uc/b6e4H750LydfAOQA6PGOaAIUQQghAq9UwvlMwAIt2R6DXK9DkQbCwhuvHIfa4eQM0MEmETEBRFJaHl3KQdMYt2DVb3e79f2BVipllQgghhAENbx2Ak40ll26ksf38DbB3h4YD1DurWa+QJEImsP9yApdvpuFgbVGwym+Jdn0OmUng3RiaPWSaAIUQQog7ONpY8lDeB/dFuyPUnfmXx479Crpc8wRmBJIImUB+JenBLWrhYGNZ8oEpsbD3G3W71/+B1sIE0QkhhBBFjetUG41GnfF86UYq1OsD9p6QFgcXt5g7PIORRMjIktJzWHNcXbfl4XsNkt7+CeRmQEC7212QQgghhBnU9nCgdyNvAH7YHQEWVrevVFSjmkKSCBnZisPXyMrV08jXibBA15IPTLgMBxep272ngqYUa5AJIYQQRjS+k7oq/W8Hr5GcmQMt8moKnVkDGYnmC8yAJBEyIkVR+HlfJACj2wehuVtys3WmupRG3V4Q0tVEEQohhBAl61zPg/rejqRl69RJP34t1DGsuiw4tcrc4RmEJEJGFH7lFufjUrGzsuCBMP+SD7x+Uh18BmpvkBBCCFEJaDQaxucVWPxhdwQ6hdu9Qkeqx+UxSYSMaGleb9DgFn4421qVfOCW9wEFGg+FWmGmCU4IIYQohQfD/HG2tSQyIZ2tZ+Og2cOg0cLVvXDzgrnDqzBJhIwkMT2b1XmDpEe3r13ygVf3w9m16ouq539MFJ0QQghROvbWljzSLgiAhbsiwNlPnUEGcOQn8wVmIJIIGcnvh6LIztUT6udMiwCX4g9SlNtLabQcDV4NTBegEEIIUUqPdaiNVgM7L9zk/PUUCBuj3nHk5ypfU0gSISNQB0lfAe4xSPrSPxCxQy1b3v0tE0YohBBClF6guz19G/sAeQUWG9wH9h6QGgsXN5s3uAqSRMgI9l9O4OKNNOytLXigZa3iD7qzN6jNJHC9R40hIYQQwowmdFan0q84FEVStgaa5w2aPrzEjFFVnCRCRrB0vzpIekiLWjiVNEj6zBqIPgxWDtD1VRNGJ4QQQpRd+xB3Gvk6kZGjY1l4JIQ9pt5xdh2k3jBvcBUgiZCB3UrLZu2JWEC9LFYsRYFt/1W3OzwFjl4mik4IIYQoH41Gw8S8XqEfdl9B5xUKtVqpNfCOLTNzdOVn9kRozpw5hISEYGtrS+vWrdmxY0epHrdr1y4sLS1p2bKlcQMso98PXSM7V09Tf2eaB7gWf9DZdRB7HKwdoeNzJo1PCCGEKK8hLWvhZm9FVGIGG09dv90rdHiJ+iG/CjJrIrRs2TJeeukl3nnnHQ4fPkzXrl0ZMGAAkZGRd31cUlISY8eOpXfv3iaKtHQUReHnvMti+VMNiznodm9Qu8fB3t1E0QkhhBAVY2tlUfD+tmj3ZWg2Aixt4cYZiDpk5ujKx6yJ0KxZs5g0aRKTJ08mNDSU2bNnExgYyNy5c+/6uCeffJLRo0fTsWNHE0VaOnsvJXDpRhoO1hYMbVlCJelzGyDmqDo2qOPzpg1QCCGEqKAxHWtjodWw91ICp29p1GLAAIcXmzewcjJbIpSdnc3Bgwfp169fof39+vVj9+7dJT5u4cKFXLx4kWnTphk7xDIrGCTd0h9HG8uiBxTqDZoMDh4mjE4IIYSoOD8XO+5r6gvAol0Rty+PHf8dstPNF1g5mS0RunnzJjqdDh8fn0L7fXx8iI2NLfYx58+f56233uKnn37C0rKYRKMYWVlZJCcnF7oZQ0JaNuvzBkk/WtIg6fMb82aK2UOnF4wShxBCCGFsEzoFA7DqSBQJXu3AtTZkp8DpP80bWDmYfbD0v4sNKopSbAFCnU7H6NGjeffdd2nQoPQVmGfOnImLi0vBLTDQOPV6lodfJVunp3mAC039i6kkfWdvUNtJ4OBplDiEEEIIY2td241m/i5k5epZeuDaHYOmfzRvYOVgtkTI09MTCwuLIr0/cXFxRXqJAFJSUggPD+e5557D0tISS0tLZsyYwdGjR7G0tGTLli3FtjNlyhSSkpIKblevXjX4c9HpFX7MryRd0iDpC5sh6iBY2klvkBBCiCpNo9EwPq9X6Me9V8hpNgrQqKslJFwya2xlZbZEyNramtatW7Nx48ZC+zdu3EinTp2KHO/s7Mzx48c5cuRIwe2pp56iYcOGHDlyhPbt2xfbjo2NDc7OzoVuhrbtXBxXEzJwsbMqfpD0nb1BbSaCo7fBYxBCCCFM6f4Wfng6WhOTlMnf16ygbi/1jsNVayFWs14ae+WVV/j+++9ZsGABp0+f5uWXXyYyMpKnnnoKUHtzxo4dqwaq1dK0adNCN29vb2xtbWnatCkODg5mex4/7FZ7gx5uE4CdtUXRAy5ugWsH1CmGnV80cXRCCCGE4dlYWjC6fW0AFu66fPvy2JGfQa8zY2RlY9ZEaOTIkcyePZsZM2bQsmVLtm/fztq1a6ldW/3BxsTE3LOmkLldvpnGtnM30GjU1XmLUBTY9pG63XoCOBW97CeEEEJURY+1D8JSqyH8yi1OOHUBOzdIiVY7AKoIjaJU0VKQ5ZScnIyLiwtJSUkGuUw2469TLNh1mV6NvFkwvm3RAy5thcVDwcIGXjwKzn4VblMIIYSoLF785TB/HIlmeKsAPnP8CfbPg9DBMNKwA6cN/f6dz+yzxqqy9Oxclh9UB1+P6VhCb9DW/N6g8ZIECSGEqHbyV6X/62g0CY0eUXeeWQvJMWaMqvQkEaqAVYejScnMpbaHPd3rF7NwasQOiNwNFtbQ5SWTxyeEEEIYW8tAV1oGupKt0/PjZUcIbA+KrspMpZdEqJwURWHxnggAxnSojVZbtPZRQW9Qq3HgXMt0wQkhhBAmNKFzMABL9l4hN2y8uvPgoioxaFoSoXLafzmBM7Ep2Fppeah1MUUaI3bClZ15vUEvmz5AIYQQwkQGNPXD28mGGylZrFPaq4Omk6+pKypUcpIIldPiveqU+QfD/HGxtyp6wNa8ukFhY8ClhAVYhRBCiGrA2lJbMHP6+72x0PJR9Y7wBWaMqnQkESqH2KRMNuStKzamQ3DRA67sVscHaa2kN0gIIUSNMLp9ENYWWo5eTeSE34PqzvN/Q2LlLoMjiVA5/Lw/kly9QttgNxrXKmYKX0Fv0GPgapy1zYQQQojKxNPRhgfC1PGwXx/TQEg3QIFDi80b2D1IIlRG2bl6ft6nZrdjOwYXPSByL1zeBlpL6PqKaYMTQgghzGhSlzoAbDgZy42GeZWmDy0GXY4Zo7o7SYTKaN2JGG6mZuHtZEP/Jr5FD8jvDWo5GlxLWIBVCCGEqIYa+jrRrYEXegW+iW0IDt6Qeh3OrjV3aCWSRKiMluzJW2W+fRDWlv/68V3dD5f+yesNetUM0QkhhBDm9XhXtcDi0kOxZDYbre6sxIOmJREqgxNRSYRfuYWlVsPodsX09uSvKdZiFLgFmzQ2IYQQojLoUs+TRr5OpGfr+J3egEZdbir+orlDK5YkQmXw/Y5LAAxs5oe3s23hO68dhAubQGMBXV8zQ3RCCCGE+Wk0GiZ1UXuFvjyUg75eb/WOgwvNGFXJJBEqpZikDFYfU9dNebxrnaIHbMsbG9RiFLiHmDAyIYQQonIZ0rIWXk42xCZnst/9AXXn4Z8gN8uscRVHEqFSWrQrgly9QvsQd5oFuBS+M+qgWitBYyFjg4QQQtR4NpYWjMtbjPzDC4Eozv6QkQCn/jRzZEVJIlQKqVm5/LxfnTI/udjeoI/Vr80fBo+6JoxMCCGEqJwebV8bWystx6LTuBbykLqzEg6alkSoFH49cJWUzFzqeDrQu5F34TujD8O59aDRQrfXzROgEEIIUcm4OVgzonUAAJ8ndFCvmkTuhuunzBxZYZII3YNOr7Bg12UAJnYJKbrKfH5vULOHpDdICCGEuMPEziFoNPDbeT2pIf3UnQe+M29Q/yKJ0D1sOBnLtVsZuNlbMbxVQOE7Y46qRaKkN0gIIYQooo6XI70b+QCwVDNA3Xn0F8i4ZcaoCpNE6B6+y5sy/1iH2thZWxS+M783qOlw8Kxv4siEEEKIym9yXoHFT896kesZCjnpcPhHM0d1myRCd3Hwyi0ORyZibaFlTN7o9wKxx+HMakAjvUFCCCFECdqHuNPM34WsXIVtrsPUnfu/A73OvIHlkUToLvILKA5tWQtvp38VUMyvIt10GHg1NHFkQgghRNWg0WgKeoX+71JjFFtXSLwC5zaYN7A8kgiVIDI+nQ0nY4FipsxfPwmn/0J6g4QQQoh7G9TMj0B3O6LTNZzwGaru3D/PvEHlkUSoBAt2XUavQLcGXjT0dSp8Z/7YoMZDwTvU9MEJIYQQVYilhZYnu6kzq6fFdETRaNX1x+LOmDcwJBEqVlJ6Dr+GXwVgcpd/LZcRdxpO/aFud3/DxJEJIYQQVdOI1gF4OdlwKNmZKJ+e6s59c80bFJIIFWvpgUjSs3U08nWia33Pwndu+xhQIHQI+DQxS3xCCCFEVWNrZVHQufBpUi9159FfIC3ejFFJIlREVq6OhXkFFCd1CUGjuaOAYtwZOLlS3e7+phmiE0IIIaquRzvUxtnWklW3gklybQK5mRA+36wxSSL0LysORXE9OQtfZ1uGtKxV+M7tnwAKNLoffJuaJT4hhBCiqnK0sWR8p2BAw7e5eQUW938LOZlmi0kSoTvk6vR8s+0ioBaAsrG8o4DijXNw4nd1W3qDhBBCiHIZ3zkEOysL5t1sTqa9L6TdgOPLzRaPJEJ3WHsilivx6bjZW/FIu6DCd26dSUFvkF9zs8QnhBBCVHXuDtY80i6IXCz5zWKQunPP16AoZolHEqE8iqIw558LAEzoHIKDjeXtO2NPwMkV6naPKWaITgghhKg+Hu8WgpWFho9vdEBn6QA3TsPFzWaJRRKhPFvOxHEmNgUHawvGdQwufOfWmerXJg/K2CAhhBCigvxc7BgWFkAyDmyx66/u3P2VWWKRRAi1N+jrvN6gxzrUxsXe6vad0YfVNcU0WukNEkIIIQzkqR510Wrg3ZvdUTQWcOkfiD5i8jgkEQL2XIrnUGQi1pZaJv27gOKWD9SvzR6WNcWEEEIIAwnxdGBAMz+uKV4cdMwrsLhrtsnjkEQImL3pPAAj2wTi7XzH4qpX98OFjaCxkCrSQgghhIE900NddmNqfB91x6k/IP6iSWOo8YnQnovx7L+cgLWFlmd61i1855b31a8tR4NH3aIPFkIIIUS5NanlQs+GXpzSB3HKsSMoetj1uUljqPGJ0OxN5wAY2TYQPxe723dc3gGXt4HWSnqDhBBCCCN5oXd9AKbf6qfuOLoUkmNM1n6NToT2Xopn3+UErCw0PN3jjh4fRYF/8sYGtR4HrkHFn0AIIYQQFRIW5EbPhl7s1zXkkl0z0GXD3q9N1n6NToQ+zx8b1DaQWq539AZd3AKRe8DCBrq+aqbohBBCiJrh5b4NAPgg+T51R/hCSE8wSds1NhEKv5zAnkvxeb1B9W7foSi3xwa1nQTOtYo/gRBCCCEMonmAK31Cvdmsa0m0TR3IToV935ik7RqbCH25Ra0b9FCbQPzv7A06tx6iD4GVPXR52UzRCSGEEDXLS30aABo+SL1f3bH3G8hINHq7NTYROhh5C2tLLc/3uqM3SK+/XTeo3RPg6G2e4IQQQogapqm/C/0a+7BW145o62DISoK9c43ertkToTlz5hASEoKtrS2tW7dmx44dJR67YsUK+vbti5eXF87OznTs2JENGzaUu+1xHWsXnil2fDlcPw42ztD5xXKfVwghhBBl93LfBqDR8kHqEHXH3rlG7xUyayK0bNkyXnrpJd555x0OHz5M165dGTBgAJGRkcUev337dvr27cvatWs5ePAgPXv2ZPDgwRw+fLjMbTvYWBQeG5SbdXtsUJeXwN69HM9ICCGEEOUV6ufM0Ba1WKtvxzXL2mqvkJHHCmkUxUzr3gPt27enVatWzJ17u+srNDSUBx54gJkzZ5bqHE2aNGHkyJFMnTq1VMcnJyfj4uLCzFUHeWtoq9t37PkaNrwNTn7w/CGwti/TcxFCCCFExUXGp9Prs63cx26+sv4SbF3gxWMk52hxcXEhKen/27v3qKrK/H/g78MdxIMJCiiIIBchLySMBiZgEt5W4ugIKjOKmQ2L+kqopKYoWmbWUGqj2TLBmvEC4z2HVMYUMLwEQjZylhhq6AgxkAJhAsLz+4MfezxyQA4Bx85+v9Y6a7mf/exnf/b5eNwfn73P2ZVQKpWdtj+dzQjV1dUhNzcXISEhau0hISHIzs5u1xiNjY2orq5G797az978yc/pfwv3K4HM95v+HLScRRAREZGODLC2wOxRA5DWOArFhgOaztFdeK+Qzgqh8vJyNDQ0wNbWVq3d1tYWpaWl7RojMTERNTU1CAsLa7VPbW0tqqqq1F4A0NPsoSfMn9kI/HIHsPEAvCO0PhYiIiLqPP/3vBvMTIyx4ZepTQ1ntwA1FV2yL53fLK1QKNSWhRAt2jTZs2cPEhISkJKSgr59W/921/r162FlZSW9HB0d1TtU/ud/lWZwAmBopO0hEBERUSfq09MU859zRlrjSFw1cAHqqoHsv3bJvnRWCNnY2MDQ0LDF7E9ZWVmLWaJHpaSkYP78+UhNTUVwcHCbfZcvX47KykrpdfPmTfUOJ9cCD34BBvgBHhM7dCxERETUuRYEuKCXhSneuj+jqeHizi7Zj84KIRMTE/j4+CA9PV2tPT09Hf7+/q1ut2fPHkRGRmL37t2YPHnyY/djamoKpVKp9pLcygUu7W368/h3gHbMRBEREVHXU5oZI/YFd2Q2DsMFPA001nfJfnR6aWzRokX49NNPkZSUBJVKhdjYWBQXFyMqKgpA02zOnDlzpP579uzBnDlzkJiYiGeffRalpaUoLS1FZWWl9jsXAji2rOnPw2cD/Ue03Z+IiIi61eyRA+DatyfeqQ3vsn3otBAKDw/Hxo0bsXbtWnh7eyMzMxNpaWlwcmr6RldJSYnabwp98sknePDgAV599VXY29tLr5iYDvz4YcFh4NaFpkdpjGvfV++JiIio+xgZGmDFZE/kC1ecbOyaCQud/o6QLjT/jlDlOg8o60qAsSuBwDhdh0VEREStmJN0AcX/zkbGh7H68ztCOld9G1A6AP6v6ToSIiIiasOKSZ64gf5dMrZ8CyEAeGENYGz++H5ERESkMx52PTHD16FLxpZvIeTkDwyZrusoiIiIqB0WPu/eJePKtxAK4dfliYiIfiusLIwf36kD5FsI2bg+vg8RERHpNfkWQkRERCR7LISIiIhItlgIERERkWyxECIiIiLZYiFEREREssVCiIiIiGSLhRARERHJFgshIiIiki0WQkRERCRbLISIiIhItlgIERERkWyxECIiIiLZYiFEREREssVCiIiIiGSLhRARERHJFgshIiIiki0WQkRERCRbLISIiIhItlgIERERkWyxECIiIiLZYiFEREREssVCiIiIiGSLhRARERHJFgshIiIiki0WQkRERCRbLISIiIhItlgIERERkWyxECIiIiLZYiFEREREssVCiIiIiGSLhRARERHJFgshIiIiki0WQkRERCRbLISIiIhItlgIERERkWyxECIiIiLZ0nkhtHXrVjg7O8PMzAw+Pj7Iyspqs39GRgZ8fHxgZmYGFxcXbNu2rZsiJSIiIn2j00IoJSUFr7/+OlasWIG8vDyMGTMGEydORHFxscb+169fx6RJkzBmzBjk5eXhzTffxMKFC7F///5ujpyIiIj0gUIIIXS181GjRmHEiBH4+OOPpTZPT09MnToV69evb9F/6dKlOHLkCFQqldQWFRWFb7/9FmfPnm3XPquqqmBlZYXKykoolcpffxBERETU5brq/K2zGaG6ujrk5uYiJCRErT0kJATZ2dkatzl79myL/uPHj0dOTg7q6+u7LFYiIiLST0a62nF5eTkaGhpga2ur1m5ra4vS0lKN25SWlmrs/+DBA5SXl8Pe3r7FNrW1taitrZWWKysrATRVlkRERPTb0Hze7uwLWTorhJopFAq1ZSFEi7bH9dfU3mz9+vVYs2ZNi3ZHR0dtQyUiIiIdq6iogJWVVaeNp7NCyMbGBoaGhi1mf8rKylrM+jSzs7PT2N/IyAjW1tYat1m+fDkWLVokLd+9exdOTk4oLi7u1DeSOqaqqgqOjo64efMm79nSMebiycFcPDmYiydHZWUlBgwYgN69e3fquDorhExMTODj44P09HT8/ve/l9rT09MRGhqqcRs/Pz988cUXam0nTpyAr68vjI2NNW5jamoKU1PTFu1WVlb8S/0EUSqVzMcTgrl4cjAXTw7m4slhYNC5tzfr9OvzixYtwqeffoqkpCSoVCrExsaiuLgYUVFRAJpmc+bMmSP1j4qKwg8//IBFixZBpVIhKSkJO3bswJIlS3R1CERERPQbptN7hMLDw1FRUYG1a9eipKQEQ4YMQVpaGpycnAAAJSUlar8p5OzsjLS0NMTGxmLLli3o168fNm/ejOnTp+vqEIiIiOg3TOc3S0dHRyM6Olrjup07d7ZoCwwMxMWLFzu8P1NTU6xevVrj5TLqfszHk4O5eHIwF08O5uLJ0VW50OkPKhIRERHpks6fNUZERESkKyyEiIiISLZYCBEREZFssRAiIiIi2dLLQmjr1q1wdnaGmZkZfHx8kJWV1Wb/jIwM+Pj4wMzMDC4uLti2bVs3Rar/tMnFgQMH8MILL6BPnz5QKpXw8/PD8ePHuzFa/aftZ6PZ119/DSMjI3h7e3dtgDKibS5qa2uxYsUKODk5wdTUFIMGDUJSUlI3RavftM3Frl27MHz4cFhYWMDe3h7z5s1DRUVFN0WrvzIzM/Hiiy+iX79+UCgUOHTo0GO36ZTzt9Aze/fuFcbGxmL79u2ioKBAxMTEiB49eogffvhBY/9r164JCwsLERMTIwoKCsT27duFsbGx2LdvXzdHrn+0zUVMTIzYsGGDuHDhgigsLBTLly8XxsbG4uLFi90cuX7SNh/N7t69K1xcXERISIgYPnx49wSr5zqSiylTpohRo0aJ9PR0cf36dXH+/Hnx9ddfd2PU+knbXGRlZQkDAwOxadMmce3aNZGVlSWefvppMXXq1G6OXP+kpaWJFStWiP379wsA4uDBg23276zzt94VQiNHjhRRUVFqbYMHDxbLli3T2P+NN94QgwcPVmv785//LJ599tkui1EutM2FJl5eXmLNmjWdHZosdTQf4eHhYuXKlWL16tUshDqJtrn48ssvhZWVlaioqOiO8GRF21y8//77wsXFRa1t8+bNwsHBoctilKP2FEKddf7Wq0tjdXV1yM3NRUhIiFp7SEgIsrOzNW5z9uzZFv3Hjx+PnJwc1NfXd1ms+q4juXhUY2MjqqurO/0Be3LU0XwkJyejqKgIq1ev7uoQZaMjuThy5Ah8fX3x3nvvoX///nB3d8eSJUvwyy+/dEfIeqsjufD398etW7eQlpYGIQR+/PFH7Nu3D5MnT+6OkOkhnXX+1vkvS3em8vJyNDQ0tHh6va2tbYun1jcrLS3V2P/BgwcoLy+Hvb19l8WrzzqSi0clJiaipqYGYWFhXRGirHQkH1evXsWyZcuQlZUFIyO9+qdCpzqSi2vXruHMmTMwMzPDwYMHUV5ejujoaPz000+8T+hX6Egu/P39sWvXLoSHh+P+/ft48OABpkyZgo8++qg7QqaHdNb5W69mhJopFAq1ZSFEi7bH9dfUTtrTNhfN9uzZg4SEBKSkpKBv375dFZ7stDcfDQ0NmD17NtasWQN3d/fuCk9WtPlsNDY2QqFQYNeuXRg5ciQmTZqEDz74ADt37uSsUCfQJhcFBQVYuHAhVq1ahdzcXBw7dgzXr1+XHhZO3aszzt969d88GxsbGBoatqjky8rKWlSNzezs7DT2NzIygrW1dZfFqu86kotmKSkpmD9/Pv7xj38gODi4K8OUDW3zUV1djZycHOTl5eG1114D0HQyFkLAyMgIJ06cwPPPP98tseubjnw27O3t0b9/f1hZWUltnp6eEELg1q1bcHNz69KY9VVHcrF+/XqMHj0acXFxAIBhw4ahR48eGDNmDN5++21eRehGnXX+1qsZIRMTE/j4+CA9PV2tPT09Hf7+/hq38fPza9H/xIkT8PX1hbGxcZfFqu86kgugaSYoMjISu3fv5jX3TqRtPpRKJb777jvk5+dLr6ioKHh4eCA/Px+jRo3qrtD1Tkc+G6NHj8bt27fx888/S22FhYUwMDCAg4NDl8arzzqSi3v37sHAQP3UaWhoCOB/sxHUPTrt/K3VrdW/Ac1fhdyxY4coKCgQr7/+uujRo4e4ceOGEEKIZcuWiT/96U9S/+av38XGxoqCggKxY8cOfn2+k2ibi927dwsjIyOxZcsWUVJSIr3u3r2rq0PQK9rm41H81ljn0TYX1dXVwsHBQfzhD38Qly9fFhkZGcLNzU28/PLLujoEvaFtLpKTk4WRkZHYunWrKCoqEmfOnBG+vr5i5MiRujoEvVFdXS3y8vJEXl6eACA++OADkZeXJ/2UQVedv/WuEBJCiC1btggnJydhYmIiRowYITIyMqR1c+fOFYGBgWr9T58+LZ555hlhYmIiBg4cKD7++ONujlh/aZOLwMBAAaDFa+7cud0fuJ7S9rPxMBZCnUvbXKhUKhEcHCzMzc2Fg4ODWLRokbh37143R62ftM3F5s2bhZeXlzA3Nxf29vYiIiJC3Lp1q5uj1j+nTp1q8xzQVedvhRCcyyMiIiJ50qt7hIiIiIi0wUKIiIiIZIuFEBEREckWCyEiIiKSLRZCREREJFsshIiIiEi2WAgRERGRbLEQIvoNGzhwIDZu3KjrMHDv3j1Mnz4dSqUSCoUCd+/e7bJ9BQUF4fXXX5eWtX0PHt1ek654XyMjIzF16tROHZOIfj0WQiQ7kZGRUCgUUCgUMDY2houLC5YsWYKamhpdh9aqnTt3olevXi3av/nmG7zyyivdH9AjPvvsM2RlZSE7OxslJSVqDwdt1tox/FravgcHDhzAW2+91elxPImCgoKwbdu2Vtd///33mDdvHhwcHGBqagpnZ2fMmjULOTk53RglkW7p1dPnidprwoQJSE5ORn19PbKysvDyyy+jpqYGH3/8cYu+9fX1On0Ab319favr+vTp042RtK6oqAienp4YMmRIt+9b2/egd+/eXRTJk+Wnn35CdnY2du3apXF9Tk4Oxo0bhyFDhuCTTz7B4MGDUV1djcOHD2Px4sXIyMjo5ojbr66uDiYmJroOg/QEZ4RIlkxNTWFnZwdHR0fMnj0bEREROHToEAAgISEB3t7eSEpKgouLC0xNTSGEQHFxMUJDQ2FpaQmlUomwsDD8+OOP0pjN233yySdwdHSEhYUFZsyYoXaZqLGxEWvXrpX+B+7t7Y1jx45J62/cuAGFQoHU1FQEBQXBzMwMf//73zFv3jxUVlZKM1kJCQkAWl7CaW+Mf/vb3zBw4EBYWVlh5syZqK6ubvP92r9/P55++mmYmppi4MCBSExMlNYFBQUhMTERmZmZUCgUCAoKalcO2hNLTU0N5syZA0tLS9jb26vtt9nD78GsWbMwc+ZMtfX19fWwsbFBcnKyFO/Dl8bKysrw4osvwtzcHM7Ozi0Kh+ac5OfnS213796FQqHA6dOnAQANDQ2YP38+nJ2dYW5uDg8PD2zatKnN49+3bx+GDh0Kc3NzWFtbIzg4uNVZSR8fH7Vjnzp1KoyMjFBVVQUAKC0thUKhwJUrV6Q+//znPzF8+HD079+/xXhCCERGRsLNzQ1ZWVmYPHkyBg0aBG9vb6xevRqHDx+W+i5duhTu7u6wsLCAi4sL4uPj1Yrz9uSxsbERGzZsgKurK0xNTTFgwACsW7dOWv+f//wH4eHheOqpp2BtbY3Q0FDcuHFDWt98WXH9+vXo168f3N3d23xvibTBQogIgLm5udo/7t9//z1SU1Oxf/9+6QQ4depU/PTTT8jIyEB6ejqKiooQHh6uNk7zdl988QWOHTuG/Px8vPrqq9L6TZs2ITExEX/5y19w6dIljB8/HlOmTMHVq1fVxlm6dCkWLlwIlUqFcePGYePGjVAqlSgpKUFJSQmWLFnS4hiEEO2KsaioCIcOHcLRo0dx9OhRZGRk4N133231vcnNzUVYWBhmzpyJ7777DgkJCYiPj8fOnTsBNF1qWrBgAfz8/FBSUoIDBw606z1vTyxxcXE4deoUDh48iBMnTuD06dPIzc1tdbyIiAgcOXIEP//8s9R2/Phx1NTUYPr06Rq3iYyMxI0bN/DVV19h37592Lp1K8rKytp9DEDTid7BwQGpqakoKCjAqlWr8OabbyI1NVVj/5KSEsyaNQsvvfQSVCoVTp8+jWnTpqG1Rz8GBQVJRZcQAllZWXjqqadw5swZAMCpU6dgZ2cHDw8PaZsjR44gNDRU43j5+fm4fPkyFi9eDAODlqeBhy9h9uzZEzt37kRBQQE2bdqE7du348MPP1Tr/7g8Ll++HBs2bEB8fDwKCgqwe/du2NraAmi6v2zs2LGwtLREZmYmzpw5A0tLS0yYMAF1dXXSGCdPnoRKpUJ6ejqOHj2q8biIOuTXPCmW6Ldo7ty5IjQ0VFo+f/68sLa2FmFhYUKIpqesGxsbi7KyMqnPiRMnhKGhoSguLpbaLl++LACICxcuSNsZGhqKmzdvSn2+/PJLYWBgIEpKSoQQQvTr10+sW7dOLZ7f/e53Ijo6WgghxPXr1wUAsXHjRrU+ycnJwsrKqsWxODk5iQ8//FCrGC0sLERVVZXUJy4uTowaNarV92v27NnihRdeUGuLi4sTXl5e0nJMTEybT67XdAyPi6W6ulqYmJiIvXv3SusrKiqEubm5iImJ0fge1NXVCRsbG/H5559L62fNmiVmzJghLQcGBkrbX7lyRQAQ586dk9arVCoBQBqzOSd5eXlSnzt37ggA4tSpU60eb3R0tJg+fbq0/PDfu9zcXAFA3Lhxo9XtH3bkyBFhZWUlGhoaRH5+vujTp4+IjY0VcXFxQgghXnnlFREeHi71v3//vujZs6e4dOmSxvFSUlIEAHHx4sV27f9h7733nvDx8ZGWH5fHqqoqYWpqKrZv365xvB07dggPDw/R2NgotdXW1gpzc3Nx/PhxIUTTe2draytqa2u1jpfocTgjRLJ09OhRWFpawszMDH5+fggICMBHH30krXdyclK790SlUsHR0RGOjo5Sm5eXF3r16gWVSiW1DRgwAA4ODtKyn58fGhsbceXKFVRVVeH27dsYPXq0WiyjR49WGwMAfH19tT6m9sY4cOBA9OzZU1q2t7dvcwZEpVJpjPnq1atoaGjQOs6HtRVLUVER6urq4OfnJ63v3bu32qzHo4yNjTFjxgzp8lZNTQ0OHz6MiIgIjf1VKhWMjIzU3u/Bgwd36Kbubdu2wdfXF3369IGlpSW2b9+O4uJijX2HDx+OcePGYejQoZgxYwa2b9+OO3futDp2QEAAqqurkZeXh4yMDAQGBmLs2LHSfTynT59GYGCg1P+rr76CtbU1hg4dqnE88f9nnhQKxWOPa9++fXjuuedgZ2cHS0tLxMfHtziutvKoUqlQW1uLcePGaRw/NzcX33//PXr27AlLS0tYWlqid+/euH//PoqKiqR+Q4cO5X1B1CVYCJEsjR07Fvn5+bhy5Qru37+PAwcOoG/fvtL6Hj16qPUXQmg8abTW3qx53cN9Hu2vaYxH998e7Y3x0Ru/FQoFGhsbtRpXtHIJR1ttxdLRfUREROBf//oXysrKcOjQIZiZmWHixIka+7anIGi+dPRwPI/ewJ6amorY2Fi89NJLOHHiBPLz8zFv3jy1SzsPMzQ0RHp6Or788kt4eXnho48+goeHB65fv66xv5WVFby9vXH69GlkZGQgKCgIY8aMQX5+Pq5evYrCwkK1e7PauiwGQLrH5tEC/FHnzp3DzJkzMXHiRBw9ehR5eXlYsWJFi+NqK4/m5uZt7qOxsRE+Pj7Iz89XexUWFmL27NlSv458Jojag4UQyVKPHj3g6uoKJyendn0jzMvLC8XFxbh586bUVlBQgMrKSnh6ekptxcXFuH37trR89uxZGBgYwN3dHUqlEv369ZPu62iWnZ2tNoYmJiYmj519aW+M2vLy8tIYs7u7OwwNDTs87uO4urrC2NgY586dk9ru3LmDwsLCNrfz9/eHo6MjUlJSsGvXLsyYMaPVmQRPT088ePBA7eviV65cUbvBvXlmsKSkRGp7+MZpAMjKyoK/vz+io6PxzDPPwNXVVW02QxOFQoHRo0djzZo1yMvLg4mJCQ4ePNhq/6CgIJw6dQqZmZkICgpCr1694OXlhbfffht9+/aVciyEwBdffIEpU6a0Opa3tze8vLyQmJiosQhuPv6vv/4aTk5OWLFiBXx9feHm5oYffvihzeN6lJubG8zNzXHy5EmN60eMGIGrV6+ib9++cHV1VXtp+hkGos7GQoioHYKDgzFs2DBERETg4sWLuHDhAubMmYPAwEC1yypmZmaYO3cuvv32W2RlZWHhwoUICwuDnZ0dgKabfzds2ICUlBRcuXIFy5YtQ35+PmJiYtrc/8CBA/Hzzz/j5MmTKC8vx7179zoco7YWL16MkydP4q233kJhYSE+++wz/PWvf9V4w3ZnsrS0xPz58xEXF4eTJ0/i3//+NyIjIzXe3PswhUKB2bNnY9u2bUhPT8cf//jHVvt6eHhgwoQJWLBgAc6fP4/c3Fy8/PLLarMY5ubmePbZZ/Huu++ioKAAmZmZWLlypdo4rq6uyMnJwfHjx1FYWIj4+Hh88803re73/PnzeOedd5CTk4Pi4mIcOHAA//3vf9ssWIOCgnDs2DEoFAp4eXlJbbt27VK7LJabm4uamhoEBAS0+R4lJyejsLAQAQEBSEtLw7Vr13Dp0iWsW7dOmk1ydXVFcXEx9u7di6KiImzevLnNYk0TMzMzLF26FG+88QY+//xzFBUV4dy5c9ixYweAphk8GxsbhIaGIisrC9evX0dGRgZiYmJw69YtrfZF1BEshIjaQaFQ4NChQ3jqqacQEBCA4OBguLi4ICUlRa2fq6srpk2bhkmTJiEkJARDhgzB1q1bpfULFy7E4sWLsXjxYgwdOhTHjh3DkSNH4Obm1ub+/f39ERUVhfDwcPTp0wfvvfdeh2PU1ogRI5Camoq9e/diyJAhWLVqFdauXYvIyMhfNW57vP/++wgICMCUKVMQHByM5557Dj4+Po/dLiIiAgUFBejfv3+L+5selZycDEdHRwQGBmLatGl45ZVX1C6TAkBSUhLq6+vh6+uLmJgYvP3222rro6KiMG3aNISHh2PUqFGoqKhAdHR0q/tUKpXIzMzEpEmT4O7ujpUrVyIxMbHVS3gApMImMDBQupQXGBiIhoYGtULo8OHDmDx5MoyM2v6ZuJEjRyInJweDBg3CggUL4OnpiSlTpuDy5cvSzxGEhoYiNjYWr732Gry9vZGdnY34+Pg2x9UkPj4eixcvxqpVq+Dp6Ynw8HDpHiILCwtkZmZiwIABmDZtGjw9PfHSSy/hl19+gVKp1HpfRNpSiM662E8kcwkJCTh06FCLyyZE3WnYsGFYuXIlwsLCdB0K0W8CZ4SIiPREXV0dpk+f3ubMEhGp4yM2iIj0hImJCVavXq3rMIh+U3hpjIiIiGSLl8aIiIhItlgIERERkWyxECIiIiLZYiFEREREssVCiIiIiGSLhRARERHJFgshIiIiki0WQkRERCRbLISIiIhItv4fHtdlOM0f7sIAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "predictive_int_bayesian = pyro.infer.Predictive(bayesian_population_forced_smokes_model, num_samples=num_samples, return_sites=(\"cancer\", \"_RETURN\"))\n", + "prediction_int_bayesian = predictive_int_bayesian(n_individuals)\n", + "visualize_proportions_multiple(prediction_int_bayesian, \"Interventional Data - Uncertain Parameters\")" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "visualize_ATE(prediction_int_bayesian, \"Interventional Data - Uncertain Parameters\")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Just as our uncertain parameters propagate to broad uncertainty about the observational relationship between cancer and smoking, we see a similar conclusion when it comes to the effects of the intervention, with ATE estimates centering around 0. However, this is not always the case, as we'll see now when explore uncertainty over causal structure as well." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "**A Brief Aside:** Intervention program transformations can be called both inside and outside of `pyro.plate` contexts, and freely compose with nested probabilistic program function calls. In practice, this means that we can easily; (i) define interventions that are themselves parameterized by random choices, and (ii) apply our intervention to the Bayesian variant of our observational model above without rewriting the model to generate a Bayesian variant of our intervened model with the same prior. As an example, we can succinctly write a variant of this intervention in which treatment assignment is randomized as follows." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "# This example is not used in the tutorial, but is included to demonstrate some of ChiRho's flexibility.\n", + "def randomized_intervention(model, intervention_variable, n_individuals):\n", + " def new_model(*args, **kwargs):\n", + " intervention_assignment = pyro.sample(\"treatment_assignment\", Bernoulli(torch.ones(n_individuals) * 0.5).to_event(1))\n", + " return do(model, {intervention_variable: intervention_assignment})(*args, **kwargs)\n", + " \n", + " return new_model\n", + "\n", + "bayesian_randomized_model = randomized_intervention(bayesian_population_causal_model, \"smokes\", n_individuals)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Adding Uncertainty over Model Structure" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In addition to adding prior distribution over model parameters given a known structure, we can further add uncertainty to our causal assumptions by writing a probabilistic program that selects between multiple probabilistic programs depending on the result of a discrete random choice. Again, we'll see how we can quickly expand the complexity of our uncertain causal assumptions without needing to rewrite our original `causal_model` from scratch, as probabilistic programs in ChiRho are compositional.\n", + "\n", + "In the context of our original smoking example, let's pretend that we don't know whether smoking influences cancer, or whether cancer influences smoking. (This might seem somewhat nonsensical now, but it could have been a \"plausible\" hypothesis 70 years ago.) Graphically, this would be represented as uncertainty about the causal edge between 'smokes` and 'cancer' variables. To implement this uncertainty in ChiRho, we first need to write a new program that represents the alternative observational model." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "image/svg+xml": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "stress\n", + "\n", + "stress\n", + "\n", + "\n", + "\n", + "cancer\n", + "\n", + "cancer\n", + "\n", + "\n", + "\n", + "stress->cancer\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "smokes\n", + "\n", + "smokes\n", + "\n", + "\n", + "\n", + "stress->smokes\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "cancer->smokes\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def alt_causal_model(stress_pt, cancer_cpt, smokes_cpt):\n", + " stress = pyro.sample(\"stress\", Bernoulli(stress_pt))\n", + " cancer = pyro.sample(\"cancer\", Bernoulli(cancer_cpt[stress.int()]))\n", + " smokes = pyro.sample(\"smokes\", Bernoulli(smokes_cpt[stress.int(), cancer.int()]))\n", + " # For now we only return smokes because we need to return a single value for the predictive handler.\n", + " # We need to return smokes because the trace address for `smokes` does not include the interventions.\n", + " # TODO: address this in the future.\n", + " return smokes\n", + " # return stress, smokes, cancer\n", + "\n", + "stress_pt = torch.tensor([0.5])\n", + "cancer_cpt = torch.tensor([0.2, 0.8])\n", + "smokes_cpt = torch.tensor([[0.1, 0.15], \n", + " [0.8, 0.85]])\n", + "\n", + "pyro.render_model(alt_causal_model, (stress_pt, cancer_cpt, smokes_cpt))" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Again, we can use Pyro's `plate` effect handler to represent a distribution over a population of individuals and place a prior over parameters for this alternative model to represent our uncertainty about the strength of effects." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "image/svg+xml": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "cluster_individuals\n", + "\n", + "individuals\n", + "\n", + "\n", + "\n", + "stress_pt_alt\n", + "\n", + "stress_pt_alt\n", + "\n", + "\n", + "\n", + "stress\n", + "\n", + "stress\n", + "\n", + "\n", + "\n", + "stress_pt_alt->stress\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "cancer_cpt_alt\n", + "\n", + "cancer_cpt_alt\n", + "\n", + "\n", + "\n", + "cancer\n", + "\n", + "cancer\n", + "\n", + "\n", + "\n", + "cancer_cpt_alt->cancer\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "smokes_cpt_alt\n", + "\n", + "smokes_cpt_alt\n", + "\n", + "\n", + "\n", + "smokes\n", + "\n", + "smokes\n", + "\n", + "\n", + "\n", + "smokes_cpt_alt->smokes\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "stress->cancer\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "stress->smokes\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "cancer->smokes\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def alt_population_model(n_individuals, stress_pt, cancer_cpt, smokes_cpt):\n", + " with pyro.plate(\"individuals\", n_individuals, dim=-1):\n", + " return alt_causal_model(stress_pt, cancer_cpt, smokes_cpt)\n", + "\n", + "def alt_parameter_prior():\n", + "\n", + " stress_pt = pyro.sample(\"stress_pt_alt\", Beta(torch.ones(1), torch.ones(1)).to_event(1))\n", + " cancer_cpt = pyro.sample(\"cancer_cpt_alt\", Beta(torch.ones(2), torch.ones(2)).to_event(1))\n", + " smokes_cpt = pyro.sample(\"smokes_cpt_alt\", Beta(torch.ones(2, 2), torch.ones(2, 2)).to_event(2)) \n", + "\n", + " return stress_pt, cancer_cpt, smokes_cpt\n", + "\n", + "def alt_bayesian_population_causal_model(n_individuals):\n", + " stress_pt, cancer_cpt, smokes_cpt = alt_parameter_prior()\n", + "\n", + " return alt_population_model(n_individuals, stress_pt, cancer_cpt, smokes_cpt)\n", + "\n", + "pyro.render_model(alt_bayesian_population_causal_model, (n_individuals,))" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "predictive_alt_bayesian = pyro.infer.Predictive(alt_bayesian_population_causal_model, num_samples=1000, return_sites=(\"cancer\", \"_RETURN\"))\n", + "prediction_alt_bayesian = predictive_alt_bayesian(n_individuals)\n", + "visualize_proportions_multiple(prediction_alt_bayesian, \"Observational Data - Uncertain Parameters - Alternative Structure\")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Just from looking at observational samples obtained using this alternative structure, we do not see anything obviously different from the causal model we've used so far. However, differences will arise when we inspect interventional distributions over random variables. In our new alternative candidate model, smoking has no effect on cancer whatsoever, and thus we shouldn't ever see any difference between cancer rates between individuals when individuals are forced to smoke or not smoke.\n", + "\n", + "To visualize this point, we can again apply an intervention to this new model and simulate from the transformed model. This time we'll implement the intervention even more succinctly by intervening on the `alt_bayesian_causal_model` directly." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "def alt_bayesian_forced_smokes_model(n_individuals):\n", + " smokes_assignment = torch.tensor([0., 1.]).repeat(n_individuals // 2)\n", + " transformed_model = do(alt_bayesian_population_causal_model, {\"smokes\": smokes_assignment})\n", + " return transformed_model(n_individuals)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "predictive_alt_int_bayesian = pyro.infer.Predictive(alt_bayesian_forced_smokes_model, num_samples=1000, return_sites=(\"cancer\", \"_RETURN\"))\n", + "prediction_alt_int_bayesian = predictive_alt_int_bayesian(n_individuals)\n", + "visualize_proportions_multiple(prediction_alt_int_bayesian, \"Interventional Data - Uncertain Parameters - Alternative Structure\")" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "visualize_ATE(prediction_alt_int_bayesian, \"Interventional Data - Uncertain Parameters - Alternative Structure\")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "While our uncertainty about the proportions of individuals with cancer is very wide, we now see that, as expected, once we've randomized whether an individual smokes, we no longer see any association between smoking and cancer after applying an intervention under this alternative model. The resulting distribution of ATE estimates is now narrowly centered around 0.\n", + "\n", + "Using our two probabilistic programs representing different plausible structures (and with uncertain parameters), we can write a probabilistic program that randomly chooses between them. Conceptually, this represents a scenario in which we think that it is equally plausible that smoking causes cancer and that cancer causes smoking." + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "from pyro.distributions import Bernoulli\n", + "\n", + "def bayesian_population_causal_model_uncertain_structure(n_individuals):\n", + " \n", + " is_original_model = pyro.sample(\"is_original_model\", Bernoulli(0.5))\n", + " model = bayesian_population_causal_model if is_original_model else alt_bayesian_population_causal_model\n", + "\n", + " return model(n_individuals)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Simulating Observational Data with Uncertain Structure and Parameters" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Again, we can simulate from the observational distribution, this time using our model with uncertainty over both structure and parameters." + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "predictive_uncertain_structure_bayesian = pyro.infer.Predictive(bayesian_population_causal_model_uncertain_structure, num_samples=1000, return_sites=(\"cancer\", \"_RETURN\"))\n", + "prediction_uncertain_structure_bayesian = predictive_uncertain_structure_bayesian(n_individuals)\n", + "visualize_proportions_multiple(prediction_uncertain_structure_bayesian, \"Observational Data - Uncertain Parameters and Structure\")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Simulating Interventional Data with Uncertain Structure and Parameters" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Earlier we showed that interventions in Casual Pyro compose freely with hierarchical Bayesian extensions of our original model with deterministic parameters. Perhaps not surprisingly, interventions are still well-behaved even when we included uncertainty over structures in our programs.\n", + "\n", + "To see this, let's again apply our intervention and visualize the results of repeated samples from our model with structural uncertainty. As expected, we see that approximately half of the simulations from this model with structural uncertainty show a difference in cancer rate between smokers and non-smokers (representing samples in which `is_original_model=1`)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "def bayesian_forced_smokes_model_uncertain_structure(n_individuals):\n", + " smokes_assignment = torch.tensor([0., 1.]).repeat(n_individuals // 2)\n", + " transformed_model = do(bayesian_population_causal_model_uncertain_structure, {\"smokes\": smokes_assignment})\n", + " return transformed_model(n_individuals)" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "predictive_uncertain_structure_int_bayesian = pyro.infer.Predictive(bayesian_forced_smokes_model_uncertain_structure, num_samples=1000, return_sites=(\"cancer\", \"_RETURN\"))\n", + "prediction_uncertain_structure_int_bayesian = predictive_uncertain_structure_int_bayesian(n_individuals)\n", + "visualize_proportions_multiple(prediction_uncertain_structure_int_bayesian, \"Interventional Data - Uncertain Parameters and Structure\")" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "visualize_ATE(prediction_uncertain_structure_int_bayesian, \"Interventional Data - Uncertain Parameters and Structure\")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now that we've incorporated uncertainty about the structure *and* parameters, we can see that samples from the post-intervention version of our program sometimes show an effect of smoking on cancer and sometimes show no effect. We this clearly with a sharp peak at $ATE=0$ above. In other words, our uncertainty over causal models naturally propagates to uncertainty over causal conclusions. We can visualize this flow of uncertainty in the following (again somewhat cartoonish) diagram showing how information flows from observational probabilistic programs to interventions probabilistic programs and subsequently to factual and counterfactual data." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![fig3](figures/Interventional_Marginal.png)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Observation 3: causal inference is probabilistic inference\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "So far we've seen how introducing intervention program transformations using ChiRho's `do` makes it straightforward to reason about the causal implications of (i) uncertainty over the strength of causal effects and (ii) uncertainty over causal structure. We can call this progress *causal modeling*. In practice however, we often don't want to just posit causal knowledge about the world, we also want to update that knowledge in light of observational and experimental data. We'll call this process of learning about cause and effect from data *causal inference*. The key insight underlying ChiRho is that once we have a Bayesian causal model representing our uncertainty about cause-effect relationships, causal inference simply reduces to probabilistic inference in what's known as a *multi-world* transformation of our original causal model. \n", + "\n", + "As we'll show in this section, to reduce causal inference to probabilistic inference using ChiRho we have to follow a few steps:\n", + "1. Transform our ChiRho program into a new Pyro program that represents a joint distribution over both outcomes, i.e. what actually happened, and counterfactual outcomes, i.e. what would have happened had we intervened. We'll call this a *twin world program*.\n", + "2. Condition the factual outcomes in our twin world program according to some observed data.\n", + "3. Run (approximate) posterior inference in the conditioned twin world program, resulting in an updated distribution over both parameters and counterfactual outcomes.\n", + "\n", + "**Important Note:** Readers familiar with causal inference may find the statement that \"causal inference reduces to probabilistic inference\" unpalatable. To clarify, we are not claiming that causal inference reduces to probabilistic inference *absent any assumptions*. Instead, we simply propose that users encode their causal assumptions as probabilistic programs." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Automatically Constructing Counterfactual Worlds - `TwinWorldCounterfactual`" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To make this concrete, we need to use another program transformation provided by ChiRho, the `TwinWorldCounterfactual` effect handler. Intuitively, this new effect handler tells ChiRho that any `pyro.sample` statements that are downstream of an intervention should be sampled twice, once for the observable world without interventions and once for the counterfactual world with interventions applied." + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([[[[[1., 1., 0., ..., 0., 0., 1.]]]],\n", + "\n", + "\n", + "\n", + " [[[[1., 1., 1., ..., 1., 1., 1.]]]]])" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from chirho.counterfactual.handlers import TwinWorldCounterfactual\n", + "twin_model = TwinWorldCounterfactual()(bayesian_randomized_model)\n", + "\n", + "# Sample from both the factual and counterfactual worlds.\n", + "twin_model(n_individuals)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "\n", + "Using somewhat light and informal mathematical notation for brevity, the tensors returned from the model transformed using the `TwinWorldCounterfactual` handler represent samples from the joint distribution over $P(stress, smokes, cancer, stress_{cf}, smokes_{cf}, cancer_{cf})$, where $stress$, $smokes$, and $cancer$ are the random variables representing individual attributes without an intervention and $stress_{cf}$, $smokes_{cf}$, and $cancer_{cf}$ are the random variables representing individual attributes after applying our intervention. \n", + "\n", + "However, as we mentioned before, causal inference is about coming to causal conclusions combining modeling assumptions *and* data, not just modeling assumptions alone. Now that we have a model representing a joint distribution over both observational and interventional data, we can condition our model and apply approximate inference techniques just as we would any other Pyro model. For example, using Pyro's support for stochastic variaitional inference we can obtain an approximate conditional distribution $P(stress_{cf}, smokes_{cf}, cancer_{cf}|stress, smokes, cancer)$. To see how ChiRho enables causal inference, let's first generate some synthetic observational data for $stress$, $smokes$, and $cancer$ in which approximately half of the individuals smoke, and those who do are more likely to have cancer than those who don't." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Generating Synthetic Data" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [], + "source": [ + "stress_pt = torch.tensor([0.5])\n", + "smokes_cpt = torch.tensor([0.3, 0.6])\n", + "cancer_cpt = torch.tensor([[0.1, 0.3], \n", + " [0.1, 0.4]])\n", + "\n", + "predictive_data = pyro.infer.Predictive(bayesian_population_causal_model, num_samples=1, return_sites=(\"cancer\", \"stress\", \"_RETURN\"))\n", + "data = predictive_data(n_individuals)\n", + "data[\"smokes\"] = data.pop(\"_RETURN\").float()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Conditioning the Causal Model on Observational Data" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now that we have synthetic data, we can condition on it inside of the `TwinWorldCounterfactual` handler we saw earlier. This creates a new model `twin_model_conditioned`, that represents the conditional distribution we're interested in, $p(stress_{cf}, smokes_{cf}, cancer_{cf}|stress, smokes, cancer)$." + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [], + "source": [ + "from chirho.observational.handlers import condition\n", + "\n", + "twin_model_conditioned = TwinWorldCounterfactual()(condition(bayesian_population_forced_smokes_model, data=data))" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Using Variational Inference for Bayesian Causal Inference" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "After using the `TwinWorldCounterfactual` and the `do` handlers, the resulting model can be treated as an ordinary Pyro program. Just as in Pyro, conditioning a model on data means that we can no longer sample directly from the `twin_model_conditioned` model by just running the program; instead we need to run an *approximate inference algorithm*.\n", + "\n", + "Because we've used ChiRho's program transformations to construct an ordinary Pyro program, we can use Pyro's built-in support for approximate inference. To see this, let's run stochastic variational inference with a reparameterized Gaussian mean-field variational approximation." + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/homebrew/anaconda3/envs/basis/lib/python3.10/site-packages/pyro/util.py:303: UserWarning: Found vars in model but not guide: {'cancer_counterfactual'}\n", + " warnings.warn(f\"Found vars in model but not guide: {bad_sites}\")\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[iteration 0001] loss: 2.7795\n", + "[iteration 0101] loss: 1.8926\n", + "[iteration 0201] loss: 1.8272\n", + "[iteration 0301] loss: 1.8648\n", + "[iteration 0401] loss: 1.8202\n", + "[iteration 0501] loss: 1.8427\n", + "[iteration 0601] loss: 1.8096\n", + "[iteration 0701] loss: 1.8314\n", + "[iteration 0801] loss: 1.8246\n", + "[iteration 0901] loss: 1.8274\n" + ] + } + ], + "source": [ + "from pyro.poutine import block\n", + "from pyro.infer.autoguide import AutoNormal\n", + "from pyro.infer import SVI\n", + "\n", + "adam = pyro.optim.Adam({'lr': 0.03})\n", + "elbo = pyro.infer.Trace_ELBO()\n", + "\n", + "guide = AutoNormal(block(twin_model_conditioned, expose=['stress_pt', 'smokes_cpt', 'cancer_cpt']))\n", + "\n", + "svi = SVI(twin_model_conditioned, guide, adam, loss=elbo)\n", + "\n", + "for j in range(num_iterations):\n", + " # calculate the loss and take a gradient step\n", + " loss = svi.step(n_individuals)\n", + " if j % 100 == 0:\n", + " print(\"[iteration %04d] loss: %.4f\" % (j + 1, loss / n_individuals))" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Simulating Interventional Data from the Approximate Posterior" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can visualize the resulting posterior distribution over intervened models just as we did before conditioning on data." + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# TODO: It's not clear that we're actually conditioning on the data here, as posterior inference returns quite different results for each run.\n", + "# It's possible that the names don't align with ChiRho's internal transformed names. Should be addressed with new indexing.\n", + "\n", + "predictive_int_posterior = pyro.infer.Predictive(bayesian_population_forced_smokes_model, guide=guide, num_samples=1000, return_sites=(\"cancer\", \"_RETURN\"))\n", + "prediction_int_posterior = predictive_int_posterior(n_individuals)\n", + "visualize_proportions_multiple(prediction_int_posterior, \"Interventional Data - Posterior Distribution\")" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "visualize_ATE(prediction_int_posterior, \"Interventional Data - Posterior Distribution\")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Using our conceptual diagrams from before, we can see how data informs our updated belief about causal models, which then propagate forward into counterfactual outcomes and causal conclusions. Even though we've only observed data in a world where people choose whether to smoke or not of their own free will, this observed data tells us something about which causal models are plausible. Importantly, this process of mapping data in one world to conclusions in another (e.g. a world in which people are randomly assigned smoking behavior), requires assumptions. When using ChiRho, the models we write encode those assumptions implicitly by how interventions transform them. In subsequent tutorials we'll discuss this subtlety and consideration in more detail. For now, remember that this ability to reduce causal inference to probabilistic inference doesn't come out of thin air." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![fig4](figures/Interventional_Posterior.png)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Recap" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Before we conclude this tutorial, let's first recap, and then zoom out thinking a bit more broadly about what it is that we illustrated.\n", + "\n", + "**Observation 1**\n", + "\n", + "1. We wrote a causal model using the Pyro probabilistic programming language relating $stress$, $smokes$ and $cancer$, defined as a function of known parameters, and showed how this model can be used to simulate observations for a population of individuals using Pyro's `plate` effect handler. \n", + "2. We wrote a modified version of our causal model in which individuals are \"forced\" to smoke or not smoke, modifying the original mechanism that determines whether individuals choose to smoke or not.\n", + "3. We showed how this program rewriting can be automated with ChiRho using the `do` program transformation.\n", + "\n", + "**Observation 2**\n", + "\n", + "4. Using our causal model defined as a function of known parameters we wrote a Bayesian hierarchical causal model relating $stress$, $smokes$, and $cancer$. We showed how this Bayesian extension induces a distribution over populations of individuals, and the observational relationships between $smokes$ and $cancer$.\n", + "5. We applied ChiRho's `do` program transformation to the Bayesian hierarchical causal model, and showed how this induces a distribution over the attributes of individuals who are forced to smoke or not smoke.\n", + "6. We wrote an alternative Bayesian hierarchical causal model in which cancer causes individuals to smoke, rather than vice-versa as in our original model. Similar to our original model, this alternative model induced broad uncertainty over the observational relationship between $smokes$ and $cancer$. However, unlike our original model, forcing individuals smoke induced no change in whether individuals got cancer. \n", + "7. We wrote a Bayesian hierarchical causal model with uncertainty over parameters and structure, implemented by randomly choosing between our two candidate causal models based on the outcome of a latent discrete random variable. We showed that this model induced a distribution over average treatment effects that had a sharp peak at $ATE=0$.\n", + "\n", + "**Observation 3**\n", + "\n", + "8. We showed how to represent a joint distribution over both observational and interventional distributions using ChiRho's `TwinWorldCounterfactual` effect handler.\n", + "9. Conditioning our model on (synthetic) observed data, we showed how causal inference problems can be solved using Pyro's extensive support for approximate variational inference.\n", + "10. Finally, we showed how the posterior distribution over causal models induced a posterior distribution over the attributes of individuals who forced to smoke or not smoke, conditional on observations of individuals who chose to smoke according to the original mechanisms." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## A Causal Bayesian Workflow" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To conclude this tutorial, let's think about how to use ChiRho for causal inference problems more broadly. We elaborate on how the program transformation-based operations we've demonstrated so far fit into the standard statistical practice embodied by Peterson and van der Laans' *Causal Roadmap* \\[Petersen et al. 2014\\]. Here, we show the original causal roadmap components in **bold**, and how we would express them in terms of ChiRho in *italics*.\n", + "\n", + "\n", + "1. **Specify knowledge about the system to be studied using a causal model**. *This knowledge should be expressed by the ordering and functional/distributional relationships of random variables in a Pyro program*.\n", + "2. **Specify the observed data and their link to the causal model.** *Express the relationships between observations and the causal model by (optionally) adding additional model components representing mechanisms for missing data, and by conditioning the original Pyro program on observations*.\n", + "3. **Specify a target causal quantity.** *Express the target causal quantity as a combination of program transformations including world-splitting (e.g. `TwinWorldCounterfactual`), intervention (`do`), and probabilistic conditioning (`condition`).*\n", + "4. **Assess identifiability.** *Currently ChiRho does not support automated methods for assessing identifiability. Future versions will implement non-parametric methods such as the do-calculus \\[Pearl 2009\\], or numerical approaches such as Simulation-based identifiability \\[Witty et al. 2022\\].*\n", + "5. **State the statistical estimation problem**. *ChiRho does not currently distinguish between causal estimation and statistical estimation. Therefore, this component of the original causal roadmap is not covered by ChiRho. In future versions we may implement nonparametric causal inference utilities using free variables, in which case causal reasoning (such as nonparametric identifiability analysis) and statistical estimation may occur over different models for the same process.*\n", + "6. **Estimate.** *Use Pyro's approximate inference capabilities (e.g. SVI) to estimate the posterior distributions over counterfactual variables of interest.*\n", + "7. **Interpret.** *ChiRho does not currently provide any support for interpretting the validity of causal assumptions or conclusions.*\n", + "\n", + "Importantly, once we arrive at step 6, we can again dispatch the standard non-causal *Bayesian Workflow* \\[Gelman et al. 2020\\] for assessing the validity of probabilistic modeling and inference. Note: while the causal roadmap and the Bayesian workflow are mostly orthogonal, there are some special considerations that can be made to make model criticism more effective in a causal inference setting \\[Tran et al. 2016\\]" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## References" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Pearl, Judea. Causality: Models, Reasoning and Inference. 2nd ed. USA: Cambridge University Press, 2009.\n", + "\n", + "Aldrich, John. “Autonomy.” Oxford Economic Papers 41, no. 1 (1989): 15–34.\n", + "\n", + "Petersen, Maya L., and Mark J. van der Laan. \"Causal models and learning from data: integrating causal modeling and statistical estimation.\" Epidemiology (Cambridge, Mass.) 25.3 (2014): 418.\n", + "\n", + "Witty, Sam, David Jensen, and Vikash Mansinghka. \"SBI: A Simulation-Based Test of Identifiability for Bayesian Causal Inference.\" arXiv preprint arXiv:2102.11761 (2021).\n", + "\n", + "Gelman, Andrew, et al. \"Bayesian workflow.\" arXiv preprint arXiv:2011.01808 (2020).\n", + "\n", + "Tran, Dustin, et al. \"Model criticism for bayesian causal inference.\" arXiv preprint arXiv:1610.09037 (2016)." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "chirho", + "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.11.4" + }, + "vscode": { + "interpreter": { + "hash": "cffe1a1fa048e49a173ef425a4ae5289f738a2b81f14c36ed87498058f2b9506" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/docs/source/annotated_tutorial_i.ipynb b/docs/source/annotated_tutorial_i.ipynb new file mode 100644 index 000000000..1a94214d2 --- /dev/null +++ b/docs/source/annotated_tutorial_i.ipynb @@ -0,0 +1,1879 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Annotated version of the tutorial_i.ipynb. This version includes some edits to the text, as well as extensive comments in the code." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Causal probabilistic programming without tears" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Despite the tremendous progress over the last several decades in reducing causal inference to statistical practice, the \\\"causal revolution\\\" proclaimed by Judea Pearl and others remains incomplete, with a sprawling and fragmented literature inaccessible to non-experts and still somewhat isolated from cutting-edge machine learning research and software tools.\n", + "\n", + "Probabilistic programming languages are promising substrates for bridging this gap thanks to the close correspondence between their operational semantics and the field’s standard mathematical formalism of structural causal models. \n", + "\n", + "In this tutorial, we elaborate on this idea with three key observations inspiring ChiRho's design and outline a causal Bayesian workflow for using ChiRho to answer causal questions." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Outline\n", + "- [Introduction](#causal-probabilistic-programming-without-tears)\n", + "- [Outline](#outline)\n", + "- [Observation 1: Causal Models are Probabilistic Programs](#observation-1:-causal-models-are-probabilistic-programs)\n", + " - [Defining a Causal Model](#defining-a-causal-model)\n", + " - [Simulating Observational Data](#simulating-observational-data-with-fixed-parameters)\n", + " - [Applying an Intervention](#applying-an-intervention)\n", + " - [Simulating Interventional Data](#simulating-interventional-data-with-fixed-parameters)\n", + " - [Transforming Causal Models using ChiRho](#transforming-causal-models-using-ChiRho---do)\n", + "- [Observation 2: Causal Uncertainty is Probabilistic Uncertainty](#observation-2:-causal-uncertainty-is-probabilistic-uncertainty)\n", + " - [Adding Uncertainty over Model Parameters](#adding-uncertainty-over-model-parameters)\n", + " - [Simulating Observational Data with Uncertain Parameters](#simulating-observational-data-with-uncertain-parameters)\n", + " - [Simulating Interventional Data with Uncertain Parameters](#simulating-interventional-data-with-uncertain-parameters)\n", + " - [Adding Uncertainty over Model Structure](#adding-uncertainty-over-model-structure)\n", + " - [Simulating Observational Data with Uncertain Structure and Parameters](#simulating-observational-data-with-uncertain-structure-and-parameters)\n", + " - [Simulating Interventional Data with Uncertain Structure and Parameters](#simulating-interventional-data-with-uncertain-structure-and-parameters)\n", + "- [Observation 3: Causal Inference is Probabilistic Inference](#observation-3:-causal-inference-is-probabilistic-inference)\n", + " - [Automatically Constructing Counterfactual Worlds](#automatically-constructing-counterfactual-worlds---twinworldcounterfactual)\n", + " - [Generating Synthetic Data](#generating-synthetic-data)\n", + " - [Conditioning the Causal Model on Observational Data](#conditioning-the-causal-model-on-observational-data)\n", + " - [Using Variational Inference for Bayesian Causal Inference](#using-variational-inference-for-bayesian-causal-inference)\n", + " - [Simulating Interventional Data from the Approximate Posterior](#simulating-interventional-data-from-the-approximate-posterior)\n", + "- [Recap](#recap)\n", + "- [Causal Bayesian Workflow](#a-causal-bayesian-workflow)\n", + "- [References](#references)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Observation 1: causal models are probabilistic programs" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Probabilistic programmers typically think of their code as defining a probability distribution over a set of variables, but programs often contain more information than just the joint distributions they induce. In practice, when we write probabilistic programs in languages such as Pyro we often bring to bear knowledge of causal relationships between variables, and implicitly, how changes to one variable would propagate to changes in others.\n", + "\n", + "Formally, a causal model specifies a *family* of probability distributions, indexed by a set of *interventions*. This set always includes a trivial *identity intervention*, which maps to the usual (acausal) joint distribution over random variables induced by simply executing the program. However, for other interventions the resulting joint distributions can differ significantly, as we'll see later throughout this tutorial.\n", + "\n", + "Somewhat less formally, causal models using these (nontrivial) interventions are useful when we want to represent hypothetical changes to a domain, such as a policy that encourages people to stop smoking. To ground this out a bit more concretely, consider the following Pyro program describing a causal model relating three random variables, *stress*, *smokes*, and *cancer*.\n", + "\n", + "**Note:** Later we'll see how to think of interventions as program transformations. ChiRho defaults to the trivial *identity intervention* if none are applied explicitly. The result of applying this identity intervention to a causal model is sometimes called an *observational model* or *factual model*." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Defining a Causal Model" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import pyro\n", + "from pyro.distributions import Bernoulli\n", + "\n", + "smoke_test = ('CI' in os.environ)\n", + "num_samples = 1000 if not smoke_test else 10\n", + "num_iterations = 1000 if not smoke_test else 10\n", + "n_individuals = 10000 if not smoke_test else 10\n", + "\n", + "def causal_model(stress_pt, smokes_cpt, cancer_cpt):\n", + " stress = pyro.sample(\"stress\", Bernoulli(stress_pt))\n", + " smokes = pyro.sample(\"smokes\", Bernoulli(smokes_cpt[stress.long()]))\n", + " cancer = pyro.sample(\"cancer\", Bernoulli(cancer_cpt[stress.long(), smokes.long()]))\n", + " # For now we only return smokes because we need to return a single value for the predictive handler.\n", + " # We need to return smokes because the trace address for `smokes` does not include the interventions.\n", + " # TODO: address this in the future.\n", + " return smokes\n", + " # return stress, smokes, cancer" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Our `causal_model` takes as input three sets of parameters, here just marginal and conditional probability tables, and returns a sample from the joint distribution over a single individual's *stress*, *smokes*, and *cancer* attributes. For now, let's just choose some parameters by hand, but later we'll see how we can place priors over these parameters to express broader uncertainty and enable Bayesian causal inference. " + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "image/svg+xml": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "stress\n", + "\n", + "stress\n", + "\n", + "\n", + "\n", + "smokes\n", + "\n", + "smokes\n", + "\n", + "\n", + "\n", + "stress->smokes\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "cancer\n", + "\n", + "cancer\n", + "\n", + "\n", + "\n", + "stress->cancer\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "smokes->cancer\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import torch\n", + "\n", + "stress_pt = torch.tensor([0.5])\n", + "smokes_cpt = torch.tensor([0.2, 0.8])\n", + "cancer_cpt = torch.tensor([[0.1, 0.15], \n", + " [0.8, 0.85]])\n", + "\n", + "pyro.render_model(causal_model, (stress_pt, smokes_cpt, cancer_cpt))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Simulating Observational Data with Fixed Parameters" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Fortunately, all causal models written in ChiRho compose freely with the probabilistic programming tooling in Pyro. Without belaboring the details, Pyro provides support for probabilistic modeling and inference with a set of composable *effect handlers*, which can be thought of as context managers that provide nonstandard interpretation of `pyro.sample` statements in Pyro programs. For more background on Pyro and its use of effect handlers, see https://pyro.ai/examples/intro_long.html and https://pyro.ai/examples/effect_handlers.html. Perhaps not surprisingly, ChiRho's main capabilities also make heavy use of similar effect handlers.\n", + "\n", + "As an example, let's use Pyro's `plate` effect handler to repeatedly sample from the `causal_model` to approximate the joint distribution for all of the attributes. " + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch.Size([10000])\n" + ] + } + ], + "source": [ + "def population_causal_model(n_individuals, stress_pt, smokes_cpt, cancer_cpt):\n", + " with pyro.plate(\"individuals\", n_individuals, dim=-1):\n", + " return causal_model(stress_pt, smokes_cpt, cancer_cpt)\n", + "\n", + "\n", + "\n", + "smokes_obs = population_causal_model(n_individuals, stress_pt, smokes_cpt, cancer_cpt)\n", + "# stress_obs, smokes_obs, cancer_obs = population_causal_model(n_individuals, stress_pt, smokes_cpt, cancer_cpt)\n", + "\n", + "print(smokes_obs.shape)\n", + "# print(stress_obs.shape, smokes_obs.shape, cancer_obs.shape)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's pretend for a moment that we're only interested in the relationship between whether individuals smoke and how likely they are to get cancer. To understand this relationship a bit better, we can simulate observations from our model." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[Text(0.5, 1.0, 'Observational Data - Fixed Parameters')]" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "import pandas as pd\n", + "\n", + "def visualize_proportions_single(prediction, title):\n", + " # TODO: Make this prettier\n", + " cancer = prediction['cancer'][0]\n", + " smokes = prediction['_RETURN'][0]\n", + "\n", + " data = torch.concat((smokes.reshape(-1, 1), \n", + " cancer.reshape(-1, 1)), axis=-1)\n", + " frame = pd.DataFrame(data.numpy(),\n", + " columns=[\"smokes\", \"cancer\"]).astype(\n", + " \"category\").replace({0:\"0\", 1:\"1\"})\n", + " \n", + " return sns.histplot(x='smokes', hue='cancer', multiple=\"dodge\", shrink=0.7, data=frame).set(title=title)\n", + "\n", + "predictive_fixed = pyro.infer.Predictive(population_causal_model, num_samples=1000, return_sites=(\"cancer\", \"_RETURN\"))\n", + "prediction_fixed = predictive_fixed(n_individuals, stress_pt, smokes_cpt, cancer_cpt)\n", + "\n", + "visualize_proportions_single(prediction_fixed, \"Observational Data - Fixed Parameters\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As we can see clearly from this simulation, individuals who smoke are much more likely to get cancer than individuals who don't. Of the ~5,000 simulated individuals who smoke ~3600 got cancer, roughly 72% of the smokers. Of the remaining ~5,000 simulated individuals who did not smoke only ~1,200 individuals got cancer, a much lower 24% of the smoking population.\n", + "\n", + "We can also approximate our uncertainty in this conclusion by repeating the process a number of times, each time calculating the proportions of individuals with cancer for smokers and non-smokers." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def visualize_proportions_multiple(prediction, title, position = (0.6, 1)):\n", + " # TODO: make these violin plots with individual data points.\n", + " cancer = prediction['cancer']\n", + " smokes = prediction['_RETURN']\n", + "\n", + " cancer_and_smokes = cancer * smokes\n", + " cancer_given_smokes = cancer_and_smokes.sum(1) / smokes.sum(1)\n", + " cancer_and_not_smokes = cancer * (1 - smokes)\n", + " cancer_given_not_smokes = cancer_and_not_smokes.sum(1) / (1 - smokes).sum(1)\n", + " # TODO: make the smoothing kernel sharper.\n", + " ax = sns.kdeplot(data=cancer_given_not_smokes.detach().numpy(), label=\"Doesn't Smoke\", legend=True)\n", + " sns.kdeplot(data=cancer_given_smokes.detach().numpy(), label=\"Smokes\", ax=ax, legend=True)\n", + " ax.legend(loc='upper left', bbox_to_anchor=position)\n", + " ax.set(xlabel='Proportion of Individuals w/ Cancer', ylabel='Density', title=title, xlim=(0, 1))\n", + " return ax\n", + "\n", + "visualize_proportions_multiple(prediction_fixed, \"Observational Data - Fixed Parameters\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As we can see clearly, even when simulating many times our model tells us that individuals who smoke are consistently much more likely to get cancer than individuals who don't. In fact, since our model together with the chosen probability tables describe a unique joint distribution over individual attributes, we're only approximating an answer that we could've straightforwardly obtained by hand. Let $c, s, t$ stand for the presence of cancer, smoking and stress, respectively. $P(t \\vert s) = \\frac{P(s\\vert t)P(t)}{P(s)}= .8$, and $P(t\\vert \\neg s ) = \\frac{P(\\neg s \\vert t)P(t)}{P(\\neg s)} = .2$. Then, $P(c\\vert s) = P(c\\vert t, s ) \\times P(t \\vert s) + P(c\\vert t, s) \\times P(\\neg t\\vert s) =.71$, and analogously $P(c\\vert \\neg s) = .24$, which are modes of the empirical distributions shown above. The variance here is only due to the fact that we are simulating a finite population." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "So far we have a program that describes the distribution over data given model parameters. Somewhat more abstractly, we can imagine this process of simulating from a model as we've done above with the following (somewhat cartoonish) diagram. Here, each point in \"model space\" or \"parameter space\" induces a joint distribution over data." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![fig1](figures/Conditional_Distribution_of_Data.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Applying an Intervention" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Simulating from our `causal_model` is certainly interesting and informative, but it doesn't exactly tell us what we're interested in. We want to know to what extent smoking *causes* cancer, not just whether smoking is associated with cancer. To answer this question, we can instead sample from a modified version of our model in which individuals are forced to smoke or not smoke, regardless of their level of stress. We can represent these kinds of modifications as **interventions**, and implement them in ChiRho as a special kind of program transformation. Later we'll see how ChiRho helps to automate the application of these kinds of interventions, but to build some intuition let's first walk through what these new programs would look like if we built them by hand instead.\n", + "\n", + "Consider the following new Pyro program; `forced_smokes_model`, which closely resembles our original `causal_model` except in how the *smokes* attribute is assigned. Specifically, we've replaced the expression `smokes = pyro.sample(\"smokes\", Bernoulli(smokes_cpt[stress]))` with the expressions `smokes = pyro.deterministic(\"smokes\", smokes_assignment)`, where `smokes_assignment` is now an argument." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "def forced_smokes_model(stress_pt, smokes_cpt, cancer_cpt, smokes_assignment):\n", + " stress = pyro.sample(\"stress\", Bernoulli(stress_pt))\n", + " # smokes no longer depends on stress.\n", + " smokes = pyro.deterministic(\"smokes\", smokes_assignment)\n", + " cancer = pyro.sample(\"cancer\", Bernoulli(cancer_cpt[stress.int(), smokes.int()]))\n", + " # For now we only return smokes because we need to return a single value for the predictive handler.\n", + " # We need to return smokes because the trace address for `smokes` does not include the interventions.\n", + " # TODO: address this in the future.\n", + " return smokes\n", + " # return stress, smokes, cancer\n", + "\n", + "def population_forced_smokes_model(n_individuals, stress_pt, smokes_cpt, cancer_cpt):\n", + " # Let's imagine that we force half the people to always smoke and half to never smoke.\n", + " smokes_assignment = torch.tensor([0., 1.]).repeat(n_individuals // 2)\n", + " with pyro.plate(\"individuals\", n_individuals, dim=-1):\n", + " return forced_smokes_model(stress_pt, smokes_cpt, cancer_cpt, smokes_assignment)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Simulating Interventional Data with Fixed Parameters" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's visualize a simulation from these new programs (compare this to the previous visualization based on the original simulation). First, one run on a barplot, then the proportions obtained in multiple (1k) runs using a kernel density estimate." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[Text(0.5, 1.0, 'Intervened Data - Fixed Parameters')]" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "predictive_int_fixed = pyro.infer.Predictive(population_forced_smokes_model, num_samples=num_samples, return_sites=(\"cancer\", \"_RETURN\"))\n", + "prediction_int_fixed = predictive_int_fixed(n_individuals, stress_pt, smokes_cpt, cancer_cpt)\n", + "\n", + "visualize_proportions_single(prediction_int_fixed, \"Intervened Data - Fixed Parameters\")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "visualize_proportions_multiple(prediction_int_fixed, \"Interventional Data - Fixed Parameters\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Using our intervened model we can clearly see that changing the mechanism by which individuals choose whether or not to smoke dramatically changes the joint distribution between smoking and cancer. In our observational model, individuals who smoke are much more likely to get cancer than those who don't smoke. However, in our modified model in which individuals are either forced to smoke or forced not no smoke, the dependence between smoking and cancer nearly disapears.\n", + "\n", + "The phenomenon we're observing in this (contrived) example is known as confounding. Here, the reason we see a statistical dependency between smoking and cancer in our original `causal_model` without any interventions is because of the individuals' stress. Given the parameters we happened to choose, individuals who are stressed are more likely to smoke and stress causes an increase in cancer. The confounding effect of stress dissapears in our intervened program, as stress no longer influences whether individuals smoke or not.\n", + "\n", + "In causal inference settings we often wish to answer a specific scientific or policy question using our causal models. For example, we may be interested in the **Average Treatment Effect** (ATE), the average difference in the proportion of individuals with cancer between individuals who were forced to smoke and those who were forced to not smoke. This ATE quantity can be expressed as a function of the population of individuals' attributes after applying an intervention." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def visualize_ATE(prediction, title, position=(0.6, 1)):\n", + " \n", + " cancer = prediction['cancer']\n", + " smokes = prediction['_RETURN']\n", + "\n", + " cancer_and_smokes = cancer * smokes\n", + " cancer_given_smokes = cancer_and_smokes.sum(1) / smokes.sum(1)\n", + " cancer_and_not_smokes = cancer * (1 - smokes)\n", + " cancer_given_not_smokes = cancer_and_not_smokes.sum(1) / (1 - smokes).sum(1)\n", + "\n", + " ate = cancer_given_smokes - cancer_given_not_smokes\n", + "\n", + " ax = sns.kdeplot(data=ate.detach().numpy())\n", + " ax.set(xlabel='Average Treatment Effect (ATE)', ylabel='Density', title=title)\n", + " return ax\n", + "\n", + "visualize_ATE(prediction_int_fixed, \"Interventional Data - Fixed Parameters\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Note:** Just as in the observational setting above, the expectation of the proportion of individuals with cancer in this interventional setting also has a closed-form analytic solution that we can easily compute by hand. This is the case here because (i) the structure of our `causal_model` is isomorphic to a causal graphical model, and thus Pearl's backdoor adjustment formula applies, and (ii) all attributes ($stress$, $smokes$, $cancer$) are discrete. In more complicated examples this will not be the case. Using Pearl's $do$ notation (see Pearl, 2009), we have $P(c\\vert do(s)) = P(c\\vert s, t)P(t) + P(c\\vert s, \\neg t) P(\\neg t) = 0.5$, and anologously $P(c\\vert do(\\neg s)) = .45$. Therefore, we have that $ATE \\equiv E[P(c\\vert do(s))] - E[P(c\\vert do(\\neq s))] = 0.5 - 0.45 = 0.05$, which is again consistent with our answer above." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Transforming Causal Models using ChiRho - `do`" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "So far, we've accomplished some limited form of causal reasoning by manually rewriting our original program, replacing the mechanism for how individuals choose to smoke directly in Pyro's syntax, and then simulating from the new programs. In fact, even though we called our program a `causal_model`, we haven't seen anything that we couldn't already do in an ordinary probabilistic programming language. \n", + "\n", + "This manual approach is perfectly reasonable in simple scenarios where we have a single model and a single \"thought experiment\" we want to explore. However, as we'll see throughout these tutorials and examples, reasoning about cause and effect can often involve much more complicated compositions of program transformations. For example, in our [Mediation Analysis](mediation.ipynb) example we'll need to simulate multiple counterfactual models simultaneously, with intervention assignments in one model that depend on simulated outcomes in another. \n", + "\n", + "One of the key insights behind ChiRho (and borrowed from Pearl's structural formalism \\[Pearl 2009\\]) is that an intervention can be represented as model agnostic program transformation, that is, a function $I: \\mathcal{P} \\rightarrow \\mathcal{P}$, where $\\mathcal{P}$ is the space of programs in our language. In ChiRho, and in many formalisms for causal models, we'll assume that models satisfy a kind of locality-preserving property known as autonomy \\[Aldrich 1989\\]. This autonomy property implies that interventions can be accurately represented as an alteration of a small number of model components, and all other model components (and the causal relationships among them) remain unchanged.\n", + "\n", + "In that vein, ChiRho addresses the complexity of causal reasoning by automating a number of probabilistic program transformations; including interventions, construction of parallel counterfactual worlds, and (as we'll see in subsequent tutorials) automatic reparameterization for counterfactual or \"what if\" reasoning. \n", + "\n", + "For example, instead of rewriting the code by hand, we can implement our `forced_smokes_model` succinctly as follows using ChiRho's `do` program transformation. As the name implies, this special function `do` operates very similarly to the $do$ operator used with structural causal models and causal graphical models. Here, `do` takes as input a probabilistic program and a dictionary describing the intervention assignment and returns a transformed probabilistic program with the intervention applied." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "from chirho.interventional.handlers import do\n", + "\n", + "def forced_smokes_model(stress_pt, smokes_cpt, cancer_cpt, smokes_assignment):\n", + " transformed_model = do(causal_model, {\"smokes\": smokes_assignment})\n", + " return transformed_model(stress_pt, smokes_cpt, cancer_cpt)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Just as with our manual implementation of the `forced_smokes_model`, models constructed using ChiRho's `do` transformation are probabilistic programs in Pyro, and can thus freely compose with all of Pyro's effect handlers. For example, we can again use an `plate` effect handler to sample from a population of individuals by calling our `forced_smokes_model` in the context of a Pyro `plate`." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([0., 1., 0., ..., 1., 0., 1.])" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def population_forced_smokes_model(n_individuals, stress_pt, smokes_cpt, cancer_cpt):\n", + " # Let's imagine that we force half the people to always smoke and half to never smoke.\n", + " smokes_assignment = torch.tensor([0., 1.]).repeat(n_individuals // 2)\n", + " with pyro.plate(\"individuals\", n_individuals, dim=-1):\n", + " return forced_smokes_model(stress_pt, smokes_cpt, cancer_cpt, smokes_assignment)\n", + "\n", + "population_forced_smokes_model(n_individuals, stress_pt, smokes_cpt, cancer_cpt)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To recap, so far we've constructed a causal model describing how data is generated in the actual world we can observe, which we called `causal_model`, and transformed our causal model to represent our thought experiments, or interventions, resulting in the `forced_smokes_model` program. Then, we sampled from our original and transformed models to generate simulated outcomes, and finally summarized the simulated outcomes yielding an answer to our causal query. Again, this process can be viewed somewhat abstractly as follows:" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![fig2](figures/Interventional_Conditional.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this section, we've seen that a probabilistic program specifies a causal model by:\n", + " 1. specifying a \"default\" or \"observational\" joint distribution over the variables of interest according to the usual semantics of probabilistic programming languages, and\n", + " 2. encoding the information necessary for determining the new joint distribution under an arbitrary intervention (program transformation)---to apply the transformation and derive the new joint distribution." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Observation 2: causal uncertainty is probabilistic uncertainty\n", + "\n", + "We've shown how to define a causal model as a probabilistic program, and how to use ChiRho's intervention program transformations, `do`, to answer causal questions. However, in doing so we made a few very strong assumptions.\n", + "\n", + "1. We assumed that we knew the **parameters** of our causal model exactly, i.e. we asserted *how much* variables causally affect which other variables.\n", + "2. We assumed that we knew the **structure** of our causal model exactly, i.e. we asserted *which* variables causally affect which other variables.\n", + "\n", + "In this section, we'll show how we can use ChiRho to substantially relax these assumptions, representing broad uncertainty over causal structure and parameters. Simply put, we can introduce uncertainty over causal model parameters the same way we would write any other Bayesian hierarchical model, by composing a prior distribution over parameters with our original causal model." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Adding Uncertainty over Model Parameters" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/svg+xml": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "cluster_individuals\n", + "\n", + "individuals\n", + "\n", + "\n", + "\n", + "stress_pt\n", + "\n", + "stress_pt\n", + "\n", + "\n", + "\n", + "stress\n", + "\n", + "stress\n", + "\n", + "\n", + "\n", + "stress_pt->stress\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "smokes_cpt\n", + "\n", + "smokes_cpt\n", + "\n", + "\n", + "\n", + "smokes\n", + "\n", + "smokes\n", + "\n", + "\n", + "\n", + "smokes_cpt->smokes\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "cancer_cpt\n", + "\n", + "cancer_cpt\n", + "\n", + "\n", + "\n", + "cancer\n", + "\n", + "cancer\n", + "\n", + "\n", + "\n", + "cancer_cpt->cancer\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "stress->smokes\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "stress->cancer\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "smokes->cancer\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from pyro.distributions import Beta\n", + "\n", + "def parameter_prior():\n", + "\n", + " stress_pt = pyro.sample(\"stress_pt\", Beta(1., 1.))\n", + " smokes_cpt = pyro.sample(\"smokes_cpt\", Beta(torch.ones(2), torch.ones(2)).to_event(1))\n", + " cancer_cpt = pyro.sample(\"cancer_cpt\", Beta(torch.ones(2, 2), torch.ones(2, 2)).to_event(2)) \n", + "\n", + " return stress_pt, smokes_cpt, cancer_cpt\n", + "\n", + "def bayesian_population_causal_model(n_individuals):\n", + " stress_pt, smokes_cpt, cancer_cpt = parameter_prior()\n", + " return population_causal_model(n_individuals, stress_pt, smokes_cpt, cancer_cpt)\n", + "\n", + "pyro.render_model(bayesian_population_causal_model, (n_individuals,))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Simulating Observational Data with Uncertain Parameters" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We have now reached a stage where seeing what the observational or an interventional distribution downstream analytically becomes cumbersome (and it is impossible in more complex cases). But again, by sampling multiple times from the model, sampling 'n_individuals' and calculating the proportions of cancer in two groups each time, we can approximate how our new uncertainty about the parameters propagates to uncertainty about the relationship between smoking and cancer." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "predictive_bayesian = pyro.infer.Predictive(bayesian_population_causal_model, num_samples=num_samples, return_sites=(\"cancer\", \"_RETURN\"))\n", + "prediction_bayesian = predictive_bayesian(n_individuals)\n", + "visualize_proportions_multiple(prediction_bayesian, \"Observational Data - Uncertain Parameters\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We see that our uniform uncertainty about the parameters propagates downstream, resulting in broad uncertainty about the observed relationship between smoking and cancer." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Simulating Interventional Data with Uncertain Parameters" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Earlier we showed how to extend the `population_causal_model` to the `bayesian_population_causal_model` by simply sampling from the prior over parameters and then calling `population_causal_model` with the sampled parameters. Perhaps not surprisingly, we can also apply this simple recipe with our `population_forced_smokes_model` to construct a `bayesian_population_forced_smokes_model` which also incorporates uncertainty over parameters.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "def bayesian_population_forced_smokes_model(n_individuals):\n", + " stress_pt, smokes_cpt, cancer_cpt = parameter_prior()\n", + " return population_forced_smokes_model(n_individuals, stress_pt, smokes_cpt, cancer_cpt)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "predictive_int_bayesian = pyro.infer.Predictive(bayesian_population_forced_smokes_model, num_samples=num_samples, return_sites=(\"cancer\", \"_RETURN\"))\n", + "prediction_int_bayesian = predictive_int_bayesian(n_individuals)\n", + "visualize_proportions_multiple(prediction_int_bayesian, \"Interventional Data - Uncertain Parameters\")" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "visualize_ATE(prediction_int_bayesian, \"Interventional Data - Uncertain Parameters\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Just as our uncertain parameters propagate to broad uncertainty about the observational relationship between cancer and smoking, we see a similar conclusion when it comes to the effects of the intervention, with ATE estimates centering around 0. However, this is not always the case, as we'll see now when explore uncertainty over causal structure as well." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "**A Brief Aside:** Intervention program transformations can be called both inside and outside of `pyro.plate` contexts, and freely compose with nested probabilistic program function calls. In practice, this means that we can easily; (i) define interventions that are themselves parameterized by random choices, and (ii) apply our intervention to the Bayesian variant of our observational model above without rewriting the model to generate a Bayesian variant of our intervened model with the same prior. As an example, we can succinctly write a variant of this intervention in which treatment assignment is randomized as follows." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "# This example is not used in the tutorial, but is included to demonstrate some of ChiRho's flexibility.\n", + "def randomized_intervention(model, intervention_variable, n_individuals):\n", + " def new_model(*args, **kwargs):\n", + " intervention_assignment = pyro.sample(\"treatment_assignment\", Bernoulli(torch.ones(n_individuals) * 0.5).to_event(1))\n", + " return do(model, {intervention_variable: intervention_assignment})(*args, **kwargs)\n", + " \n", + " return new_model\n", + "\n", + "bayesian_randomized_model = randomized_intervention(bayesian_population_causal_model, \"smokes\", n_individuals)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Adding Uncertainty over Model Structure" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In addition to adding prior distribution over model parameters given a known structure, we can further add uncertainty to our causal assumptions by writing a probabilistic program that selects between multiple probabilistic programs depending on the result of a discrete random choice. Again, we'll see how we can quickly expand the complexity of our uncertain causal assumptions without needing to rewrite our original `causal_model` from scratch, as probabilistic programs in ChiRho are compositional.\n", + "\n", + "In the context of our original smoking example, let's pretend that we don't know whether smoking influences cancer, or whether cancer influences smoking. (This might seem somewhat nonsensical now, but it could have been a \"plausible\" hypothesis 70 years ago.) Graphically, this would be represented as uncertainty about the causal edge between 'smokes` and 'cancer' variables. To implement this uncertainty in ChiRho, we first need to write a new program that represents the alternative observational model." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "image/svg+xml": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "stress\n", + "\n", + "stress\n", + "\n", + "\n", + "\n", + "cancer\n", + "\n", + "cancer\n", + "\n", + "\n", + "\n", + "stress->cancer\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "smokes\n", + "\n", + "smokes\n", + "\n", + "\n", + "\n", + "stress->smokes\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "cancer->smokes\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def alt_causal_model(stress_pt, cancer_cpt, smokes_cpt):\n", + " stress = pyro.sample(\"stress\", Bernoulli(stress_pt))\n", + " cancer = pyro.sample(\"cancer\", Bernoulli(cancer_cpt[stress.int()]))\n", + " smokes = pyro.sample(\"smokes\", Bernoulli(smokes_cpt[stress.int(), cancer.int()]))\n", + " # For now we only return smokes because we need to return a single value for the predictive handler.\n", + " # We need to return smokes because the trace address for `smokes` does not include the interventions.\n", + " # TODO: address this in the future.\n", + " return smokes\n", + " # return stress, smokes, cancer\n", + "\n", + "stress_pt = torch.tensor([0.5])\n", + "cancer_cpt = torch.tensor([0.2, 0.8])\n", + "smokes_cpt = torch.tensor([[0.1, 0.15], \n", + " [0.8, 0.85]])\n", + "\n", + "pyro.render_model(alt_causal_model, (stress_pt, cancer_cpt, smokes_cpt))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Again, we can use Pyro's `plate` effect handler to represent a distribution over a population of individuals and place a prior over parameters for this alternative model to represent our uncertainty about the strength of effects." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "image/svg+xml": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "cluster_individuals\n", + "\n", + "individuals\n", + "\n", + "\n", + "\n", + "stress_pt_alt\n", + "\n", + "stress_pt_alt\n", + "\n", + "\n", + "\n", + "stress\n", + "\n", + "stress\n", + "\n", + "\n", + "\n", + "stress_pt_alt->stress\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "cancer_cpt_alt\n", + "\n", + "cancer_cpt_alt\n", + "\n", + "\n", + "\n", + "cancer\n", + "\n", + "cancer\n", + "\n", + "\n", + "\n", + "cancer_cpt_alt->cancer\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "smokes_cpt_alt\n", + "\n", + "smokes_cpt_alt\n", + "\n", + "\n", + "\n", + "smokes\n", + "\n", + "smokes\n", + "\n", + "\n", + "\n", + "smokes_cpt_alt->smokes\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "stress->cancer\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "stress->smokes\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "cancer->smokes\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def alt_population_model(n_individuals, stress_pt, cancer_cpt, smokes_cpt):\n", + " with pyro.plate(\"individuals\", n_individuals, dim=-1):\n", + " return alt_causal_model(stress_pt, cancer_cpt, smokes_cpt)\n", + "\n", + "def alt_parameter_prior():\n", + "\n", + " stress_pt = pyro.sample(\"stress_pt_alt\", Beta(torch.ones(1), torch.ones(1)).to_event(1))\n", + " cancer_cpt = pyro.sample(\"cancer_cpt_alt\", Beta(torch.ones(2), torch.ones(2)).to_event(1))\n", + " smokes_cpt = pyro.sample(\"smokes_cpt_alt\", Beta(torch.ones(2, 2), torch.ones(2, 2)).to_event(2)) \n", + "\n", + " return stress_pt, cancer_cpt, smokes_cpt\n", + "\n", + "def alt_bayesian_population_causal_model(n_individuals):\n", + " stress_pt, cancer_cpt, smokes_cpt = alt_parameter_prior()\n", + "\n", + " return alt_population_model(n_individuals, stress_pt, cancer_cpt, smokes_cpt)\n", + "\n", + "pyro.render_model(alt_bayesian_population_causal_model, (n_individuals,))" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "predictive_alt_bayesian = pyro.infer.Predictive(alt_bayesian_population_causal_model, num_samples=1000, return_sites=(\"cancer\", \"_RETURN\"))\n", + "prediction_alt_bayesian = predictive_alt_bayesian(n_individuals)\n", + "visualize_proportions_multiple(prediction_alt_bayesian, \"Observational Data - Uncertain Parameters - Alternative Structure\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Just from looking at observational samples obtained using this alternative structure, we do not see anything obviously different from the causal model we've used so far. However, differences will arise when we inspect interventional distributions over random variables. In our new alternative candidate model, smoking has no effect on cancer whatsoever, and thus we shouldn't ever see any difference between cancer rates between individuals when individuals are forced to smoke or not smoke.\n", + "\n", + "To visualize this point, we can again apply an intervention to this new model and simulate from the transformed model. This time we'll implement the intervention even more succinctly by intervening on the `alt_bayesian_causal_model` directly." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "def alt_bayesian_forced_smokes_model(n_individuals):\n", + " smokes_assignment = torch.tensor([0., 1.]).repeat(n_individuals // 2)\n", + " transformed_model = do(alt_bayesian_population_causal_model, {\"smokes\": smokes_assignment})\n", + " return transformed_model(n_individuals)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "predictive_alt_int_bayesian = pyro.infer.Predictive(alt_bayesian_forced_smokes_model, num_samples=1000, return_sites=(\"cancer\", \"_RETURN\"))\n", + "prediction_alt_int_bayesian = predictive_alt_int_bayesian(n_individuals)\n", + "visualize_proportions_multiple(prediction_alt_int_bayesian, \"Interventional Data - Uncertain Parameters - Alternative Structure\")" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "visualize_ATE(prediction_alt_int_bayesian, \"Interventional Data - Uncertain Parameters - Alternative Structure\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "While our uncertainty about the proportions of individuals with cancer is very wide, we now see that, as expected, once we've randomized whether an individual smokes, we no longer see any association between smoking and cancer after applying an intervention under this alternative model. The resulting distribution of ATE estimates is now narrowly centered around 0.\n", + "\n", + "Using our two probabilistic programs representing different plausible structures (and with uncertain parameters), we can write a probabilistic program that randomly chooses between them. Conceptually, this represents a scenario in which we think that it is equally plausible that smoking causes cancer and that cancer causes smoking." + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "from pyro.distributions import Bernoulli\n", + "\n", + "def bayesian_population_causal_model_uncertain_structure(n_individuals):\n", + " \n", + " is_original_model = pyro.sample(\"is_original_model\", Bernoulli(0.5))\n", + " model = bayesian_population_causal_model if is_original_model else alt_bayesian_population_causal_model\n", + "\n", + " return model(n_individuals)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Simulating Observational Data with Uncertain Structure and Parameters" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Again, we can simulate from the observational distribution, this time using our model with uncertainty over both structure and parameters." + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "predictive_uncertain_structure_bayesian = pyro.infer.Predictive(bayesian_population_causal_model_uncertain_structure, num_samples=1000, return_sites=(\"cancer\", \"_RETURN\"))\n", + "prediction_uncertain_structure_bayesian = predictive_uncertain_structure_bayesian(n_individuals)\n", + "visualize_proportions_multiple(prediction_uncertain_structure_bayesian, \"Observational Data - Uncertain Parameters and Structure\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Simulating Interventional Data with Uncertain Structure and Parameters" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Earlier we showed that interventions in Casual Pyro compose freely with hierarchical Bayesian extensions of our original model with deterministic parameters. Perhaps not surprisingly, interventions are still well-behaved even when we included uncertainty over structures in our programs.\n", + "\n", + "To see this, let's again apply our intervention and visualize the results of repeated samples from our model with structural uncertainty. As expected, we see that approximately half of the simulations from this model with structural uncertainty show a difference in cancer rate between smokers and non-smokers (representing samples in which `is_original_model=1`)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "def bayesian_forced_smokes_model_uncertain_structure(n_individuals):\n", + " smokes_assignment = torch.tensor([0., 1.]).repeat(n_individuals // 2)\n", + " transformed_model = do(bayesian_population_causal_model_uncertain_structure, {\"smokes\": smokes_assignment})\n", + " return transformed_model(n_individuals)" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "predictive_uncertain_structure_int_bayesian = pyro.infer.Predictive(bayesian_forced_smokes_model_uncertain_structure, num_samples=1000, return_sites=(\"cancer\", \"_RETURN\"))\n", + "prediction_uncertain_structure_int_bayesian = predictive_uncertain_structure_int_bayesian(n_individuals)\n", + "visualize_proportions_multiple(prediction_uncertain_structure_int_bayesian, \"Interventional Data - Uncertain Parameters and Structure\")" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "visualize_ATE(prediction_uncertain_structure_int_bayesian, \"Interventional Data - Uncertain Parameters and Structure\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now that we've incorporated uncertainty about the structure *and* parameters, we can see that samples from the post-intervention version of our program sometimes show an effect of smoking on cancer and sometimes show no effect. We this clearly with a sharp peak at $ATE=0$ above. In other words, our uncertainty over causal models naturally propagates to uncertainty over causal conclusions. We can visualize this flow of uncertainty in the following (again somewhat cartoonish) diagram showing how information flows from observational probabilistic programs to interventions probabilistic programs and subsequently to factual and counterfactual data." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![fig3](figures/Interventional_Marginal.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Observation 3: causal inference is probabilistic inference\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "So far we've seen how introducing intervention program transformations using ChiRho's `do` makes it straightforward to reason about the causal implications of (i) uncertainty over the strength of causal effects and (ii) uncertainty over causal structure. We can call this progress *causal modeling*. In practice however, we often don't want to just posit causal knowledge about the world, we also want to update that knowledge in light of observational and experimental data. We'll call this process of learning about cause and effect from data *causal inference*. The key insight underlying ChiRho is that once we have a Bayesian causal model representing our uncertainty about cause-effect relationships, causal inference simply reduces to probabilistic inference in what's known as a *multi-world* transformation of our original causal model. \n", + "\n", + "As we'll show in this section, to reduce causal inference to probabilistic inference using ChiRho we have to follow a few steps:\n", + "1. Transform our ChiRho program into a new Pyro program that represents a joint distribution over both outcomes, i.e. what actually happened, and counterfactual outcomes, i.e. what would have happened had we intervened. We'll call this a *twin world program*.\n", + "2. Condition the factual outcomes in our twin world program according to some observed data.\n", + "3. Run (approximate) posterior inference in the conditioned twin world program, resulting in an updated distribution over both parameters and counterfactual outcomes.\n", + "\n", + "**Important Note:** Readers familiar with causal inference may find the statement that \"causal inference reduces to probabilistic inference\" unpalatable. To clarify, we are not claiming that causal inference reduces to probabilistic inference *absent any assumptions*. Instead, we simply propose that users encode their causal assumptions as probabilistic programs." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Automatically Constructing Counterfactual Worlds - `TwinWorldCounterfactual`" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To make this concrete, we need to use another program transformation provided by ChiRho, the `TwinWorldCounterfactual` effect handler. Intuitively, this new effect handler tells ChiRho that any `pyro.sample` statements that are downstream of an intervention should be sampled twice, once for the observable world without interventions and once for the counterfactual world with interventions applied." + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([[[[[1., 1., 0., ..., 0., 0., 1.]]]],\n", + "\n", + "\n", + "\n", + " [[[[1., 1., 1., ..., 1., 1., 1.]]]]])" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from chirho.counterfactual.handlers import TwinWorldCounterfactual\n", + "twin_model = TwinWorldCounterfactual()(bayesian_randomized_model)\n", + "\n", + "# Sample from both the factual and counterfactual worlds.\n", + "twin_model(n_individuals)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "\n", + "Using somewhat light and informal mathematical notation for brevity, the tensors returned from the model transformed using the `TwinWorldCounterfactual` handler represent samples from the joint distribution over $P(stress, smokes, cancer, stress_{cf}, smokes_{cf}, cancer_{cf})$, where $stress$, $smokes$, and $cancer$ are the random variables representing individual attributes without an intervention and $stress_{cf}$, $smokes_{cf}$, and $cancer_{cf}$ are the random variables representing individual attributes after applying our intervention. \n", + "\n", + "However, as we mentioned before, causal inference is about coming to causal conclusions combining modeling assumptions *and* data, not just modeling assumptions alone. Now that we have a model representing a joint distribution over both observational and interventional data, we can condition our model and apply approximate inference techniques just as we would any other Pyro model. For example, using Pyro's support for stochastic variaitional inference we can obtain an approximate conditional distribution $P(stress_{cf}, smokes_{cf}, cancer_{cf}|stress, smokes, cancer)$. To see how ChiRho enables causal inference, let's first generate some synthetic observational data for $stress$, $smokes$, and $cancer$ in which approximately half of the individuals smoke, and those who do are more likely to have cancer than those who don't." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Generating Synthetic Data" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [], + "source": [ + "stress_pt = torch.tensor([0.5])\n", + "smokes_cpt = torch.tensor([0.3, 0.6])\n", + "cancer_cpt = torch.tensor([[0.1, 0.3], \n", + " [0.1, 0.4]])\n", + "\n", + "predictive_data = pyro.infer.Predictive(bayesian_population_causal_model, num_samples=1, return_sites=(\"cancer\", \"stress\", \"_RETURN\"))\n", + "data = predictive_data(n_individuals)\n", + "data[\"smokes\"] = data.pop(\"_RETURN\").float()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Conditioning the Causal Model on Observational Data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now that we have synthetic data, we can condition on it inside of the `TwinWorldCounterfactual` handler we saw earlier. This creates a new model `twin_model_conditioned`, that represents the conditional distribution we're interested in, $p(stress_{cf}, smokes_{cf}, cancer_{cf}|stress, smokes, cancer)$." + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [], + "source": [ + "from chirho.observational.handlers import condition\n", + "\n", + "twin_model_conditioned = TwinWorldCounterfactual()(condition(bayesian_population_forced_smokes_model, data=data))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Using Variational Inference for Bayesian Causal Inference" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "After using the `TwinWorldCounterfactual` and the `do` handlers, the resulting model can be treated as an ordinary Pyro program. Just as in Pyro, conditioning a model on data means that we can no longer sample directly from the `twin_model_conditioned` model by just running the program; instead we need to run an *approximate inference algorithm*.\n", + "\n", + "Because we've used ChiRho's program transformations to construct an ordinary Pyro program, we can use Pyro's built-in support for approximate inference. To see this, let's run stochastic variational inference with a reparameterized Gaussian mean-field variational approximation." + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/homebrew/anaconda3/envs/basis/lib/python3.10/site-packages/pyro/util.py:303: UserWarning: Found vars in model but not guide: {'cancer_counterfactual'}\n", + " warnings.warn(f\"Found vars in model but not guide: {bad_sites}\")\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[iteration 0001] loss: 2.7795\n", + "[iteration 0101] loss: 1.8926\n", + "[iteration 0201] loss: 1.8272\n", + "[iteration 0301] loss: 1.8648\n", + "[iteration 0401] loss: 1.8202\n", + "[iteration 0501] loss: 1.8427\n", + "[iteration 0601] loss: 1.8096\n", + "[iteration 0701] loss: 1.8314\n", + "[iteration 0801] loss: 1.8246\n", + "[iteration 0901] loss: 1.8274\n" + ] + } + ], + "source": [ + "from pyro.poutine import block\n", + "from pyro.infer.autoguide import AutoNormal\n", + "from pyro.infer import SVI\n", + "\n", + "adam = pyro.optim.Adam({'lr': 0.03})\n", + "elbo = pyro.infer.Trace_ELBO()\n", + "\n", + "guide = AutoNormal(block(twin_model_conditioned, expose=['stress_pt', 'smokes_cpt', 'cancer_cpt']))\n", + "\n", + "svi = SVI(twin_model_conditioned, guide, adam, loss=elbo)\n", + "\n", + "for j in range(num_iterations):\n", + " # calculate the loss and take a gradient step\n", + " loss = svi.step(n_individuals)\n", + " if j % 100 == 0:\n", + " print(\"[iteration %04d] loss: %.4f\" % (j + 1, loss / n_individuals))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Simulating Interventional Data from the Approximate Posterior" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can visualize the resulting posterior distribution over intervened models just as we did before conditioning on data." + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# TODO: It's not clear that we're actually conditioning on the data here, as posterior inference returns quite different results for each run.\n", + "# It's possible that the names don't align with ChiRho's internal transformed names. Should be addressed with new indexing.\n", + "\n", + "predictive_int_posterior = pyro.infer.Predictive(bayesian_population_forced_smokes_model, guide=guide, num_samples=1000, return_sites=(\"cancer\", \"_RETURN\"))\n", + "prediction_int_posterior = predictive_int_posterior(n_individuals)\n", + "visualize_proportions_multiple(prediction_int_posterior, \"Interventional Data - Posterior Distribution\")" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "visualize_ATE(prediction_int_posterior, \"Interventional Data - Posterior Distribution\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Using our conceptual diagrams from before, we can see how data informs our updated belief about causal models, which then propagate forward into counterfactual outcomes and causal conclusions. Even though we've only observed data in a world where people choose whether to smoke or not of their own free will, this observed data tells us something about which causal models are plausible. Importantly, this process of mapping data in one world to conclusions in another (e.g. a world in which people are randomly assigned smoking behavior), requires assumptions. When using ChiRho, the models we write encode those assumptions implicitly by how interventions transform them. In subsequent tutorials we'll discuss this subtlety and consideration in more detail. For now, remember that this ability to reduce causal inference to probabilistic inference doesn't come out of thin air." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![fig4](figures/Interventional_Posterior.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Recap" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Before we conclude this tutorial, let's first recap, and then zoom out thinking a bit more broadly about what it is that we illustrated.\n", + "\n", + "**Observation 1**\n", + "\n", + "1. We wrote a causal model using the Pyro probabilistic programming language relating $stress$, $smokes$ and $cancer$, defined as a function of known parameters, and showed how this model can be used to simulate observations for a population of individuals using Pyro's `plate` effect handler. \n", + "2. We wrote a modified version of our causal model in which individuals are \"forced\" to smoke or not smoke, modifying the original mechanism that determines whether individuals choose to smoke or not.\n", + "3. We showed how this program rewriting can be automated with ChiRho using the `do` program transformation.\n", + "\n", + "**Observation 2**\n", + "\n", + "4. Using our causal model defined as a function of known parameters we wrote a Bayesian hierarchical causal model relating $stress$, $smokes$, and $cancer$. We showed how this Bayesian extension induces a distribution over populations of individuals, and the observational relationships between $smokes$ and $cancer$.\n", + "5. We applied ChiRho's `do` program transformation to the Bayesian hierarchical causal model, and showed how this induces a distribution over the attributes of individuals who are forced to smoke or not smoke.\n", + "6. We wrote an alternative Bayesian hierarchical causal model in which cancer causes individuals to smoke, rather than vice-versa as in our original model. Similar to our original model, this alternative model induced broad uncertainty over the observational relationship between $smokes$ and $cancer$. However, unlike our original model, forcing individuals smoke induced no change in whether individuals got cancer. \n", + "7. We wrote a Bayesian hierarchical causal model with uncertainty over parameters and structure, implemented by randomly choosing between our two candidate causal models based on the outcome of a latent discrete random variable. We showed that this model induced a distribution over average treatment effects that had a sharp peak at $ATE=0$.\n", + "\n", + "**Observation 3**\n", + "\n", + "8. We showed how to represent a joint distribution over both observational and interventional distributions using ChiRho's `TwinWorldCounterfactual` effect handler.\n", + "9. Conditioning our model on (synthetic) observed data, we showed how causal inference problems can be solved using Pyro's extensive support for approximate variational inference.\n", + "10. Finally, we showed how the posterior distribution over causal models induced a posterior distribution over the attributes of individuals who forced to smoke or not smoke, conditional on observations of individuals who chose to smoke according to the original mechanisms." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## A Causal Bayesian Workflow" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To conclude this tutorial, let's think about how to use ChiRho for causal inference problems more broadly. We elaborate on how the program transformation-based operations we've demonstrated so far fit into the standard statistical practice embodied by Peterson and van der Laans' *Causal Roadmap* \\[Petersen et al. 2014\\]. Here, we show the original causal roadmap components in **bold**, and how we would express them in terms of ChiRho in *italics*.\n", + "\n", + "\n", + "1. **Specify knowledge about the system to be studied using a causal model**. *This knowledge should be expressed by the ordering and functional/distributional relationships of random variables in a Pyro program*.\n", + "2. **Specify the observed data and their link to the causal model.** *Express the relationships between observations and the causal model by (optionally) adding additional model components representing mechanisms for missing data, and by conditioning the original Pyro program on observations*.\n", + "3. **Specify a target causal quantity.** *Express the target causal quantity as a combination of program transformations including world-splitting (e.g. `TwinWorldCounterfactual`), intervention (`do`), and probabilistic conditioning (`condition`).*\n", + "4. **Assess identifiability.** *Currently ChiRho does not support automated methods for assessing identifiability. Future versions will implement non-parametric methods such as the do-calculus \\[Pearl 2009\\], or numerical approaches such as Simulation-based identifiability \\[Witty et al. 2022\\].*\n", + "5. **State the statistical estimation problem**. *ChiRho does not currently distinguish between causal estimation and statistical estimation. Therefore, this component of the original causal roadmap is not covered by ChiRho. In future versions we may implement nonparametric causal inference utilities using free variables, in which case causal reasoning (such as nonparametric identifiability analysis) and statistical estimation may occur over different models for the same process.*\n", + "6. **Estimate.** *Use Pyro's approximate inference capabilities (e.g. SVI) to estimate the posterior distributions over counterfactual variables of interest.*\n", + "7. **Interpret.** *ChiRho does not currently provide any support for interpretting the validity of causal assumptions or conclusions.*\n", + "\n", + "Importantly, once we arrive at step 6, we can again dispatch the standard non-causal *Bayesian Workflow* \\[Gelman et al. 2020\\] for assessing the validity of probabilistic modeling and inference. Note: while the causal roadmap and the Bayesian workflow are mostly orthogonal, there are some special considerations that can be made to make model criticism more effective in a causal inference setting \\[Tran et al. 2016\\]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## References" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Pearl, Judea. Causality: Models, Reasoning and Inference. 2nd ed. USA: Cambridge University Press, 2009.\n", + "\n", + "Aldrich, John. “Autonomy.” Oxford Economic Papers 41, no. 1 (1989): 15–34.\n", + "\n", + "Petersen, Maya L., and Mark J. van der Laan. \"Causal models and learning from data: integrating causal modeling and statistical estimation.\" Epidemiology (Cambridge, Mass.) 25.3 (2014): 418.\n", + "\n", + "Witty, Sam, David Jensen, and Vikash Mansinghka. \"SBI: A Simulation-Based Test of Identifiability for Bayesian Causal Inference.\" arXiv preprint arXiv:2102.11761 (2021).\n", + "\n", + "Gelman, Andrew, et al. \"Bayesian workflow.\" arXiv preprint arXiv:2011.01808 (2020).\n", + "\n", + "Tran, Dustin, et al. \"Model criticism for bayesian causal inference.\" arXiv preprint arXiv:1610.09037 (2016)." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.10.9" + }, + "vscode": { + "interpreter": { + "hash": "cffe1a1fa048e49a173ef425a4ae5289f738a2b81f14c36ed87498058f2b9506" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}