From 3661279e6deac08fccb0c72ef39fe0ab767f2042 Mon Sep 17 00:00:00 2001 From: Jeremy Zucker Date: Thu, 2 Feb 2023 03:51:32 -0500 Subject: [PATCH 1/4] scenario 2 unit tests 1 and 2 using SIDARTHE model developed by MIRA team --- .../scenario2-mira-unit-test1-and-2.ipynb | 1003 +++++++++++++++++ 1 file changed, 1003 insertions(+) create mode 100644 6-month-milestone/evaluation/scenario_2/ta_3/ciemss/scenario2-mira-unit-test1-and-2.ipynb diff --git a/6-month-milestone/evaluation/scenario_2/ta_3/ciemss/scenario2-mira-unit-test1-and-2.ipynb b/6-month-milestone/evaluation/scenario_2/ta_3/ciemss/scenario2-mira-unit-test1-and-2.ipynb new file mode 100644 index 0000000..8e292bf --- /dev/null +++ b/6-month-milestone/evaluation/scenario_2/ta_3/ciemss/scenario2-mira-unit-test1-and-2.ipynb @@ -0,0 +1,1003 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "b087c52b-a505-45d3-b643-df44d8c924a5", + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "markdown", + "id": "542b06c1-28fb-47ec-9a34-170acc7d2a84", + "metadata": {}, + "source": [ + "# Load Dependencies" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "84e0bb12-68af-4a6d-a384-db4837c44ac0", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/zuck016/.pyenv/versions/jz-scenario2-eval/lib/python3.10/site-packages/tqdm/auto.py:22: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n" + ] + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "import torch\n", + "\n", + "import pyro\n", + "import numpy as np\n", + "import pyro.distributions as dist\n", + "# from pyro.poutine import trace, replay, block\n", + "# from pyro.infer.autoguide.guides import AutoDelta, AutoNormal\n", + "# from pyro.infer import SVI, Trace_ELBO, Predictive\n", + "\n", + "from pyciemss.ODE.askem_primitives import sample, infer_parameters, intervene, optimization\n", + "from pyciemss.ODE.base import get_name\n", + "from pyciemss.ODE.interventions import time_and_state_dependent_intervention_builder\n", + "# import sys\n", + "# sys.path.append(\"../\")\n", + "\n", + "#\n", + "from pyciemss.utils import get_tspan\n", + "\n", + "import warnings\n", + "warnings.filterwarnings('ignore')" + ] + }, + { + "cell_type": "markdown", + "id": "4855961d-9c38-4050-b6b7-aaae03500fc9", + "metadata": {}, + "source": [ + "# Plotting Utilities" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "f233104e-c29d-4e25-859f-2a328ec7892a", + "metadata": {}, + "outputs": [], + "source": [ + "def setup_ax(ax=None):\n", + "\n", + " if not ax:\n", + " fig = plt.figure(facecolor='w', figsize=(9, 9))\n", + " ax = fig.add_subplot(111, axisbelow=True)\n", + "\n", + " ax.set_xlabel('Time /days')\n", + " ax.set_ylabel('Infected ')\n", + " return ax\n", + "\n", + "def plot_predictive(prediction, tspan, tmin=None, ax=None, alpha=0.2, color=\"black\", **kwargs):\n", + " vars = [\"I_total_obs\"]\n", + " #infection_total = sum([prediction[x].squeeze().detach().numpy()/1000. for x in ['I_obs', 'D_obs', 'A_obs', 'R_obs', 'T_obs']])\n", + "\n", + " I_low = torch.quantile(prediction[\"I_total_obs\"], 0.05, dim=0).detach().numpy()\n", + " I_up = torch.quantile(prediction[\"I_total_obs\"], 0.95, dim=0).detach().numpy()\n", + "\n", + " if tmin:\n", + " indeces = tspan >= tmin\n", + " else:\n", + " indeces = torch.ones_like(tspan).bool()\n", + "\n", + " if not ax:\n", + " fig = plt.figure(facecolor='w')\n", + " ax = fig.add_subplot(111, facecolor='#dddddd', axisbelow=True)\n", + " \n", + " ax.fill_between(tspan[indeces], I_low[indeces], I_up[indeces], alpha=alpha, color=color, **kwargs)\n", + "\n", + " legend = ax.legend()\n", + " legend.get_frame().set_alpha(0.5)\n", + "\n", + " return ax\n", + "\n", + "def plot_trajectory(data, tspan, ax=None, color='black', alpha=0.5, lw=0, marker='.', label=None, observation='I_total_obs'):\n", + " # Plot the data on three separate curves for S(t), I(t) and R(t)\n", + "\n", + " if not ax:\n", + " fig = plt.figure(facecolor='w')\n", + " ax = fig.add_subplot(111, facecolor='#dddddd', axisbelow=True)\n", + " #infection_total = sum([data[x].squeeze().detach().numpy()/1000. for x in ['I_obs', 'D_obs', 'A_obs', 'R_obs', 'T_obs']])\n", + " ax.plot(tspan, data[observation].squeeze().detach().numpy(), color, alpha=alpha, lw=lw, marker=marker, label=label)\n", + " \n", + " return ax\n", + "\n", + "def plot_intervention_line(t, ax=None):\n", + " if not ax:\n", + " fig = plt.figure(facecolor='w')\n", + " ax = fig.add_subplot(111, facecolor='#dddddd', axisbelow=True)\n", + "\n", + " ylim = ax.get_ylim()\n", + "\n", + " ax.vlines(t, min(ylim), max(ylim), color=\"grey\", ls='-')\n", + "\n", + " return ax" + ] + }, + { + "cell_type": "markdown", + "id": "3e0c3726-5ec0-475d-8305-f20b5d84e424", + "metadata": {}, + "source": [ + "# Setup Parameters" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "16608500-97b5-4081-9e6b-b7c193c10285", + "metadata": {}, + "outputs": [], + "source": [ + "full_tspan = get_tspan(1, 100, 100)\n", + "\n", + "num_samples = 500\n", + "\n", + "# Total population, N.\n", + "N = 1\n", + "# Initial number of infected and recovered individuals, I0 and R0.\n", + "I0, D0, A0, R0, T0, H0, E0 = 200./60e6, 20./60e6, 1./60e6, 2./60e6, 0, 0, 0\n", + "\n", + "# Everyone else, S0, is susceptible to infection initially.\n", + "\n", + "S0 = N - I0 - D0 - A0 - R0 - T0 - H0 - E0\n", + "\n", + "\n", + "#I_obs = torch.tensor([81.47, 84.3, 86.44, 89.66, 93.32, 94.1, 96.31])\n", + "\n", + "initial_state = tuple(torch.as_tensor(s) for s in (S0, I0, D0, A0, R0, T0, H0, E0))\n", + "final_observed_state = tuple(torch.as_tensor(s) for s in (S0, I0, D0, A0, R0, T0, H0, E0))" + ] + }, + { + "cell_type": "markdown", + "id": "23fc9c9d-f8bc-4e95-a243-865690d3b43b", + "metadata": {}, + "source": [ + "# Probabilistic Forecasting - Passing unit test 1\n", + "There are two ‘unit tests’ we want to pass, to ensure that we understood and can reproduce the published model:\n", + "\n", + "## 1.a Unit Test \\#1:\n", + "\n", + "Set the initial values and parameters, as described in the Supplementary Methods section of the publication (pg. 9 of the pdf): \n", + "\n", + "### 1.a.1 Initial Values: \n", + "* $I = 200/60e6$,\n", + "* $D = 20/60e6$, \n", + "* $A = 1/60e6$, \n", + "* $R = 2/60e6$, \n", + "* $T = 0$, \n", + "* $H = 0$, \n", + "* $E = 0$; \n", + "* $S = 1 – I – D – A – R – T – H – E$. \n", + "\n", + "Let total population = 60e6.\n", + "\n", + "\n", + "### 1.a.2 Parameters: \n", + "\n", + "$$\\alpha = 0.570, \\beta = \\delta = 0.011, \\gamma = 0.456, \\epsilon = 0.171, \\theta = 0.371, \\zeta = \\eta = 0.125, \\mu = 0.017, \\nu = 0.027, \\tau = 0.01, \\lambda = \\rho = 0.034$$ and $$\\kappa = \\xi = \\sigma = 0.017$$." + ] + }, + { + "cell_type": "markdown", + "id": "2ebe2162-f586-48c6-a4b1-233c9895721c", + "metadata": {}, + "source": [ + "### 1.a.3 Time of peak total infections\n", + "\n", + "Simulate for 100 days, and determine the day and level of peak total infections (sum over all the infected states I, D, A, R, T). Expected output: The peak should occur around day 47, when ~60% of the population is infected.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "dbd7d430-325f-4f40-9b20-d8a0c0264f62", + "metadata": {}, + "outputs": [], + "source": [ + "from pyciemss.ODE.models import SIDARTHE\n", + "\n", + "pyro.set_rng_seed(0)\n", + "\n", + "# ode_model = SIDARTHE(N=1,\n", + "# alpha_prior=dist.Delta(torch.tensor (0.570)) ,\n", + "# beta_prior=dist.Delta(torch.tensor (0.011)) ,\n", + "# gamma_prior=dist.Delta(torch.tensor (0.456)) ,\n", + "# delta_prior=dist.Delta(torch.tensor (0.011)) ,\n", + "# epsilon_prior=dist.Delta(torch.tensor (0.171)) ,\n", + "# lamb_prior =dist.Delta(torch.tensor (0.034)) ,\n", + "# zeta_prior=dist.Delta(torch.tensor (0.125)) ,\n", + "# eta_prior=dist.Delta(torch.tensor (0.125)) ,\n", + "# kappa_prior=dist.Delta(torch.tensor (0.017)) ,\n", + "# theta_prior=dist.Delta(torch.tensor (0.371)) ,\n", + "# rho_prior=dist.Delta(torch.tensor (0.034)) ,\n", + "# xi_prior=dist.Delta(torch.tensor (0.017)) ,\n", + "# sigma_prior=dist.Delta(torch.tensor (0.017)) ,\n", + "# mu_prior=dist.Delta(torch.tensor (0.017)) ,\n", + "# nu_prior=dist.Delta(torch.tensor (0.027)) ,\n", + "# tau_prior=dist.Delta(torch.tensor (0.01)) )" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "9475b4c7-27b4-47e7-be57-539ff040ea1e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'beta': ,\n", + " 'gamma': ,\n", + " 'delta': ,\n", + " 'alpha': ,\n", + " 'epsilon': ,\n", + " 'zeta': ,\n", + " 'lambda': ,\n", + " 'eta': ,\n", + " 'rho': ,\n", + " 'theta': ,\n", + " 'kappa': ,\n", + " 'mu': ,\n", + " 'nu': ,\n", + " 'xi': ,\n", + " 'tau': ,\n", + " 'sigma': }" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from pyciemss.ODE.models import MIRA_SIDARTHE\n", + "from pathlib import Path\n", + "import os\n", + "MODELPATH = '../../../test/models/evaluation_examples/scenario_2/'\n", + "\n", + "SIDARTHEPATH = 'scenario2_sidarthe.json'\n", + "plotting_ode_model = MIRA_SIDARTHE.from_mira(os.path.join(MODELPATH,SIDARTHEPATH))\n", + "param2transition = {\n", + " trans.rate.key: trans\n", + " for trans in plotting_ode_model.G.transitions.values()\n", + "}\n", + "param2transition" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "30b811eb-83a8-4555-85ab-f9be7a987143", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "OrderedDict([('Ailing', ),\n", + " ('Diagnosed', ),\n", + " ('Extinct', ),\n", + " ('Healed', ),\n", + " ('Infected', ),\n", + " ('Recognized', ),\n", + " ('Susceptible', ),\n", + " ('Threatened', )])" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "plotting_ode_model.var_order" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "d8967995-5cc5-46ad-858d-6446359a0869", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(tensor(1.6667e-08),\n", + " tensor(3.3333e-07),\n", + " tensor(0.),\n", + " tensor(0.),\n", + " tensor(3.3333e-06),\n", + " tensor(3.3333e-08),\n", + " tensor(1.0000),\n", + " tensor(0.))" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "initial_state = tuple(torch.as_tensor(v.data['initial_value'])\n", + " if v.data['initial_value'] is not None else torch.as_tensor(0.)\n", + " for v in plotting_ode_model.var_order.values())\n", + "initial_state" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "31473cdd-9896-42ed-b487-36362c1c9744", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "#prior_prediction = sample(plotting_ode_model, num_samples, initial_state, full_tspan)\n", + "single_prediction = sample(plotting_ode_model, 1, initial_state, full_tspan)" + ] + }, + { + "cell_type": "markdown", + "id": "0f212306-ed0d-42b1-9aa9-1a3f7af5bed5", + "metadata": {}, + "source": [ + "### Day of peak infection\n", + "\n", + "Simulate for 100 days, and determine the day and level of peak total infections (sum over all the infected states I, D, A, R, T). Expected output: The peak should occur around day 47, when ~60% of the population is infected.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "15f03c6f-d085-4f36-bc7a-312057d82758", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#single_prediction = sample(plotting_ode_model, 1, initial_state, full_tspan)\n", + "ax = plot_trajectory(single_prediction, full_tspan, ax=setup_ax(), color=\"blue\", marker='', lw=1., label=\"Before Seeing Data - Single Forecast\",\n", + " observation='obs_total_infections')\n", + "#ax = plot_predictive(prior_prediction, full_tspan, ax=ax, label=\"Before Seeing Data - Probabilistic Forecast\", color=\"red\")\n", + "ax.axvline(47)\n" + ] + }, + { + "cell_type": "markdown", + "id": "d17abb80-e619-4810-b9dd-f76a4c252ef7", + "metadata": {}, + "source": [ + "## 1.b Unit Test \\#2: \n", + "\n", + "Now update the parameters to reflect various interventions that Italy implemented during the first wave, as described in detail on pg. 9. Simulate for 100 days, reproduce the trajectories in Fig. 2B, and determine the day and level of peak total infections (sum over all the infected states I, D, A, R, T). Expected output: Trajectories in Fig. 2B, peak occurs around day 50, with ~0.2% of the total population infected." + ] + }, + { + "cell_type": "markdown", + "id": "11148b1b-3e9e-4190-a90b-c1dc6291fa2f", + "metadata": {}, + "source": [ + "### Day 4 social distancing\n", + "\n", + "After day 4, as a consequence of basic social-distancing measures due to the public being aware of the epidemic outbreak and due to recommendations (such as washing hands often, not touching one’s face, avoiding handshakes and keeping distance) and early measures (such as closing schools) by the Italian government, we set $\\alpha= 0.422, \\beta = \\delta = 0.0057$ and $\\gamma = 0.285$, so the new basic reproduction number becomes $R_0 = 1.66$.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "3fd41fe4-57d7-4fe1-be7c-6deb93210584", + "metadata": {}, + "outputs": [], + "source": [ + "def SI_alpha_intervention(t, flux):\n", + " alpha = 0.570\n", + " if t < 4:\n", + " return flux\n", + " elif t < 22:\n", + " return flux/alpha * 0.422\n", + " elif t < 28:\n", + " return flux/alpha* 0.360\n", + " else:\n", + " return flux/alpha*0.210\n", + " \n", + "def SD_beta_intervention(t, flux):\n", + " beta = 0.011\n", + " if t < 4:\n", + " return flux\n", + " elif t < 22:\n", + " return flux/beta * 0.0057\n", + " else:\n", + " return flux/beta* 0.005\n", + "\n", + "def SA_gamma_intervention(t, flux):\n", + " gamma = 0.456\n", + " if t < 4:\n", + " return flux\n", + " elif t < 22:\n", + " return flux/gamma * 0.285\n", + " elif t < 28:\n", + " return flux/gamma * 0.200\n", + " else:\n", + " return flux/gamma * 0.110\n", + "\n", + "def SR_delta_intervention(t, flux):\n", + " delta = 0.011\n", + " if t < 4:\n", + " return flux\n", + " elif t < 22:\n", + " return flux/delta* 0.0057\n", + " else:\n", + " return flux/delta* 0.0057\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "37e07865-5065-4dbe-ac46-2590c8834a61", + "metadata": {}, + "source": [ + "### Day 12 screening limited to symptomatic individuals\n", + "Also, after day 12, we set $\\epsilon = 0.143$ as a consequence of the policy limiting screening to symptomatic individuals only; thus, totally asymptomatic individuals are almost no longer detected, while individuals with very mild symptoms are still detected (hence $\\epsilon$ is not set exactly to zero). Due to this, $R_0 = 1.80$. " + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "f17d16be", + "metadata": {}, + "outputs": [], + "source": [ + "def ID_epsilon_intervention(t, flux):\n", + " epsilon = 0.171\n", + " if t < 12:\n", + " return flux\n", + " elif t < 38:\n", + " return flux/epsilon * 0.143\n", + " else:\n", + " return flux/epsilon * 0.200\n", + " \n", + "\n", + "#plotting_ode_model = pyro.do(ode_model, {\"noise_var\": torch.tensor([0.000001])})" + ] + }, + { + "cell_type": "markdown", + "id": "b7fcf4fc-00a8-4c92-950a-15118ab8cf7d", + "metadata": {}, + "source": [ + "### Day 22 incomplete lockdown\n", + "[SIDARTHE](SIDARTHE.png)\n", + "\n", + "After day 22, the lockdown, at first incomplete, yields $\\alpha = 0.360, \\beta = \\delta = 0.005$ and $\\gamma = 0.200$; also, $\\zeta = \\eta = 0.034, \\mu = 0.008, \\nu = 0.015, \\lambda = 0.08$ and $\\rho= \\kappa = \\xi = \\sigma = 0.017$. Hence, the new basic reproduction number becomes $R_0 = 1.60$.[SIDARTHE-eqn.png](SIDARTHE-eqn.png)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "7f577887-41c7-48c3-906f-424aae29c600", + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "def IA_zeta_intervention(t, flux):\n", + " zeta = 0.125\n", + " if t < 22:\n", + " return flux\n", + " elif t < 38:\n", + " return flux/zeta*0.034\n", + " else:\n", + " return flux/zeta*0.025\n", + " \n", + "def DR_eta_intervention(t, flux):\n", + " eta = 0.125\n", + " if t < 22:\n", + " return flux\n", + " elif t < 38:\n", + " return flux/eta * 0.034\n", + " else: \n", + " return flux/eta*0.025\n", + " \n", + "def AT_mu_intervention(t, flux):\n", + " mu = 0.017\n", + " if t < 22:\n", + " return flux\n", + " else:\n", + " return flux/mu * 0.008\n", + " \n", + "def RT_nu_intervention(t, flux):\n", + " nu = 0.027\n", + " if t < 22:\n", + " return flux\n", + " else:\n", + " return flux/nu*0.015\n", + " \n", + "def IH_lamb_intervention(t, flux):\n", + " lamb = 0.034\n", + " if t < 22:\n", + " return flux\n", + " else:\n", + " return flux/lamb*0.08\n", + "\n", + "def DH_rho_intervention(t, flux):\n", + " rho = 0.034\n", + " if t < 22:\n", + " return flux\n", + " elif t < 38:\n", + " return flux/rho*0.017\n", + " else:\n", + " return flux/rho*0.020\n", + "\n", + " " + ] + }, + { + "cell_type": "markdown", + "id": "aa345f66-ef80-4a3e-84c6-52d6fa44e30c", + "metadata": {}, + "source": [ + "### Day 28 fully operational lockdown\n", + "After day 28, the lockdown is fully operational and gets stricter (working is no longer a good reason for going out: gradually, non-indispensable activities are stopped): we get $\\alpha = 0.210$ and $\\gamma = \n", + "0.110$, hence $R_0 = 0.99$. " + ] + }, + { + "cell_type": "markdown", + "id": "8061e2a9-5541-4c14-bad5-d3a012077de2", + "metadata": {}, + "source": [ + "### Day 38 wider testing campaign launched\n", + "After day 38, a wider testing campaign is launched: this yields $\\epsilon = 0.200$, and also $\\rho = \\kappa = \\xi = 0.020$, while $\\sigma = 0.010$ and $\\zeta = \\eta = 0.025$. Therefore, $R_0 = 0.85$." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "e67b4f96-696e-4a33-961f-2971f34fc86d", + "metadata": {}, + "outputs": [], + "source": [ + "def AH_kappa_intervention(t, flux):\n", + " kappa = 0.017\n", + " if t < 38:\n", + " return flux\n", + " else:\n", + " return flux/kappa*0.020\n", + "\n", + "def RH_xi_intervention(t, flux):\n", + " xi = 0.017\n", + " if t < 38:\n", + " return flux\n", + " else:\n", + " return flux/xi*0.020\n", + " \n", + "def TH_sigma_intervention(t, flux):\n", + " sigma = 0.017\n", + " if t < 38:\n", + " return flux\n", + " else:\n", + " return flux/sigma*0.010" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f7acbcf7-e486-4198-9ae4-56ff7fcbe4f2", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "8879bf6d-ff2c-4003-a14a-e6e0c295ce99", + "metadata": {}, + "source": [ + "\n", + "### Unit Test \\#2: \n", + "Now update the parameters to reflect various interventions that Italy implemented during the first wave, as described in detail on pg. 9. Simulate for 100 days, reproduce the trajectories in Fig. 2B, and determine the day and level of peak total infections (sum over all the infected states I, D, A, R, T). Expected output: Trajectories in Fig. 2B, peak occurs around day 50, with ~0.2% of the total population infected.\n", + "\n", + "![SIDARTHE.png](../SIDARTHE.png)" + ] + }, + { + "cell_type": "markdown", + "id": "b0b513c9-7b71-4d29-9c54-2df995c2c7be", + "metadata": {}, + "source": [ + "Reproduction number $\\mathcal{R}_0$:\n", + "$$r_1 = \\epsilon + \\zeta + \\lambda$$ \n", + "$$r_2 = \\eta + \\rho$$ \n", + "$$r_3 = \\theta + \\mu + \\kappa$$ \n", + "$$r_4 =\\nu + \\xi + \\tau_1$$ \n", + "$$r_5 =\\sigma + \\tau_2$$ \n", + "\n", + " $$\\mathcal{R}_0 = \\frac{\\alpha + \\frac{\\beta\\epsilon}{r_2} + \\frac{\\gamma\\zeta}{r_3} + \\delta\\left( \\frac{\\eta\\epsilon}{r_2r_4}+ \\frac{\\zeta\\theta}{r_3r_4}\\right)}{r_1}$$\n" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "19224127-fa94-43ff-bc82-96f14e614b07", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "flux_trans_(('Infected', ('identity', 'ido:0000511'), ('disease_status', 'ncit:C3833'), ('property', 'ncit:C113725')), ('Ailing', ('identity', 'ido:0000511'), ('disease_status', 'ncit:C25269'), ('property', 'ncit:C113725')), 'NaturalConversion') 5.000000\n" + ] + } + ], + "source": [ + "\n", + "zeta = 'flux_' + get_name(param2transition['zeta'])\n", + "print(zeta + \" %f\" % (5.0000))" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "60f90a2c-ee3e-4d28-9995-2f771f997140", + "metadata": {}, + "outputs": [], + "source": [ + "interventions = {\"alpha\": SI_alpha_intervention,\n", + " \"beta\": SD_beta_intervention,\n", + " \"gamma\": SA_gamma_intervention,\n", + " \"delta\": SR_delta_intervention,\n", + " \"epsilon\": ID_epsilon_intervention,\n", + " \"lambda\": IH_lamb_intervention,\n", + " \"zeta\": IA_zeta_intervention,\n", + " \"eta\": DR_eta_intervention,\n", + " \"kappa\": AH_kappa_intervention,\n", + " # \"theta\": AR_theta_intervention,\n", + " \"rho\": DH_rho_intervention,\n", + " \"xi\": RH_xi_intervention,\n", + " \"sigma\": TH_sigma_intervention,\n", + " \"mu\": AT_mu_intervention,\n", + " \"nu\": RT_nu_intervention}\n", + "parameter_intervention = {}\n", + "intervened_ode_model = plotting_ode_model\n", + "\n", + "for param in interventions:\n", + " parameter_intervention.update(time_and_state_dependent_intervention_builder(\n", + " \"flux_\" + get_name(param2transition[param]),\n", + " interventions[param], full_tspan))\n", + " \n", + "intervened_ode_model = intervene(intervened_ode_model, parameter_intervention)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "4d22ad97-cbcc-489c-9c05-0516b20bc6bd", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "single_prediction = sample(intervened_ode_model, 1, initial_state, full_tspan)\n", + "ax = plot_trajectory(single_prediction, full_tspan, ax=setup_ax(), color=\"blue\", marker='', lw=1., label=\"Before Seeing Data - Single Forecast\",\n", + " observation='obs_total_infections')\n", + "#ax = plot_predictive(prior_prediction, full_tspan, ax=ax, label=\"Before Seeing Data - Probabilistic Forecast\", color=\"red\")\n", + "ax.axvline(51)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "142da20c-35b4-4cb1-8a3c-45d82d0f1a6e", + "metadata": { + "collapsed": true, + "jupyter": { + "outputs_hidden": true + }, + "tags": [] + }, + "outputs": [ + { + "ename": "AssertionError", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAssertionError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[23], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m pyro\u001b[38;5;241m.\u001b[39mpoutine\u001b[38;5;241m.\u001b[39mtrace() \u001b[38;5;28;01mas\u001b[39;00m tr:\n\u001b[0;32m----> 2\u001b[0m \u001b[43mnew_intervened_model\u001b[49m\u001b[43m(\u001b[49m\u001b[43minitial_state\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mfull_tspan\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 4\u001b[0m \u001b[38;5;28mprint\u001b[39m(tr\u001b[38;5;241m.\u001b[39mtrace\u001b[38;5;241m.\u001b[39mnodes\u001b[38;5;241m.\u001b[39mkeys())\n", + "File \u001b[0;32m~/.pyenv/versions/jz-scenario2-eval/lib/python3.10/site-packages/pyro/poutine/messenger.py:12\u001b[0m, in \u001b[0;36m_context_wrap\u001b[0;34m(context, fn, *args, **kwargs)\u001b[0m\n\u001b[1;32m 10\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_context_wrap\u001b[39m(context, fn, \u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[1;32m 11\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m context:\n\u001b[0;32m---> 12\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfn\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/.pyenv/versions/jz-scenario2-eval/lib/python3.10/site-packages/pyro/poutine/messenger.py:12\u001b[0m, in \u001b[0;36m_context_wrap\u001b[0;34m(context, fn, *args, **kwargs)\u001b[0m\n\u001b[1;32m 10\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_context_wrap\u001b[39m(context, fn, \u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[1;32m 11\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m context:\n\u001b[0;32m---> 12\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfn\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + " \u001b[0;31m[... skipping similar frames: _context_wrap at line 12 (12 times)]\u001b[0m\n", + "File \u001b[0;32m~/.pyenv/versions/jz-scenario2-eval/lib/python3.10/site-packages/pyro/poutine/messenger.py:12\u001b[0m, in \u001b[0;36m_context_wrap\u001b[0;34m(context, fn, *args, **kwargs)\u001b[0m\n\u001b[1;32m 10\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_context_wrap\u001b[39m(context, fn, \u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[1;32m 11\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m context:\n\u001b[0;32m---> 12\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfn\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/.pyenv/versions/jz-scenario2-eval/lib/python3.10/site-packages/pyro/nn/module.py:448\u001b[0m, in \u001b[0;36mPyroModule.__call__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 446\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m__call__\u001b[39m(\u001b[38;5;28mself\u001b[39m, \u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[1;32m 447\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_pyro_context:\n\u001b[0;32m--> 448\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43msuper\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[38;5;21;43m__call__\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 449\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m (\n\u001b[1;32m 450\u001b[0m pyro\u001b[38;5;241m.\u001b[39msettings\u001b[38;5;241m.\u001b[39mget(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mvalidate_poutine\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 451\u001b[0m \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_pyro_context\u001b[38;5;241m.\u001b[39mactive\n\u001b[1;32m 452\u001b[0m \u001b[38;5;129;01mand\u001b[39;00m _is_module_local_param_enabled()\n\u001b[1;32m 453\u001b[0m ):\n\u001b[1;32m 454\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_check_module_local_param_usage()\n", + "File \u001b[0;32m~/.pyenv/versions/jz-scenario2-eval/lib/python3.10/site-packages/torch/nn/modules/module.py:1194\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *input, **kwargs)\u001b[0m\n\u001b[1;32m 1190\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m 1191\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m 1192\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m 1193\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1194\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;28;43minput\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1195\u001b[0m \u001b[38;5;66;03m# Do not call functions when jit is used\u001b[39;00m\n\u001b[1;32m 1196\u001b[0m full_backward_hooks, non_full_backward_hooks \u001b[38;5;241m=\u001b[39m [], []\n", + "File \u001b[0;32m~/Projects/Proposals/ASKEM/build/jz-scenario2-eval/src/pyciemss/ODE/base.py:64\u001b[0m, in \u001b[0;36mODE.forward\u001b[0;34m(self, initial_state, tspan, data)\u001b[0m\n\u001b[1;32m 60\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mparam_prior()\n\u001b[1;32m 62\u001b[0m \u001b[38;5;66;03m# Simulate from ODE.\u001b[39;00m\n\u001b[1;32m 63\u001b[0m \u001b[38;5;66;03m# Constant deltaT method like `euler` necessary to get interventions without name collision.\u001b[39;00m\n\u001b[0;32m---> 64\u001b[0m solution \u001b[38;5;241m=\u001b[39m \u001b[43modeint\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mderiv\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43minitial_state\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtspan\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmethod\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43meuler\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m 66\u001b[0m \u001b[38;5;66;03m# Add Observation noise\u001b[39;00m\n\u001b[1;32m 67\u001b[0m observations \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mobservation_model(solution, data)\n", + "File \u001b[0;32m~/.pyenv/versions/jz-scenario2-eval/lib/python3.10/site-packages/torchdiffeq/_impl/odeint.py:77\u001b[0m, in \u001b[0;36modeint\u001b[0;34m(func, y0, t, rtol, atol, method, options, event_fn)\u001b[0m\n\u001b[1;32m 74\u001b[0m solver \u001b[38;5;241m=\u001b[39m SOLVERS[method](func\u001b[38;5;241m=\u001b[39mfunc, y0\u001b[38;5;241m=\u001b[39my0, rtol\u001b[38;5;241m=\u001b[39mrtol, atol\u001b[38;5;241m=\u001b[39matol, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39moptions)\n\u001b[1;32m 76\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m event_fn \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m---> 77\u001b[0m solution \u001b[38;5;241m=\u001b[39m \u001b[43msolver\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mintegrate\u001b[49m\u001b[43m(\u001b[49m\u001b[43mt\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 78\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 79\u001b[0m event_t, solution \u001b[38;5;241m=\u001b[39m solver\u001b[38;5;241m.\u001b[39mintegrate_until_event(t[\u001b[38;5;241m0\u001b[39m], event_fn)\n", + "File \u001b[0;32m~/.pyenv/versions/jz-scenario2-eval/lib/python3.10/site-packages/torchdiffeq/_impl/solvers.py:105\u001b[0m, in \u001b[0;36mFixedGridODESolver.integrate\u001b[0;34m(self, t)\u001b[0m\n\u001b[1;32m 103\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m t0, t1 \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mzip\u001b[39m(time_grid[:\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m], time_grid[\u001b[38;5;241m1\u001b[39m:]):\n\u001b[1;32m 104\u001b[0m dt \u001b[38;5;241m=\u001b[39m t1 \u001b[38;5;241m-\u001b[39m t0\n\u001b[0;32m--> 105\u001b[0m dy, f0 \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_step_func\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfunc\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mt0\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdt\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mt1\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my0\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 106\u001b[0m y1 \u001b[38;5;241m=\u001b[39m y0 \u001b[38;5;241m+\u001b[39m dy\n\u001b[1;32m 108\u001b[0m \u001b[38;5;28;01mwhile\u001b[39;00m j \u001b[38;5;241m<\u001b[39m \u001b[38;5;28mlen\u001b[39m(t) \u001b[38;5;129;01mand\u001b[39;00m t1 \u001b[38;5;241m>\u001b[39m\u001b[38;5;241m=\u001b[39m t[j]:\n", + "File \u001b[0;32m~/.pyenv/versions/jz-scenario2-eval/lib/python3.10/site-packages/torchdiffeq/_impl/fixed_grid.py:10\u001b[0m, in \u001b[0;36mEuler._step_func\u001b[0;34m(self, func, t0, dt, t1, y0)\u001b[0m\n\u001b[1;32m 9\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_step_func\u001b[39m(\u001b[38;5;28mself\u001b[39m, func, t0, dt, t1, y0):\n\u001b[0;32m---> 10\u001b[0m f0 \u001b[38;5;241m=\u001b[39m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[43mt0\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my0\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mperturb\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mPerturb\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mNEXT\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mif\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mperturb\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01melse\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mPerturb\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mNONE\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 11\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m dt \u001b[38;5;241m*\u001b[39m f0, f0\n", + "File \u001b[0;32m~/.pyenv/versions/jz-scenario2-eval/lib/python3.10/site-packages/torch/nn/modules/module.py:1194\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *input, **kwargs)\u001b[0m\n\u001b[1;32m 1190\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m 1191\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m 1192\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m 1193\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1194\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;28;43minput\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1195\u001b[0m \u001b[38;5;66;03m# Do not call functions when jit is used\u001b[39;00m\n\u001b[1;32m 1196\u001b[0m full_backward_hooks, non_full_backward_hooks \u001b[38;5;241m=\u001b[39m [], []\n", + "File \u001b[0;32m~/.pyenv/versions/jz-scenario2-eval/lib/python3.10/site-packages/torchdiffeq/_impl/misc.py:189\u001b[0m, in \u001b[0;36m_PerturbFunc.forward\u001b[0;34m(self, t, y, perturb)\u001b[0m\n\u001b[1;32m 186\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 187\u001b[0m \u001b[38;5;66;03m# Do nothing.\u001b[39;00m\n\u001b[1;32m 188\u001b[0m \u001b[38;5;28;01mpass\u001b[39;00m\n\u001b[0;32m--> 189\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbase_func\u001b[49m\u001b[43m(\u001b[49m\u001b[43mt\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/.pyenv/versions/jz-scenario2-eval/lib/python3.10/site-packages/torch/nn/modules/module.py:1194\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *input, **kwargs)\u001b[0m\n\u001b[1;32m 1190\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m 1191\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m 1192\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m 1193\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1194\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;28;43minput\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1195\u001b[0m \u001b[38;5;66;03m# Do not call functions when jit is used\u001b[39;00m\n\u001b[1;32m 1196\u001b[0m full_backward_hooks, non_full_backward_hooks \u001b[38;5;241m=\u001b[39m [], []\n", + "File \u001b[0;32m~/.pyenv/versions/jz-scenario2-eval/lib/python3.10/site-packages/torchdiffeq/_impl/misc.py:138\u001b[0m, in \u001b[0;36m_TupleFunc.forward\u001b[0;34m(self, t, y)\u001b[0m\n\u001b[1;32m 137\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mforward\u001b[39m(\u001b[38;5;28mself\u001b[39m, t, y):\n\u001b[0;32m--> 138\u001b[0m f \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbase_func\u001b[49m\u001b[43m(\u001b[49m\u001b[43mt\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m_flat_to_shape\u001b[49m\u001b[43m(\u001b[49m\u001b[43my\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mshapes\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 139\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m torch\u001b[38;5;241m.\u001b[39mcat([f_\u001b[38;5;241m.\u001b[39mreshape(\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m) \u001b[38;5;28;01mfor\u001b[39;00m f_ \u001b[38;5;129;01min\u001b[39;00m f])\n", + "File \u001b[0;32m~/.pyenv/versions/jz-scenario2-eval/lib/python3.10/site-packages/pyro/nn/module.py:677\u001b[0m, in \u001b[0;36mpyro_method..cached_fn\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 674\u001b[0m \u001b[38;5;129m@functools\u001b[39m\u001b[38;5;241m.\u001b[39mwraps(fn)\n\u001b[1;32m 675\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mcached_fn\u001b[39m(\u001b[38;5;28mself\u001b[39m, \u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[1;32m 676\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_pyro_context:\n\u001b[0;32m--> 677\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfn\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/Projects/Proposals/ASKEM/build/jz-scenario2-eval/src/pyciemss/ODE/base.py:188\u001b[0m, in \u001b[0;36mPetriNetODESystem.deriv\u001b[0;34m(self, t, state)\u001b[0m\n\u001b[1;32m 185\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(transition\u001b[38;5;241m.\u001b[39mcontrol) \u001b[38;5;241m>\u001b[39m \u001b[38;5;241m0\u001b[39m:\n\u001b[1;32m 186\u001b[0m flux \u001b[38;5;241m=\u001b[39m flux \u001b[38;5;241m*\u001b[39m \u001b[38;5;28msum\u001b[39m([states[k] \u001b[38;5;28;01mfor\u001b[39;00m k \u001b[38;5;129;01min\u001b[39;00m transition\u001b[38;5;241m.\u001b[39mcontrol]) \u001b[38;5;241m/\u001b[39m population_size\n\u001b[0;32m--> 188\u001b[0m flux \u001b[38;5;241m=\u001b[39m \u001b[43mpyro\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdeterministic\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43mf\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mflux_\u001b[39;49m\u001b[38;5;132;43;01m{\u001b[39;49;00m\u001b[43mget_name\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtransition\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;132;43;01m}\u001b[39;49;00m\u001b[38;5;124;43m \u001b[39;49m\u001b[38;5;132;43;01m{\u001b[39;49;00m\u001b[43mt\u001b[49m\u001b[38;5;132;43;01m}\u001b[39;49;00m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mflux\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mevent_dim\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m 190\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m c \u001b[38;5;129;01min\u001b[39;00m transition\u001b[38;5;241m.\u001b[39mconsumed:\n\u001b[1;32m 191\u001b[0m derivs[c] \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m=\u001b[39m flux\n", + "File \u001b[0;32m~/.pyenv/versions/jz-scenario2-eval/lib/python3.10/site-packages/pyro/primitives.py:209\u001b[0m, in \u001b[0;36mdeterministic\u001b[0;34m(name, value, event_dim)\u001b[0m\n\u001b[1;32m 192\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 193\u001b[0m \u001b[38;5;124;03mDeterministic statement to add a :class:`~pyro.distributions.Delta` site\u001b[39;00m\n\u001b[1;32m 194\u001b[0m \u001b[38;5;124;03mwith name `name` and value `value` to the trace. This is useful when we\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 206\u001b[0m \u001b[38;5;124;03m:param int event_dim: Optional event dimension, defaults to `value.ndim`.\u001b[39;00m\n\u001b[1;32m 207\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 208\u001b[0m event_dim \u001b[38;5;241m=\u001b[39m value\u001b[38;5;241m.\u001b[39mndim \u001b[38;5;28;01mif\u001b[39;00m event_dim \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;28;01melse\u001b[39;00m event_dim\n\u001b[0;32m--> 209\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43msample\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 210\u001b[0m \u001b[43m \u001b[49m\u001b[43mname\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 211\u001b[0m \u001b[43m \u001b[49m\u001b[43mdist\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mDelta\u001b[49m\u001b[43m(\u001b[49m\u001b[43mvalue\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mevent_dim\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mevent_dim\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmask\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 212\u001b[0m \u001b[43m \u001b[49m\u001b[43mobs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mvalue\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 213\u001b[0m \u001b[43m \u001b[49m\u001b[43minfer\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m{\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43m_deterministic\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m}\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 214\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/.pyenv/versions/jz-scenario2-eval/lib/python3.10/site-packages/pyro/primitives.py:163\u001b[0m, in \u001b[0;36msample\u001b[0;34m(name, fn, *args, **kwargs)\u001b[0m\n\u001b[1;32m 146\u001b[0m msg \u001b[38;5;241m=\u001b[39m {\n\u001b[1;32m 147\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mtype\u001b[39m\u001b[38;5;124m\"\u001b[39m: \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124msample\u001b[39m\u001b[38;5;124m\"\u001b[39m,\n\u001b[1;32m 148\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mname\u001b[39m\u001b[38;5;124m\"\u001b[39m: name,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 160\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mcontinuation\u001b[39m\u001b[38;5;124m\"\u001b[39m: \u001b[38;5;28;01mNone\u001b[39;00m,\n\u001b[1;32m 161\u001b[0m }\n\u001b[1;32m 162\u001b[0m \u001b[38;5;66;03m# apply the stack and return its return value\u001b[39;00m\n\u001b[0;32m--> 163\u001b[0m \u001b[43mapply_stack\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmsg\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 164\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m msg[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mvalue\u001b[39m\u001b[38;5;124m\"\u001b[39m]\n", + "File \u001b[0;32m~/.pyenv/versions/jz-scenario2-eval/lib/python3.10/site-packages/pyro/poutine/runtime.py:221\u001b[0m, in \u001b[0;36mapply_stack\u001b[0;34m(initial_msg)\u001b[0m\n\u001b[1;32m 218\u001b[0m default_process_message(msg)\n\u001b[1;32m 220\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m frame \u001b[38;5;129;01min\u001b[39;00m stack[\u001b[38;5;241m-\u001b[39mpointer:]:\n\u001b[0;32m--> 221\u001b[0m \u001b[43mframe\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_postprocess_message\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmsg\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 223\u001b[0m cont \u001b[38;5;241m=\u001b[39m msg[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mcontinuation\u001b[39m\u001b[38;5;124m\"\u001b[39m]\n\u001b[1;32m 224\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m cont \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n", + "File \u001b[0;32m~/.pyenv/versions/jz-scenario2-eval/lib/python3.10/site-packages/pyro/poutine/messenger.py:168\u001b[0m, in \u001b[0;36mMessenger._postprocess_message\u001b[0;34m(self, msg)\u001b[0m\n\u001b[1;32m 166\u001b[0m method \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mgetattr\u001b[39m(\u001b[38;5;28mself\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m_pyro_post_\u001b[39m\u001b[38;5;132;01m{}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;241m.\u001b[39mformat(msg[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mtype\u001b[39m\u001b[38;5;124m\"\u001b[39m]), \u001b[38;5;28;01mNone\u001b[39;00m)\n\u001b[1;32m 167\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m method \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m--> 168\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mmethod\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmsg\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 169\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n", + "File \u001b[0;32m~/Projects/Proposals/ASKEM/build/jz-scenario1-eval/causal_pyro/causal_pyro/query/do_messenger.py:19\u001b[0m, in \u001b[0;36mDoMessenger._pyro_post_sample\u001b[0;34m(self, msg)\u001b[0m\n\u001b[1;32m 17\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_pyro_post_sample\u001b[39m(\u001b[38;5;28mself\u001b[39m, msg):\n\u001b[1;32m 18\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m msg[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mname\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mactions:\n\u001b[0;32m---> 19\u001b[0m msg[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mvalue\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m \u001b[43mintervene\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 20\u001b[0m \u001b[43m \u001b[49m\u001b[43mmsg\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mvalue\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 21\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mactions\u001b[49m\u001b[43m[\u001b[49m\u001b[43mmsg\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mname\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 22\u001b[0m \u001b[43m \u001b[49m\u001b[43mevent_dim\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mlen\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mmsg\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mfn\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m]\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mevent_shape\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 23\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/.pyenv/versions/jz-scenario2-eval/lib/python3.10/site-packages/pyro/poutine/runtime.py:283\u001b[0m, in \u001b[0;36meffectful.._fn\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 266\u001b[0m msg \u001b[38;5;241m=\u001b[39m {\n\u001b[1;32m 267\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mtype\u001b[39m\u001b[38;5;124m\"\u001b[39m: \u001b[38;5;28mtype\u001b[39m,\n\u001b[1;32m 268\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mname\u001b[39m\u001b[38;5;124m\"\u001b[39m: name,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 280\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124minfer\u001b[39m\u001b[38;5;124m\"\u001b[39m: infer,\n\u001b[1;32m 281\u001b[0m }\n\u001b[1;32m 282\u001b[0m \u001b[38;5;66;03m# apply the stack and return its return value\u001b[39;00m\n\u001b[0;32m--> 283\u001b[0m \u001b[43mapply_stack\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmsg\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 284\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m msg[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mvalue\u001b[39m\u001b[38;5;124m\"\u001b[39m]\n", + "File \u001b[0;32m~/.pyenv/versions/jz-scenario2-eval/lib/python3.10/site-packages/pyro/poutine/runtime.py:218\u001b[0m, in \u001b[0;36mapply_stack\u001b[0;34m(initial_msg)\u001b[0m\n\u001b[1;32m 215\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m msg[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mstop\u001b[39m\u001b[38;5;124m\"\u001b[39m]:\n\u001b[1;32m 216\u001b[0m \u001b[38;5;28;01mbreak\u001b[39;00m\n\u001b[0;32m--> 218\u001b[0m \u001b[43mdefault_process_message\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmsg\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 220\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m frame \u001b[38;5;129;01min\u001b[39;00m stack[\u001b[38;5;241m-\u001b[39mpointer:]:\n\u001b[1;32m 221\u001b[0m frame\u001b[38;5;241m.\u001b[39m_postprocess_message(msg)\n", + "File \u001b[0;32m~/.pyenv/versions/jz-scenario2-eval/lib/python3.10/site-packages/pyro/poutine/runtime.py:179\u001b[0m, in \u001b[0;36mdefault_process_message\u001b[0;34m(msg)\u001b[0m\n\u001b[1;32m 176\u001b[0m msg[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mdone\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mTrue\u001b[39;00m\n\u001b[1;32m 177\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m msg\n\u001b[0;32m--> 179\u001b[0m msg[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mvalue\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m \u001b[43mmsg\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mfn\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mmsg\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43margs\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mmsg\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mkwargs\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 181\u001b[0m \u001b[38;5;66;03m# after fn has been called, update msg to prevent it from being called again.\u001b[39;00m\n\u001b[1;32m 182\u001b[0m msg[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mdone\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mTrue\u001b[39;00m\n", + "File \u001b[0;32m~/Projects/Proposals/ASKEM/build/jz-scenario1-eval/causal_pyro/causal_pyro/primitives.py:75\u001b[0m, in \u001b[0;36mintervene\u001b[0;34m(obs, act, event_dim)\u001b[0m\n\u001b[1;32m 71\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 72\u001b[0m \u001b[38;5;124;03mIntervene on a value in a probabilistic program.\u001b[39;00m\n\u001b[1;32m 73\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 74\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m callable(act) \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(act, pyro\u001b[38;5;241m.\u001b[39mdistributions\u001b[38;5;241m.\u001b[39mDistribution):\n\u001b[0;32m---> 75\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mact\u001b[49m\u001b[43m(\u001b[49m\u001b[43mobs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 76\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m act \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 77\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m obs\n", + "Cell \u001b[0;32mIn[14], line 3\u001b[0m, in \u001b[0;36mIA_zeta_intervention\u001b[0;34m(t, flux)\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mIA_zeta_intervention\u001b[39m(t, flux):\n\u001b[1;32m 2\u001b[0m zeta \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m0.125\u001b[39m\n\u001b[0;32m----> 3\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m \u001b[38;5;28;01mFalse\u001b[39;00m\n\u001b[1;32m 4\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m t \u001b[38;5;241m<\u001b[39m \u001b[38;5;241m22\u001b[39m:\n\u001b[1;32m 5\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m flux\n", + "\u001b[0;31mAssertionError\u001b[0m: " + ] + } + ], + "source": [ + "with pyro.poutine.trace() as tr:\n", + " new_intervened_model(initial_state, full_tspan)\n", + " \n", + "print(tr.trace.nodes.keys())\n" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "id": "f388cd12-3b48-41a3-b325-4fafd7623734", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'type': 'sample',\n", + " 'name': \"flux_trans_(('Infected', ('identity', 'ido:0000511'), ('disease_status', 'ncit:C3833'), ('property', 'ncit:C113725')), ('Ailing', ('identity', 'ido:0000511'), ('disease_status', 'ncit:C25269'), ('property', 'ncit:C113725')), 'NaturalConversion') 5.0\",\n", + " 'fn': MaskedDistribution(),\n", + " 'is_observed': True,\n", + " 'args': (),\n", + " 'kwargs': {},\n", + " 'value': tensor(1.1530e-06),\n", + " 'infer': {'_deterministic': True},\n", + " 'scale': 1.0,\n", + " 'mask': None,\n", + " 'cond_indep_stack': (),\n", + " 'done': True,\n", + " 'stop': False,\n", + " 'continuation': None}" + ] + }, + "execution_count": 49, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tr.trace.nodes[f\"{zeta} 5.0\"]" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "a8cebc75-730c-43f8-9081-ba846098f669", + "metadata": {}, + "outputs": [], + "source": [ + "from pyciemss.ODE.models import SIDARTHE\n", + "\n", + "pyro.set_rng_seed(0)\n", + "\n", + "# ode_model = SIDARTHE(N=1,\n", + "# alpha_prior=dist.LogNormal(torch.log(torch.tensor (0.570)), torch.tensor(0.5)) ,\n", + "# beta_prior=dist.LogNormal(torch.log(torch.tensor (0.011)), torch.tensor(0.5)) ,\n", + "# gamma_prior=dist.LogNormal(torch.log(torch.tensor (0.456)), torch.tensor(0.5)) ,\n", + "# delta_prior=dist.LogNormal(torch.log(torch.tensor (0.011)), torch.tensor(0.5)) ,\n", + "# epsilon_prior=dist.LogNormal(torch.log(torch.tensor (0.171)), torch.tensor(0.5)) ,\n", + "# lamb_prior =dist.LogNormal(torch.log(torch.tensor (0.034)), torch.tensor(0.5)) ,\n", + "# zeta_prior=dist.LogNormal(torch.log(torch.tensor (0.125)), torch.tensor(0.5)) ,\n", + "# eta_prior=dist.LogNormal(torch.log(torch.tensor (0.125)), torch.tensor(0.5)) ,\n", + "# kappa_prior=dist.LogNormal(torch.log(torch.tensor (0.017)), torch.tensor(0.5)) ,\n", + "# theta_prior=dist.LogNormal(torch.log(torch.tensor (0.371)), torch.tensor(0.5)) ,\n", + "# rho_prior=dist.LogNormal(torch.log(torch.tensor (0.034)), torch.tensor(0.5)) ,\n", + "# xi_prior=dist.LogNormal(torch.log(torch.tensor (0.017)), torch.tensor(0.5)) ,\n", + "# sigma_prior=dist.LogNormal(torch.log(torch.tensor (0.017)), torch.tensor(0.5)) ,\n", + "# mu_prior=dist.LogNormal(torch.log(torch.tensor (0.017)), torch.tensor(0.5)) ,\n", + "# nu_prior=dist.LogNormal(torch.log(torch.tensor (0.027)), torch.tensor(0.5)) ,\n", + "# tau_prior=dist.LogNormal(torch.log(torch.tensor (0.01)), torch.tensor(0.5)) )" + ] + }, + { + "cell_type": "markdown", + "id": "da8e85b3-25df-4001-8cdf-cc47779fc584", + "metadata": {}, + "source": [ + "## 1.c Sensitivity analysis" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "79911dc3-6611-45d3-be49-f2e190b616c2", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "2ed894bb-0eb9-4d26-aa96-886307b175d7", + "metadata": {}, + "source": [ + "## 1.d Policies that prevent infections from exceeding 1/3 of the population\n", + "\n", + "Now return to the situation in b.i (constant parameters that don’t change over time). Let’s say we want to increase testing, diagnostics, and contact tracing efforts (implemented by increasing the detection parameters and ). Assume that $\\theta \\ge 2\\epsilon$ , because a symptomatic person is more likely to be tested. What minimum constant values do these parameters need to be over the course of a 100-day simulation, to ensure that the total infected population (sum over all the infected states I, D, A, R, T) never rises above 1/3 of the total population?\n" + ] + }, + { + "cell_type": "markdown", + "id": "15526fb6-c00c-4b76-9dd3-3c961504006b", + "metadata": {}, + "source": [ + "\n", + "\n", + "### Problem Formulation\n", + "* **Quantity of interest**: Total infections out of $N=60,000,000$ population\n", + "$$I_{total}(t; \\mathbf{u}, \\mathbf{Z}) = I(t) + D(t) + A(t) + R(t) + T(t)$$\n", + "\n", + "A conservative estimate for the quantity of interest is\n", + "$$M(u, Z) = \\max_{1\\leq t \\leq 100} I_{total}(t; \\mathbf{u}, \\mathbf{Z})/N$$\n", + "\n", + "\n", + "\n", + "\n", + "* **Control**: $\\mathbf{u}\\in \\mathcal{U} \\subseteq \\mathbb{R}^{n_u}$\n", + " * Detection parameter for Infected ($\\epsilon$) assuming that $\\theta=2\\epsilon$\n", + " * Two detection parameters $\\theta, \\epsilon$, constraining $\\theta \\ge 2\\epsilon$.\n", + " " + ] + }, + { + "cell_type": "markdown", + "id": "c860c6aa-44e2-4456-8b12-90e87b4d8e0f", + "metadata": {}, + "source": [ + "\n", + "* **Risk-based optimization under uncertainty problem formulation**\n", + " * Objective Function - Minimize the magnitude of the parameter interventions.\n", + " * Constraint - Risk of normalized total infections exceeding the prescribed threshold of $1/3$, $\\mathcal{R}( M(\\mathbf{u},\\mathbf{Z}))$, is below the acceptable risk threshold, $\\mathcal{R}_\\text{threshold}$.\n", + "\n", + "\\begin{equation} \n", + "\\begin{split} \n", + "\\mathbf{u}^*= \\underset{\\mathbf{u}\\in\\mathcal{U}}{\\arg\\min}\\ & \\lVert \\mathbf{u} \\rVert_1 \\\\ \\text{s.t.}\\ & \\mathcal{R}( M(\\mathbf{u}, \\theta)) \\le \\mathcal{R}_\\text{threshold} \n", + "\\end{split} \n", + "\\end{equation}" + ] + }, + { + "cell_type": "markdown", + "id": "305ab3fb-0dfe-4d6f-9ae2-fadc960e83d5", + "metadata": { + "tags": [] + }, + "source": [ + "#### Formulation 1: Optimize $\\epsilon$ only, assuming $\\epsilon = \\theta$\n", + "\\begin{equation} \n", + "\\begin{split} \n", + "\\epsilon^*= \\underset{\\epsilon\\in\\mathcal{U}}{\\arg\\min}\\ & \\epsilon \\\\ \\text{s.t.}\\ & \\mathbb{P}( M(\\epsilon, \\mathbf{Z}) \\ge 1/3) \\le 0.05\n", + "\\end{split} \n", + "\\end{equation}" + ] + }, + { + "cell_type": "markdown", + "id": "431d0bc3-4d3b-4cd9-9317-f02aefde7cb5", + "metadata": { + "tags": [] + }, + "source": [ + "#### Formulation 2: Optimize $\\epsilon$ and $\\theta$ constraining $\\theta \\ge 2\\epsilon$\n", + "\\begin{equation} \n", + "\\begin{split} \n", + "\\epsilon^\\ast, \\theta^\\ast= \\underset{\\{\\epsilon,\\theta\\}\\in\\mathcal{U}}{\\arg\\min}\\ & \\theta + \\epsilon \\\\ \\text{s.t.}\\ & \\mathbb{P}( M(\\epsilon,\\theta, \\mathbf{Z}) \\ge 1/3) \\le 0.05, \\\\\n", + "& \\theta \\ge 2\\epsilon\n", + "\\end{split} \n", + "\\end{equation}" + ] + }, + { + "cell_type": "markdown", + "id": "c65bcf10-9d12-4efe-be10-cc313e123d14", + "metadata": {}, + "source": [ + "Apart from probability of exceedance, we will explore quantiles and superquantiles as risk measures." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "69c1f480-87e4-4e35-b2ad-ac7769ff78ff", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "jz-scenario2-eval", + "language": "python", + "name": "jz-scenario2-eval" + }, + "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": "a3e1d8fdda916c248c87d86618e3945b28961cf939001a0529e724463670a41a" + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 667e1db710200dc9a5204b2bb9793535c7ed64f4 Mon Sep 17 00:00:00 2001 From: Jeremy Zucker Date: Thu, 2 Feb 2023 04:45:16 -0500 Subject: [PATCH 2/4] risk-based optimization under uncertainty. Still computing optimal control policy and assessing its effect --- .../ta_3/ciemss/scenario2_q1_epsilon.ipynb | 889 ++++++++++++++++++ .../ciemss/scenario2_q1_thetaepsilon.ipynb | 767 +++++++++++++++ .../ta_3/ciemss/scenario2_q2_SIDARTHEV.ipynb | 794 ++++++++++++++++ .../scenario2_q2b_SIDARTHEV_alpha.ipynb | 802 ++++++++++++++++ .../ciemss/scenario2_q2b_SIDARTHEV_beta.ipynb | 802 ++++++++++++++++ .../scenario2_q2b_SIDARTHEV_delta.ipynb | 802 ++++++++++++++++ .../scenario2_q2b_SIDARTHEV_phiflux.ipynb | 830 ++++++++++++++++ 7 files changed, 5686 insertions(+) create mode 100644 6-month-milestone/evaluation/scenario_2/ta_3/ciemss/scenario2_q1_epsilon.ipynb create mode 100644 6-month-milestone/evaluation/scenario_2/ta_3/ciemss/scenario2_q1_thetaepsilon.ipynb create mode 100644 6-month-milestone/evaluation/scenario_2/ta_3/ciemss/scenario2_q2_SIDARTHEV.ipynb create mode 100644 6-month-milestone/evaluation/scenario_2/ta_3/ciemss/scenario2_q2b_SIDARTHEV_alpha.ipynb create mode 100644 6-month-milestone/evaluation/scenario_2/ta_3/ciemss/scenario2_q2b_SIDARTHEV_beta.ipynb create mode 100644 6-month-milestone/evaluation/scenario_2/ta_3/ciemss/scenario2_q2b_SIDARTHEV_delta.ipynb create mode 100644 6-month-milestone/evaluation/scenario_2/ta_3/ciemss/scenario2_q2b_SIDARTHEV_phiflux.ipynb diff --git a/6-month-milestone/evaluation/scenario_2/ta_3/ciemss/scenario2_q1_epsilon.ipynb b/6-month-milestone/evaluation/scenario_2/ta_3/ciemss/scenario2_q1_epsilon.ipynb new file mode 100644 index 0000000..a7bbec7 --- /dev/null +++ b/6-month-milestone/evaluation/scenario_2/ta_3/ciemss/scenario2_q1_epsilon.ipynb @@ -0,0 +1,889 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "b087c52b-a505-45d3-b643-df44d8c924a5", + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "markdown", + "id": "542b06c1-28fb-47ec-9a34-170acc7d2a84", + "metadata": {}, + "source": [ + "# Load Dependencies" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "84e0bb12-68af-4a6d-a384-db4837c44ac0", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "import torch\n", + "\n", + "import pyro\n", + "import numpy as np\n", + "import pyro.distributions as dist\n", + "# from pyro.poutine import trace, replay, block\n", + "# from pyro.infer.autoguide.guides import AutoDelta, AutoNormal\n", + "# from pyro.infer import SVI, Trace_ELBO, Predictive\n", + "\n", + "import sys\n", + "sys.path.append(\"../../src/\")\n", + "\n", + "from pyciemss.ODE.askem_primitives import sample, infer_parameters, intervene, optimization\n", + "\n", + "# from pyciemss.utils import run_inference, get_tspan\n", + "from pyciemss.utils import get_tspan\n", + "\n", + "import warnings\n", + "warnings.filterwarnings('ignore')" + ] + }, + { + "cell_type": "markdown", + "id": "4855961d-9c38-4050-b6b7-aaae03500fc9", + "metadata": {}, + "source": [ + "# Plotting Utilities" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "43d74fcc", + "metadata": {}, + "outputs": [], + "source": [ + "def setup_ax(ax=None):\n", + "\n", + " if not ax:\n", + " fig = plt.figure(facecolor='w', figsize=(9, 5))\n", + " ax = fig.add_subplot(111, axisbelow=True)\n", + "\n", + " ax.set_xlabel('Time (days)')\n", + " ax.set_ylabel('Total infected')\n", + " return ax\n", + "\n", + "def plot_predictive(prediction, tspan, tmin=None, ax=None, alpha=0.2, color=\"black\", **kwargs):\n", + " vars = [\"I_total_obs\"]\n", + " #infection_total = sum([prediction[x].squeeze().detach().numpy()/1000. for x in ['I_obs', 'D_obs', 'A_obs', 'R_obs', 'T_obs']])\n", + "\n", + " I_low = torch.quantile(prediction[\"I_total_obs\"], 0.05, dim=0).detach().numpy()\n", + " I_up = torch.quantile(prediction[\"I_total_obs\"], 0.95, dim=0).detach().numpy()\n", + "\n", + " if tmin:\n", + " indeces = tspan >= tmin\n", + " else:\n", + " indeces = torch.ones_like(tspan).bool()\n", + "\n", + " if not ax:\n", + " fig = plt.figure(facecolor='w')\n", + " ax = fig.add_subplot(111, facecolor='#dddddd', axisbelow=True)\n", + " \n", + " ax.fill_between(tspan[indeces], I_low[indeces], I_up[indeces], alpha=alpha, color=color, **kwargs)\n", + "\n", + " legend = ax.legend()\n", + " legend.get_frame().set_alpha(0.5)\n", + "\n", + " return ax\n", + "\n", + "def plot_trajectory(data, tspan, ax=None, color='black', alpha=0.5, lw=0, marker='.', label=None):\n", + " # Plot the data on three separate curves for S(t), I(t) and R(t)\n", + "\n", + " if not ax:\n", + " fig = plt.figure(facecolor='w')\n", + " ax = fig.add_subplot(111, facecolor='#dddddd', axisbelow=True)\n", + " #infection_total = sum([data[x].squeeze().detach().numpy()/1000. for x in ['I_obs', 'D_obs', 'A_obs', 'R_obs', 'T_obs']])\n", + " ax.plot(tspan, data['I_total_obs'].squeeze().detach().numpy(), color, alpha=alpha, lw=lw, marker=marker, label=label)\n", + " \n", + " return ax\n", + "\n", + "def plot_intervention_line(t, ax=None):\n", + " if not ax:\n", + " fig = plt.figure(facecolor='w')\n", + " ax = fig.add_subplot(111, facecolor='#dddddd', axisbelow=True)\n", + "\n", + " ylim = ax.get_ylim()\n", + "\n", + " ax.vlines(t, min(ylim), max(ylim), color=\"grey\", ls='-')\n", + "\n", + " return ax\n", + "\n", + "def sideaxis(ax):\n", + " ax.spines['top'].set_visible(False)\n", + " ax.spines['right'].set_visible(False)\n", + " return\n", + "\n", + "def sideaxishist(ax):\n", + " ax.spines['top'].set_visible(False)\n", + " ax.spines['right'].set_visible(False)\n", + " ax.spines['left'].set_visible(False)\n", + " # For y-axis\n", + " ax.yaxis.set_major_locator(ticker.NullLocator())\n", + " ax.tick_params(axis='x', labelsize=12) # change fontsize for x-axis tick labels\n", + " # ax.xaxis.major.formatter._useMathText = True\n", + " return" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "f233104e-c29d-4e25-859f-2a328ec7892a", + "metadata": {}, + "outputs": [], + "source": [ + "def LogNormalPrior(mean, variance):\n", + " mu = torch.log(mean**2/torch.sqrt((mean**2 + variance)))\n", + " scale = torch.sqrt(torch.log(1 + variance/mean**2))\n", + " return dist.LogNormal(mu, scale)\n", + "\n", + "def LogNormalPrior_propVar(mean, cov=0.05):\n", + " variance = mean*cov \n", + " return LogNormalPrior(mean, variance)" + ] + }, + { + "cell_type": "markdown", + "id": "3e0c3726-5ec0-475d-8305-f20b5d84e424", + "metadata": {}, + "source": [ + "# Setup Parameters" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "16608500-97b5-4081-9e6b-b7c193c10285", + "metadata": {}, + "outputs": [], + "source": [ + "tspan = get_tspan(1, 100, 100)\n", + "\n", + "num_samples = 500\n", + "\n", + "# Total population, N.\n", + "N = 1\n", + "# Initial number of infected and recovered individuals, I0 and R0.\n", + "I0, D0, A0, R0, T0, H0, E0 = 200/60e6, 20/60e6, 1/60e6, 2/60e6, 0, 0, 0\n", + "\n", + "# Everyone else, S0, is susceptible to infection initially.\n", + "S0 = N - I0 - D0 - A0 - R0 - T0 - H0 - E0\n", + "\n", + "initial_state = tuple(torch.as_tensor(s) for s in (S0, I0, D0, A0, R0, T0, H0, E0))" + ] + }, + { + "cell_type": "markdown", + "id": "23fc9c9d-f8bc-4e95-a243-865690d3b43b", + "metadata": {}, + "source": [ + "# Probabilistic Forecasting - Passing unit test 1\n", + "There are two ‘unit tests’ we want to pass, to ensure that we understood and can reproduce the published model:\n", + "\n", + "## 1.a Unit Test \\#1:\n", + "\n", + "Set the initial values and parameters, as described in the Supplementary Methods section of the publication (pg. 9 of the pdf): \n", + "\n", + "1. Initial Values: \n", + "* $I = 200/60e6$,\n", + "* $D = 20/60e6$, \n", + "* $A = 1/60e6$, \n", + "* $R = 2/60e6$, \n", + "* $T = 0$, \n", + "* $H = 0$, \n", + "* $E = 0$; \n", + "* $S = 1 – I – D – A – R – T – H – E$. \n", + "\n", + "Let total population = 60e6.\n", + "Parameters: $$\\alpha = 0.570, \\beta = \\delta = 0.011, \\gamma = 0.456, \\epsilon = 0.171, \\theta = 0.371, \\zeta = \\eta = 0.125, \\mu = 0.017, \\nu = 0.027, \\tau = 0.01, \\lambda = \\rho = 0.034$$ and $$\\kappa = \\xi = \\sigma = 0.017$$." + ] + }, + { + "cell_type": "markdown", + "id": "e175daf8", + "metadata": {}, + "source": [ + "### Deterministic forecasting" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "dbd7d430-325f-4f40-9b20-d8a0c0264f62", + "metadata": {}, + "outputs": [], + "source": [ + "from pyciemss.ODE.models import SIDARTHE\n", + "\n", + "pyro.set_rng_seed(0)\n", + "\n", + "ode_model = SIDARTHE(N=1,\n", + " alpha_prior=dist.Delta(torch.tensor (0.570)) ,\n", + " beta_prior=dist.Delta(torch.tensor (0.011)) ,\n", + " gamma_prior=dist.Delta(torch.tensor (0.456)) ,\n", + " delta_prior=dist.Delta(torch.tensor (0.011)) ,\n", + " epsilon_prior=dist.Delta(torch.tensor (0.171)) ,\n", + " lamb_prior =dist.Delta(torch.tensor (0.034)) ,\n", + " zeta_prior=dist.Delta(torch.tensor (0.125)) ,\n", + " eta_prior=dist.Delta(torch.tensor (0.125)) ,\n", + " kappa_prior=dist.Delta(torch.tensor (0.017)) ,\n", + " theta_prior=dist.Delta(torch.tensor (0.371)) ,\n", + " rho_prior=dist.Delta(torch.tensor (0.034)) ,\n", + " xi_prior=dist.Delta(torch.tensor (0.017)) ,\n", + " sigma_prior=dist.Delta(torch.tensor (0.017)) ,\n", + " mu_prior=dist.Delta(torch.tensor (0.017)) ,\n", + " nu_prior=dist.Delta(torch.tensor (0.027)) ,\n", + " tau_prior=dist.Delta(torch.tensor (0.01)) )" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "31473cdd-9896-42ed-b487-36362c1c9744", + "metadata": {}, + "outputs": [], + "source": [ + "#prior_prediction = sample(plotting_ode_model, num_samples, initial_state, tspan)\n", + "single_prediction = sample(ode_model, 1, initial_state, tspan)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "15f03c6f-d085-4f36-bc7a-312057d82758", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ax = plot_trajectory(single_prediction, tspan, ax=setup_ax(), color=\"blue\", marker='', lw=1., label=\"Before Seeing Data - Single Forecast\")\n", + "#ax = plot_predictive(prior_prediction, tspan, ax=ax, label=\"Before Seeing Data - Probabilistic Forecast\", color=\"red\")\n", + "ax.axvline(47)" + ] + }, + { + "cell_type": "markdown", + "id": "2958fd8d", + "metadata": {}, + "source": [ + "### Probabilistic forecasting" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "a8cebc75-730c-43f8-9081-ba846098f669", + "metadata": {}, + "outputs": [], + "source": [ + "from pyciemss.ODE.models import SIDARTHE\n", + "\n", + "pyro.set_rng_seed(0)\n", + "\n", + "ode_model = SIDARTHE(N=1,\n", + " alpha_prior=LogNormalPrior_propVar(torch.tensor(0.570)) ,\n", + " beta_prior=LogNormalPrior_propVar(torch.tensor(0.011)) ,\n", + " gamma_prior=LogNormalPrior_propVar(torch.tensor(0.456)) ,\n", + " delta_prior=LogNormalPrior_propVar(torch.tensor(0.011)) ,\n", + " epsilon_prior=LogNormalPrior_propVar(torch.tensor(0.171)) ,\n", + " lamb_prior =LogNormalPrior_propVar(torch.tensor(0.034)) ,\n", + " zeta_prior=LogNormalPrior_propVar(torch.tensor(0.125)) ,\n", + " eta_prior=LogNormalPrior_propVar(torch.tensor(0.125)) ,\n", + " kappa_prior=LogNormalPrior_propVar(torch.tensor(0.017)) ,\n", + " theta_prior=LogNormalPrior_propVar(torch.tensor(0.371)) ,\n", + " rho_prior=LogNormalPrior_propVar(torch.tensor(0.034)) ,\n", + " xi_prior=LogNormalPrior_propVar(torch.tensor(0.017)) ,\n", + " sigma_prior=LogNormalPrior_propVar(torch.tensor(0.017)) ,\n", + " mu_prior=LogNormalPrior_propVar(torch.tensor(0.017)) ,\n", + " nu_prior=LogNormalPrior_propVar(torch.tensor(0.027)) ,\n", + " tau_prior=LogNormalPrior_propVar(torch.tensor(0.01)))" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "795ecb3a", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "prior_prediction = sample(ode_model, num_samples, initial_state, tspan)\n", + "\n", + "ax1 = plot_predictive(prior_prediction, tspan, ax=setup_ax(), label=\"probabilistic forecast\", color=\"red\")\n", + "ax1.axvline(47)\n", + "sideaxis(ax1)" + ] + }, + { + "cell_type": "markdown", + "id": "c65bcf10-9d12-4efe-be10-cc313e123d14", + "metadata": {}, + "source": [ + "## 1.d Policies that prevent infections from exceeding 1/3 of the population\n", + "\n", + "Now return to the situation in b.i (constant parameters that don’t change over time). Let’s say we want to increase testing, diagnostics, and contact tracing efforts (implemented by increasing the detection parameters and ). Assume that $\\theta \\ge 2\\epsilon$ , because a symptomatic person is more likely to be tested. What minimum constant values do these parameters need to be over the course of a 100-day simulation, to ensure that the total infected population (sum over all the infected states I, D, A, R, T) never rises above 1/3 of the total population?\n", + "\n", + "\n", + "### Problem Formulation\n", + "* **Quantity of interest**: Total infections out of $N=60,000,000$ population\n", + "$$I_{total}(t; \\mathbf{u}, \\mathbf{Z}) = I(t) + D(t) + A(t) + R(t) + T(t)$$\n", + "\n", + "A conservative estimate for the quantity of interest is\n", + "$$M(u, Z) = \\max_{1\\leq t \\leq 100} I_{total}(t; \\mathbf{u}, \\mathbf{Z})/N$$\n", + "\n", + "\n", + "\n", + "\n", + "* **Control**: $\\mathbf{u}\\in \\mathcal{U} \\subseteq \\mathbb{R}^{n_u}$\n", + " * Detection parameter for Infected ($\\epsilon$) assuming that $\\theta=2\\epsilon$\n", + " * Two detection parameters $\\theta, \\epsilon$, constraining $\\theta \\ge 2\\epsilon$.\n", + " \n", + "\n", + "\n", + "* **Risk-based optimization under uncertainty problem formulation**\n", + " * Objective Function - Minimize the magnitude of the parameter interventions.\n", + " * Constraint - Risk of normalized total infections exceeding the prescribed threshold of $1/3$, $\\mathcal{R}( M(\\mathbf{u},\\mathbf{Z}))$, is below the acceptable risk threshold, $\\mathcal{R}_\\text{threshold}$.\n", + "\n", + "\\begin{equation} \n", + "\\begin{split} \n", + "\\mathbf{u}^*= \\underset{\\mathbf{u}\\in\\mathcal{U}}{\\arg\\min}\\ & \\lVert \\mathbf{u} \\rVert_1 \\\\ \\text{s.t.}\\ & \\mathcal{R}( M(\\mathbf{u}, \\theta)) \\le \\mathcal{R}_\\text{threshold} \n", + "\\end{split} \n", + "\\end{equation}\n", + "\n", + "#### Formulation 1: Optimize $\\epsilon$ only, assuming $\\theta = 2\\epsilon$\n", + "\\begin{equation} \n", + "\\begin{split} \n", + "\\epsilon^*= \\underset{\\epsilon\\in\\mathcal{U}}{\\arg\\min}\\ & \\epsilon \\\\ \\text{s.t.}\\ & \\mathbb{P}( M(\\epsilon, \\mathbf{Z}) \\ge 1/3) \\le 0.05\n", + "\\end{split} \n", + "\\end{equation}\n", + "\n", + "#### Formulation 2: Optimize $\\epsilon$ and $\\theta$ constraining $\\theta \\ge 2\\epsilon$\n", + "\\begin{equation} \n", + "\\begin{split} \n", + "\\epsilon^\\ast, \\theta^\\ast= \\underset{\\{\\epsilon,\\theta\\}\\in\\mathcal{U}}{\\arg\\min}\\ & \\theta + \\epsilon \\\\ \\text{s.t.}\\ & \\mathbb{P}( M(\\epsilon,\\theta, \\mathbf{Z}) \\ge 1/3) \\le 0.05, \\\\\n", + "& \\theta \\ge 2\\epsilon\n", + "\\end{split} \n", + "\\end{equation}\n", + "\n", + "Apart from probability of exceedance, we will explore quantiles and superquantiles as risk measures." + ] + }, + { + "cell_type": "markdown", + "id": "b17b31c6", + "metadata": {}, + "source": [ + "# Probabilistic forecasting - Exploring interventions\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "44c86c6c", + "metadata": {}, + "outputs": [], + "source": [ + "from causal_pyro.query.do_messenger import do\n", + "from pyciemss.ODE.interventions import constant_intervention_builder, time_dependent_intervention_builder, state_dependent_intervention_builder, parameter_intervention_builder" + ] + }, + { + "cell_type": "markdown", + "id": "7b8a45b6", + "metadata": {}, + "source": [ + "\n", + "## Q: \"What would happen if we set the diagnosis rate parameter for infected, $\\epsilon$?\"\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "14565c79", + "metadata": {}, + "outputs": [], + "source": [ + "pyro.set_rng_seed(0)\n", + "\n", + "# plotting_intervened_parameter_model = intervene(ode_model, rate_parameter_intervention)\n", + "plotting_intervened_parameter_model = do(ode_model, {\"epsilon\": torch.tensor([0.5]), \"theta\": torch.tensor([1.])})\n", + "# intervened_parameter_prediction = Predictive(intervened_parameter_model, guide=guide, num_samples=num_samples)(initial_state, tspan)\n", + "intervened_parameter_prediction = sample(plotting_intervened_parameter_model, num_samples, initial_state, tspan)\n", + "# posterior_prediction = Predictive(plotting_intervened_parameter_model, guide=None, num_samples=num_samples)(initial_state,tspan)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "cf692801", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ax = setup_ax()\n", + "# ax = plot_trajectory(data, observed_tspan, ax=ax)\n", + "ax = plot_predictive(prior_prediction, tspan, tmin=7, ax=ax, label=\"no intervention\")\n", + "ax = plot_predictive(intervened_parameter_prediction, tspan, ax=ax, color='red', label=\"epsilon parameter intervention\")\n", + "sideaxis(ax)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "97ab7988", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import time\n", + "import pickle\n", + "\n", + "import numpy as np\n", + "from scipy import stats\n", + "from matplotlib import ticker\n", + "\n", + "# from pyciemss.ODE.models import SVIIvR\n", + "from pyciemss.ODE.interventions import constant_intervention_builder, parameter_intervention_builder\n", + "\n", + "from pyciemss.risk.risk_measures import alpha_quantile, alpha_superquantile\n", + "from pyciemss.risk.ouu import computeRisk, solveOUU\n", + "from pyciemss.risk.qoi import max_total_infections_SIDARTHE\n", + "import scipy\n", + "\n", + "\n", + "co = ['#377eb8', '#ff7f00', '#984ea3', '#ffd92f', '#a65628']\n", + "rlabel = ['Q_alpha-based OUU', 'barQ_alpha-based OUU']" + ] + }, + { + "cell_type": "markdown", + "id": "5fb87509", + "metadata": {}, + "source": [ + "## Exploring the difference between Quantiles and Superquantiles" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "35ebe5d7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Forward UQ took 82.47 seconds total (1.65e-01 seconds per model evaluation).\n", + "0.11042073369025945 0.3344451749324797\n" + ] + } + ], + "source": [ + "torch.manual_seed(1)\n", + "\n", + "POLICY = np.array([0.75])\n", + "N_SAMPLES = 500\n", + "\n", + "RISK = computeRisk(model=ode_model,\n", + "# intervention_fun=lambda x: parameter_intervention_builder(\"epsilon\", torch.from_numpy(x)),\n", + " intervention_fun=lambda x: {\"epsilon\": torch.from_numpy(x), \"theta\": torch.from_numpy(2*x)},\n", + " qoi=lambda y: max_total_infections_SIDARTHE(y, contexts=[\"I_total_obs\"]),\n", + " risk_measure=alpha_superquantile,\n", + " num_samples=N_SAMPLES,\n", + " model_state=initial_state,\n", + " tspan=tspan,\n", + " guide=None)\n", + "\n", + "start_time = time.time()\n", + "sq_dataCube = RISK.propagate_uncertainty(POLICY)\n", + "end_time = time.time()\n", + "forward_time = end_time - start_time\n", + "time_per_eval = forward_time / N_SAMPLES\n", + "print(f\"Forward UQ took {forward_time:.2f} seconds total ({forward_time/N_SAMPLES:.2e} seconds per model evaluation).\")\n", + "sq_qoi = RISK.qoi(sq_dataCube)\n", + "sq_sv = RISK.risk_measure(sq_qoi)\n", + "\n", + "RISK.risk_measure = alpha_quantile\n", + "q_sv = RISK(POLICY)\n", + "print(q_sv, sq_sv)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "7fc330e1", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "bins_hist = 50\n", + "fig1 = plt.figure()\n", + "plt.rc('text', usetex=False)\n", + "plt.rc('font', family='serif', size=18.)\n", + "cax = plt.gca()\n", + "sideaxishist(cax)\n", + "cax.hist(sq_qoi, color=co[2], bins=bins_hist, histtype='stepfilled', alpha=0.5, label='total infections')\n", + "miny = min(cax.get_ylim())\n", + "maxy = max(cax.get_ylim())\n", + "cax.vlines(q_sv, miny, maxy, linestyle='--', linewidth=2.5, label='alpha-quantile', color=co[0])\n", + "cax.vlines(sq_sv, miny, maxy, linestyle='--', linewidth=2.5, label='alpha-superquantile', color=co[1])\n", + "cax.set_xlabel('Maximum total infections over 100 days', size=14)\n", + "cax.legend(loc='upper right', prop={'size': 14})" + ] + }, + { + "cell_type": "markdown", + "id": "2a4005a9", + "metadata": {}, + "source": [ + "## Risk-based optimization under uncertainty with intervention on detection rate parameter $\\epsilon$\n", + "**NOTE:** This is a demonstration of the interface, optimization is not run to convergence nor are enough samples generated to accurately estimate the risk, so take the results with a grain of salt." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "6fe11138", + "metadata": {}, + "outputs": [], + "source": [ + "# Define problem specifics.\n", + "RISK_BOUND = 1./3.\n", + "X_MIN = 0.\n", + "X_MAX = 3.\n", + "N_SAMPLES = int(5e2)\n", + "MAXITER = 0\n", + "MAXFEVAL = 30\n", + "# TOL = 1e-5\n", + "\n", + "RISK_ALPHA = 0.95\n", + "\n", + "# Control action / intervention.\n", + "INIT_GUESS = 0.6\n", + "# INTERVENTION = lambda x: parameter_intervention_builder(\"nu\", torch.tensor(x))\n", + "INTERVENTION = lambda x: {\"epsilon\": torch.from_numpy(np.array([x])), \"theta\": torch.from_numpy(2*np.array([x]))}\n", + "\n", + "# Objective function.\n", + "OBJFUN = lambda x: x # minimize the scalar value itself." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "ba6b2d82", + "metadata": {}, + "outputs": [], + "source": [ + "# Define the risk measure.\n", + "RISK = computeRisk(\n", + " model=ode_model,\n", + " intervention_fun=INTERVENTION,\n", + " qoi=lambda y: max_total_infections_SIDARTHE(y, contexts=[\"I_total_obs\"]),\n", + " model_state=initial_state,\n", + " tspan=tspan,\n", + " risk_measure=lambda z: alpha_superquantile(z, alpha=RISK_ALPHA),\n", + " num_samples=N_SAMPLES,\n", + " guide=None,\n", + " )\n", + "\n", + "# Define problem constraints.\n", + "CONSTRAINTS = (\n", + " # risk constraint\n", + " {'type': 'ineq', 'fun': lambda x: RISK_BOUND - RISK(x)},\n", + "\n", + " # bounds on control\n", + " # NOTE: perhaps use scipy.optimize.LinearConstraint in the future\n", + " {'type': 'ineq', 'fun': lambda x: x - X_MIN},\n", + " {'type': 'ineq', 'fun': lambda x: X_MAX - x}\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "13a9803a", + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Performing risk-based optimization under uncertainty (using alpha-superquantile)...\n", + "Estimated wait time 2474.1 seconds.\n", + "Optimization completed in time 1747.32 seconds. Optimal epsilon:\t0.7903427180394644\n" + ] + } + ], + "source": [ + "print(\"Performing risk-based optimization under uncertainty (using alpha-superquantile)...\")\n", + "print(f\"Estimated wait time {time_per_eval*N_SAMPLES*(MAXITER+1)*MAXFEVAL:.1f} seconds.\")\n", + "start_time = time.time()\n", + "sq_result_1 = solveOUU(\n", + " x0=INIT_GUESS,\n", + " objfun=OBJFUN,\n", + " constraints=CONSTRAINTS,\n", + " maxiter=MAXITER,\n", + " maxfeval=MAXFEVAL,\n", + " ).solve()\n", + "print(f\"Optimization completed in time {time.time()-start_time:.2f} seconds. Optimal epsilon:\\t{sq_result_1.x}\")\n", + "# est_risk_sq1 = RISK(sq_result_1.x)\n", + "# print(f\"Estimated risk:\\t{est_risk_sq1:.2f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "ff6e2279", + "metadata": {}, + "outputs": [], + "source": [ + "# Define the risk measure.\n", + "RISK = computeRisk(\n", + " model=ode_model,\n", + " intervention_fun=INTERVENTION,\n", + " qoi=lambda y: max_total_infections_SIDARTHE(y, contexts=[\"I_total_obs\"]),\n", + " model_state=initial_state,\n", + " tspan=tspan,\n", + " risk_measure=lambda z: alpha_quantile(z, alpha=RISK_ALPHA),\n", + " num_samples=N_SAMPLES,\n", + " guide=None,\n", + " )\n", + "\n", + "# Define problem constraints.\n", + "CONSTRAINTS = (\n", + " # risk constraint\n", + " {'type': 'ineq', 'fun': lambda x: RISK_BOUND - RISK(x)},\n", + "\n", + " # bounds on control\n", + " # NOTE: perhaps use scipy.optimize.LinearConstraint in the future\n", + " {'type': 'ineq', 'fun': lambda x: x - X_MIN},\n", + " {'type': 'ineq', 'fun': lambda x: X_MAX - x}\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "93709fdf", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Performing risk-based optimization under uncertainty (using alpha-quantile)...\n", + "Estimated wait time 2474.1 seconds.\n", + "Optimization completed in time 2154.51 seconds. Optimal epsilon:\t0.6293048708505159\n" + ] + } + ], + "source": [ + "print(\"Performing risk-based optimization under uncertainty (using alpha-quantile)...\")\n", + "print(f\"Estimated wait time {time_per_eval*N_SAMPLES*(MAXITER+1)*MAXFEVAL:.1f} seconds.\")\n", + "start_time = time.time()\n", + "q_result_1 = solveOUU(\n", + " x0=INIT_GUESS,\n", + " objfun=OBJFUN,\n", + " constraints=CONSTRAINTS,\n", + " maxiter=MAXITER\n", + " ).solve()\n", + "print(f\"Optimization completed in time {time.time()-start_time:.2f} seconds. Optimal epsilon:\\t{q_result_1.x}\")\n", + "# est_risk_q1 = RISK(q_result_1.x)\n", + "# print(f\"Estimated risk:\\t{est_risk_q1:.2f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "abfeda8c", + "metadata": {}, + "source": [ + "## Assess the effect of the control policy." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "60c9d1a9", + "metadata": { + "scrolled": false + }, + "outputs": [], + "source": [ + "RISK.num_samples = int(5e2)\n", + "q_optimal_prediction = RISK.propagate_uncertainty(q_result_1.x)\n", + "sq_optimal_prediction = RISK.propagate_uncertainty(sq_result_1.x)\n", + "qois_q = RISK.qoi(q_optimal_prediction)\n", + "qois_sq = RISK.qoi(sq_optimal_prediction)\n", + "# sq_sv = RISK.risk_measure(qois_q)\n", + "# RISK.risk_measure = alpha_quantile\n", + "# q_sv = RISK(POLICY)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "c92e52b7", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ax = setup_ax()\n", + "ax = plot_predictive(q_optimal_prediction, tspan, ax=ax, color=co[1], label=\"alpha-quantile OUU\")\n", + "ax = plot_predictive(sq_optimal_prediction, tspan, ax=ax, color=co[2], label=\"alpha-superquantile OUU\")\n", + "plt.title(\"Epsilon parameter intervention (theta=2*epsilon)\", size=14)\n", + "sideaxis(ax)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "13bf129e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "bins_hist = 50\n", + "fig1 = plt.figure()\n", + "plt.rc('font', family='serif', size=14.)\n", + "cax = plt.gca()\n", + "sideaxishist(cax)\n", + "cax.hist(qois_q, color=co[2], bins=bins_hist, histtype='stepfilled', alpha=0.5, label=\"alpha-quantile OUU\", density=True)\n", + "cax.hist(qois_sq, color=co[4], bins=bins_hist, histtype='stepfilled', alpha=0.5, label=\"alpha-superquantile OUU\", density=True)\n", + "miny = min(cax.get_ylim())\n", + "maxy = max(cax.get_ylim())\n", + "# cax.vlines(est_risk, miny, maxy, linestyle='--', linewidth=2.5, label='alpha-superquantile', color=co[1])\n", + "cax.set_xlabel('Maximum total infections over 100 days', size=14)\n", + "cax.legend(loc='upper right', prop={'size': 14})" + ] + } + ], + "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.9.7" + }, + "vscode": { + "interpreter": { + "hash": "a3e1d8fdda916c248c87d86618e3945b28961cf939001a0529e724463670a41a" + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/6-month-milestone/evaluation/scenario_2/ta_3/ciemss/scenario2_q1_thetaepsilon.ipynb b/6-month-milestone/evaluation/scenario_2/ta_3/ciemss/scenario2_q1_thetaepsilon.ipynb new file mode 100644 index 0000000..a3c2994 --- /dev/null +++ b/6-month-milestone/evaluation/scenario_2/ta_3/ciemss/scenario2_q1_thetaepsilon.ipynb @@ -0,0 +1,767 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "b087c52b-a505-45d3-b643-df44d8c924a5", + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "markdown", + "id": "542b06c1-28fb-47ec-9a34-170acc7d2a84", + "metadata": {}, + "source": [ + "# Load Dependencies" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "84e0bb12-68af-4a6d-a384-db4837c44ac0", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "import torch\n", + "\n", + "import pyro\n", + "import numpy as np\n", + "import pyro.distributions as dist\n", + "# from pyro.poutine import trace, replay, block\n", + "# from pyro.infer.autoguide.guides import AutoDelta, AutoNormal\n", + "# from pyro.infer import SVI, Trace_ELBO, Predictive\n", + "\n", + "import sys\n", + "sys.path.append(\"../../src/\")\n", + "\n", + "from pyciemss.ODE.askem_primitives import sample, infer_parameters, intervene, optimization\n", + "\n", + "# from pyciemss.utils import run_inference, get_tspan\n", + "from pyciemss.utils import get_tspan\n", + "\n", + "import warnings\n", + "warnings.filterwarnings('ignore')" + ] + }, + { + "cell_type": "markdown", + "id": "4855961d-9c38-4050-b6b7-aaae03500fc9", + "metadata": {}, + "source": [ + "# Plotting Utilities" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "1c7ae081", + "metadata": {}, + "outputs": [], + "source": [ + "def setup_ax(ax=None):\n", + "\n", + " if not ax:\n", + " fig = plt.figure(facecolor='w', figsize=(9, 5))\n", + " ax = fig.add_subplot(111, axisbelow=True)\n", + "\n", + " ax.set_xlabel('Time (days)')\n", + " ax.set_ylabel('Total infected')\n", + " return ax\n", + "\n", + "def plot_predictive(prediction, tspan, tmin=None, ax=None, alpha=0.2, color=\"black\", ptiles=[0.05,0.95], **kwargs):\n", + " vars = [\"I_total_obs\"]\n", + " #infection_total = sum([prediction[x].squeeze().detach().numpy()/1000. for x in ['I_obs', 'D_obs', 'A_obs', 'R_obs', 'T_obs']])\n", + "\n", + " I_low = torch.quantile(prediction[\"I_total_obs\"], ptiles[0], dim=0).detach().numpy()\n", + " I_up = torch.quantile(prediction[\"I_total_obs\"], ptiles[1], dim=0).detach().numpy()\n", + "\n", + " if tmin:\n", + " indeces = tspan >= tmin\n", + " else:\n", + " indeces = torch.ones_like(tspan).bool()\n", + "\n", + " if not ax:\n", + " fig = plt.figure(facecolor='w')\n", + " ax = fig.add_subplot(111, facecolor='#dddddd', axisbelow=True)\n", + " \n", + " ax.fill_between(tspan[indeces], I_low[indeces], I_up[indeces], alpha=alpha, color=color, **kwargs)\n", + "\n", + " legend = ax.legend()\n", + " legend.get_frame().set_alpha(0.5)\n", + "\n", + " return ax\n", + "\n", + "def plot_trajectory(data, tspan, ax=None, color='black', alpha=0.5, lw=0, marker='.', label=None, ind=0):\n", + " # Plot the data on three separate curves for S(t), I(t) and R(t)\n", + " if len(data['I_total_obs'].squeeze().detach().numpy().shape)>1:\n", + " plot_data = data['I_total_obs'].squeeze().detach().numpy()[ind,:]\n", + " else:\n", + " plot_data = data['I_total_obs'].squeeze().detach().numpy()\n", + "\n", + " if not ax:\n", + " fig = plt.figure(facecolor='w')\n", + " ax = fig.add_subplot(111, facecolor='#dddddd', axisbelow=True)\n", + " #infection_total = sum([data[x].squeeze().detach().numpy()/1000. for x in ['I_obs', 'D_obs', 'A_obs', 'R_obs', 'T_obs']])\n", + " ax.plot(tspan, plot_data, color, alpha=alpha, lw=lw, marker=marker, label=label)\n", + " \n", + " return ax\n", + "\n", + "def plot_intervention_line(t, ax=None):\n", + " if not ax:\n", + " fig = plt.figure(facecolor='w')\n", + " ax = fig.add_subplot(111, facecolor='#dddddd', axisbelow=True)\n", + "\n", + " ylim = ax.get_ylim()\n", + "\n", + " ax.vlines(t, min(ylim), max(ylim), color=\"grey\", ls='-')\n", + "\n", + " return ax\n", + "\n", + "def sideaxis(ax):\n", + " ax.spines['top'].set_visible(False)\n", + " ax.spines['right'].set_visible(False)\n", + " return\n", + "\n", + "def sideaxishist(ax):\n", + " ax.spines['top'].set_visible(False)\n", + " ax.spines['right'].set_visible(False)\n", + " ax.spines['left'].set_visible(False)\n", + " # For y-axis\n", + " ax.yaxis.set_major_locator(ticker.NullLocator())\n", + " ax.tick_params(axis='x', labelsize=12) # change fontsize for x-axis tick labels\n", + " # ax.xaxis.major.formatter._useMathText = True\n", + " return" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "f233104e-c29d-4e25-859f-2a328ec7892a", + "metadata": {}, + "outputs": [], + "source": [ + "def LogNormalPrior(mean, variance):\n", + " mu = torch.log(mean**2/torch.sqrt((mean**2 + variance)))\n", + " scale = torch.sqrt(torch.log(1 + variance/mean**2))\n", + " return dist.LogNormal(mu, scale)\n", + "\n", + "def LogNormalPrior_propVar(mean, cov=0.05):\n", + " variance = mean*cov \n", + " return LogNormalPrior(mean, variance)" + ] + }, + { + "cell_type": "markdown", + "id": "3e0c3726-5ec0-475d-8305-f20b5d84e424", + "metadata": {}, + "source": [ + "# Setup Parameters" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "16608500-97b5-4081-9e6b-b7c193c10285", + "metadata": {}, + "outputs": [], + "source": [ + "tspan = get_tspan(1, 100, 100)\n", + "\n", + "num_samples = 500\n", + "\n", + "# Total population, N.\n", + "N = 1\n", + "# Initial number of infected and recovered individuals, I0 and R0.\n", + "I0, D0, A0, R0, T0, H0, E0 = 200/60e6, 20/60e6, 1/60e6, 2/60e6, 0, 0, 0\n", + "\n", + "# Everyone else, S0, is susceptible to infection initially.\n", + "S0 = N - I0 - D0 - A0 - R0 - T0 - H0 - E0\n", + "\n", + "initial_state = tuple(torch.as_tensor(s) for s in (S0, I0, D0, A0, R0, T0, H0, E0))" + ] + }, + { + "cell_type": "markdown", + "id": "23fc9c9d-f8bc-4e95-a243-865690d3b43b", + "metadata": {}, + "source": [ + "# Probabilistic Forecasting - Passing unit test 1\n", + "There are two ‘unit tests’ we want to pass, to ensure that we understood and can reproduce the published model:\n", + "\n", + "## 1.a Unit Test \\#1:\n", + "\n", + "Set the initial values and parameters, as described in the Supplementary Methods section of the publication (pg. 9 of the pdf): \n", + "\n", + "1. Initial Values: \n", + "* $I = 200/60e6$,\n", + "* $D = 20/60e6$, \n", + "* $A = 1/60e6$, \n", + "* $R = 2/60e6$, \n", + "* $T = 0$, \n", + "* $H = 0$, \n", + "* $E = 0$; \n", + "* $S = 1 – I – D – A – R – T – H – E$. \n", + "\n", + "Let total population = 60e6.\n", + "Parameters: $$\\alpha = 0.570, \\beta = \\delta = 0.011, \\gamma = 0.456, \\epsilon = 0.171, \\theta = 0.371, \\zeta = \\eta = 0.125, \\mu = 0.017, \\nu = 0.027, \\tau = 0.01, \\lambda = \\rho = 0.034$$ and $$\\kappa = \\xi = \\sigma = 0.017$$." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "dbd7d430-325f-4f40-9b20-d8a0c0264f62", + "metadata": {}, + "outputs": [], + "source": [ + "from pyciemss.ODE.models import SIDARTHE\n", + "\n", + "pyro.set_rng_seed(0)\n", + "\n", + "ode_model = SIDARTHE(N=1,\n", + " alpha_prior=dist.Delta(torch.tensor (0.570)) ,\n", + " beta_prior=dist.Delta(torch.tensor (0.011)) ,\n", + " gamma_prior=dist.Delta(torch.tensor (0.456)) ,\n", + " delta_prior=dist.Delta(torch.tensor (0.011)) ,\n", + " epsilon_prior=dist.Delta(torch.tensor (0.171)) ,\n", + " lamb_prior =dist.Delta(torch.tensor (0.034)) ,\n", + " zeta_prior=dist.Delta(torch.tensor (0.125)) ,\n", + " eta_prior=dist.Delta(torch.tensor (0.125)) ,\n", + " kappa_prior=dist.Delta(torch.tensor (0.017)) ,\n", + " theta_prior=dist.Delta(torch.tensor (0.371)) ,\n", + " rho_prior=dist.Delta(torch.tensor (0.034)) ,\n", + " xi_prior=dist.Delta(torch.tensor (0.017)) ,\n", + " sigma_prior=dist.Delta(torch.tensor (0.017)) ,\n", + " mu_prior=dist.Delta(torch.tensor (0.017)) ,\n", + " nu_prior=dist.Delta(torch.tensor (0.027)) ,\n", + " tau_prior=dist.Delta(torch.tensor (0.01)) )" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "31473cdd-9896-42ed-b487-36362c1c9744", + "metadata": {}, + "outputs": [], + "source": [ + "#prior_prediction = sample(plotting_ode_model, num_samples, initial_state, tspan)\n", + "single_prediction = sample(ode_model, 1, initial_state, tspan)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "15f03c6f-d085-4f36-bc7a-312057d82758", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ax = plot_trajectory(single_prediction, tspan, ax=setup_ax(), color=\"blue\", marker='', lw=1., label=\"Before Seeing Data - Single Forecast\")\n", + "#ax = plot_predictive(prior_prediction, tspan, ax=ax, label=\"Before Seeing Data - Probabilistic Forecast\", color=\"red\")\n", + "ax.axvline(47)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "595205b8", + "metadata": {}, + "outputs": [], + "source": [ + "from pyciemss.ODE.models import SIDARTHE\n", + "\n", + "pyro.set_rng_seed(0)\n", + "\n", + "ode_model = SIDARTHE(N=1,\n", + " alpha_prior=LogNormalPrior_propVar(torch.tensor(0.570)) ,\n", + " beta_prior=LogNormalPrior_propVar(torch.tensor(0.011)) ,\n", + " gamma_prior=LogNormalPrior_propVar(torch.tensor(0.456)) ,\n", + " delta_prior=LogNormalPrior_propVar(torch.tensor(0.011)) ,\n", + " epsilon_prior=LogNormalPrior_propVar(torch.tensor(0.171)) ,\n", + " lamb_prior =LogNormalPrior_propVar(torch.tensor(0.034)) ,\n", + " zeta_prior=LogNormalPrior_propVar(torch.tensor(0.125)) ,\n", + " eta_prior=LogNormalPrior_propVar(torch.tensor(0.125)) ,\n", + " kappa_prior=LogNormalPrior_propVar(torch.tensor(0.017)) ,\n", + " theta_prior=LogNormalPrior_propVar(torch.tensor(0.371)) ,\n", + " rho_prior=LogNormalPrior_propVar(torch.tensor(0.034)) ,\n", + " xi_prior=LogNormalPrior_propVar(torch.tensor(0.017)) ,\n", + " sigma_prior=LogNormalPrior_propVar(torch.tensor(0.017)) ,\n", + " mu_prior=LogNormalPrior_propVar(torch.tensor(0.017)) ,\n", + " nu_prior=LogNormalPrior_propVar(torch.tensor(0.027)) ,\n", + " tau_prior=LogNormalPrior_propVar(torch.tensor(0.01)))\n", + "\n", + "prior_prediction = sample(ode_model, num_samples, initial_state, tspan)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "f62475f8", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ax1 = plot_predictive(prior_prediction, tspan, ax=setup_ax(), label=\"probabilistic forecast\", color=\"red\")\n", + "ax1.axvline(47)\n", + "sideaxis(ax1)" + ] + }, + { + "cell_type": "markdown", + "id": "c65bcf10-9d12-4efe-be10-cc313e123d14", + "metadata": {}, + "source": [ + "## 1.d Policies that prevent infections from exceeding 1/3 of the population\n", + "\n", + "Now return to the situation in b.i (constant parameters that don’t change over time). Let’s say we want to increase testing, diagnostics, and contact tracing efforts (implemented by increasing the detection parameters and ). Assume that $\\theta \\ge 2\\epsilon$ , because a symptomatic person is more likely to be tested. What minimum constant values do these parameters need to be over the course of a 100-day simulation, to ensure that the total infected population (sum over all the infected states I, D, A, R, T) never rises above 1/3 of the total population?\n", + "\n", + "\n", + "\n", + "\n", + "### Problem Formulation\n", + "* **Quantity of interest**: Total infections out of $N=60,000,000$ population\n", + "$$I_{total}(t; \\mathbf{u}, \\mathbf{Z}) = I(t) + D(t) + A(t) + R(t) + T(t)$$\n", + "\n", + "A conservative estimate for the quantity of interest is\n", + "$$M(u, Z) = \\max_{1\\leq t \\leq 100} I_{total}(t; \\mathbf{u}, \\mathbf{Z})/N$$\n", + "\n", + "\n", + "\n", + "\n", + "* **Control**: $\\mathbf{u}\\in \\mathcal{U} \\subseteq \\mathbb{R}^{n_u}$\n", + " * Detection parameter for Infected ($\\epsilon$) assuming that $\\theta=2\\epsilon$\n", + " * Two detection parameters $\\theta, \\epsilon$, constraining $\\theta \\ge 2\\epsilon$.\n", + " \n", + "\n", + "\n", + "* **Risk-based optimization under uncertainty problem formulation**\n", + " * Objective Function - Minimize the magnitude of the parameter interventions.\n", + " * Constraint - Risk of normalized total infections exceeding the prescribed threshold of $1/3$, $\\mathcal{R}( M(\\mathbf{u},\\mathbf{Z}))$, is below the acceptable risk threshold, $\\mathcal{R}_\\text{threshold}$.\n", + "\n", + "\\begin{equation} \n", + "\\begin{split} \n", + "\\mathbf{u}^*= \\underset{\\mathbf{u}\\in\\mathcal{U}}{\\arg\\min}\\ & \\lVert \\mathbf{u} \\rVert_1 \\\\ \\text{s.t.}\\ & \\mathcal{R}( M(\\mathbf{u}, \\theta)) \\le \\mathcal{R}_\\text{threshold} \n", + "\\end{split} \n", + "\\end{equation}\n", + "\n", + "#### Formulation 1: Optimize $\\epsilon$ only, assuming $\\theta = 2\\epsilon$\n", + "\\begin{equation} \n", + "\\begin{split} \n", + "\\epsilon^*= \\underset{\\epsilon\\in\\mathcal{U}}{\\arg\\min}\\ & \\epsilon \\\\ \\text{s.t.}\\ & \\mathbb{P}( M(\\epsilon, \\mathbf{Z}) \\ge 1/3) \\le 0.05\n", + "\\end{split} \n", + "\\end{equation}\n", + "\n", + "#### Formulation 2: Optimize $\\epsilon$ and $\\theta$ constraining $\\theta \\ge 2\\epsilon$\n", + "\\begin{equation} \n", + "\\begin{split} \n", + "\\epsilon^\\ast, \\theta^\\ast= \\underset{\\{\\epsilon,\\theta\\}\\in\\mathcal{U}}{\\arg\\min}\\ & \\theta + \\epsilon \\\\ \\text{s.t.}\\ & \\mathbb{P}( M(\\epsilon,\\theta, \\mathbf{Z}) \\ge 1/3) \\le 0.05, \\\\\n", + "& \\theta \\ge 2\\epsilon\n", + "\\end{split} \n", + "\\end{equation}\n", + "\n", + "Apart from probability of exceedance, we will explore quantiles and superquantiles as risk measures." + ] + }, + { + "cell_type": "markdown", + "id": "b17b31c6", + "metadata": {}, + "source": [ + "# Probabilistic forecasting - Exploring interventions\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "44c86c6c", + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "from causal_pyro.query.do_messenger import do\n", + "from pyciemss.ODE.interventions import constant_intervention_builder, time_dependent_intervention_builder, state_dependent_intervention_builder, parameter_intervention_builder" + ] + }, + { + "cell_type": "markdown", + "id": "7b8a45b6", + "metadata": {}, + "source": [ + "\n", + "## Q: \"What would happen if we set the diagnosis rate parameters, $\\theta, \\epsilon$?\"\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "14565c79", + "metadata": {}, + "outputs": [], + "source": [ + "pyro.set_rng_seed(0)\n", + "\n", + "plotting_intervened_parameter_model = do(ode_model, {\"epsilon\": torch.tensor([0.4]), \"theta\": torch.tensor([1.1])})\n", + "intervened_parameter_prediction = sample(plotting_intervened_parameter_model, num_samples, initial_state, tspan)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "cf692801", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAwAAAAHACAYAAAAV9g8TAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAAByKUlEQVR4nO3deXwU5f0H8M/s7L2bk5CEIxjvE0FEEG09UayVetSzVJFqbSkqiBe2FcULtWLxqqht1Vqt/qrWWg9apB5IURA5RDBABALk3CR73zPP74/NjllykMAmk939vF+vvJKdneO7O0n2+c48z/eRhBACRERERESUEwx6B0BERERERP2HCQARERERUQ5hAkBERERElEOYABARERER5RAmAEREREREOYQJABERERFRDmECQERERESUQ5gAEBERERHlkJxLAIQQ8Hq94PxnRERERJSLci4B8Pl8KCgogM/n0zsUIiIiIqJ+l3MJABERERFRLmMCQERERESUQ5gAEBERERHlECYAREREREQ5hAkAEREREVEOMeodABEREX1HCAFVVaGqqt6hENEAYzAYYDAYIEnSfu2HCQAREdEAEY/H4Xa7EY1G9Q6FiAYos9mMwsJCGI373oxnAkBERDQACCHQ1NQEg8GAoqIiyLK831f5iCh7CCGgKAq8Xi+amppQXl6+z/8jmAAQERENAPF4HEIIFBUVwWw26x0OEQ1QsizD5XIhHo/DZDLt0z44CJiIiGgA4VV/IupOOv5HMAEgIiIiIsohTACIiIiIiHIIxwAQERENcNFoFPF4vN+OZzQadR+HsH37dhx44IFYs2YNRo8erWssejjttNMwevRoLFy4UO9QKAsxASAiIhrAotEoVq5cCb/f32/HdDqdGDdunK5JQEVFBerq6lBSUtLjbe6++2689dZbWLt2bd8FlmYfffQRTj/9dLS2tqKwsFBb/uabb+7zAE+ivWECQERENIDF43H4/X6YzWZYLJY+P14kEoHf70c8Htc1AZBlGeXl5bocOxqN6n4HpLi4WNfjU3bjGAAiIqIMYLFYYLVa+/xrX5KM0047DTfeeCNuu+02FBcXo7y8HHfffXfKOjU1NTj//PPhdDqRn5+PSy+9FA0NDV3uc/v27ZAkSbua/9FHH0GSJCxduhRjx46F3W7HSSedhKqqKgDACy+8gHnz5mHdunWQJAmSJOGFF14AALjdblx77bUYPHgw8vPzccYZZ2DdunXase6++26MHj0af/zjH3HggQfCarXi2WefxdChQzvMyHz++efjZz/7mfb4n//8J8aMGQOr1YqDDjoI8+bNS+muJUkS/vjHP+LCCy+E3W7HoYceirffflt7jaeffjoAoKioCJIk4eqrr9be01mzZmn7aW1txVVXXYWioiLY7Xb84Ac/wJYtW7TnX3jhBRQWFuLf//43jjzySDidTpxzzjmoq6vr5sxRrmICQES0D8LhMDZs2IA1a9Zg+/btcLlcCIfDXa4vhNCurCqK0o+REvWPF198EQ6HA59//jkefvhh3HPPPViyZAkAQFVVnH/++WhpacHHH3+MJUuW4Ntvv8Vll13W6+P85je/wYIFC/DFF1/AaDRqjfHLLrsMN998M44++mjU1dWhrq5O2/8ll1yCxsZGvP/++1i9ejXGjBmDM888Ey0tLdp+t27dijfeeANvvvkm1q5di0suuQTNzc348MMPtXVaWlqwePFiTJkyBQCwbNkyXHXVVZg5cyY2btyIZ555Bi+88ALuv//+lJjnzZuHSy+9FOvXr8e5556LKVOmoKWlBRUVFXjjjTcAAFVVVairq8Njjz3W6eu++uqr8cUXX+Dtt9/GihUrIITAueeei1gspq0TDAbxyCOP4KWXXsInn3yCmpoa3HLLLb1+jyn7sQsQEVEvud1ubNq0CXV1dbBYLNixYwckSYLNZkN+fj4GDRoEq9WKWCyGYDCIQCCAUCiEWCyGeDwOu92OYcOGYdCgQSgoKIDBwGsxlPmOPfZY3HXXXQCAQw89FE8++SSWLl2Ks846C0uXLsVXX32Fbdu2oaKiAgDwl7/8BUcffTRWrVqFE044ocfHuf/++3HqqacCAObMmYMf/vCHCIfDsNlscDqdMBqNKV2HPv30U6xcuRKNjY3a3Y1HHnkEb731Fl5//XVcd911ABLdfv7yl79g8ODB2rY/+MEP8Morr+DMM88EALz++usoKSnRrtrPmzcPc+bMwdSpUwEABx10EO69917cdttt2nsBJBrvV1xxBQDggQcewOOPP46VK1finHPO0br6lJaWpowBaG/Lli14++23sXz5cpx00kkAgJdffhkVFRV46623cMkllwAAYrEYFi1ahIMPPhgAcP311+Oee+7p8XtLuYMJABFRDwkhUFdXh40bNyIQCGD48OGQZRkAoCgKwuEwPB4PGhoaIIQAkOjHbDKZYDKZYLFYYLfbEQgEsGHDBhiNRhQWFmLYsGEoLi5Gfn4+J4GijHXsscemPB4yZAgaGxsBAJs2bUJFRYXW+AeAo446CoWFhdi0aVOvEoD2xxkyZAgAoLGxESNGjOh0/XXr1sHv92PQoEEpy0OhEKqrq7XHBxxwQErjHwCmTJmCn//85/jDH/4Ai8WCl19+GZdffrmWtK9btw7Lly9PueKf/F8QDAZht9s7xOxwOJCfn6+9Nz2xadMmGI1GjB8/Xls2aNAgHH744di0aZO2zG63a41/IPUcELXHBICIqAcURUF1dTWqqqpgNpsxfPjwlOdlWYbD4YDD4djrvqxWKwYNGoRoNAqv14s1a9bAarUiPz8fJSUlyM/Ph9PphNPp5N0Byhh7VqyRJKlD//l0HyeZMHd3HL/fjyFDhuCjjz7q8Fz7K+6d/e1OnjwZQgi8++67OOGEE7Bs2TL8/ve/T9n3vHnzcNFFF3XY1mq1dhpzMu6+fm+Sx0lejCBqjwkAEdFehEIhfPPNN9i+fTuKi4vhdDrTsl+z2YySkhKUlJQgHA7D7/ejubkZQgiYzWY4HA4UFxejsLAQeXl5WveG7iiKAr/fj1AoBEVRoKoqFEWBoihaF6T8/HwUFBQgLy+PCQb1iyOPPBI7d+7Ezp07tbsAGzduhNvtxlFHHZW245jN5g5jbMaMGYP6+noYjUZUVlb2an9WqxUXXXQRXn75ZWzduhWHH344xowZk7LvqqoqHHLIIfsVM4BuxwYdeeSRiMfj+Pzzz7UuQM3Nzaiqqkrr+0e5gwkAEVE3Wlpa8PXXX8PlcqG8vLzPSgMmK7AkRSIRhEIhbN++HYqiwGg0wm63Y9CgQSguLkZeXh7y8vKgqir8fj/8fj9aWlrQ0tKCYDCYMjAQgFYVRZIkrbxjQUEBysvLUVhYiIKCgg5XD4UQ2tVDJgr6i0QiGXuciRMnYuTIkZgyZQoWLlyIeDyOX/3qVzj11FMxduzYtB2nsrIS27Ztw9q1azF8+HDk5eVh4sSJmDBhAi644AI8/PDDOOyww1BbW4t3330XF1544V6PP2XKFJx33nn4+uuv8dOf/jTlublz5+K8887DiBEjcPHFF8NgMGDdunXYsGED7rvvvh7FfMABB0CSJLzzzjs499xztbEM7R166KE4//zz8fOf/xzPPPMM8vLyMGfOHAwbNgznn39+794kIjABICLqlBACu3fvxsaNGxGJRDB8+PB+bQRbLBZYLBati0IsFkMgEEBNTQ2+/fZbmM1m2O12qKqKYDCIeDyuJQnFxcV7TVQikQh8Ph82bNgASZKQl5cHh8MBIYR2x0BVVaiqCoPBgMrKSgwdOlT32ui5yGg0wul0wu/3IxqN9ssxe3K3qTckScI///lP3HDDDTjllFNgMBhwzjnn4IknnkjbMQDgxz/+Md58802cfvrpcLvdeP7553H11Vfjvffew29+8xtMmzYNTU1NKC8vxymnnIKysrK97vOMM85AcXExqqqq8JOf/CTluUmTJuGdd97BPffcg4ceeggmkwlHHHEErr322h7HPGzYMG0w8bRp03DVVVdp5Uvbe/755zFz5kycd955iEajOOWUU/Dee+9xsjDaJ5LIsc5hXq8XBQUF8Hg8yM/P1zscIhqA4vE4qqursXnzZlit1gE5IU8yITAYDLDb7fvVWEtONBWLxbS7BAaDIeWOQXIQ5SGHHILy8nJt8DOlTywWQ1NTEwYPHtyhUReNRlNqy/c1o9HIZI9ogOruf0VP6X4H4KmnnsLvfvc71NfXY9SoUXjiiScwbty4LtdfuHAhnn76adTU1KCkpAQXX3wx5s+fn3LrnIhoX7Xv7z9o0KAeDerVg8lk6rJkYG8lqxF1p7CwEC0tLVi1ahXKy8tx0EEHYfDgwaxa1E/MZjMb5ESUNromAK+99hpmz56NRYsWYfz48Vi4cCEmTZqEqqoqlJaWdlj/lVdewZw5c/DnP/8ZJ510EjZv3oyrr74akiTh0Ucf1eEVEJEeFEWB1+uFx+OBqqowGo0pX7IsQ5ZlrQ+7qqraz0KIlNKcJpNJa8S2trbi66+/RlNTE4YMGcJb6+3IsozBgwcjHo+jqakJjY2NqKiowIgRI1BcXMxEgIgog+jaBWj8+PE44YQT8OSTTwJIlPGqqKjADTfcgDlz5nRY//rrr8emTZuwdOlSbdnNN9+Mzz//HJ9++mmPjskuQESZKRqNwuPxoKWlBfX19fD5fFqXlfYkSYLRaITBYNDK7LVPBIBEYzaZKBiNRlgsFthsNm023/Lycg563YtIJIKmpibIsowhQ4agoqICJSUlfN/2Qzpu6xNR9svoLkDRaBSrV6/GHXfcoS0zGAyYOHEiVqxY0ek2J510Ev76179i5cqVGDduHL799lu89957uPLKK/srbCLqZ8FgENXV1WhsbITf74cQAg6HAyUlJZ3+40uWvVRVNaXyTfsvRVEQj8e1L5/Ph9bWVlitVgwdOlSHV5l5LBYLhg8fjnA4jNraWuzevRuDBw/GAQccgNLS0rQOICUiovTS7T+0y+WCoigdRuCXlZXhm2++6XSbn/zkJ3C5XPje974HIQTi8Th++ctf4te//nWXx4lEIiklzbxeb3peABH1Ob/fj6+++gp1dXUoLCzEkCFD9jr41GAw7PUqdLKrEO2/ZNIUi8XQ3NyMhoYGDBo0CMOHD4fZbIbBYIAsyynfkxWO2G2IiEgfGfUJ+NFHH+GBBx7AH/7wB4wfPx5bt27FzJkzce+99+LOO+/sdJv58+dj3rx5/RwpEe0vr9eL9evXo6mpCcOHD2fVmQHOZDKhvLwc8Xgcbrcb69atS3k+efclOf7CarWisLAQ+fn5sFqtsNlssNlsHOhKRNQPdBsDEI1GYbfb8frrr+OCCy7Qlk+dOhVutxv//Oc/O2zz/e9/HyeeeCJ+97vfacv++te/4rrrroPf7+/0ql9ndwAqKio4BoBoAEs2IN1uN4YOHcp+5VkgOQZDVVVEo1Htf3M8HtdmPrZarXA4HCgqKoLT6YTNZoPdbs+ZuwUcA0BEPZHRYwDMZjOOP/54LF26VEsAVFXF0qVLcf3113e6TTAY7NAQSF4V7CqPSd5qJqLM0NLSgvXr18Pr9WLYsGE50fDLBcmr/8k7AHuWV43FYgiHw/B4PGhoaIAQAgaDAVarFXa7HTabTRusbTKZYDQaYTKZYLPZ4HA4+HtCRNQLunYBmj17NqZOnYqxY8di3LhxWLhwIQKBAKZNmwYAuOqqqzBs2DDMnz8fADB58mQ8+uijOO6447QuQHfeeScmT57M7gFEWcDlcmHdunUIBoMYOnQoG3U5JFmSNS8vT1sWj8cRiUQQCoXg8/kQj8ehKErKdlarFfn5+SgrK9O6FGXl1fNoFOjHicBgNAIDqDvWRx99hNNPPx2tra0oLCzECy+8gFmzZsHtdusdGnWisrISs2bNwqxZs/QOpd/dfffdeOutt7B27Vq9Q+mWrgnAZZddhqamJsydOxf19fUYPXo0Fi9erA0MrqmpSbni/9vf/haSJOG3v/2tVnFi8uTJuP/++/V6CUSUJk1NTVizZg1isRgr8RCA7wZrdzcZWzgchs/nQ0NDAwwGA5xOJ0pLS1FcXAyn0wmHw5H5A76jUWDlSsDv779jOp3AuHEDJgk46aSTUFdXh4KCAr1DyQqSJOEf//hHShfsdFq1alWvJlHcM8HLFJ29j7fccgtuuOEG/YLqId3/K15//fVddvn56KOPUh4bjUbcdddduOuuu/ohMiLqL5FIBBs3bkQsFkN5ebne4VAGsVqt2kzw8XgcgUAA27ZtQ3V1tTbYuKioCMXFxXA4HHA4HLDZbJl1dykeTzT+zWagP7q0RiKJ48XjAyYBMJvNWfO/QVEUSJKUFWObYrFYp3fcBg8erEM0ie7giqLomvQ7nU44nU7djt9Tmf/bR0QZb9u2bWhubu50BnCinjIajSgoKMCwYcNQUVGhzVBcV1eHNWvW4H//+x+WLVuG5cuX45tvvkFtbS08Hg/i/dm1Zn9YLIDV2vdf+5BkqKqK+fPn48ADD4TNZsOoUaPw+uuva89/9NFHkCQJ7777Lo499lhYrVaceOKJ2LBhg7bOjh07MHnyZBQVFcHhcODoo4/Ge++9l7J9d11+nn76aRx88MEwm804/PDD8dJLL6U8L0kS/vjHP+LCCy+E3W7HoYceirfffrvb11VZWYl7770XV1xxBRwOB4YNG4annnoqZZ1HH30UI0eOhMPhQEVFBX71q1/B3+5uzQsvvIDCwkK8/fbbOOqoo2CxWFBTU4NVq1bhrLPOQklJCQoKCnDqqafiyy+/7BDzM888g/POOw92ux1HHnkkVqxYga1bt+K0006Dw+HASSedhOrq6pTt/vnPf2LMmDGwWq046KCDMG/ePO33vLKyEgBw4YUXQpIk7fHetkvG8/TTT+NHP/oRHA5Hlz0wKisrsXDhwh6999u3b8fpp58OACgqKoIkSbj66qsB9Pz36v3338fxxx8Pi8WCP//5z5AkqUNJ+d///vc4+OCDtccbNmzAD37wAzidTpSVleHKK6+Ey+XSnj/ttNNw44034rbbbkNxcTHKy8tx9913p7zGzt7Hu+++G6NHj9bWU1UV99xzD4YPHw6LxaL1dknavn07JEnCm2++idNPPx12ux2jRo3qck6sdGECQES6crlcqK6uxqBBg7LiihgNHGazGQUFBSgvL8eIESMwdOhQ2O12BAIBVFVVabPIf/LJJ1izZg22b9+O5ubmlMpx1DPz58/HX/7yFyxatAhff/01brrpJvz0pz/Fxx9/nLLerbfeigULFmDVqlVaN95YLAYAmDFjBiKRCD755BN89dVXeOihh3p8JfUf//gHZs6ciZtvvhkbNmzAL37xC0ybNg0ffvhhynrz5s3DpZdeivXr1+Pcc8/FlClT0NLS0u2+f/e732HUqFFYs2YN5syZg5kzZ2LJkiXa8waDAY8//ji+/vprvPjii/jvf/+L2267LWUfwWAQDz30EP74xz/i66+/RmlpKXw+H6ZOnYpPP/0Un332GQ499FCce+658Pl8Kdvee++9uOqqq7B27VocccQR+MlPfoJf/OIXuOOOO/DFF19ACJHSk2LZsmW46qqrMHPmTGzcuBHPPPMMXnjhBa2xvmrVKgDA888/j7q6Ou3x3rZLuvvuu3HhhRfiq6++ws9+9rOenJ5u3/uKigq88cYbAICqqirU1dXhscceA9Dz36s5c+bgwQcfxKZNm3DxxRdj7NixePnll1PWefnll/GTn/wEQKLS3BlnnIHjjjsOX3zxBRYvXoyGhgZceumlKdu8+OKLcDgc+Pzzz/Hwww/jnnvu0c59V+/jnh577DEsWLAAjzzyCNavX49JkybhRz/6EbZs2ZKy3m9+8xvccsstWLt2LQ477DBcccUVfXpxQrcyoHrxer0oKChgGVCiASAWi+GLL76Ay+Viv3/SRTQaRSgUQigUQjQahcFggN1uR35+PgYPHqzdzu+PbkNdlvYLBoFPPgHy8hJX6PtaOAz4fMAppwB2+15Xj0QiKC4uxgcffIAJEyZoy6+99loEg0G88sorWh/vV199FZdddhmARMWv4cOH44UXXsCll16KY489Fj/+8Y877ea7t0HAJ598Mo4++mg8++yz2jaXXnopAoEA3n33XQDQxhDee++9AIBAIACn04n3338f55xzTqevrbKyEkceeSTef/99bdnll18Or9er3Z3Y0+uvv45f/vKX2tXkF154AdOmTcPatWsxatSoLt9HVVVRWFiIV155Beedd16nMX/22WeYMGEC/vSnP2mN71dffRXTpk1DKBQCAEycOBFnnnkm7rjjDm3ff/3rX3HbbbehtrZW2++efdd7ut2sWbPw+9//vsvXkXzf2g8C3tt739kYgN78Xr311ls4//zztXUWLlyIJ598Elu3bgUAbN68GYcffjg2bdqEI444Avfddx+WLVuGf//739o2u3btQkVFBaqqqnDYYYfhtNNOg6IoWLZsmbbOuHHjcMYZZ+DBBx/s8n3ccxDwsGHDMGPGjJRJa8eNG4cTTjgBTz31FLZv344DDzwQf/zjH3HNNdcAADZu3Iijjz5ai3dPGV0GlIiopqYGdXV1GDZsmN6hUI4ym83anQIg0T87FAqhpaUFdXV1kCQJVqsVeXl5GDx4MPLy8pCXlwe73Z5Z4wj60NatWxEMBnHWWWelLI9GozjuuONSlrVvyBUXF2uNMgC48cYbMX36dPznP//BxIkT8eMf/xjHHntsj2LYtGkTrrvuupRlJ598snYlOan9/hwOB/Lz89HY2NjtvtvHnHzcvnvLBx98gPnz5+Obb76B1+tFPB5HOBxGMBiEvS2BMpvNHV5LQ0MDfvvb3+Kjjz5CY2MjFEVBMBhETU1NlzEni6SMHDkyZVk4HIbX60V+fj7WrVuH5cuXp1y5VxSlQ0x76ul2Y8eO7fb96kpv3/ve/F7tGdPll1+OW265BZ999hlOPPFEvPzyyxgzZozWmF63bh0+/PDDTu8wVVdX47DDDusQMwAMGTJkr78v7Xm9XtTW1uLkk09OWX7yySd3mCyx/bGGDBkCAGhsbOw0AUgHJgBEpAuPx4OtW7eisLAw86u0UNaQZTllEJ+qqloZ0qamJgghtAnLBg8eDJvNps1D0/67wWBAQUEBCgoKsr5rW7K/+7vvvtshme/NPDzXXnstJk2ahHfffRf/+c9/MH/+fCxYsCCtFVX2vFoqSRJUVd3n/W3fvh3nnXcepk+fjvvvvx/FxcX49NNPcc0112gTngLo9A7S1KlT0dzcjMceewwHHHAALBYLJkyYgGg02mXMyX10tiz5Ovx+P+bNm4eLLrqoQ7zWbu4g9XS73lT3aa+3731vfq/2jKm8vBxnnHEGXnnlFZx44ol45ZVXMH369JR9T548GQ899FCH4yYb3/sS8/7o7pz2BX7qElG/UxQFW7duRTgcRklJid7hEHXJYDBo1YOAROM+eUW0qqoKQghIktThu6qqMJlMKCgowNChQ1FcXJy1yUD7ga2nnnpqt+t+9tlnGDFiBACgtbUVmzdvxpFHHqk9X1FRgV/+8pf45S9/iTvuuAPPPfdcjxKAI488EsuXL8fUqVO1ZcuXL8dRRx21j68qNeY9HydjXr16NVRVxYIFC7Rz+3//93892u/y5cvxhz/8Aeeeey4AYOfOnSmDUPfVmDFjUFVVhUMOOaTLdUwmU4c5NXqyXV8xt1Wbah9Tb36vOjNlyhTcdtttuOKKK/Dtt9/i8ssv154bM2YM3njjDVRWVu7XBajO3sf28vPzMXToUCxfvjzlNSxfvhzjxo3b5+OmAxMAIup3tbW12LlzZ9aU9aPcIUkSbDYbbDbbXteNRqPwer1Yv359SjJgNpuhKApUVYWiKIjFYlo5RavV2uXM9gNVXl4ebrnlFtx0001QVRXf+9734PF4sHz5cuTn56c0yu+55x4MGjQIZWVl+M1vfoOSkhKt//SsWbPwgx/8AIcddhhaW1vx4YcfpiQH3bn11ltx6aWX4rjjjsPEiRPxr3/9C2+++SY++OCD/X59y5cvx8MPP4wLLrgAS5Yswd///ndtXMEhhxyCWCyGJ554ApMnT8by5cuxaNGiHu330EMPxUsvvYSxY8fC6/Xi1ltv7dHv1d7MnTsX5513HkaMGIGLL74YBoMB69atw4YNG3DfffcBSPTRX7p0KU4++WRYLBYUFRX1aLu+csABB0CSJLzzzjs499xzYbPZevV71ZmLLroI06dPx/Tp03H66aenjDObMWMGnnvuOVxxxRValZ+tW7fi1VdfxR//+MceTy7b2fu4p1tvvRV33XUXDj74YIwePRrPP/881q5d22GQcn/LvksRRDSgBQIBbN68GQ6HIztnbCVqYzabUVJSghEjRmDQoEEIBoP46quvsHr1aqxduxbr16/Hxo0bUV1djV27dqG6uhpNTU2ora2F2+3u0BUEkUhigG5ff+1DFaR7770Xd955J+bPn48jjzwS55xzDt59910ceOCBKes9+OCDmDlzJo4//njU19fjX//6V8rV3xkzZmjbH3bYYfjDH/7Qo+NfcMEFeOyxx/DII4/g6KOPxjPPPIPnn38ep512Wq9fy55uvvlmfPHFFzjuuONw33334dFHH8WkSZMAAKNGjcKjjz6Khx56CMcccwxefvllzJ8/v0f7/dOf/oTW1laMGTMGV155JW688ca0lEKeNGkS3nnnHfznP//BCSecgBNPPBG///3vccABB2jrLFiwAEuWLEFFRYXWn74n2/WVYcOGYd68eZgzZw7Kysq0qkY9/b3qTF5eHiZPnox169ZhypQpKc8lr8orioKzzz4bI0eOxKxZs1BYWNiru3SdvY97uvHGGzF79mzcfPPNGDlyJBYvXoy3334bhx56aI+P0xdYBYiI+o2iKPjqq6+wbds2VFRUcBAl0R6MRiNsNhsURYHJZILT6USexQLzunUwhcP9F0iaZwLO1Jle96xmQzQQsAoQEWWMSCSCTZs2Ydu2bSgtLWXjn6gTyS5GsiwjGo3C4/HALQRMZWWwyDKsVqtWuchkMvW4q0KvGY0DZhZgIko/JgBE1Of8fj82bNiA2tpaDBkyRLvlT0RdSzb0hRCJ0pKxGPzBIBAMwmAwwGg0wmq1wm63a+uyohYR9QT/UxBRn2pubsaGDRvQ2tqKYcOGsYFC1EuSJMFkMqXc6ldVFbFYDH6/H16vF0CiIonFYoHD4UhJCAbC3bbTTjst4wY3A4kyn0TZiJ/ERNRnamtrsWHDBkQiEQwfPnxANESIsoHBYIDFYtHqoQshEIvFEAqFtPrpRqMRFosl5Q6B2Wzm3yERMQEgovRTVRXbt2/Hxo0bYTKZUsqvEVH6SZKkNfABaN2GIpEIAoEAgMQkZyaTCTabDRaLBUajESaTCUajse/GEhDRgMQEgIjSrq6uDhs2bEBeXh6rbRHpoLNuQ/F4HPF4HB6PR5thNDmWwGw2awOMk9uxux7RwJSO7nT86yaitFIUBTt27IDJZGLjn6iXkpOD9cUVeaPR2KFRrygKFEVBOBzWug5JkqTdHbDZbFpSkNw+G2czJsokyTlC9uf/BBMAIkqr5uZmuFyutExoQ5RrFEWB3++H0+nst245sixDlmVtPEEyCWmfFADQugolBxsnkwKr1cpxBUT9QAihzTBut9v3KxlnAkBEaSOEwM6dO7XuB0TUe5FIBPF4fMBdaY9EIlBVVUsQgEQXovZ3Csxm84CLmyjb2O12FBQU7Nc+mAAQUdq43W7U19ejuLhY71CIMlqya85AZDAYtEZ+crKyUCgEg8EAp9OJ0tJSFBUVIT8/n3N+EKWZLMtpSbKZABBR2tTV1SEWi8FqteodChH1A7PZrCX88Xgcfr8fW7ZsAQA4nU6Ul5ejpKQERUVFTAaIBhBJZOLMHPvB6/WioKAAHo+HAxSJ0igQCGD58uUwm83Iy8vTOxwi0lFyLIPP54MQAnl5eSgrK9OSgeR4AyLSB+8AEFFa1NfXw+/3Y8SIEXqHQkQ6k2UZBQUFKCgo0JKB6upqVFdXw+FwYPDgwRg8eDCKiopgs9n0Dpco5zABIKL9Fo1GsWPHDuTn57MaCBGlaJ8MqKoKv9+PHTt2YNu2bbDb7SgpKUFpaSkKCwvhdDr1DpcoJzABIKL91tjYCI/Hg+HDh+sdChENYAaDAfn5+cjPz4cQAoFAAHV1ddixYwfsdjuKiopQXl6OwsJC5OXl8YICUR9hAkBE+0VRFNTU1MBqtbL8HxH1mCRJcDqdcDqdEEIgFArB5XJh165dsFqtKCoqwpAhQ1BYWJhSVrh9UrDnbMdE1DNMAIhov7hcLjQ1NaG8vFzvUIgoQ0mSBLvdDrvdDgAIh8PweDyoq6uDxWLRLi60b/wnZywuLi5GcXEx8vLykJeXx4SAqAeYABDRPhNCYNeuXTAYDDAa+e+EiNLDarVq5YRjsViXcyJEo1HU1tZi+/btMBqNWjeiQYMGMSEg6gY/sYlon3HiLyLqa91187FarVpJ73g8jmAwqI0pSCYEgwYNSrlDwIsVREwAiGg/cOIvIhoojEajNsAY+C4h2L17N7Zt2waTyaTdISgoKNC6HNntdiYFlHP4G09E+0RRFDQ0NHDSLyIakPZMCGKxGILBIGpra7Fjxw4IIWA2m7W7CMnBxkajsdsvomzA32Qi2ieBQADBYJDdf4goI5hMJm0+gqRIJIJIJAKXy4Xa2loIIVIGGsuynPJlNBphsVhSvtonB8l19lzGcqY00DABIKJ94vP5EI1GYTab9Q6FiGifJBvxybsE7QkhoCgK4vE4VFXVfg6Hw1AUBYqiQFVVCCG0bSRJ6pA0yLIMs9mckjS0v9PQWdJgNBqZNFCfYgJARPvE4/FAlmW9wyAi6hPJMqO96fbTWdKgKAp8Ph/cbre2rH3SAKDDXQaDwQCz2awlDlarVUsa2icMJpNJe46oN5gAEFGvCSHgcrlgs9n0DoWIaMDYl6QBQIeEIR6PIxAIwOv1assApCQOyfLLFosFNpsNTqcTeXl5WglVu90Oi8WS1tdH2YMJABH1WrL/PwcAExHtv30ZXKyqKmKxGKLRKHw+H1paWhCPxwEk7ihYrVbk5eVh0KBBcDqdcDgccDgcvHNLAJgAENE+8Pv9CIfDKCkp0TsUIqKcZDAYtDEFe16MSY5VcLvdaGhogKqqMJvNWhnUwsJCLSGw2Wwcb5CDmAAQUa/5fD5IksQPDSKiAchoNMLpdMLpdGrLIpEIQqEQdu/eje3bt0OSJK2r0KBBg5Cfn68lBftS3EFVVUSjUUQiEcRiMRgMBsiyrH1P/swBzgMDEwAi6jWXy8XJv4iIMkjybkGSqqoIh8MIhULYsmULVFWF0WiEzWZL6Tpkt9shSZI2NqH9OIV4PA6/349gMIhQKIRoNKotB6A1+pNfyQHMDocDTqcTNpsNFoslpUoS51roH3yXiahXQqEQfD4fBwATEWUwg8GgzYScFI/HEQqF0Nraivr6egghYDKZtARAVVUA3w1GTpY9TVYostvt2s9CCKiqqn0lt4/FYmhqasLu3bu1/SSrHplMJm1As9Pp7DDnQjIW2n9MAIioV/x+P0KhEIqKivQOhYiI0shoNCIvLy9lTEE0GgUA7Qp+TxvgkiTBYDD0aF1FUboc0CxJEkwmk1YWNS8vD06nE1artUOCwOSg55gAEFGv+P1+CCF6/I+diIgyV39M9pgcI9BZ11IhhJYcRCIR+Hw+xONx7e6ByWTSEgSHw4G8vDyta1H7L1Y/SsUEgIh6xeVycfZfIiLqF5IkaVf/O5NMDmKxGFwuF2pra7XkIDkLs8lkgt1u18qhdta1KNcwASCiHotGo/B4PCl9RomIiPSSvAPQmXg8riUIHo8HTU1N2qRq7ROLZCnVzsYdmM3mrOxaxASAiHosWe2hrKxM71CIiIi6lZyVubOiFcmypbFYDMFgEB6PB7FYDMB3MzonE4T2syzvmSBkandYJgBE1GN+vx+KorBMGxERZTSDwQCr1brXcQexWAwNDQ3YtWuX1rXIaDRq4w7sdjvy8vJgt9u1pCA5v8JAxk9xIuqxlpaWnOwrSUREuWNv4w7i8Tii0Sii0ShaW1u12ZaTBTIKCgowduzYlInYBhomAETUI/F4HC0tLQP+qgYREVFfSnYt6uzzMBKJoLW1VZszYaDKzI5LRNTvkvX/mQAQERF1LlPGBGRGlESkO7/fj1gsxi5AREREGY4JABH1iMfjyZgrG0RERNQ1fpoT0V6pqgqXy8XuP0RERFmACQAR7VUgEEAwGOy0ljIRERFlFiYARLRXfr8fkUik03rJRERElFmYABDRXnm93qycCp2IiCgXMQEgom4JIeByuXj1n4iIKEswASCiboVCIfj9fg4AJiIiyhJMAIioW4FAAOFwmHcAiIiIsgQTACLqVjAYhBCCcwAQERFlCX6iE1G33G43jEaj3mEQERFRmjABIKIuqaoKt9vN+v9ERERZhAkAEXUpFAohFAqx/z8REVEWYQJARF1KDgC2WCx6h0JERERpwgSAiLoUDAYBgJOAERERZREmAETUJbfbDZPJpHcYRERElEZMAIioU4qioLW1lf3/iYiIsgwTACLqVCgU4gRgREREWYgJABF1KhAIIBKJcAAwERFRlmECQESd4gBgIiKi7MQEgIg61draygHAREREWYgJABF1oCgKZwAmIiLKUkwAiKiDYDDIAcBERERZigkAEXXAAcBERETZiwkAEXUQDAY5+JeIiChLMQEgog5aWlpgNpv1DoOIiIj6gO4JwFNPPYXKykpYrVaMHz8eK1eu7HZ9t9uNGTNmYMiQIbBYLDjssMPw3nvv9VO0RNkvHo/D4/Gw/z8REVGWMup58Ndeew2zZ8/GokWLMH78eCxcuBCTJk1CVVUVSktLO6wfjUZx1llnobS0FK+//jqGDRuGHTt2oLCwsP+DJ8pSyQHAxcXFeodCREREfUDXBODRRx/Fz3/+c0ybNg0AsGjRIrz77rv485//jDlz5nRY/89//jNaWlrwv//9T6tPXllZ2Z8hE2W9QCCAaDTKLkBERERZSrcuQNFoFKtXr8bEiRO/C8ZgwMSJE7FixYpOt3n77bcxYcIEzJgxA2VlZTjmmGPwwAMPQFGULo8TiUTg9XpTvoioa4FAAAaD7r0DiYiIqI/o9invcrmgKArKyspSlpeVlaG+vr7Tbb799lu8/vrrUBQF7733Hu68804sWLAA9913X5fHmT9/PgoKCrSvioqKtL4OomzDAcBERETZLaMu86mqitLSUjz77LM4/vjjcdlll+E3v/kNFi1a1OU2d9xxBzwej/a1c+fOfoyYKLPEYjH4fD4OACYiIspiuo0BKCkpgSzLaGhoSFne0NCA8vLyTrcZMmQITCYTZFnWlh155JGor6/vss+yxWLhZEZEPZQcADxo0CC9QyEiIqI+otsdALPZjOOPPx5Lly7VlqmqiqVLl2LChAmdbnPyySdj69atUFVVW7Z582YMGTKEXRaI0iA5ADg5yJ6IiIiyj65dgGbPno3nnnsOL774IjZt2oTp06cjEAhoVYGuuuoq3HHHHdr606dPR0tLC2bOnInNmzfj3XffxQMPPIAZM2bo9RKIskogEOAMwERERFlO1zKgl112GZqamjB37lzU19dj9OjRWLx4sTYwuKamJqUaSUVFBf7973/jpptuwrHHHothw4Zh5syZuP322/V6CURZpbm5mf3/iYiIspwkhBB6B9GfvF4vCgoK4PF4kJ+fr3c4RANGNBrFJ598AqPRiLy8PL3DISIiyjixWAzNzc34/ve/P6DbmRlVBYiI+k5yALDNZtM7FCIiIupDTACICECi/38sFoPRqGvPQCIiIupjTACICEDiDgBnACYiIsp+/LQnIgCJBIBX/4mIiLIfEwAiAgD4/X7W/yciIsoBTACICIqiIBwOMwEgIiLKAUwAiAiRSATxeJwJABERUQ5gAkBEiEajiMViTACIiIhyABMAIkI0GkU8HucgYCIiohzABICIEI1G9Q6BiIiI+gkTACJiAkBERJRDmAAQEYLBIGRZ1jsMIiIi6gdMAIgIgUCAA4CJiIhyBBMAohynqipCoRATACIiohzBBIAox8ViMUSjUSYAREREOYIJAFGO4xwAREREuYUJAFGO4yzAREREuYUJAFGOi0ajEEJAkiS9QyEiIqJ+wASAKMdxDgAiIqLcYtQ7ACLSVzgc5tV/6poQMAQC3z2WJMBggEj+zhgMEAaD9jMMvK5ERDTQMQEgynGcA4A6JQSMbjdM9fUwNTcDQiQa/wAgSd81+iUp8bh9YmAwQLXZEB0yBEpBgX6vgYiIOsUEgCjHMQGgFO0b/k1NAAAlPx+ibaZoSYhEMtD2tedjg6oCsRhkrxem5mZEhg5FdOhQCItFz1dFRETtMAEgymGxWAyxWAxms1nvUEhvqgqjxwNzbS2Mzc0AAKWgAGKP3w2xx2Z7Pm7PEAzCun17IhEYMQKxkhJ2ESIiGgCYABDlsGg0img0CqvVqnco1N/iccjBIAzBIGSfD0avFwa/H5CkThv++0K126FarTB6vbBv3IhoWRmiw4ZBNZthiERgiEYhRSIwhEKQ/X4IsxmRYcOgFBbu/+sjIqIuMQEgymGcBCzHKApMTU0wtrRA9vthCIchKUqiz77VCqWoCCLdvwsGA+KFhZBiMZgaG2FqboaQZUjRqNZ9SBiNECYTJJ8PxtZWRIYMQWzoUKg2W3pjISIiAEwAiHJaJBKBqqqQ2/p3U/aSYjFYtm+HZdcuCLMZqsWCeFERYOyfjwFhMiFeWgopHE48zs/vtDuQFA7DWlMDs8uFyPDhiJaV9X2M8TiMXi+gqogXFvbZ8aRoNHGno22QNMdFEJFeevRf7u233+7xDn/0ox/tczBE1L84B0BukMJh2KqrYWpoQHzQoLR079lXYi/dzYTVilhZGWS/H7aqKpgaGxGpqIDidCbiTtcYAlVNdH1qbYXJ5YIhEICkqlDy8xEdMgSx4uK9xtoTUjgMo88H2e2GsbUVcjAIIUkQFgtUmw3x/PxEVymbDarFAmE0AkzIiaiP9SgBuOCCC1IeS5IEIUTK4yRFUdITGRH1uUgkwjkAspzs88G6dSuMbjdigwf32xX//SJJUPLyoDgcMLrdcHz1FVSrFcJkgmKzQc3Lg2qxJBrMZjNUs3nvr0sISNEoDNFookJRYyNknw+SokC12xEfNAiQJMg+H2xVVbDY7YiWlSE2eDBUh6Nncatq4hht4xqMra0wejwwhEKAwQDF4UicAyCxTjAIq9sNqCqELEOYzYnvRiNUq1V7fcJkgmqzQbHb9T9/ipIYsxEKJcaMCAHV4UgkMFarrsklEfVcj/6TqKqq/fzBBx/g9ttvxwMPPIAJEyYAAFasWIHf/va3eOCBB/omSiLqE8FgEEa9GxTUZ4zNzbBWV8MQDiNWWpp5FXgMBsSLi79rWMdiMLndQFMTJCEScw6YTFBNpkQj2emEYrNpDWkpFtMa2nIgACkehxSLQYrHIaxWKIWFHcY8KAUFUPLzYQgEYP32W5jr6hArKUmMR9hjrgNhMECKx2EIh2EIBCCHQon9R6OQVDXRkHc4EMvP/24OhTaqzQbYbNAumSkKDNFo4nskAjkYhBSPA22fv0KWE+M0CgoQLyiAarf3T0KgqonxIsnB4h5PYuxILJZ4/W3rCFlO3NWw2xPx2WzaeRFmc+LOBi82EA0Yvf7PMWvWLCxatAjf+973tGWTJk2C3W7Hddddh02bNqU1QCLqO4FAgAlANhICpoYG2KqrAQDxtqvOGctgSDTY9+ySo6pao94QiUD2+2FO3oVuN3GZaNcQVRyOvTeaJQmq0wnV6YQhFIKltva7uQ6Sjdjkz23fk8dQrdYuxzd0S5a7H/TclmiYGhthrq39LiHIz4eSn5+4Q5AcV5CGhrYUDsPodsPc0ADZ600kI8lj5uV1vNKfTFx8PsjNzZDQViK2bYC32nYXI3mXIHmnA7Kc+FmWtXNERH2v15/81dXVKOykRFtBQQG2b9+ehpCIqD8oioJwOMwKQBlAisV6dAVVikQSk3g1NsLY0gJhs0HJy+unKHVgMCQak33YaFRttoFRjcho1JISAN8lBE1NMNfXJ8YVmM3fXYF3OFK6SfUoKWgbDG1sboapuRmGYBDCYkmUhd3b/wlZToxlsNu/W5ZM0BQFhlgscYckHk8kTUlCJGaVbksI4nl5UIqKoDgcPUvW+pMQidcTjwOKor02AB3f37bZsoUsJ35P25IcGAyJ/SjKd++Pqmr7US0WqFZr5t2to4zT67+sE044AbNnz8ZLL72EsrIyAEBDQwNuvfVWjBs3Lu0BElHfSJYAdfS0fzPpQvZ4YN26FTAaES8ogOJ0ftcoNRgSXTS8XhhbWmByuSAHAom+8oWFvJqazfZMCFRV6+5kaW1NXIE3GBJX3y2WRPeotnkZAEBSFEiqmmjIRqMwxOMw+P2Qfb7E7pxOxMrL9+9uQjJBA4Dukqi2BrDU1sXL3NioVUqKFxUlxoO0/d7vzwBpg98PU1MTDOFw4nW1fYnknSJJgiREoltTMklR1cQM18muXYqSaKwnv4s9psJL3hVq2x/aEndhMGiJQDIBkFQ1sX9FSZTEBbTzpeTnJ16z1aqNB+HgcEqnXicAf/7zn3HhhRdixIgRqKioAADs3LkThx56KN566610x0dEfYRzAAx8UiQC67ffwuj3QzWbEw07IbRBofH8fMihEGSPB1I8DsXpzMy+/rT/2hrMKQ3ttnEFhlgMckMDzPF4aoO+bRyFJElal5x4cXH/X3VvG08hTKbv7iC03eEw19dD2rVL+52PFRVBbRsgro3L6I4QkH0+mBoaYG5shBSNfpcYJ7t1dSW572QDPjlA22JJNORlufvjtzXwpT2+I3m3pt0dAu3OQNtAdVNDA8y7dyfCtFigGo0QFgviDgdE2zgXNdnljBM50j7o9V/5IYccgvXr12PJkiX45ptvAABHHnkkJk6cyGoiRBkkGo0iHo9zDMBApaqw1NTA1NqaqIXfrlEvRaMwhMOw1NVByHLPumhQ7kmOKxgIXZh6a487HFIslhiPsWsXJEVJdE2y2RAvLEzMqdBWDUrrEiYEZI8H5vp6mFyuRIKcnw+1uLj/XkPyqn/bw25SjYS28rCKxQIku+61JQVSPJ64u+P1at2FBBLJQbygAPHi4sQdA4eDg62pR/bpk1+SJJx99tk45ZRTYLFY2PAnykCRSETvEKgb5vp6WHbtQmzQoA5X9IXZDMVsBosuU64QJhOUZJKbvFIeCsFaU/NdlxujUbtCD1mG7HYDAJT8/MyddK0tKeg0/rZuX6aWFpgbGhLvkcOBWEkJlLw8qHY7uwFSl3qdAKiqivvvvx+LFi1CQ0MDNm/ejIMOOgh33nknKisrcc011/RFnESUZpwEbOCS3W5Yt2+H6nDwA5xoT+2ulKckwfE4DG0VoSRVTdwZy+a/n7ZuX8lB6lI0CkMwCNvWrYkuVVYrFLtdu0uiJseAtI0d0sYytA1mllQ1pcSt9n2PZbzDkB16nQDcd999ePHFF/Hwww/j5z//ubb8mGOOwcKFC5kAEGWIYDAImYPKBhwpHIZ12zZI8TjiRUV6h0OUOYxGqEZjZnZ5SoOUO4NtZVmNPh9MLpf2vGq1avNXpAxEjse/K92abOi3/ZxMArTvbWMhtK+2eR46Le3atnyv4yWo3/U6AfjLX/6CZ599FmeeeSZ++ctfastHjRqljQkgooEvEAhwAPBA09bv3+h2JwbzEhHtiz3LsgqRGEcRDicKCbTNPN3ZQGQI8d2g5bbHyZ+lZOnScPi7Qc7tqyElKyq1q3qklUJtG6ehGo2J+SGMxo53G2Q55bG2bdu6lD69TgB2796NQw45pMNyVVURi8XSEhQR9S0hBEKhEBOAAcZcVwfL7t2JSiz8sCOidGmrPKTsrUtUsjxqu8HLQA8GMO8pWSY1WeJVVSEFApB9vu8Shj0n1wO0ylTJOwYi+d1oTExCZ7dDWK3a5HJiz0SiH+80JGcVV02mjLzD0esE4KijjsKyZctwwAEHpCx//fXXcdxxx6UtMCLqO8kSoOZs7h+bYYytrbDu2MF+/0SU+ZJX/rEPycOe5VPbJmAzer0wNTd/V0oVSJSsTd4tSN45MBoTjXKTKVE+1Wz+bp3k+u26KKHdXYruSOEw5FAIhmAQsscD2e+HIR5PzMqdnG/DZoNBlmHx+xNxDmC9TgDmzp2LqVOnYvfu3VBVFW+++Saqqqrwl7/8Be+8805fxEhEaZZMAJzJSYRIV8bWVli3bAFUNbtn7iUi2puelk9Ndj/aY64FKRyGHAxqz4v2k7u1TdSmdTdqP1Nzu2XJcQui7S6E0e+HIRiE1DbAXJjNiQnb7PbUma5dLpii0USRDb8fKCzsj3dsn/Q6ATj//PPxr3/9C/fccw8cDgfmzp2LMWPG4F//+hfOOuusvoiRiNIsmQBwDgD9GVtaYNu8OTHod9AgvcMhIsoMyav+2I+7DO1mxDZEo4lxDu27J7WNe9Aa/Hl5Hcsy77FrJRyGtGvXPr+s/rJPn/7f//73sWTJknTHQkT9JBqNQggBA/uZ68rocsG2ZQskVWXjn4iov7TrLtTr5CFL9PrT/6CDDkJzc3OH5W63GwcddFBagiKivsU5APRnamqCffNmSEIkBv0SERH1k17fAdi+fTsUpeP8k5FIBLt3705LUETUt0KhEGfw1pGpoUGbrEcZwH1EiYgoO/U4AXj77be1n//973+joKBAe6woCpYuXYrKysq0BkdEfYNzAOgkHoe5qQnW6moIoxFKu/+jRERE/aXHCcAFF1wAAJAkCVOnTk15zmQyobKyEgsWLEhrcETUN5gA9CNVhez3w+h2w9TYCNnng+pwsNoPERHppscJgNpWz/TAAw/EqlWrUFJS0mdBEVHficViiMViTAD6mCEUguzxwNzYCNnrhRSLQbXbEzP8cvA1ERHpqNdjALZt29YXcRBRP0mWALVarXqHkrWMra2wbd4MQyAA0VY6jpN7ERHRQNHry1A33ngjHn/88Q7Ln3zyScyaNSsdMRFRH+IcAH1MCJjq62EIhxErL0e8uJiNfyIiGlB6nQC88cYbOPnkkzssP+mkk/D666+nJSgi6jvRaBTxeJwJQB+R26arjxcWJmadJCIiGmB6nQA0NzenVABKys/Ph8vlSktQRNR3otEoS4D2IVNjI6R4nFf9iYhowOp1AnDIIYdg8eLFHZa///77nAiMKANEIhEmAH3E4PfD5HJByc/XOxQiIqIu9boPwOzZs3H99dejqakJZ5xxBgBg6dKlWLBgARYuXJju+IgozQKBALv/9BGTy5Xo+8/JvYiIaADrdSvgZz/7GSKRCO6//37ce++9AIDKyko8/fTTuOqqq9IeIBGlFxOAviGFwzA3NEBxOvUOhYiIqFv71AqYPn06pk+fjqamJthsNjj5gUeUERRFQTgc5hwAfcDU0gJDIIBYebneoRAREXVrn2ajicfj+OCDD/Dmm29CCAEAqK2thd/vT2twRJReyRKgTADSS4rFYK6thWq3s/IPERENeL2+A7Bjxw6cc845qKmpQSQSwVlnnYW8vDw89NBDiEQiWLRoUV/ESURpkCwBamaFmrQytrRA9vkSs/wSERENcL2+AzBz5kyMHTsWra2tsNls2vILL7wQS5cuTWtwRJRenASsDygKzPX1ibKfhn26qUpERNSvet0KWLZsGf73v/91uIJYWVmJ3bt3py0wIkq/SCSidwhZx9jaCtntRry4WO9QiIiIeqTXl6tUVYWiKB2W79q1C3l5eWkJioj6RjQa1TuE7CIEzA0NiSv/vKtCREQZotcJwNlnn51S71+SJPj9ftx1110499xz0xkbEaVZMBiELMt6h5E1ZI8HxpYWTvxFREQZpdeXrBYsWIBJkybhqKOOQjgcxk9+8hNs2bIFJSUl+Nvf/tYXMRJRmgQCAQ4ATiNTUxOgKIn+/0RERBmi1wnA8OHDsW7dOrz22mtYt24d/H4/rrnmGkyZMiVlUDARDSyqqiIYDHIAcJpIkQhMLS1QOQ8KERFlmB61BMaMGYOlS5eiqKgI99xzD2655RZMmTIFU6ZM6ev4iChNkhWArFar3qFkBdnngyEYZOlPIiLKOD0aA7Bp0yYEAgEAwLx58zjhF1EG4iRg6WVsaQFkmaU/iYgo4/ToDsDo0aMxbdo0fO9734MQAo888gicXdz2njt3bloDJKL0YAKQPlI4DFNLCxSHQ+9QiIiIeq1HCcALL7yAu+66C++88w4kScL777/faT9iSZKYABANUMk5ACRJ0jmSzGf0+WAIhRBj9R8iIspAPUoADj/8cLz66qsAAIPBgKVLl6KU/V6JMgrnAEgfY3NzovsPkykiIspAvS4HoqpqX8RBRH0sFArBwP7q+00Kh2F0u6Gw+g8REWWofaoHuGXLFnz44YdobGzskBCwCxDRwMQ5ANLD6PWy+w8REWW0XicAzz33HKZPn46SkhKUl5en9CfmGACigUkIgUAgwAHAaWBsboYwGtn9h4iIMlavE4D77rsP999/P26//fa+iIeI+kCyAhDvAOwfQygEo9sNldV/iIgog/W6Q3BraysuueSStAbx1FNPobKyElarFePHj8fKlSt7tN2rr74KSZJwwQUXpDUeomzDEqDpIXu9MITDUDmZGhERZbBeJwCXXHIJ/vOf/6QtgNdeew2zZ8/GXXfdhS+//BKjRo3CpEmT0NjY2O1227dvxy233ILvf//7aYuFKFsxAUgPdv8hIqJs0OsuQIcccgjuvPNOfPbZZxg5cmSHBsWNN97Yq/09+uij+PnPf45p06YBABYtWoR3330Xf/7znzFnzpxOt1EUBVOmTMG8efOwbNkyuN3u3r4MopwSiUQghGAVoP1gCAZh9HhY/YeIiDJerxOAZ599Fk6nEx9//DE+/vjjlOckSepVAhCNRrF69Wrccccd2jKDwYCJEydixYoVXW53zz33oLS0FNdccw2WLVvW7TEikYg2ARIAeL3eHsdHlC04B8D+k9uq/yiFhXqHQkREtF96nQBs27YtbQd3uVxQFAVlZWUpy8vKyvDNN990us2nn36KP/3pT1i7dm2PjjF//nzMmzdvf0MlymjhcJgzAO8PIWByuSA4iJqIiLJARvUH8Pl8uPLKK/Hcc8+hpKSkR9vccccd8Hg82tfOnTv7OEqigYdzAOwfQzAIo9cLhdV/iIgoC/ToDsDs2bNx7733wuFwYPbs2d2u++ijj/b44CUlJZBlGQ0NDSnLGxoaUF5e3mH96upqbN++HZMnT9aWJSciMxqNqKqqwsEHH5yyjcVigcVi6XFMRNlGCAG/388BwPtB9vkghcMQRUV6h0JERLTfepQArFmzBrFYTPu5K73tYmA2m3H88cdj6dKlWilPVVWxdOlSXH/99R3WP+KII/DVV1+lLPvtb38Ln8+Hxx57DBUVFb06PlEuiMVirAC0P4SAqakJghcSiIgoS/QoAfjwww87/TkdZs+ejalTp2Ls2LEYN24cFi5ciEAgoFUFuuqqqzBs2DDMnz8fVqsVxxxzTMr2hW0D8vZcTkQJyRKgNptN71AyErv/EBFRtun1IOB0u+yyy9DU1IS5c+eivr4eo0ePxuLFi7WBwTU1NSxdSLQfOAvw/pF9PkiRCERxsd6hEBERpYUkhBB6B9GfvF4vCgoK4PF4kJ+fr3c4RH2urq4On3/+ObvI7SP7hg0wut2IDxqkdyhERDTAKeEwgrt24Yhrr0X+8OF6h9MlXlonynKcA2DfGUIhyD4fu/8QEVFWYQJAlOUikQjnANhHstcLQzjMAcBERJRVmAAQZblAIACjUffhPhnJ2NICYTQCTKCIiCiL9KhV8Pbbb/d4hz/60Y/2ORgiSj+/388BwPtACodh9HigsvsPERFlmR4lAMka/XsjSRIURdmfeIgojWKxGKLRKOcA2AdGnw+GUAgxFgsgIqIs06MEIDnbLhFllmQJUKvVqncoGUd2uwGDgd1/iIgo63AMAFEWSyYAvAPQO1I0ClNLC6v/EBFRVtqnkYGBQAAff/wxampqOpQYvPHGG9MSGBHtv2g0CkVRIMuy3qFkFDnZ/WfwYL1DISIiSrteJwBr1qzBueeei2AwiEAggOLiYrhcLtjtdpSWljIBIBpAIpGI3iFkJNnthpCkRBcgIiKiLNPrT7ebbroJkydPRmtrK2w2Gz777DPs2LEDxx9/PB555JG+iJGI9hHnANgH8ThMzc0QNpvekRAREfWJXicAa9euxc033wyDwQBZlhGJRFBRUYGHH34Yv/71r/siRiLaR8FgkHMA9FKy+g/7/xMRUbbqdQJgMplgaLstXlpaipqaGgBAQUEBdu7cmd7oiGi/+Hw+DgDuJdnthiQEu/8QEVHW6vWlweOOOw6rVq3CoYceilNPPRVz586Fy+XCSy+9hGOOOaYvYiSifRCPxxGJRJgA9EY8DlNLC1R2/yEioizW60tcDzzwAIYMGQIAuP/++1FUVITp06ejqakJzzzzTNoDJKJ9E41GEY/HmQD0guz3w+D3Q7Hb9Q6FiIioz/T6DsDYsWO1n0tLS7F48eK0BkRE6cE5AHpP9vkgqSrAcRNERJTFen0H4IwzzoDb7e6w3Ov14owzzkhHTESUBsk7ABwE3EOqClNTE7v/EBFR1ut1AvDRRx91mPwLAMLhMJYtW5aWoIho/3EOgN6R/X7IgQBUdv8hIqIs1+NLg+vXr9d+3rhxI+rr67XHiqJg8eLFGDZsWHqjI6J91lmiTl2TfT5IigLBLlNERJTlepwAjB49GpIkQZKkTrv62Gw2PPHEE2kNjoj2XSAQYPefnhIiMfmX2ax3JERERH2ux62Dbdu2QQiBgw46CCtXrsTgwYO158xmM0pLSyHLcp8ESUS9FwgEOAC4hwyhEGRW/yEiohzR4wTggAMOAACoqtpnwRBReiiKglAoxASgh2SfD1IkAlFUpHcoREREfW6f+gdUV1dj4cKF2LRpEwDgqKOOwsyZM3HwwQenNTgi2jfJEqB2XtHuEaPbDcHuUkRElCN6XQXo3//+N4466iisXLkSxx57LI499lh8/vnnOProo7FkyZK+iJGIeomTgPWcFI3C6Haz/CcREeWMXl/ymjNnDm666SY8+OCDHZbffvvtOOuss9IWHBHtG84B0HOy3w9DKIRYu3FNRERE2azXdwA2bdqEa665psPyn/3sZ9i4cWNagiKi/ROJRCCEgCRJeocy4MkeDwQAGHr975CIiCgj9foTb/DgwVi7dm2H5WvXrkVpaWk6YiKi/RQKhdj47wlFgamlBYLdf4iIKIf0uH/APffcg1tuuQU///nPcd111+Hbb7/FSSedBABYvnw5HnroIcyePbvPAiWinvP5fOz/3wNyIABDMIh4YaHeoRAREfUbSQgherKiLMuoq6vD4MGDsXDhQixYsAC1tbUAgKFDh+LWW2/FjTfeOOCvOnq9XhQUFMDj8SA/P1/vcIjSTgiBTz75BLFYDEUsa9ktc20tbFVViJWX6x0KERFlASUcRnDXLhxx7bXIHz5c73C61OM7AMk8QZIk3HTTTbjpppvg8/kAAHl5eX0THRH1WiQSQSQSgdVq1TuUgU0IGDn7LxER5aBelQjZ8+o+G/5EA084HEY0GkVBQYHeoQxohlAIRp+Ps/8SEVHO6VUCcNhhh+21i09LS8t+BURE+yccDrMEaA/Ifn9i9l/2/yciohzTqxbCvHnzeFWRaICLRCJ6h5ARZI8HkGVggI9bIiIiSrdeJQCXX345S30SDXCBQAAG1rTvlhSNwtjayu4/RESUk3rcShjo1X2IKMHr9cJisegdxoAm+/2Qg0GorP9PREQ5qMcJQA+rhRKRjhRFQTAY5BwAeyF7vYkfeKeEiIhyUI+7AKmq2pdxEFEaJCsAsUJXNxQFxpYWqCyTSkREOYqXv4iySDgcRiQSgZm17bskB4OJ7j/s/09ERDmKCQBRFolEIhBCcBBwN2SfD1IsBsFuUkRElKPYSiDKIuFwWO8QBjzO/ktERLmOCQBRFvH5fBwA3A1DKATZ72f5TyIiymlMAIiyiNfrZf//bsh+PwzhMATLpBIRUQ5jAkCUJaLRKAcA74XsdidKf3JeEyIiymFMAIiyBCsA7UU8ztl/iYiIwASAKGuEw2HEYjGOAeiC7PfDwNl/iYiImAAQZYtIJAIAkNi9pVOyzwdJCECW9Q6FiIhIV0wAiLJEMBhk478rQsDkcnH2XyIiIjABIMoarADUNUMgADkQ4Oy/REREYAJAlBVUVYXf72cC0AXZ70/M/sv3h4iIiAkAUTaIRCKIRqNMALpgbG2FMBr1DoOIiGhAYAJAlAXC4TATgC5IkQiMHg+7/xAREbVhAkCUBcLhMBRFgZFXuTtIzv7LAcBEREQJTACIskAkEoEQQu8wBiTZ64UAEjMAExERERMAomzg9/t59b8zigJTSwsEJ/8iIiLSMAEgygIsAdo5ORCAIRiEwv7/REREGiYARBkuHo8jFArBYrHoHcqAI/v9MMRiAO+OEBERaZgAEGW4ZAUgk8mkdygDjrG5GSoTIyIiohRMAIgyXDIB4B2AVIZQCLLfz+4/REREe2ACQJThwuEwhBCQJEnvUAaUZPlPwcSIiIgoBRMAogwXDof1DmFAkt3uROlPJkZEREQpmAAQZTifz8f+/3uKx2FsbWX3HyIiok4wASDKYEIIeL1e9v/fg+z3wxAMQmX9fyIiog6YABBlsGg0ikgkwjkA9mD0eiEJAciy3qEQERENOEwAiDJYOBxGLBZjAtCeosDocvHqPxERUReYABBlsGQCwDEA35EDAciBABSHQ+9QiIiIBiQmAEQZjBWAOpK9XkjxOGf/JSIi6gITAKIMFgqFWP+/PVWFyeWCsFr1joSIiGjAYgJAlMHcbjcrALVjCAY5+y8REdFeMAEgylCxWAyBQABWXu3WGH0+SLEYBAdFExERdYkJAFGGCgQCCIVCTACShIDR5WLjn4iIaC+YABBlqGAwiHg8zgpAbQzBIIxeL7v/EBER7QUTAKIMFQgEOAC4HdnngxSNcgAwERHRXjABIMpQzc3NHADcjrGlBYJ3Q4iIiPaKCQBRBopGo/D7/bBxtlsAgCEUgtHjgcruP0RERHvFBIAoAwWDQYTDYQ4AbiP7fDCEw1D5fhAREe3VgEgAnnrqKVRWVsJqtWL8+PFYuXJll+s+99xz+P73v4+ioiIUFRVh4sSJ3a5PlI0CgQDi8TiMnO0WAGBsbQVkGeCYCCIior3SPQF47bXXMHv2bNx111348ssvMWrUKEyaNAmNjY2drv/RRx/hiiuuwIcffogVK1agoqICZ599Nnbv3t3PkRPpx+/3cwBwGykSgbG1FYrDoXcoREREGUESQgg9Axg/fjxOOOEEPPnkkwAAVVVRUVGBG264AXPmzNnr9oqioKioCE8++SSuuuqqva7v9XpRUFAAj8eD/Pz8/Y6fSA+fffYZPB4PSkpK9A5Fd0aXC46vvkKstBQw6H5Ng4iIcpgSDiO4axeOuPZa5A8frnc4XdL10zIajWL16tWYOHGitsxgMGDixIlYsWJFj/YRDAYRi8VQXFzc6fORSARerzfliyiTJQcAs/9/grG1FUKW2fgnIiLqIV0/MV0uFxRFQVlZWcrysrIy1NfX92gft99+O4YOHZqSRLQ3f/58FBQUaF8VFRX7HTeRnjgD8HekWAzG1laorIZERETUYxl9yezBBx/Eq6++in/84x9dNobuuOMOeDwe7Wvnzp39HCVRegWDQSiKwgHASFT/kYNBlv8kIiLqBV1bECUlJZBlGQ0NDSnLGxoaUF5e3u22jzzyCB588EF88MEHOPbYY7tcz2KxcLIkyiocAPwd2e2GANj9h4iIqBd0/dQ0m804/vjjsXTpUm2ZqqpYunQpJkyY0OV2Dz/8MO69914sXrwYY8eO7Y9QiQaMlpYWdv9BovuPyeWC4NV/IiKiXtG9D8Hs2bMxdepUjB07FuPGjcPChQsRCAQwbdo0AMBVV12FYcOGYf78+QCAhx56CHPnzsUrr7yCyspKbayA0+mE0+nU7XUQ9YdIJMIBwG1kjwdyIJCo/kNEREQ9pnsCcNlll6GpqQlz585FfX09Ro8ejcWLF2sDg2tqamBod3v/6aefRjQaxcUXX5yyn7vuugt33313f4ZO1O+SMwCzhC1gbGlJdP1h9x8iIqJe0X0egP7GeQAok+3atQtffPFFzlezMoRCcKxdC2GxsAIQERENGJwHgIjSjgOAE2SPB4ZwGCq7QhEREfUaEwCiDMIBwACEgKmpCcJsBpgMERER9RoTAKIMEYlEEAgEcj4BMAQCMHo8UDjon4iIaJ8wASDKEJwBOMHY2gopFkvcASAiIqJeYwJAlCE4AzAARYGpqYkDf4mIiPYDEwCiDOH3+1NK4uYi2eeD7PNBcTj0DoWIiChj5XZrgiiDcABwova/JASQy3dBiIiI9hMTAKIMEA6Hc34GYCkahcnl4tV/IiKi/cQEgCgDJGcAtuVw33fZ64UcCEC12/UOhYiIKKMxASDKAIFAAKqqQpZlvUPRjcnlAmQZyPFxEERERPuLn6REGcDn8+X0DMCGUAjG1lbW/iciIkoDJgBEA5wQAi0tLbnd/cfjgSEUgprDYyCIiIjShQkA0QAXiUQQDAZzdwCwEDA3NUFYLEAO3wUhIiJKFyYARAOc3+/P6RmAZZ8PssfD7j9ERERpwgSAaIBzu90QQuTsAGCjywUpFoMwm/UOhYiIKCswASAawIQQaGhoyNn+/4ZQCObGRih5eXqHQkRElDWYABANYH6/H16vF84c7f5ibGlJDP5l7X8iIqK0YQJANIB5PB6Ew+Hc7P8fj8NcXw/VZuPgXyIiojRiAkA0gDU3N8NoNOodhi5Mra2QvV52/yEiIkozJgBEA1Q0GoXL5crN7j+qClN9PYTJxJl/iYiI0oyfrEQDlNfrhd/vhz0H+7/LXm9i5t/8fL1DISIiyjpMAIgGqGT5z1zsAmRqagJUNXEHgIiIiNKKCQDRACSEQGNjY06W/zQEAjC5XFB59Z+IiKhPMAEgGoD8fj88Hk9O9v83trTAEA4nqv8QERFR2jEBIBqAvF5vTpb/lKJRmOvqoDoceodCRESUtZgAEA1ALpcrJ/v+G1taIAcCUJgAEBER9RkmAEQDTM6W/1QUmBsaIMxmlv4kIiLqQ/yUJRpgcrX8p9Hjgex2I87Bv0RERH2KCQDRAJOT5T9VFea6OkCSgFx63URERDpgAkA0gORq+U9jSwuMLheUwkK9QyEiIsp6TACIBpCcLP8Zj8NSWwvIMif+IiIi6gdMAIgGkFws/2lqboaxuRlxXv0nIiLqF0wAiAaQXCv/KcViMO/eDWG1ArKsdzhEREQ5gQkA0QARi8XgcrngyKEa+KamJhg9Hlb+ISIi6kdMAIgGCI/HA7/fnzMJgBQOw7xrF1S7nXX/iYiI+hE/dYkGCLfbDVVVc6YLkLmhITHrb16e3qEQERHlFCYARANANBrFrl27kJcjjWFDIABzXV2i8S9JeodDRESUU5gAEA0ALpcLbrcb+TnSF95UXw9DKAQ1R7o7ERERDSRMAIh0pqoqdu7cCZPJBDkHKuHIPh8s9fVQCgr0DoWIiCgnMQEg0llrayuamppQVFSkdyh9TwiY6uogxWJQc2y2YyIiooGCCQCRzurr66EoCiwWi96h9DmTywVzXR3iuZDsEBERDVBMAIh0FAgEsHv3bhTmwCy4hlAIlu3bAbMZwmzWOxwiIqKcxQSASEdNTU0IBALZX/tfVWHeuROy3484+/4TERHpigkAkU7i8Th27NgBh8MBKctLYZoaG2GprUW8uJhlP4mIiHTGBIBIJ01NTXC73SjI8ivihkAA1h07oFqt7PpDREQ0ADABINKBEAK7du2CLMvZPfOvosBSUwNDMMiyn0RERAMEEwAiHbjdbjQ2NmZ96U9zQwPM9fWIlZToHQoRERG1YQJApIOGhgbEYjFYrVa9Q+kzss8Hy44didl+s/kuBxERUYZhAkDUz0KhEHbt2pXdff/jcVi2b4cUiUDJy9M7GiIiImqHCQBRP2tsbITX60VetjaMhYBl506YmpoQHzRI72iIiIhoD0wAiPpRLBZDTU1NVpf+NO/aBeuOHYnZftn1h4iIaMBhAkDUj2pqatDU1JS1M/+aGhpg3bYNitMJkcXjG4iIiDIZEwCifuJ2u7F161YUFhZmZelPY3MzbNXVEBZLYuAvERERDUhMAIj6gaIo2LJlC8LhcFYO/pW9XlirqwEhoOTn6x0OERERdYMJAFE/2LVrF3bv3o2ysjK9Q0k7QyAA69atMITDiBcX6x0OERER7QUTAKI+5vP5sHnzZjidTphMJr3DSSspHIatuhpGrxdxTvZFRESUEZgAEPUhVVWxdetWBAKBrJv1V2v8u1yIDR4MZGlVIyIiomyTfSMRiQaQ2tpa1NTUZF3XH9nng3XrVhjd7kTj38BrCURERJmCCQBRHwkEAqiqqoLNZoPZbNY7nLQxNjfDWl0NQziMWGkpG/9EREQZhp/cRH1ACIHq6mp4vV4UZ8vAWCFgqq+H/ZtvYIjFEOeVfyIioozEOwBEfWDXrl3Yvn07SktLs2PGX0WBZedOWHbsgLDZoOTl6R0RERER7SMmAERptnPnTqxfvx52ux3WLJgNV4pEYKmpgWXXLigFBVBtNr1DIiIiov3ABIAojWpqavDVV1/BarWisLBQ73D2jxAwNjfDUlMDo8eDeHExRBaNZSAiIspVTACI0qSmpgbr16+HzWbL+Ma/IRSCedcumGtrAaORg32JiIiyCBMAojTYsWMHvvrqq8xv/KsqTI2NsNTUQA4EeNWfiIgoCzEBINoPQgit8W+32zO68S/7fImr/g0NUK1WxMrKOLkXERFRFmICQLSPFEVBTU0NNmzYAIfDgYKCAr1D6j0hIHu9MDU2wtzYCCkWS1z1N5n0joyIiIj6CBMAon3Q2tqKrVu3YteuXSgsLER+fr7eIfWOEJA9Hpjr62FyuSDF44gXFEBkQdUiIiIi6h4TAKJeiEaj2LFjB6qrqxGJRDBkyBCYMulqeTwOY1vD39jcDABQ8vMhLBadAyMiIqL+wgSAqAeEEGhsbMSWLVvQ2NiI4uJiDB48WO+wekZRIPv9MLa2wuRywRAIQJKkxBV/DvAlIiLKOUwAiLohhIDb7cbOnTuxfft2yLKM4cOHQ5ZlvUPrnqrCEAzC6HbD1NQE2eeDpChQ7XbEBw0CBnr8RERE1GeYABB1IhwOw+VyYdeuXWhubkYsFsPgwYMH7sy+QsAQDsMQCED2+WB0uyEHApBiMahWK+JFRYCRf+5ERETEBIBIo6oqWltb0dDQgNraWvh8PlgsFhQVFcEy0PrIK0qiwR8OQw4EYGxthSEYhCEUgjAYIKxWKHl57OJDREREHQyIqT2feuopVFZWwmq1Yvz48Vi5cmW36//973/HEUccAavVipEjR+K9997rp0gpmyiKAo/Hg927d+Prr7/GsmXL8L///Q9btmyBLMuoqKhAWVmZvo1/ISBFIjD4/TC6XDDv3Anbxo1wfvklnGvWwLF+PazV1ZCDwUTt/vJyxMvKoLB/PxEREXVB9zsAr732GmbPno1FixZh/PjxWLhwISZNmoSqqiqUlpZ2WP9///sfrrjiCsyfPx/nnXceXnnlFVxwwQX48ssvccwxx+jwCigTxGIxRCIRhMNhhEIhuN1uuFwuBINBRKNRGAwGOBwODB48uH+r+ggBKR6HFIt99z0W+647TyiUWN72BSEgzGaoZnPiCr/JxMm6iIiIqFckIYTQM4Dx48fjhBNOwJNPPgkg0Q2joqICN9xwA+bMmdNh/csuuwyBQADvvPOOtuzEE0/E6NGjsWjRor0ez+v1oqCgAB6PJ/Nqt1OnVFVFLBZDPB5HLBbTvqLRKPx+P7xeL0KhEKLRKKLRKIQQWoPfbrfDnK4r5aoKqCokRYGkqoCiJH5WlMTyeDzxOB6HIRKBIRKBFIloy5PrQ5IASYIwGiFMJgijEarJxD78RES0T5JNPSHEdz93XCllvfbfk6R2F5ySP3e1bsqjds91WK+TZqgQIrF9J/vu8Bo6iXlvcWuPJQnSnsuS67c9t+f2e+53z32pkQjijY044tprkT98eKfbDQS6tiii0ShWr16NO+64Q1tmMBgwceJErFixotNtVqxYgdmzZ6csmzRpEt56661O149EIohEItpjr9e7/4Fnua5ywk7/aLv5ZyGEgFDV735u/0erqlBVNWV5cllyuaoo2mNVUaAoCuLxOOJtjftoJJJo7Eej2nJFUaDE45DajikbDDCbTLBYLHAYjbDk5yf+oJOxB4OQAoHvHgsBSYhEY74tVin5c9vVeigKDKoKxOOJajvxOBCPQ1JVbV2pLRlAMhlI/oMQItG4l2UIoxGQ5cQV/eRjw4DolZcxdL5+0S29Y0vn8QfUu7wPr6u370VP10/3Od7r3ro5Xk//b+/9EF3sp4fx9OR4e2sAdtYw7en+utt3l3vpYvvu9tvt/tpInazT02V7PtfdOns77p5N12SDdc/G6577aL8e0HVDv8t9dlypwzG62kfKsrZ97hmTZDDAkHzOYNCeNxgMqcfqJHlQ2z7TVVWF2tb+0NoiyW2S67XbttOf2x1DCAHEYnBarYk4BjBdEwCXywVFUVBWVpayvKysDN98802n29TX13e6fn19fafrz58/H/PmzUtPwOkQjwPr1ukdRaf/UGtra9Ha2tr1Ju1/bmvYd7Xfrq4iaH80bX94320mtIRCtD0n9vijVBUlZb0kCYlfZGO7ZSl/dm3LYwBiQmgJgNTuOW1Zu0QAeyyT+qgRka26/BCgXuu39zKNx8mk89/TSHvzmva67n6+P3vuv0Njaj/31+v1Olm+txi7a3Qmn09pDHZz/M6uxHb6XCfHSNl3skG5Zxzttuuu4dydzq4md9bobR/Tnq+xy+32eNxt47qLdTucr3brajppBPckhi7f/z21f4/brd9tYpFGe95FEHssb3vQ9TbJx04nbHl5fR7v/sj6PgV33HFHyh0Dr9eLiooK/QKSZaC0FOjqToSOH5pFw4YhYjRqDfPO/tg6+wch0PGfUYfvbZlw++UGgyFluSRJMMjyd1cbOh688+/Jnzt7fs/lbfF2eG6AyKRGU3/LxPemP2Lur/clncfZn33ty7Z9+R71ZN/pWGdfn+9uu95sk+5lRAORtMf3fd+RBDid+7uXPqVrAlBSUgJZltHQ0JCyvKGhAeXl5Z1uU15e3qv1LRbLwCrhKEmAnglIN2wADtQ7CCIiIiLqU7p2UDKbzTj++OOxdOlSbZmqqli6dCkmTJjQ6TYTJkxIWR8AlixZ0uX6RERERET0Hd27AM2ePRtTp07F2LFjMW7cOCxcuBCBQADTpk0DAFx11VUYNmwY5s+fDwCYOXMmTj31VCxYsAA//OEP8eqrr+KLL77As88+q+fLICIiIiLKCLonAJdddhmampowd+5c1NfXY/To0Vi8eLE20LempiZlJPVJJ52EV155Bb/97W/x61//GoceeijeeustzgFARERERNQDus8D0N84DwARERER5bKBXaSUiIiIiIjSigkAEREREVEOYQJARERERJRDmAAQEREREeUQJgBERERERDmECQARERERUQ5hAkBERERElEOYABARERER5RAmAEREREREOYQJABERERFRDjHqHUB/E0IAALxer86REBERERGlX15eHiRJ6vL5nEsAfD4fAKCiokLnSIiIiIiI0s/j8SA/P7/L5yWRvCSeI1RVRW1t7V4zo/3l9XpRUVGBnTt3dnsCKDvx/Oc2nv/cxvOf23j+c9tAOf+8A7AHg8GA4cOH99vx8vPz+Q8gh/H85zae/9zG85/beP5z20A//xwETERERESUQ5gAEBERERHlECYAfcRiseCuu+6CxWLROxTSAc9/buP5z208/7mN5z+3Zcr5z7lBwEREREREuYx3AIiIiIiIcggTACIiIiKiHMIEgIiIiIgohzABICIiIiLKIUwA+sBTTz2FyspKWK1WjB8/HitXrtQ7JOoD8+fPxwknnIC8vDyUlpbiggsuQFVVVco64XAYM2bMwKBBg+B0OvHjH/8YDQ0NOkVMfenBBx+EJEmYNWuWtoznP7vt3r0bP/3pTzFo0CDYbDaMHDkSX3zxhfa8EAJz587FkCFDYLPZMHHiRGzZskXHiCldFEXBnXfeiQMPPBA2mw0HH3ww7r33XrSvq8Lznz0++eQTTJ48GUOHDoUkSXjrrbdSnu/JuW5pacGUKVOQn5+PwsJCXHPNNfD7/f34KlIxAUiz1157DbNnz8Zdd92FL7/8EqNGjcKkSZPQ2Niod2iUZh9//DFmzJiBzz77DEuWLEEsFsPZZ5+NQCCgrXPTTTfhX//6F/7+97/j448/Rm1tLS666CIdo6a+sGrVKjzzzDM49thjU5bz/Gev1tZWnHzyyTCZTHj//fexceNGLFiwAEVFRdo6Dz/8MB5//HEsWrQIn3/+ORwOByZNmoRwOKxj5JQODz30EJ5++mk8+eST2LRpEx566CE8/PDDeOKJJ7R1eP6zRyAQwKhRo/DUU091+nxPzvWUKVPw9ddfY8mSJXjnnXfwySef4Lrrruuvl9CRoLQaN26cmDFjhvZYURQxdOhQMX/+fB2jov7Q2NgoAIiPP/5YCCGE2+0WJpNJ/P3vf9fW2bRpkwAgVqxYoVeYlGY+n08ceuihYsmSJeLUU08VM2fOFELw/Ge722+/XXzve9/r8nlVVUV5ebn43e9+py1zu93CYrGIv/3tb/0RIvWhH/7wh+JnP/tZyrKLLrpITJkyRQjB85/NAIh//OMf2uOenOuNGzcKAGLVqlXaOu+//76QJEns3r2732Jvj3cA0igajWL16tWYOHGitsxgMGDixIlYsWKFjpFRf/B4PACA4uJiAMDq1asRi8VSfh+OOOIIjBgxgr8PWWTGjBn44Q9/mHKeAZ7/bPf2229j7NixuOSSS1BaWorjjjsOzz33nPb8tm3bUF9fn3L+CwoKMH78eJ7/LHDSSSdh6dKl2Lx5MwBg3bp1+PTTT/GDH/wAAM9/LunJuV6xYgUKCwsxduxYbZ2JEyfCYDDg888/7/eYAcCoy1GzlMvlgqIoKCsrS1leVlaGb775RqeoqD+oqopZs2bh5JNPxjHHHAMAqK+vh9lsRmFhYcq6ZWVlqK+v1yFKSrdXX30VX375JVatWtXhOZ7/7Pbtt9/i6aefxuzZs/HrX/8aq1atwo033giz2YypU6dq57izzwOe/8w3Z84ceL1eHHHEEZBlGYqi4P7778eUKVMAgOc/h/TkXNfX16O0tDTleaPRiOLiYt1+H5gAEKXBjBkzsGHDBnz66ad6h0L9ZOfOnZg5cyaWLFkCq9WqdzjUz1RVxdixY/HAAw8AAI477jhs2LABixYtwtSpU3WOjvra//3f/+Hll1/GK6+8gqOPPhpr167FrFmzMHToUJ5/ygjsApRGJSUlkGW5Q5WPhoYGlJeX6xQV9bXrr78e77zzDj788EMMHz5cW15eXo5oNAq3252yPn8fssPq1avR2NiIMWPGwGg0wmg04uOPP8bjjz8Oo9GIsrIynv8sNmTIEBx11FEpy4488kjU1NQAgHaO+XmQnW699VbMmTMHl19+OUaOHIkrr7wSN910E+bPnw+A5z+X9ORcl5eXdygGE4/H0dLSotvvAxOANDKbzTj++OOxdOlSbZmqqli6dCkmTJigY2TUF4QQuP766/GPf/wD//3vf3HggQemPH/88cfDZDKl/D5UVVWhpqaGvw9Z4Mwzz8RXX32FtWvXal9jx47FlClTtJ95/rPXySef3KHs7+bNm3HAAQcAAA488ECUl5ennH+v14vPP/+c5z8LBINBGAypTShZlqGqKgCe/1zSk3M9YcIEuN1urF69Wlvnv//9L1RVxfjx4/s9ZgCsApRur776qrBYLOKFF14QGzduFNddd50oLCwU9fX1eodGaTZ9+nRRUFAgPvroI1FXV6d9BYNBbZ1f/vKXYsSIEeK///2v+OKLL8SECRPEhAkTdIya+lL7KkBC8Pxns5UrVwqj0Sjuv/9+sWXLFvHyyy8Lu90u/vrXv2rrPPjgg6KwsFD885//FOvXrxfnn3++OPDAA0UoFNIxckqHqVOnimHDhol33nlHbNu2Tbz55puipKRE3Hbbbdo6PP/Zw+fziTVr1og1a9YIAOLRRx8Va9asETt27BBC9Oxcn3POOeK4444Tn3/+ufj000/FoYceKq644gq9XpJgAtAHnnjiCTFixAhhNpvFuHHjxGeffaZ3SNQHAHT69fzzz2vrhEIh8atf/UoUFRUJu90uLrzwQlFXV6df0NSn9kwAeP6z27/+9S9xzDHHCIvFIo444gjx7LPPpjyvqqq48847RVlZmbBYLOLMM88UVVVVOkVL6eT1esXMmTPFiBEjhNVqFQcddJD4zW9+IyKRiLYOz3/2+PDDDzv9vJ86daoQomfnurm5WVxxxRXC6XSK/Px8MW3aNOHz+XR4NQmSEO2mrSMiIiIioqzGMQBERERERDmECQARERERUQ5hAkBERERElEOYABARERER5RAmAEREREREOYQJABERERFRDmECQERERESUQ5gAEBFluauvvhoXXHCBbse/8sor8cADD3S7TmVlJRYuXNgv8USjUVRWVuKLL77ol+MREQ00Rr0DICKifSdJUrfP33XXXXjssceg15yP69atw3vvvYenn35al+N3xmw245ZbbsHtt9+OpUuX6h0OEVG/YwJARJTB6urqtJ9fe+01zJ07F1VVVdoyp9MJp9OpR2gAgCeeeAKXXHKJrjF0ZsqUKbj55pvx9ddf4+ijj9Y7HCKifsUuQEREGay8vFz7KigogCRJKcucTmeHLkCnnXYabrjhBsyaNQtFRUUoKyvDc889h0AggGnTpiEvLw+HHHII3n///ZRjbdiwAT/4wQ/gdDpRVlaGK6+8Ei6Xq8vYFEXB66+/jsmTJ6csb2xsxOTJk2Gz2XDggQfi5Zdf7rDto48+ipEjR8LhcKCiogK/+tWv4Pf7AQCBQAD5+fl4/fXXU7Z566234HA44PP5EI1Gcf3112PIkCGwWq044IADMH/+fG3doqIinHzyyXj11Vd7/F4TEWULJgBERDnoxRdfRElJCVauXIkbbrgB06dPxyWXXIKTTjoJX375Jc4++2xceeWVCAaDAAC3240zzjgDxx13HL744gssXrwYDQ0NuPTSS7s8xvr16+HxeDB27NiU5VdffTV27tyJDz/8EK+//jr+8Ic/oLGxMWUdg8GAxx9/HF9//TVefPFF/Pe//8Vtt90GAHA4HLj88svx/PPPp2zz/PPP4+KLL0ZeXh4ef/xxvP322/i///s/VFVV4eWXX0ZlZWXK+uPGjcOyZcv29S0kIspcgoiIssLzzz8vCgoKOiyfOnWqOP/887XHp556qvje976nPY7H48LhcIgrr7xSW1ZXVycAiBUrVgghhLj33nvF2WefnbLfnTt3CgCiqqqq03j+8Y9/CFmWhaqq2rKqqioBQKxcuVJbtmnTJgFA/P73v+/ytf39738XgwYN0h5//vnnQpZlUVtbK4QQoqGhQRiNRvHRRx8JIYS44YYbxBlnnJFy7D099thjorKyssvniYiyFe8AEBHloGOPPVb7WZZlDBo0CCNHjtSWlZWVAYB2ZX7dunX48MMPtTEFTqcTRxxxBACgurq602OEQiFYLJaUgcqbNm2C0WjE8ccfry074ogjUFhYmLLtBx98gDPPPBPDhg1DXl4errzySjQ3N2t3JMaNG4ejjz4aL774IgDgr3/9Kw444ACccsopABJ3GdauXYvDDz8cN954I/7zn/90iM9ms2n7IyLKJUwAiIhykMlkSnksSVLKsmSjXVVVAIDf78fkyZOxdu3alK8tW7Zoje49lZSUIBgMIhqN9iq27du347zzzsOxxx6LN954A6tXr8ZTTz0FACn7uvbaa/HCCy8ASHT/mTZtmhb3mDFjsG3bNtx7770IhUK49NJLcfHFF6ccp6WlBYMHD+5VbERE2YAJABER7dWYMWPw9ddfo7KyEoccckjKl8Ph6HSb0aNHAwA2btyoLTviiCMQj8exevVqbVlVVRXcbrf2ePXq1VBVFQsWLMCJJ56Iww47DLW1tR32/9Of/hQ7duzA448/jo0bN2Lq1Kkpz+fn5+Oyyy7Dc889h9deew1vvPEGWlpatOc3bNiA4447bl/eDiKijMYEgIiI9mrGjBloaWnBFVdcgVWrVqG6uhr//ve/MW3aNCiK0uk2gwcPxpgxY/Dpp59qyw4//HCcc845+MUvfoHPP/8cq1evxrXXXgubzaatc8ghhyAWi+GJJ57At99+i5deegmLFi3qsP+ioiJcdNFFuPXWW3H22Wdj+PDh2nOPPvoo/va3v+Gbb77B5s2b8fe//x3l5eUpXY2WLVuGs88+Ow3vDhFRZmECQEREezV06FAsX74ciqLg7LPPxsiRIzFr1iwUFhbCYOj6o+Taa6/tUObz+eefx9ChQ3HqqafioosuwnXXXYfS0lLt+VGjRuHRRx/FQw89hGOOOQYvv/xySgnP9q655hpEo1H87Gc/S1mel5eHhx9+GGPHjsUJJ5yA7du347333tNiXbFiBTweT4duQUREuUASQqfpIYmIKOuFQiEcfvjheO211zBhwoS07/+ll17CTTfdhNraWpjN5h5vd9lll2HUqFH49a9/nfaYiIgGOs4ETEREfcZms+Evf/lLtxOG7YtgMIi6ujo8+OCD+MUvftGrxn80GsXIkSNx0003pTUmIqJMwTsARESUce6++27cf//9OOWUU/DPf/4TTqdT75CIiDIGEwAiIiIiohzCQcBERERERDmECQARERERUQ5hAkBERERElEOYABARERER5RAmAEREREREOYQJABERERFRDmECQERERESUQ5gAEBERERHlECYAREREREQ55P8BG2HdPwPxKvAAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ax = setup_ax()\n", + "ax = plot_predictive(prior_prediction, tspan, tmin=7, ax=ax, label=\"no intervention\")\n", + "ax = plot_predictive(intervened_parameter_prediction, tspan, ax=ax, color='red', label=\"epsilon parameter intervention\")\n", + "sideaxis(ax)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "97ab7988", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import time\n", + "import pickle\n", + "\n", + "import numpy as np\n", + "from scipy import stats\n", + "from matplotlib import ticker\n", + "\n", + "# from pyciemss.ODE.models import SVIIvR\n", + "from pyciemss.ODE.interventions import constant_intervention_builder, parameter_intervention_builder\n", + "\n", + "from pyciemss.risk.risk_measures import alpha_quantile, alpha_superquantile\n", + "from pyciemss.risk.ouu import computeRisk, solveOUU\n", + "from pyciemss.risk.qoi import max_total_infections_SIDARTHE\n", + "import scipy\n", + "\n", + "co = ['#377eb8', '#ff7f00', '#984ea3', '#ffd92f', '#a65628']\n", + "rlabel = ['Q_alpha-based OUU', 'barQ_alpha-based OUU']" + ] + }, + { + "cell_type": "markdown", + "id": "5fb87509", + "metadata": {}, + "source": [ + "## Exploring the difference between Quantiles and Superquantiles" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "35ebe5d7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Forward UQ took 81.63 seconds total (1.63e-01 seconds per model evaluation).\n", + "0.582008454203605 0.656692063808441\n" + ] + } + ], + "source": [ + "torch.manual_seed(1)\n", + "\n", + "POLICY = np.array([0.45,1.])\n", + "N_SAMPLES = 500\n", + "\n", + "RISK = computeRisk(model=ode_model,\n", + "# intervention_fun=lambda x: parameter_intervention_builder(\"epsilon\", torch.from_numpy(x)),\n", + " intervention_fun=lambda x: {\"epsilon\": torch.from_numpy(np.array([x[0]])), \n", + " \"theta\": torch.from_numpy(np.array([x[1]]))},\n", + " qoi=lambda y: max_total_infections_SIDARTHE(y, contexts=[\"I_total_obs\"]),\n", + " risk_measure=alpha_superquantile,\n", + " num_samples=N_SAMPLES,\n", + " model_state=initial_state,\n", + " tspan=tspan,\n", + " guide=None)\n", + "\n", + "start_time = time.time()\n", + "sq_dataCube = RISK.propagate_uncertainty(POLICY)\n", + "end_time = time.time()\n", + "forward_time = end_time - start_time\n", + "time_per_eval = forward_time / N_SAMPLES\n", + "print(f\"Forward UQ took {forward_time:.2f} seconds total ({forward_time/N_SAMPLES:.2e} seconds per model evaluation).\")\n", + "sq_qoi = RISK.qoi(sq_dataCube)\n", + "sq_sv = RISK.risk_measure(sq_qoi)\n", + "\n", + "RISK.risk_measure = alpha_quantile\n", + "q_sv = RISK(POLICY)\n", + "print(q_sv, sq_sv)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "7fc330e1", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "bins_hist = 50\n", + "fig1 = plt.figure()\n", + "plt.rc('text', usetex=False)\n", + "plt.rc('font', family='serif', size=18.)\n", + "cax = plt.gca()\n", + "sideaxishist(cax)\n", + "cax.hist(sq_qoi, color=co[2], bins=bins_hist, histtype='stepfilled', alpha=0.5, label='total infections')\n", + "miny = min(cax.get_ylim())\n", + "maxy = max(cax.get_ylim())\n", + "cax.vlines(q_sv, miny, maxy, linestyle='--', linewidth=2.5, label='alpha-quantile', color=co[0])\n", + "cax.vlines(sq_sv, miny, maxy, linestyle='--', linewidth=2.5, label='alpha-superquantile', color=co[1])\n", + "cax.set_xlabel('Maximum total infections over 100 days', size=14)\n", + "cax.legend(loc='upper right', prop={'size': 14})" + ] + }, + { + "cell_type": "markdown", + "id": "2a4005a9", + "metadata": {}, + "source": [ + "## Risk-based optimization under uncertainty with intervention on detection rate parameters $\\theta, \\epsilon$\n", + "**NOTE:** This is a demonstration of the interface, optimization is not run to convergence nor are enough samples generated to accurately estimate the risk, so take the results with a grain of salt." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "6fe11138", + "metadata": {}, + "outputs": [], + "source": [ + "# Define problem specifics.\n", + "RISK_BOUND = 1./3.\n", + "X_MIN = 0.\n", + "X_MAX = 3.\n", + "N_SAMPLES = int(5e2)\n", + "MAXITER = 0\n", + "MAXFEVAL = 60\n", + "RISK_ALPHA = 0.95\n", + "\n", + "# Control action / intervention.\n", + "INIT_GUESS = np.array([0.5,1.5])\n", + "INTERVENTION = lambda x: {\"epsilon\": torch.from_numpy(np.array([x[0]])), \"theta\": torch.from_numpy(np.array([x[1]]))}\n", + "\n", + "# Objective function.\n", + "OBJFUN = lambda x: np.sum(x) # minimize the scalar value itself." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "ba6b2d82", + "metadata": {}, + "outputs": [], + "source": [ + "# Define the risk measure.\n", + "RISK = computeRisk(\n", + " model=ode_model,\n", + " intervention_fun=INTERVENTION,\n", + " qoi=lambda y: max_total_infections_SIDARTHE(y, contexts=[\"I_total_obs\"]),\n", + " model_state=initial_state,\n", + " tspan=tspan,\n", + " risk_measure=lambda z: alpha_superquantile(z, alpha=RISK_ALPHA),\n", + " num_samples=N_SAMPLES,\n", + " guide=None,\n", + " )\n", + "\n", + "# Define problem constraints.\n", + "CONSTRAINTS = (\n", + " # risk constraint\n", + " {'type': 'ineq', 'fun': lambda x: RISK_BOUND - RISK(x)},\n", + " {'type': 'ineq', 'fun': lambda x: x[1] - 2*x[0]},\n", + "\n", + " # bounds on control\n", + " # NOTE: perhaps use scipy.optimize.LinearConstraint in the future\n", + " {'type': 'ineq', 'fun': lambda x: x - X_MIN},\n", + " {'type': 'ineq', 'fun': lambda x: X_MAX - x}\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "13a9803a", + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Performing risk-based optimization under uncertainty (using alpha-superquantile)...\n", + "Estimated wait time 4897.5 seconds.\n" + ] + } + ], + "source": [ + "print(\"Performing risk-based optimization under uncertainty (using alpha-superquantile)...\")\n", + "print(f\"Estimated wait time {time_per_eval*N_SAMPLES*(MAXITER+1)*MAXFEVAL:.1f} seconds.\")\n", + "start_time = time.time()\n", + "sq_result_1 = solveOUU(\n", + " x0=INIT_GUESS,\n", + " objfun=OBJFUN,\n", + " constraints=CONSTRAINTS,\n", + " maxiter=MAXITER,\n", + " maxfeval=MAXFEVAL,\n", + " ).solve()\n", + "print(f\"Optimization completed in time {time.time()-start_time:.2f} seconds. Optimal solution:\\t{sq_result_1.x}\")" + ] + }, + { + "cell_type": "markdown", + "id": "abfeda8c", + "metadata": {}, + "source": [ + "## Assess the effect of the control policy." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "60c9d1a9", + "metadata": {}, + "outputs": [], + "source": [ + "RISK.num_samples = int(5e2)\n", + "sq_optimal_prediction = RISK.propagate_uncertainty(sq_result_1.x)\n", + "qois_sq = RISK.qoi(sq_optimal_prediction)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c92e52b7", + "metadata": {}, + "outputs": [], + "source": [ + "ax = setup_ax()\n", + "# print(sq_optimal_prediction.shape)\n", + "ax = plot_predictive(sq_optimal_prediction, tspan, ax=ax, color=co[2], ptiles=[0.01,0.98])\n", + "ax = plot_trajectory(sq_optimal_prediction, tspan, ax=ax, color=\"blue\", marker='', lw=1., ind=1)\n", + "plt.title(\"Optimal theta, epsilon parameter intervention (theta>=2*epsilon) \\n with risk-based OUU\", size=14)\n", + "sideaxis(ax)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "13bf129e", + "metadata": {}, + "outputs": [], + "source": [ + "bins_hist = 50\n", + "fig1 = plt.figure()\n", + "plt.rc('font', family='serif', size=14.)\n", + "cax = plt.gca()\n", + "sideaxishist(cax)\n", + "cax.hist(qois_sq, color=co[4], bins=bins_hist, histtype='stepfilled', alpha=0.5, density=True)\n", + "miny = min(cax.get_ylim())\n", + "maxy = max(cax.get_ylim())\n", + "cax.set_xlabel('Maximum total infections over 100 days', size=14)\n", + "# cax.legend(loc='upper right', prop={'size': 14})" + ] + } + ], + "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.9.7" + }, + "vscode": { + "interpreter": { + "hash": "a3e1d8fdda916c248c87d86618e3945b28961cf939001a0529e724463670a41a" + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/6-month-milestone/evaluation/scenario_2/ta_3/ciemss/scenario2_q2_SIDARTHEV.ipynb b/6-month-milestone/evaluation/scenario_2/ta_3/ciemss/scenario2_q2_SIDARTHEV.ipynb new file mode 100644 index 0000000..da6a3c0 --- /dev/null +++ b/6-month-milestone/evaluation/scenario_2/ta_3/ciemss/scenario2_q2_SIDARTHEV.ipynb @@ -0,0 +1,794 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "b087c52b-a505-45d3-b643-df44d8c924a5", + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "markdown", + "id": "542b06c1-28fb-47ec-9a34-170acc7d2a84", + "metadata": {}, + "source": [ + "# Load Dependencies" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "84e0bb12-68af-4a6d-a384-db4837c44ac0", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "import torch\n", + "\n", + "import pyro\n", + "import numpy as np\n", + "import pyro.distributions as dist\n", + "# from pyro.poutine import trace, replay, block\n", + "# from pyro.infer.autoguide.guides import AutoDelta, AutoNormal\n", + "# from pyro.infer import SVI, Trace_ELBO, Predictive\n", + "\n", + "import sys\n", + "sys.path.append(\"../../src/\")\n", + "\n", + "from pyciemss.ODE.askem_primitives import sample, infer_parameters, intervene, optimization\n", + "\n", + "# from pyciemss.utils import run_inference, get_tspan\n", + "from pyciemss.utils import get_tspan\n", + "\n", + "import warnings\n", + "warnings.filterwarnings('ignore')" + ] + }, + { + "cell_type": "markdown", + "id": "4855961d-9c38-4050-b6b7-aaae03500fc9", + "metadata": {}, + "source": [ + "# Plotting Utilities" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "260901d9", + "metadata": {}, + "outputs": [], + "source": [ + "def setup_ax(ax=None):\n", + "\n", + " if not ax:\n", + " fig = plt.figure(facecolor='w', figsize=(9, 5))\n", + " ax = fig.add_subplot(111, axisbelow=True)\n", + "\n", + " ax.set_xlabel('Time (days)')\n", + " ax.set_ylabel('Total infected')\n", + " return ax\n", + "\n", + "def plot_predictive(prediction, tspan, tmin=None, ax=None, alpha=0.2, color=\"black\", **kwargs):\n", + " vars = [\"I_total_obs\"]\n", + " #infection_total = sum([prediction[x].squeeze().detach().numpy()/1000. for x in ['I_obs', 'D_obs', 'A_obs', 'R_obs', 'T_obs']])\n", + "\n", + " I_low = torch.quantile(prediction[\"I_total_obs\"], 0.05, dim=0).detach().numpy()\n", + " I_up = torch.quantile(prediction[\"I_total_obs\"], 0.95, dim=0).detach().numpy()\n", + "\n", + " if tmin:\n", + " indeces = tspan >= tmin\n", + " else:\n", + " indeces = torch.ones_like(tspan).bool()\n", + "\n", + " if not ax:\n", + " fig = plt.figure(facecolor='w')\n", + " ax = fig.add_subplot(111, facecolor='#dddddd', axisbelow=True)\n", + " \n", + " ax.fill_between(tspan[indeces], I_low[indeces], I_up[indeces], alpha=alpha, color=color, **kwargs)\n", + "\n", + " legend = ax.legend()\n", + " legend.get_frame().set_alpha(0.5)\n", + "\n", + " return ax\n", + "\n", + "def plot_trajectory(data, tspan, ax=None, color='black', alpha=0.5, lw=0, marker='.', label=None):\n", + " # Plot the data on three separate curves for S(t), I(t) and R(t)\n", + "\n", + " if not ax:\n", + " fig = plt.figure(facecolor='w')\n", + " ax = fig.add_subplot(111, facecolor='#dddddd', axisbelow=True)\n", + " #infection_total = sum([data[x].squeeze().detach().numpy()/1000. for x in ['I_obs', 'D_obs', 'A_obs', 'R_obs', 'T_obs']])\n", + " ax.plot(tspan, data['I_total_obs'].squeeze().detach().numpy(), color, alpha=alpha, lw=lw, marker=marker, label=label)\n", + " \n", + " return ax\n", + "\n", + "def plot_intervention_line(t, ax=None):\n", + " if not ax:\n", + " fig = plt.figure(facecolor='w')\n", + " ax = fig.add_subplot(111, facecolor='#dddddd', axisbelow=True)\n", + "\n", + " ylim = ax.get_ylim()\n", + "\n", + " ax.vlines(t, min(ylim), max(ylim), color=\"grey\", ls='-')\n", + "\n", + " return ax\n", + "\n", + "def sideaxis(ax):\n", + " ax.spines['top'].set_visible(False)\n", + " ax.spines['right'].set_visible(False)\n", + " return\n", + "\n", + "def sideaxishist(ax):\n", + " ax.spines['top'].set_visible(False)\n", + " ax.spines['right'].set_visible(False)\n", + " ax.spines['left'].set_visible(False)\n", + " # For y-axis\n", + " ax.yaxis.set_major_locator(ticker.NullLocator())\n", + " ax.tick_params(axis='x', labelsize=12) # change fontsize for x-axis tick labels\n", + " # ax.xaxis.major.formatter._useMathText = True\n", + " return" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "f233104e-c29d-4e25-859f-2a328ec7892a", + "metadata": {}, + "outputs": [], + "source": [ + "def LogNormalPrior(mean, variance):\n", + " mu = torch.log(mean**2/torch.sqrt((mean**2 + variance)))\n", + " scale = torch.sqrt(torch.log(1 + variance/mean**2))\n", + " return dist.LogNormal(mu, scale)\n", + "\n", + "def LogNormalPrior_propVar(mean, cov=0.05):\n", + " variance = mean*cov \n", + " return LogNormalPrior(mean, variance)" + ] + }, + { + "cell_type": "markdown", + "id": "3e0c3726-5ec0-475d-8305-f20b5d84e424", + "metadata": {}, + "source": [ + "# Setup Parameters" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "16608500-97b5-4081-9e6b-b7c193c10285", + "metadata": {}, + "outputs": [], + "source": [ + "tspan = get_tspan(1, 100, 100)\n", + "\n", + "num_samples = 50\n", + "\n", + "# Total population, N.\n", + "N = 1\n", + "# Initial number of infected and recovered individuals, I0 and R0.\n", + "I0, D0, A0, R0, T0, H0, E0, V0 = 200/60e6, 20/60e6, 1/60e6, 2/60e6, 0, 0, 0, 0\n", + "\n", + "# Everyone else, S0, is susceptible to infection initially.\n", + "S0 = N - I0 - D0 - A0 - R0 - T0 - H0 - E0 - V0\n", + "\n", + "initial_state = tuple(torch.as_tensor(s) for s in (S0, I0, D0, A0, R0, T0, H0, E0, V0))" + ] + }, + { + "cell_type": "markdown", + "id": "23fc9c9d-f8bc-4e95-a243-865690d3b43b", + "metadata": {}, + "source": [ + "# Probabilistic Forecasting - Passing unit test 1\n", + "There are two ‘unit tests’ we want to pass, to ensure that we understood and can reproduce the published model:\n", + "\n", + "## 1.a Unit Test \\#1:\n", + "\n", + "Set the initial values and parameters, as described in the Supplementary Methods section of the publication (pg. 9 of the pdf): \n", + "\n", + "1. Initial Values: \n", + "* $I = 200/60e6$,\n", + "* $D = 20/60e6$, \n", + "* $A = 1/60e6$, \n", + "* $R = 2/60e6$, \n", + "* $T = 0$, \n", + "* $H = 0$, \n", + "* $E = 0$; \n", + "* $S = 1 – I – D – A – R – T – H – E$. \n", + "\n", + "Let total population = 60e6.\n", + "Parameters: $$\\alpha = 0.570, \\beta = \\delta = 0.011, \\gamma = 0.456, \\epsilon = 0.171, \\theta = 0.371, \\zeta = \\eta = 0.125, \\mu = 0.017, \\nu = 0.027, \\tau = 0.01, \\lambda = \\rho = 0.034$$ and $$\\kappa = \\xi = \\sigma = 0.017$$." + ] + }, + { + "cell_type": "markdown", + "id": "f6228f01", + "metadata": {}, + "source": [ + "### Deterministic forecasting" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "dbd7d430-325f-4f40-9b20-d8a0c0264f62", + "metadata": {}, + "outputs": [], + "source": [ + "from pyciemss.ODE.models import SIDARTHEV\n", + "\n", + "pyro.set_rng_seed(0)\n", + "\n", + "ode_model = SIDARTHEV(N=1,\n", + " alpha_prior=dist.Delta(torch.tensor (0.570)) ,\n", + " beta_prior=dist.Delta(torch.tensor (0.011)) ,\n", + " gamma_prior=dist.Delta(torch.tensor (0.456)) ,\n", + " delta_prior=dist.Delta(torch.tensor (0.011)) ,\n", + " epsilon_prior=dist.Delta(torch.tensor (0.171)) ,\n", + " lamb_prior =dist.Delta(torch.tensor (0.034)) ,\n", + " zeta_prior=dist.Delta(torch.tensor (0.125)) ,\n", + " eta_prior=dist.Delta(torch.tensor (0.125)) ,\n", + " kappa_prior=dist.Delta(torch.tensor (0.017)) ,\n", + " theta_prior=dist.Delta(torch.tensor (0.371)) ,\n", + " rho_prior=dist.Delta(torch.tensor (0.034)) ,\n", + " xi_prior=dist.Delta(torch.tensor (0.017)) ,\n", + " sigma_prior=dist.Delta(torch.tensor (0.017)) ,\n", + " mu_prior=dist.Delta(torch.tensor (0.017)) ,\n", + " nu_prior=dist.Delta(torch.tensor (0.027)) ,\n", + " tau2_prior=dist.Delta(torch.tensor (0.01)) ,\n", + " phi_prior=dist.Delta(torch.tensor (0.)) )" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "31473cdd-9896-42ed-b487-36362c1c9744", + "metadata": { + "scrolled": false + }, + "outputs": [], + "source": [ + "single_prediction = sample(ode_model, 1, initial_state, tspan)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "15f03c6f-d085-4f36-bc7a-312057d82758", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ax = plot_trajectory(single_prediction, tspan, ax=setup_ax(), color=\"blue\", marker='', lw=1., label=\"Before Seeing Data - Single Forecast\")\n", + "ax.axvline(47)" + ] + }, + { + "cell_type": "markdown", + "id": "7c9b53f3", + "metadata": {}, + "source": [ + "### Probabilistic forecasting" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "a8cebc75-730c-43f8-9081-ba846098f669", + "metadata": {}, + "outputs": [], + "source": [ + "pyro.set_rng_seed(0)\n", + "\n", + "# var_prior = 0.05**2\n", + "mean_values = np.array([])\n", + "\n", + "ode_model = SIDARTHEV(N=1,\n", + " alpha_prior=LogNormalPrior_propVar(torch.tensor(0.570)) ,\n", + " beta_prior=LogNormalPrior_propVar(torch.tensor(0.011)) ,\n", + " gamma_prior=LogNormalPrior_propVar(torch.tensor(0.456)) ,\n", + " delta_prior=LogNormalPrior_propVar(torch.tensor(0.011)) ,\n", + " epsilon_prior=LogNormalPrior_propVar(torch.tensor(0.171)) ,\n", + " lamb_prior =LogNormalPrior_propVar(torch.tensor(0.034)) ,\n", + " zeta_prior=LogNormalPrior_propVar(torch.tensor(0.125)) ,\n", + " eta_prior=LogNormalPrior_propVar(torch.tensor(0.125)) ,\n", + " kappa_prior=LogNormalPrior_propVar(torch.tensor(0.017)) ,\n", + " theta_prior=LogNormalPrior_propVar(torch.tensor(0.371)) ,\n", + " rho_prior=LogNormalPrior_propVar(torch.tensor(0.034)) ,\n", + " xi_prior=LogNormalPrior_propVar(torch.tensor(0.017)) ,\n", + " sigma_prior=LogNormalPrior_propVar(torch.tensor(0.017)) ,\n", + " mu_prior=LogNormalPrior_propVar(torch.tensor(0.017)) ,\n", + " nu_prior=LogNormalPrior_propVar(torch.tensor(0.027)) ,\n", + " tau2_prior=LogNormalPrior_propVar(torch.tensor(0.01)) ,\n", + " phi_prior=dist.Delta(torch.tensor (0.)) )\n", + "\n", + "# interventions = {\"alpha\": SI_alpha_intervention,\n", + "# \"beta\": SD_beta_intervention,\n", + "# \"gamma\": SA_gamma_intervention,\n", + "# \"delta\": SR_delta_intervention,\n", + "# \"epsilon\": ID_epsilon_intervention,\n", + "# \"lambda\": IH_lamb_intervention,\n", + "# \"zeta\": IA_zeta_intervention,\n", + "# \"eta\": DR_eta_intervention,\n", + "# \"kappa\": AH_kappa_intervention,\n", + "# # \"theta\": AR_theta_intervention,\n", + "# \"rho\": DH_rho_intervention,\n", + "# \"xi\": RH_xi_intervention,\n", + "# \"sigma\": TH_sigma_intervention,\n", + "# \"mu\": AT_mu_intervention,\n", + "# \"nu\": RT_nu_intervention}" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "795ecb3a", + "metadata": {}, + "outputs": [], + "source": [ + "prior_prediction = sample(ode_model, num_samples, initial_state, tspan)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "f62475f8", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ax1 = plot_predictive(prior_prediction, tspan, ax=setup_ax(), label=\"probabilistic forecast\", color=\"red\")\n", + "ax1.axvline(30)\n", + "sideaxis(ax1)" + ] + }, + { + "cell_type": "markdown", + "id": "c65bcf10-9d12-4efe-be10-cc313e123d14", + "metadata": {}, + "source": [ + "## 1.d Policies that prevent infections from exceeding 1/3 of the population\n", + "\n", + "Now return to the situation in b.i (constant parameters that don’t change over time). Let’s say we want to increase testing, diagnostics, and contact tracing efforts (implemented by increasing the detection parameters and ). Assume that $\\theta \\ge 2\\epsilon$ , because a symptomatic person is more likely to be tested. What minimum constant values do these parameters need to be over the course of a 100-day simulation, to ensure that the total infected population (sum over all the infected states I, D, A, R, T) never rises above 1/3 of the total population?\n", + "\n", + "\n", + "### Problem Formulation\n", + "* **Quantity of interest**: Total infections out of $N=60,000,000$ population\n", + "$$I_{total}(t; \\mathbf{u}, \\mathbf{Z}) = I(t) + D(t) + A(t) + R(t) + T(t)$$\n", + "\n", + "A conservative estimate for the quantity of interest is\n", + "$$M(u, Z) = \\max_{1\\leq t \\leq 100} I_{total}(t; \\mathbf{u}, \\mathbf{Z})/N$$\n", + "\n", + "\n", + "\n", + "\n", + "* **Control**: $\\mathbf{u}\\in \\mathcal{U} \\subseteq \\mathbb{R}^{n_u}$\n", + " * Detection parameter for Infected ($\\epsilon$) assuming that $\\theta=2\\epsilon$\n", + " * Two detection parameters $\\theta, \\epsilon$, constraining $\\theta \\ge 2\\epsilon$.\n", + " \n", + "\n", + "\n", + "* **Risk-based optimization under uncertainty problem formulation**\n", + " * Objective Function - Minimize the magnitude of the parameter interventions.\n", + " * Constraint - Risk of normalized total infections exceeding the prescribed threshold of $1/3$, $\\mathcal{R}( M(\\mathbf{u},\\mathbf{Z}))$, is below the acceptable risk threshold, $\\mathcal{R}_\\text{threshold}$.\n", + "\n", + "\\begin{equation} \n", + "\\begin{split} \n", + "\\mathbf{u}^*= \\underset{\\mathbf{u}\\in\\mathcal{U}}{\\arg\\min}\\ & \\lVert \\mathbf{u} \\rVert_1 \\\\ \\text{s.t.}\\ & \\mathcal{R}( M(\\mathbf{u}, \\theta)) \\le \\mathcal{R}_\\text{threshold} \n", + "\\end{split} \n", + "\\end{equation}\n", + "\n", + "#### Formulation 1: Optimize $u=\\{\\alpha, \\beta, \\gamma, \\delta\\}$\n", + "\\begin{equation} \n", + "\\begin{split} \n", + "u^*= \\underset{\\epsilon\\in\\mathcal{U}}{\\arg\\min}\\ & u\\\\ \\text{s.t.}\\ & \\mathbb{P}( M(u, \\mathbf{Z}) \\ge 1/3) \\le 0.05\n", + "\\end{split} \n", + "\\end{equation}\n", + "\n", + "#### Formulation 2: Optimize $\\epsilon$ and $\\theta$ constraining $\\theta \\ge 2\\epsilon$\n", + "\\begin{equation} \n", + "\\begin{split} \n", + "\\epsilon^\\ast, \\theta^\\ast= \\underset{\\{\\epsilon,\\theta\\}\\in\\mathcal{U}}{\\arg\\min}\\ & \\theta + \\epsilon \\\\ \\text{s.t.}\\ & \\mathbb{P}( M(\\epsilon,\\theta, \\mathbf{Z}) \\ge 1/3) \\le 0.05, \\\\\n", + "& \\theta \\ge 2\\epsilon\n", + "\\end{split} \n", + "\\end{equation}\n", + "\n", + "Apart from probability of exceedance, we will explore quantiles and superquantiles as risk measures." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "97ab7988", + "metadata": {}, + "outputs": [], + "source": [ + "from causal_pyro.query.do_messenger import do\n", + "import time\n", + "import pickle\n", + "\n", + "import numpy as np\n", + "from scipy import stats\n", + "from matplotlib import ticker\n", + "\n", + "from pyciemss.ODE.interventions import parameter_intervention_builder, time_and_state_dependent_intervention_builder, time_dependent_intervention_builder\n", + "from pyciemss.risk.risk_measures import alpha_quantile, alpha_superquantile\n", + "from pyciemss.risk.ouu import computeRisk, solveOUU\n", + "from pyciemss.risk.qoi import max_total_infections_SIDARTHE\n", + "import scipy\n", + "\n", + "\n", + "co = ['#377eb8', '#ff7f00', '#984ea3', '#ffd92f', '#a65628']\n", + "rlabel = ['Q_alpha-based OUU', 'barQ_alpha-based OUU']" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "3613329e", + "metadata": {}, + "outputs": [], + "source": [ + "def delayed_intervention_controller(name, x, init_value):\n", + " def delayed_intervention(t, flux):\n", + " if t<30:\n", + " return flux\n", + " else:\n", + " return flux/init_value*x\n", + " return time_and_state_dependent_intervention_builder(name, delayed_intervention, tspan) \n", + "\n", + "def delayed_intervention_controller_flux(name, x):\n", + " def delayed_intervention(t):\n", + " if t<15:\n", + " return torch.tensor(0.)\n", + " else:\n", + " return x\n", + " return time_dependent_intervention_builder(name, delayed_intervention, tspan) " + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "09b64716", + "metadata": {}, + "outputs": [], + "source": [ + "# # Control action / intervention.\n", + "# phi_init = torch.tensor(0.)\n", + "# param_intervention = parameter_intervention_builder(\"phi\", phi_init)\n", + "# control_model = intervene(ode_model,param_intervention)\n", + "\n", + "# # Control action / intervention.\n", + "# alpha_init = torch.tensor(0.57)\n", + "# param_intervention = parameter_intervention_builder(\"alpha\", alpha_init)\n", + "# control_model = intervene(ode_model,param_intervention)\n", + "control_model = ode_model\n", + "\n", + "# # intervened_tspan = tspan[torch.where(tspan > 30, True, False)]\n", + "# INTERVENTION = lambda x: delayed_intervention_controller(\"SV_flux\", torch.from_numpy(np.array([x])), phi_init)\n", + "\n", + "INTERVENTION = lambda x: delayed_intervention_controller_flux(\"SV_flux\", torch.from_numpy(np.array([x])))" + ] + }, + { + "cell_type": "markdown", + "id": "5fb87509", + "metadata": {}, + "source": [ + "## Exploring the intervention and difference between Quantiles and Superquantiles" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "35ebe5d7", + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Forward UQ took 9.40 seconds total (1.88e-01 seconds per model evaluation).\n" + ] + }, + { + "ename": "KeyboardInterrupt", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[15], line 25\u001b[0m\n\u001b[1;32m 22\u001b[0m sq_sv \u001b[38;5;241m=\u001b[39m RISK\u001b[38;5;241m.\u001b[39mrisk_measure(sq_qoi)\n\u001b[1;32m 24\u001b[0m RISK\u001b[38;5;241m.\u001b[39mrisk_measure \u001b[38;5;241m=\u001b[39m alpha_quantile\n\u001b[0;32m---> 25\u001b[0m q_sv \u001b[38;5;241m=\u001b[39m \u001b[43mRISK\u001b[49m\u001b[43m(\u001b[49m\u001b[43mPOLICY\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 26\u001b[0m \u001b[38;5;28mprint\u001b[39m(q_sv, sq_sv)\n", + "File \u001b[0;32m/storage/achaudhuri/covid_askem/pyciemss/notebook/evaluation/../../src/pyciemss/risk/ouu.py:51\u001b[0m, in \u001b[0;36mcomputeRisk.__call__\u001b[0;34m(self, x)\u001b[0m\n\u001b[1;32m 49\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m__call__\u001b[39m(\u001b[38;5;28mself\u001b[39m, x):\n\u001b[1;32m 50\u001b[0m \u001b[38;5;66;03m# Apply intervention, perform forward uncertainty propagation\u001b[39;00m\n\u001b[0;32m---> 51\u001b[0m samples \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mpropagate_uncertainty\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 52\u001b[0m \u001b[38;5;66;03m# print(x)\u001b[39;00m\n\u001b[1;32m 53\u001b[0m \n\u001b[1;32m 54\u001b[0m \u001b[38;5;66;03m# Compute quanity of interest\u001b[39;00m\n\u001b[1;32m 55\u001b[0m sample_qoi \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mqoi(samples)\n", + "File \u001b[0;32m/storage/achaudhuri/covid_askem/pyciemss/notebook/evaluation/../../src/pyciemss/risk/ouu.py:69\u001b[0m, in \u001b[0;36mcomputeRisk.propagate_uncertainty\u001b[0;34m(self, x)\u001b[0m\n\u001b[1;32m 66\u001b[0m \u001b[38;5;66;03m# Apply intervention to model\u001b[39;00m\n\u001b[1;32m 67\u001b[0m intervened_model \u001b[38;5;241m=\u001b[39m do(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mmodel, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mintervention_fun(x))\n\u001b[0;32m---> 69\u001b[0m samples \u001b[38;5;241m=\u001b[39m \u001b[43mPredictive\u001b[49m\u001b[43m(\u001b[49m\u001b[43mintervened_model\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mguide\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mguide\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mnum_samples\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mnum_samples\u001b[49m\u001b[43m)\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmodel_state\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtspan\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 71\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m samples\n", + "File \u001b[0;32m/storage/achaudhuri/envs/anaconda3/envs/askem/lib/python3.9/site-packages/torch/nn/modules/module.py:1194\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *input, **kwargs)\u001b[0m\n\u001b[1;32m 1190\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m 1191\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m 1192\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m 1193\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1194\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;28;43minput\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1195\u001b[0m \u001b[38;5;66;03m# Do not call functions when jit is used\u001b[39;00m\n\u001b[1;32m 1196\u001b[0m full_backward_hooks, non_full_backward_hooks \u001b[38;5;241m=\u001b[39m [], []\n", + "File \u001b[0;32m/storage/achaudhuri/envs/anaconda3/envs/askem/lib/python3.9/site-packages/pyro/infer/predictive.py:273\u001b[0m, in \u001b[0;36mPredictive.forward\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 263\u001b[0m return_sites \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m return_sites \u001b[38;5;28;01melse\u001b[39;00m return_sites\n\u001b[1;32m 264\u001b[0m posterior_samples \u001b[38;5;241m=\u001b[39m _predictive(\n\u001b[1;32m 265\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mguide,\n\u001b[1;32m 266\u001b[0m posterior_samples,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 271\u001b[0m model_kwargs\u001b[38;5;241m=\u001b[39mkwargs,\n\u001b[1;32m 272\u001b[0m )\n\u001b[0;32m--> 273\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43m_predictive\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 274\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmodel\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 275\u001b[0m \u001b[43m \u001b[49m\u001b[43mposterior_samples\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 276\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mnum_samples\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 277\u001b[0m \u001b[43m \u001b[49m\u001b[43mreturn_sites\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mreturn_sites\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 278\u001b[0m \u001b[43m \u001b[49m\u001b[43mparallel\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mparallel\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 279\u001b[0m \u001b[43m \u001b[49m\u001b[43mmodel_args\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 280\u001b[0m \u001b[43m \u001b[49m\u001b[43mmodel_kwargs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 281\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m/storage/achaudhuri/envs/anaconda3/envs/askem/lib/python3.9/site-packages/pyro/infer/predictive.py:127\u001b[0m, in \u001b[0;36m_predictive\u001b[0;34m(model, posterior_samples, num_samples, return_sites, return_trace, parallel, model_args, model_kwargs)\u001b[0m\n\u001b[1;32m 124\u001b[0m return_site_shapes[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m_RETURN\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m shape\n\u001b[1;32m 126\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m parallel:\n\u001b[0;32m--> 127\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43m_predictive_sequential\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 128\u001b[0m \u001b[43m \u001b[49m\u001b[43mmodel\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 129\u001b[0m \u001b[43m \u001b[49m\u001b[43mposterior_samples\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 130\u001b[0m \u001b[43m \u001b[49m\u001b[43mmodel_args\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 131\u001b[0m \u001b[43m \u001b[49m\u001b[43mmodel_kwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 132\u001b[0m \u001b[43m \u001b[49m\u001b[43mnum_samples\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 133\u001b[0m \u001b[43m \u001b[49m\u001b[43mreturn_site_shapes\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 134\u001b[0m \u001b[43m \u001b[49m\u001b[43mreturn_trace\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m 135\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 137\u001b[0m trace \u001b[38;5;241m=\u001b[39m poutine\u001b[38;5;241m.\u001b[39mtrace(\n\u001b[1;32m 138\u001b[0m poutine\u001b[38;5;241m.\u001b[39mcondition(vectorize(model), reshaped_samples)\n\u001b[1;32m 139\u001b[0m )\u001b[38;5;241m.\u001b[39mget_trace(\u001b[38;5;241m*\u001b[39mmodel_args, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mmodel_kwargs)\n\u001b[1;32m 140\u001b[0m predictions \u001b[38;5;241m=\u001b[39m {}\n", + "File \u001b[0;32m/storage/achaudhuri/envs/anaconda3/envs/askem/lib/python3.9/site-packages/pyro/infer/predictive.py:48\u001b[0m, in \u001b[0;36m_predictive_sequential\u001b[0;34m(model, posterior_samples, model_args, model_kwargs, num_samples, return_site_shapes, return_trace)\u001b[0m\n\u001b[1;32m 44\u001b[0m samples \u001b[38;5;241m=\u001b[39m [\n\u001b[1;32m 45\u001b[0m {k: v[i] \u001b[38;5;28;01mfor\u001b[39;00m k, v \u001b[38;5;129;01min\u001b[39;00m posterior_samples\u001b[38;5;241m.\u001b[39mitems()} \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(num_samples)\n\u001b[1;32m 46\u001b[0m ]\n\u001b[1;32m 47\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(num_samples):\n\u001b[0;32m---> 48\u001b[0m trace \u001b[38;5;241m=\u001b[39m \u001b[43mpoutine\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtrace\u001b[49m\u001b[43m(\u001b[49m\u001b[43mpoutine\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcondition\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmodel\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msamples\u001b[49m\u001b[43m[\u001b[49m\u001b[43mi\u001b[49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget_trace\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 49\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mmodel_args\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mmodel_kwargs\u001b[49m\n\u001b[1;32m 50\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 51\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m return_trace:\n\u001b[1;32m 52\u001b[0m collected\u001b[38;5;241m.\u001b[39mappend(trace)\n", + "File \u001b[0;32m/storage/achaudhuri/envs/anaconda3/envs/askem/lib/python3.9/site-packages/pyro/poutine/trace_messenger.py:198\u001b[0m, in \u001b[0;36mTraceHandler.get_trace\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 190\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mget_trace\u001b[39m(\u001b[38;5;28mself\u001b[39m, \u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[1;32m 191\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 192\u001b[0m \u001b[38;5;124;03m :returns: data structure\u001b[39;00m\n\u001b[1;32m 193\u001b[0m \u001b[38;5;124;03m :rtype: pyro.poutine.Trace\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 196\u001b[0m \u001b[38;5;124;03m Calls this poutine and returns its trace instead of the function's return value.\u001b[39;00m\n\u001b[1;32m 197\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m--> 198\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 199\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mmsngr\u001b[38;5;241m.\u001b[39mget_trace()\n", + "File \u001b[0;32m/storage/achaudhuri/envs/anaconda3/envs/askem/lib/python3.9/site-packages/pyro/poutine/trace_messenger.py:174\u001b[0m, in \u001b[0;36mTraceHandler.__call__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 170\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mmsngr\u001b[38;5;241m.\u001b[39mtrace\u001b[38;5;241m.\u001b[39madd_node(\n\u001b[1;32m 171\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m_INPUT\u001b[39m\u001b[38;5;124m\"\u001b[39m, name\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m_INPUT\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;28mtype\u001b[39m\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124margs\u001b[39m\u001b[38;5;124m\"\u001b[39m, args\u001b[38;5;241m=\u001b[39margs, kwargs\u001b[38;5;241m=\u001b[39mkwargs\n\u001b[1;32m 172\u001b[0m )\n\u001b[1;32m 173\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 174\u001b[0m ret \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfn\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 175\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m (\u001b[38;5;167;01mValueError\u001b[39;00m, \u001b[38;5;167;01mRuntimeError\u001b[39;00m) \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[1;32m 176\u001b[0m exc_type, exc_value, traceback \u001b[38;5;241m=\u001b[39m sys\u001b[38;5;241m.\u001b[39mexc_info()\n", + "File \u001b[0;32m/storage/achaudhuri/envs/anaconda3/envs/askem/lib/python3.9/site-packages/pyro/poutine/messenger.py:12\u001b[0m, in \u001b[0;36m_context_wrap\u001b[0;34m(context, fn, *args, **kwargs)\u001b[0m\n\u001b[1;32m 10\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_context_wrap\u001b[39m(context, fn, \u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[1;32m 11\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m context:\n\u001b[0;32m---> 12\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfn\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m/storage/achaudhuri/envs/anaconda3/envs/askem/lib/python3.9/site-packages/torch/autograd/grad_mode.py:27\u001b[0m, in \u001b[0;36m_DecoratorContextManager.__call__..decorate_context\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 24\u001b[0m \u001b[38;5;129m@functools\u001b[39m\u001b[38;5;241m.\u001b[39mwraps(func)\n\u001b[1;32m 25\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mdecorate_context\u001b[39m(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[1;32m 26\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mclone():\n\u001b[0;32m---> 27\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m/storage/achaudhuri/envs/anaconda3/envs/askem/lib/python3.9/site-packages/pyro/poutine/messenger.py:12\u001b[0m, in \u001b[0;36m_context_wrap\u001b[0;34m(context, fn, *args, **kwargs)\u001b[0m\n\u001b[1;32m 10\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_context_wrap\u001b[39m(context, fn, \u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[1;32m 11\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m context:\n\u001b[0;32m---> 12\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfn\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m/storage/achaudhuri/envs/anaconda3/envs/askem/lib/python3.9/site-packages/pyro/poutine/messenger.py:12\u001b[0m, in \u001b[0;36m_context_wrap\u001b[0;34m(context, fn, *args, **kwargs)\u001b[0m\n\u001b[1;32m 10\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_context_wrap\u001b[39m(context, fn, \u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[1;32m 11\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m context:\n\u001b[0;32m---> 12\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfn\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m/storage/achaudhuri/envs/anaconda3/envs/askem/lib/python3.9/site-packages/pyro/nn/module.py:448\u001b[0m, in \u001b[0;36mPyroModule.__call__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 446\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m__call__\u001b[39m(\u001b[38;5;28mself\u001b[39m, \u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[1;32m 447\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_pyro_context:\n\u001b[0;32m--> 448\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43msuper\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[38;5;21;43m__call__\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 449\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m (\n\u001b[1;32m 450\u001b[0m pyro\u001b[38;5;241m.\u001b[39msettings\u001b[38;5;241m.\u001b[39mget(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mvalidate_poutine\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 451\u001b[0m \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_pyro_context\u001b[38;5;241m.\u001b[39mactive\n\u001b[1;32m 452\u001b[0m \u001b[38;5;129;01mand\u001b[39;00m _is_module_local_param_enabled()\n\u001b[1;32m 453\u001b[0m ):\n\u001b[1;32m 454\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_check_module_local_param_usage()\n", + "File \u001b[0;32m/storage/achaudhuri/envs/anaconda3/envs/askem/lib/python3.9/site-packages/torch/nn/modules/module.py:1194\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *input, **kwargs)\u001b[0m\n\u001b[1;32m 1190\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m 1191\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m 1192\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m 1193\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1194\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;28;43minput\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1195\u001b[0m \u001b[38;5;66;03m# Do not call functions when jit is used\u001b[39;00m\n\u001b[1;32m 1196\u001b[0m full_backward_hooks, non_full_backward_hooks \u001b[38;5;241m=\u001b[39m [], []\n", + "File \u001b[0;32m/storage/achaudhuri/covid_askem/pyciemss/notebook/evaluation/../../src/pyciemss/ODE/base.py:64\u001b[0m, in \u001b[0;36mODE.forward\u001b[0;34m(self, initial_state, tspan, data)\u001b[0m\n\u001b[1;32m 60\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mparam_prior()\n\u001b[1;32m 62\u001b[0m \u001b[38;5;66;03m# Simulate from ODE.\u001b[39;00m\n\u001b[1;32m 63\u001b[0m \u001b[38;5;66;03m# Constant deltaT method like `euler` necessary to get interventions without name collision.\u001b[39;00m\n\u001b[0;32m---> 64\u001b[0m solution \u001b[38;5;241m=\u001b[39m \u001b[43modeint\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mderiv\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43minitial_state\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtspan\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmethod\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43meuler\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m 66\u001b[0m \u001b[38;5;66;03m# Add Observation noise\u001b[39;00m\n\u001b[1;32m 67\u001b[0m observations \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mobservation_model(solution, data)\n", + "File \u001b[0;32m/storage/achaudhuri/envs/anaconda3/envs/askem/lib/python3.9/site-packages/torchdiffeq/_impl/odeint.py:77\u001b[0m, in \u001b[0;36modeint\u001b[0;34m(func, y0, t, rtol, atol, method, options, event_fn)\u001b[0m\n\u001b[1;32m 74\u001b[0m solver \u001b[38;5;241m=\u001b[39m SOLVERS[method](func\u001b[38;5;241m=\u001b[39mfunc, y0\u001b[38;5;241m=\u001b[39my0, rtol\u001b[38;5;241m=\u001b[39mrtol, atol\u001b[38;5;241m=\u001b[39matol, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39moptions)\n\u001b[1;32m 76\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m event_fn \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m---> 77\u001b[0m solution \u001b[38;5;241m=\u001b[39m \u001b[43msolver\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mintegrate\u001b[49m\u001b[43m(\u001b[49m\u001b[43mt\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 78\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 79\u001b[0m event_t, solution \u001b[38;5;241m=\u001b[39m solver\u001b[38;5;241m.\u001b[39mintegrate_until_event(t[\u001b[38;5;241m0\u001b[39m], event_fn)\n", + "File \u001b[0;32m/storage/achaudhuri/envs/anaconda3/envs/askem/lib/python3.9/site-packages/torchdiffeq/_impl/solvers.py:105\u001b[0m, in \u001b[0;36mFixedGridODESolver.integrate\u001b[0;34m(self, t)\u001b[0m\n\u001b[1;32m 103\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m t0, t1 \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mzip\u001b[39m(time_grid[:\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m], time_grid[\u001b[38;5;241m1\u001b[39m:]):\n\u001b[1;32m 104\u001b[0m dt \u001b[38;5;241m=\u001b[39m t1 \u001b[38;5;241m-\u001b[39m t0\n\u001b[0;32m--> 105\u001b[0m dy, f0 \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_step_func\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfunc\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mt0\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdt\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mt1\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my0\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 106\u001b[0m y1 \u001b[38;5;241m=\u001b[39m y0 \u001b[38;5;241m+\u001b[39m dy\n\u001b[1;32m 108\u001b[0m \u001b[38;5;28;01mwhile\u001b[39;00m j \u001b[38;5;241m<\u001b[39m \u001b[38;5;28mlen\u001b[39m(t) \u001b[38;5;129;01mand\u001b[39;00m t1 \u001b[38;5;241m>\u001b[39m\u001b[38;5;241m=\u001b[39m t[j]:\n", + "File \u001b[0;32m/storage/achaudhuri/envs/anaconda3/envs/askem/lib/python3.9/site-packages/torchdiffeq/_impl/fixed_grid.py:10\u001b[0m, in \u001b[0;36mEuler._step_func\u001b[0;34m(self, func, t0, dt, t1, y0)\u001b[0m\n\u001b[1;32m 9\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_step_func\u001b[39m(\u001b[38;5;28mself\u001b[39m, func, t0, dt, t1, y0):\n\u001b[0;32m---> 10\u001b[0m f0 \u001b[38;5;241m=\u001b[39m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[43mt0\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my0\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mperturb\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mPerturb\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mNEXT\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mif\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mperturb\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01melse\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mPerturb\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mNONE\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 11\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m dt \u001b[38;5;241m*\u001b[39m f0, f0\n", + "File \u001b[0;32m/storage/achaudhuri/envs/anaconda3/envs/askem/lib/python3.9/site-packages/torch/nn/modules/module.py:1194\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *input, **kwargs)\u001b[0m\n\u001b[1;32m 1190\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m 1191\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m 1192\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m 1193\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1194\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;28;43minput\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1195\u001b[0m \u001b[38;5;66;03m# Do not call functions when jit is used\u001b[39;00m\n\u001b[1;32m 1196\u001b[0m full_backward_hooks, non_full_backward_hooks \u001b[38;5;241m=\u001b[39m [], []\n", + "File \u001b[0;32m/storage/achaudhuri/envs/anaconda3/envs/askem/lib/python3.9/site-packages/torchdiffeq/_impl/misc.py:189\u001b[0m, in \u001b[0;36m_PerturbFunc.forward\u001b[0;34m(self, t, y, perturb)\u001b[0m\n\u001b[1;32m 186\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 187\u001b[0m \u001b[38;5;66;03m# Do nothing.\u001b[39;00m\n\u001b[1;32m 188\u001b[0m \u001b[38;5;28;01mpass\u001b[39;00m\n\u001b[0;32m--> 189\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbase_func\u001b[49m\u001b[43m(\u001b[49m\u001b[43mt\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m/storage/achaudhuri/envs/anaconda3/envs/askem/lib/python3.9/site-packages/torch/nn/modules/module.py:1194\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *input, **kwargs)\u001b[0m\n\u001b[1;32m 1190\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m 1191\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m 1192\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m 1193\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1194\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;28;43minput\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1195\u001b[0m \u001b[38;5;66;03m# Do not call functions when jit is used\u001b[39;00m\n\u001b[1;32m 1196\u001b[0m full_backward_hooks, non_full_backward_hooks \u001b[38;5;241m=\u001b[39m [], []\n", + "File \u001b[0;32m/storage/achaudhuri/envs/anaconda3/envs/askem/lib/python3.9/site-packages/torchdiffeq/_impl/misc.py:138\u001b[0m, in \u001b[0;36m_TupleFunc.forward\u001b[0;34m(self, t, y)\u001b[0m\n\u001b[1;32m 137\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mforward\u001b[39m(\u001b[38;5;28mself\u001b[39m, t, y):\n\u001b[0;32m--> 138\u001b[0m f \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbase_func\u001b[49m\u001b[43m(\u001b[49m\u001b[43mt\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m_flat_to_shape\u001b[49m\u001b[43m(\u001b[49m\u001b[43my\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mshapes\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 139\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m torch\u001b[38;5;241m.\u001b[39mcat([f_\u001b[38;5;241m.\u001b[39mreshape(\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m) \u001b[38;5;28;01mfor\u001b[39;00m f_ \u001b[38;5;129;01min\u001b[39;00m f])\n", + "File \u001b[0;32m/storage/achaudhuri/envs/anaconda3/envs/askem/lib/python3.9/site-packages/pyro/nn/module.py:677\u001b[0m, in \u001b[0;36mpyro_method..cached_fn\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 674\u001b[0m \u001b[38;5;129m@functools\u001b[39m\u001b[38;5;241m.\u001b[39mwraps(fn)\n\u001b[1;32m 675\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mcached_fn\u001b[39m(\u001b[38;5;28mself\u001b[39m, \u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[1;32m 676\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_pyro_context:\n\u001b[0;32m--> 677\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfn\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m/storage/achaudhuri/covid_askem/pyciemss/notebook/evaluation/../../src/pyciemss/ODE/models.py:335\u001b[0m, in \u001b[0;36mSIDARTHEV.deriv\u001b[0;34m(self, t, state)\u001b[0m\n\u001b[1;32m 332\u001b[0m \u001b[38;5;66;03m# Local fluxes exposed to pyro for interventions.\u001b[39;00m\n\u001b[1;32m 333\u001b[0m \u001b[38;5;66;03m# Note: This only works with solvers that use fixed time increments, such as Euler's method. Otherwise, we have name collisions.\u001b[39;00m\n\u001b[1;32m 334\u001b[0m SI_flux_ \u001b[38;5;241m=\u001b[39m pyro\u001b[38;5;241m.\u001b[39mdeterministic(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mSI_flux \u001b[39m\u001b[38;5;132;01m%f\u001b[39;00m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;241m%\u001b[39m (t), \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39malpha \u001b[38;5;241m*\u001b[39m S \u001b[38;5;241m*\u001b[39m I \u001b[38;5;241m/\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mN)\n\u001b[0;32m--> 335\u001b[0m SD_flux_ \u001b[38;5;241m=\u001b[39m \u001b[43mpyro\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdeterministic\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mSD_flux \u001b[39;49m\u001b[38;5;132;43;01m%f\u001b[39;49;00m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m%\u001b[39;49m\u001b[43m \u001b[49m\u001b[43m(\u001b[49m\u001b[43mt\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbeta\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mS\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mD\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m/\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mN\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 336\u001b[0m SA_flux_ \u001b[38;5;241m=\u001b[39m pyro\u001b[38;5;241m.\u001b[39mdeterministic(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mSA_flux \u001b[39m\u001b[38;5;132;01m%f\u001b[39;00m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;241m%\u001b[39m (t), \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mgamma \u001b[38;5;241m*\u001b[39m S \u001b[38;5;241m*\u001b[39m A \u001b[38;5;241m/\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mN)\n\u001b[1;32m 337\u001b[0m SR_flux_ \u001b[38;5;241m=\u001b[39m pyro\u001b[38;5;241m.\u001b[39mdeterministic(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mSR_flux \u001b[39m\u001b[38;5;132;01m%f\u001b[39;00m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;241m%\u001b[39m (t), \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdelta \u001b[38;5;241m*\u001b[39m S \u001b[38;5;241m*\u001b[39m R \u001b[38;5;241m/\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mN)\n", + "File \u001b[0;32m/storage/achaudhuri/envs/anaconda3/envs/askem/lib/python3.9/site-packages/pyro/primitives.py:211\u001b[0m, in \u001b[0;36mdeterministic\u001b[0;34m(name, value, event_dim)\u001b[0m\n\u001b[1;32m 192\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 193\u001b[0m \u001b[38;5;124;03mDeterministic statement to add a :class:`~pyro.distributions.Delta` site\u001b[39;00m\n\u001b[1;32m 194\u001b[0m \u001b[38;5;124;03mwith name `name` and value `value` to the trace. This is useful when we\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 206\u001b[0m \u001b[38;5;124;03m:param int event_dim: Optional event dimension, defaults to `value.ndim`.\u001b[39;00m\n\u001b[1;32m 207\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 208\u001b[0m event_dim \u001b[38;5;241m=\u001b[39m value\u001b[38;5;241m.\u001b[39mndim \u001b[38;5;28;01mif\u001b[39;00m event_dim \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;28;01melse\u001b[39;00m event_dim\n\u001b[1;32m 209\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m sample(\n\u001b[1;32m 210\u001b[0m name,\n\u001b[0;32m--> 211\u001b[0m \u001b[43mdist\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mDelta\u001b[49m\u001b[43m(\u001b[49m\u001b[43mvalue\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mevent_dim\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mevent_dim\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241m.\u001b[39mmask(\u001b[38;5;28;01mFalse\u001b[39;00m),\n\u001b[1;32m 212\u001b[0m obs\u001b[38;5;241m=\u001b[39mvalue,\n\u001b[1;32m 213\u001b[0m infer\u001b[38;5;241m=\u001b[39m{\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m_deterministic\u001b[39m\u001b[38;5;124m\"\u001b[39m: \u001b[38;5;28;01mTrue\u001b[39;00m},\n\u001b[1;32m 214\u001b[0m )\n", + "File \u001b[0;32m/storage/achaudhuri/envs/anaconda3/envs/askem/lib/python3.9/site-packages/pyro/distributions/distribution.py:24\u001b[0m, in \u001b[0;36mDistributionMeta.__call__\u001b[0;34m(cls, *args, **kwargs)\u001b[0m\n\u001b[1;32m 22\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m result \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 23\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m result\n\u001b[0;32m---> 24\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43msuper\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[38;5;21;43m__call__\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m/storage/achaudhuri/envs/anaconda3/envs/askem/lib/python3.9/site-packages/pyro/distributions/delta.py:33\u001b[0m, in \u001b[0;36mDelta.__init__\u001b[0;34m(self, v, log_density, event_dim, validate_args)\u001b[0m\n\u001b[1;32m 32\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m__init__\u001b[39m(\u001b[38;5;28mself\u001b[39m, v, log_density\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m0.0\u001b[39m, event_dim\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m0\u001b[39m, validate_args\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m):\n\u001b[0;32m---> 33\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m event_dim \u001b[38;5;241m>\u001b[39m \u001b[43mv\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdim\u001b[49m():\n\u001b[1;32m 34\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\n\u001b[1;32m 35\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mExpected event_dim <= v.dim(), actual \u001b[39m\u001b[38;5;132;01m{}\u001b[39;00m\u001b[38;5;124m vs \u001b[39m\u001b[38;5;132;01m{}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;241m.\u001b[39mformat(\n\u001b[1;32m 36\u001b[0m event_dim, v\u001b[38;5;241m.\u001b[39mdim()\n\u001b[1;32m 37\u001b[0m )\n\u001b[1;32m 38\u001b[0m )\n\u001b[1;32m 39\u001b[0m batch_dim \u001b[38;5;241m=\u001b[39m v\u001b[38;5;241m.\u001b[39mdim() \u001b[38;5;241m-\u001b[39m event_dim\n", + "\u001b[0;31mKeyboardInterrupt\u001b[0m: " + ] + } + ], + "source": [ + "pyro.set_rng_seed(0)\n", + "\n", + "POLICY = np.array([0.025])\n", + "N_SAMPLES = 50\n", + "\n", + "RISK = computeRisk(model=control_model,\n", + " intervention_fun=INTERVENTION,\n", + " qoi=lambda y: max_total_infections_SIDARTHE(y, contexts=[\"I_total_obs\"]),\n", + " risk_measure=alpha_superquantile,\n", + " num_samples=N_SAMPLES,\n", + " model_state=initial_state,\n", + " tspan=tspan,\n", + " guide=None)\n", + "\n", + "start_time = time.time()\n", + "sq_dataCube = RISK.propagate_uncertainty(POLICY)\n", + "end_time = time.time()\n", + "forward_time = end_time - start_time\n", + "time_per_eval = forward_time / N_SAMPLES\n", + "print(f\"Forward UQ took {forward_time:.2f} seconds total ({forward_time/N_SAMPLES:.2e} seconds per model evaluation).\")\n", + "sq_qoi = RISK.qoi(sq_dataCube)\n", + "sq_sv = RISK.risk_measure(sq_qoi)\n", + "\n", + "RISK.risk_measure = alpha_quantile\n", + "q_sv = RISK(POLICY)\n", + "print(q_sv, sq_sv)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "dead83d2", + "metadata": {}, + "outputs": [], + "source": [ + "ax = setup_ax()\n", + "ax = plot_predictive(sq_dataCube, tspan, ax=ax, color=co[1])\n", + "ax.axvline(15)\n", + "sideaxis(ax)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7fc330e1", + "metadata": {}, + "outputs": [], + "source": [ + "bins_hist = 50\n", + "fig1 = plt.figure()\n", + "plt.rc('text', usetex=False)\n", + "plt.rc('font', family='serif', size=18.)\n", + "cax = plt.gca()\n", + "sideaxishist(cax)\n", + "cax.hist(sq_qoi, color=co[2], bins=bins_hist, histtype='stepfilled', alpha=0.5, label='total infections')\n", + "miny = min(cax.get_ylim())\n", + "maxy = max(cax.get_ylim())\n", + "cax.vlines(q_sv, miny, maxy, linestyle='--', linewidth=2.5, label='alpha-quantile', color=co[0])\n", + "cax.vlines(sq_sv, miny, maxy, linestyle='--', linewidth=2.5, label='alpha-superquantile', color=co[1])\n", + "cax.set_xlabel('Maximum total infections over 100 days', size=14)\n", + "cax.legend(loc='upper right', prop={'size': 14})" + ] + }, + { + "cell_type": "markdown", + "id": "2a4005a9", + "metadata": {}, + "source": [ + "## Risk-based optimization under uncertainty with intervention on $\\phi$\n", + "**NOTE:** This is a demonstration of the interface, optimization is not run to convergence nor are enough samples generated to accurately estimate the risk, so take the results with a grain of salt." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ba6b2d82", + "metadata": {}, + "outputs": [], + "source": [ + "# Define problem specifics.\n", + "RISK_BOUND = 1./3.\n", + "RISK_ALPHA = 0.95\n", + "X_MIN = 0.\n", + "X_MAX = 3.\n", + "N_SAMPLES = int(5e2)\n", + "MAXITER = 0\n", + "MAXFEVAL = 30\n", + "\n", + "INIT_GUESS = 0.025\n", + "\n", + "# Objective function.\n", + "OBJFUN = lambda x: x # minimize the scalar value itself.\n", + "\n", + "# Define the risk measure.\n", + "RISK = computeRisk(\n", + " model=control_model,\n", + " intervention_fun=INTERVENTION,\n", + " qoi=lambda y: max_total_infections_SIDARTHE(y, contexts=[\"I_total_obs\"]),\n", + " model_state=initial_state,\n", + " tspan=tspan,\n", + " risk_measure=lambda z: alpha_superquantile(z, alpha=RISK_ALPHA),\n", + " num_samples=N_SAMPLES,\n", + " guide=None,\n", + " )\n", + "\n", + "# Define problem constraints.\n", + "CONSTRAINTS = (\n", + " # risk constraint\n", + " {'type': 'ineq', 'fun': lambda x: RISK_BOUND - RISK(x)},\n", + "\n", + " # bounds on control\n", + " # NOTE: perhaps use scipy.optimize.LinearConstraint in the future\n", + " {'type': 'ineq', 'fun': lambda x: x - X_MIN},\n", + " {'type': 'ineq', 'fun': lambda x: X_MAX - x}\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "13a9803a", + "metadata": { + "scrolled": false + }, + "outputs": [], + "source": [ + "print(\"Performing risk-based optimization under uncertainty (using alpha-superquantile)...\")\n", + "print(f\"Estimated wait time {time_per_eval*N_SAMPLES*(MAXITER+1)*MAXFEVAL:.1f} seconds.\")\n", + "start_time = time.time()\n", + "sq_result_1 = solveOUU(\n", + " x0=INIT_GUESS,\n", + " objfun=OBJFUN,\n", + " constraints=CONSTRAINTS,\n", + " maxiter=MAXITER,\n", + " maxfeval=MAXFEVAL,\n", + " ).solve()\n", + "print(f\"Optimization completed in time {time.time()-start_time:.2f} seconds. Optimal solution:\\t{sq_result_1.x}\")" + ] + }, + { + "cell_type": "markdown", + "id": "abfeda8c", + "metadata": {}, + "source": [ + "## Assess the effect of the control policy." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "60c9d1a9", + "metadata": { + "scrolled": false + }, + "outputs": [], + "source": [ + "RISK.num_samples = int(5e2)\n", + "sq_optimal_prediction = RISK.propagate_uncertainty(sq_result_1.x)\n", + "qois_sq = RISK.qoi(sq_optimal_prediction)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c92e52b7", + "metadata": {}, + "outputs": [], + "source": [ + "ax = setup_ax()\n", + "# print(sq_optimal_prediction.shape)\n", + "ax = plot_predictive(sq_optimal_prediction, tspan, ax=ax, color=co[2], ptiles=[0.0,1.])\n", + "plt.title(\"Optimal theta, epsilon parameter intervention (theta>=2*epsilon) \\n with risk-based OUU\", size=14)\n", + "sideaxis(ax)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "13bf129e", + "metadata": {}, + "outputs": [], + "source": [ + "bins_hist = 50\n", + "fig1 = plt.figure()\n", + "plt.rc('font', family='serif', size=14.)\n", + "cax = plt.gca()\n", + "sideaxishist(cax)\n", + "cax.hist(qois_sq, color=co[4], bins=bins_hist, histtype='stepfilled', alpha=0.5, density=True)\n", + "miny = min(cax.get_ylim())\n", + "maxy = max(cax.get_ylim())\n", + "cax.set_xlabel('Maximum total infections over 100 days', size=14)" + ] + } + ], + "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.9.7" + }, + "vscode": { + "interpreter": { + "hash": "a3e1d8fdda916c248c87d86618e3945b28961cf939001a0529e724463670a41a" + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/6-month-milestone/evaluation/scenario_2/ta_3/ciemss/scenario2_q2b_SIDARTHEV_alpha.ipynb b/6-month-milestone/evaluation/scenario_2/ta_3/ciemss/scenario2_q2b_SIDARTHEV_alpha.ipynb new file mode 100644 index 0000000..66f7330 --- /dev/null +++ b/6-month-milestone/evaluation/scenario_2/ta_3/ciemss/scenario2_q2b_SIDARTHEV_alpha.ipynb @@ -0,0 +1,802 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "b087c52b-a505-45d3-b643-df44d8c924a5", + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "markdown", + "id": "542b06c1-28fb-47ec-9a34-170acc7d2a84", + "metadata": {}, + "source": [ + "# Load Dependencies" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "84e0bb12-68af-4a6d-a384-db4837c44ac0", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "import torch\n", + "\n", + "import pyro\n", + "import numpy as np\n", + "import pyro.distributions as dist\n", + "# from pyro.poutine import trace, replay, block\n", + "# from pyro.infer.autoguide.guides import AutoDelta, AutoNormal\n", + "# from pyro.infer import SVI, Trace_ELBO, Predictive\n", + "\n", + "import sys\n", + "sys.path.append(\"../../src/\")\n", + "\n", + "from pyciemss.ODE.askem_primitives import sample, infer_parameters, intervene, optimization\n", + "\n", + "# from pyciemss.utils import run_inference, get_tspan\n", + "from pyciemss.utils import get_tspan\n", + "\n", + "import warnings\n", + "warnings.filterwarnings('ignore')" + ] + }, + { + "cell_type": "markdown", + "id": "4855961d-9c38-4050-b6b7-aaae03500fc9", + "metadata": {}, + "source": [ + "# Plotting Utilities" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "260901d9", + "metadata": {}, + "outputs": [], + "source": [ + "def setup_ax(ax=None):\n", + "\n", + " if not ax:\n", + " fig = plt.figure(facecolor='w', figsize=(9, 5))\n", + " ax = fig.add_subplot(111, axisbelow=True)\n", + "\n", + " ax.set_xlabel('Time (days)')\n", + " ax.set_ylabel('Total infected')\n", + " return ax\n", + "\n", + "def plot_predictive(prediction, tspan, tmin=None, ax=None, alpha=0.2, color=\"black\", ptiles=[0.05,0.95], **kwargs):\n", + " vars = [\"I_total_obs\"]\n", + " #infection_total = sum([prediction[x].squeeze().detach().numpy()/1000. for x in ['I_obs', 'D_obs', 'A_obs', 'R_obs', 'T_obs']])\n", + "\n", + " I_low = torch.quantile(prediction[\"I_total_obs\"], ptiles[0], dim=0).detach().numpy()\n", + " I_up = torch.quantile(prediction[\"I_total_obs\"], ptiles[1], dim=0).detach().numpy()\n", + "\n", + " if tmin:\n", + " indeces = tspan >= tmin\n", + " else:\n", + " indeces = torch.ones_like(tspan).bool()\n", + "\n", + " if not ax:\n", + " fig = plt.figure(facecolor='w')\n", + " ax = fig.add_subplot(111, facecolor='#dddddd', axisbelow=True)\n", + " \n", + " ax.fill_between(tspan[indeces], I_low[indeces], I_up[indeces], alpha=alpha, color=color, **kwargs)\n", + "\n", + " legend = ax.legend()\n", + " legend.get_frame().set_alpha(0.5)\n", + "\n", + " return ax\n", + "\n", + "def plot_trajectory(data, tspan, ax=None, color='black', alpha=0.5, lw=0, marker='.', label=None, ind=0):\n", + " # Plot the data on three separate curves for S(t), I(t) and R(t)\n", + " if len(data['I_total_obs'].squeeze().detach().numpy().shape)>1:\n", + " plot_data = data['I_total_obs'].squeeze().detach().numpy()[ind,:]\n", + " else:\n", + " plot_data = data['I_total_obs'].squeeze().detach().numpy()\n", + "\n", + " if not ax:\n", + " fig = plt.figure(facecolor='w')\n", + " ax = fig.add_subplot(111, facecolor='#dddddd', axisbelow=True)\n", + " #infection_total = sum([data[x].squeeze().detach().numpy()/1000. for x in ['I_obs', 'D_obs', 'A_obs', 'R_obs', 'T_obs']])\n", + " ax.plot(tspan, plot_data, color, alpha=alpha, lw=lw, marker=marker, label=label)\n", + " \n", + " return ax\n", + "\n", + "def plot_intervention_line(t, ax=None):\n", + " if not ax:\n", + " fig = plt.figure(facecolor='w')\n", + " ax = fig.add_subplot(111, facecolor='#dddddd', axisbelow=True)\n", + "\n", + " ylim = ax.get_ylim()\n", + "\n", + " ax.vlines(t, min(ylim), max(ylim), color=\"grey\", ls='-')\n", + "\n", + " return ax\n", + "\n", + "def sideaxis(ax):\n", + " ax.spines['top'].set_visible(False)\n", + " ax.spines['right'].set_visible(False)\n", + " return\n", + "\n", + "def sideaxishist(ax):\n", + " ax.spines['top'].set_visible(False)\n", + " ax.spines['right'].set_visible(False)\n", + " ax.spines['left'].set_visible(False)\n", + " # For y-axis\n", + " ax.yaxis.set_major_locator(ticker.NullLocator())\n", + " ax.tick_params(axis='x', labelsize=12) # change fontsize for x-axis tick labels\n", + " # ax.xaxis.major.formatter._useMathText = True\n", + " return" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "f233104e-c29d-4e25-859f-2a328ec7892a", + "metadata": {}, + "outputs": [], + "source": [ + "def LogNormalPrior(mean, variance):\n", + " mu = torch.log(mean**2/torch.sqrt((mean**2 + variance)))\n", + " scale = torch.sqrt(torch.log(1 + variance/mean**2))\n", + " return dist.LogNormal(mu, scale)\n", + "\n", + "def LogNormalPrior_propVar(mean, cov=0.05):\n", + " variance = mean*cov \n", + " return LogNormalPrior(mean, variance)" + ] + }, + { + "cell_type": "markdown", + "id": "3e0c3726-5ec0-475d-8305-f20b5d84e424", + "metadata": {}, + "source": [ + "# Setup Parameters" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "16608500-97b5-4081-9e6b-b7c193c10285", + "metadata": {}, + "outputs": [], + "source": [ + "tspan = get_tspan(1, 100, 100)\n", + "\n", + "num_samples = 50\n", + "\n", + "# Total population, N.\n", + "N = 1\n", + "# Initial number of infected and recovered individuals, I0 and R0.\n", + "I0, D0, A0, R0, T0, H0, E0, V0 = 200/60e6, 20/60e6, 1/60e6, 2/60e6, 0, 0, 0, 0\n", + "\n", + "# Everyone else, S0, is susceptible to infection initially.\n", + "S0 = N - I0 - D0 - A0 - R0 - T0 - H0 - E0 - V0\n", + "\n", + "initial_state = tuple(torch.as_tensor(s) for s in (S0, I0, D0, A0, R0, T0, H0, E0, V0))" + ] + }, + { + "cell_type": "markdown", + "id": "23fc9c9d-f8bc-4e95-a243-865690d3b43b", + "metadata": {}, + "source": [ + "# Probabilistic Forecasting - Passing unit test 1\n", + "There are two ‘unit tests’ we want to pass, to ensure that we understood and can reproduce the published model:\n", + "\n", + "## 1.a Unit Test \\#1:\n", + "\n", + "Set the initial values and parameters, as described in the Supplementary Methods section of the publication (pg. 9 of the pdf): \n", + "\n", + "1. Initial Values: \n", + "* $I = 200/60e6$,\n", + "* $D = 20/60e6$, \n", + "* $A = 1/60e6$, \n", + "* $R = 2/60e6$, \n", + "* $T = 0$, \n", + "* $H = 0$, \n", + "* $E = 0$; \n", + "* $S = 1 – I – D – A – R – T – H – E$. \n", + "\n", + "Let total population = 60e6.\n", + "Parameters: $$\\alpha = 0.570, \\beta = \\delta = 0.011, \\gamma = 0.456, \\epsilon = 0.171, \\theta = 0.371, \\zeta = \\eta = 0.125, \\mu = 0.017, \\nu = 0.027, \\tau = 0.01, \\lambda = \\rho = 0.034$$ and $$\\kappa = \\xi = \\sigma = 0.017$$." + ] + }, + { + "cell_type": "markdown", + "id": "f6228f01", + "metadata": {}, + "source": [ + "### Deterministic forecasting" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "dbd7d430-325f-4f40-9b20-d8a0c0264f62", + "metadata": {}, + "outputs": [], + "source": [ + "from pyciemss.ODE.models import SIDARTHEV\n", + "\n", + "pyro.set_rng_seed(0)\n", + "\n", + "ode_model = SIDARTHEV(N=1,\n", + " alpha_prior=dist.Delta(torch.tensor (0.570)) ,\n", + " beta_prior=dist.Delta(torch.tensor (0.011)) ,\n", + " gamma_prior=dist.Delta(torch.tensor (0.456)) ,\n", + " delta_prior=dist.Delta(torch.tensor (0.011)) ,\n", + " epsilon_prior=dist.Delta(torch.tensor (0.171)) ,\n", + " lamb_prior =dist.Delta(torch.tensor (0.034)) ,\n", + " zeta_prior=dist.Delta(torch.tensor (0.125)) ,\n", + " eta_prior=dist.Delta(torch.tensor (0.125)) ,\n", + " kappa_prior=dist.Delta(torch.tensor (0.017)) ,\n", + " theta_prior=dist.Delta(torch.tensor (0.371)) ,\n", + " rho_prior=dist.Delta(torch.tensor (0.034)) ,\n", + " xi_prior=dist.Delta(torch.tensor (0.017)) ,\n", + " sigma_prior=dist.Delta(torch.tensor (0.017)) ,\n", + " mu_prior=dist.Delta(torch.tensor (0.017)) ,\n", + " nu_prior=dist.Delta(torch.tensor (0.027)) ,\n", + " tau2_prior=dist.Delta(torch.tensor (0.01)) ,\n", + " phi_prior=dist.Delta(torch.tensor (0.)) )" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "31473cdd-9896-42ed-b487-36362c1c9744", + "metadata": { + "scrolled": false + }, + "outputs": [], + "source": [ + "single_prediction = sample(ode_model, 1, initial_state, tspan)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "15f03c6f-d085-4f36-bc7a-312057d82758", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ax = plot_trajectory(single_prediction, tspan, ax=setup_ax(), color=\"blue\", marker='', lw=1., label=\"Before Seeing Data - Single Forecast\")\n", + "ax.axvline(47)" + ] + }, + { + "cell_type": "markdown", + "id": "7c9b53f3", + "metadata": {}, + "source": [ + "### Probabilistic forecasting" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "a8cebc75-730c-43f8-9081-ba846098f669", + "metadata": {}, + "outputs": [], + "source": [ + "pyro.set_rng_seed(0)\n", + "\n", + "# var_prior = 0.05**2\n", + "mean_values = np.array([])\n", + "\n", + "ode_model = SIDARTHEV(N=1,\n", + " alpha_prior=LogNormalPrior_propVar(torch.tensor(0.570)) ,\n", + " beta_prior=LogNormalPrior_propVar(torch.tensor(0.011)) ,\n", + " gamma_prior=LogNormalPrior_propVar(torch.tensor(0.456)) ,\n", + " delta_prior=LogNormalPrior_propVar(torch.tensor(0.011)) ,\n", + " epsilon_prior=LogNormalPrior_propVar(torch.tensor(0.171)) ,\n", + " lamb_prior =LogNormalPrior_propVar(torch.tensor(0.034)) ,\n", + " zeta_prior=LogNormalPrior_propVar(torch.tensor(0.125)) ,\n", + " eta_prior=LogNormalPrior_propVar(torch.tensor(0.125)) ,\n", + " kappa_prior=LogNormalPrior_propVar(torch.tensor(0.017)) ,\n", + " theta_prior=LogNormalPrior_propVar(torch.tensor(0.371)) ,\n", + " rho_prior=LogNormalPrior_propVar(torch.tensor(0.034)) ,\n", + " xi_prior=LogNormalPrior_propVar(torch.tensor(0.017)) ,\n", + " sigma_prior=LogNormalPrior_propVar(torch.tensor(0.017)) ,\n", + " mu_prior=LogNormalPrior_propVar(torch.tensor(0.017)) ,\n", + " nu_prior=LogNormalPrior_propVar(torch.tensor(0.027)) ,\n", + " tau2_prior=LogNormalPrior_propVar(torch.tensor(0.01)) ,\n", + " phi_prior=dist.Delta(torch.tensor (0.)) )\n", + "\n", + "# interventions = {\"alpha\": SI_alpha_intervention,\n", + "# \"beta\": SD_beta_intervention,\n", + "# \"gamma\": SA_gamma_intervention,\n", + "# \"delta\": SR_delta_intervention,\n", + "# \"epsilon\": ID_epsilon_intervention,\n", + "# \"lambda\": IH_lamb_intervention,\n", + "# \"zeta\": IA_zeta_intervention,\n", + "# \"eta\": DR_eta_intervention,\n", + "# \"kappa\": AH_kappa_intervention,\n", + "# # \"theta\": AR_theta_intervention,\n", + "# \"rho\": DH_rho_intervention,\n", + "# \"xi\": RH_xi_intervention,\n", + "# \"sigma\": TH_sigma_intervention,\n", + "# \"mu\": AT_mu_intervention,\n", + "# \"nu\": RT_nu_intervention}" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "795ecb3a", + "metadata": {}, + "outputs": [], + "source": [ + "prior_prediction = sample(ode_model, num_samples, initial_state, tspan)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "f62475f8", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ax1 = plot_predictive(prior_prediction, tspan, ax=setup_ax(), label=\"probabilistic forecast\", color=\"red\")\n", + "ax1.axvline(30)\n", + "sideaxis(ax1)" + ] + }, + { + "cell_type": "markdown", + "id": "c65bcf10-9d12-4efe-be10-cc313e123d14", + "metadata": {}, + "source": [ + "## 1.d Policies that prevent infections from exceeding 1/3 of the population\n", + "\n", + "Now return to the situation in b.i (constant parameters that don’t change over time). Let’s say we want to increase testing, diagnostics, and contact tracing efforts (implemented by increasing the detection parameters and ). Assume that $\\theta \\ge 2\\epsilon$ , because a symptomatic person is more likely to be tested. What minimum constant values do these parameters need to be over the course of a 100-day simulation, to ensure that the total infected population (sum over all the infected states I, D, A, R, T) never rises above 1/3 of the total population?\n", + "\n", + "\n", + "### Problem Formulation\n", + "* **Quantity of interest**: Total infections out of $N=60,000,000$ population\n", + "$$I_{total}(t; \\mathbf{u}, \\mathbf{Z}) = I(t) + D(t) + A(t) + R(t) + T(t)$$\n", + "\n", + "A conservative estimate for the quantity of interest is\n", + "$$M(u, Z) = \\max_{1\\leq t \\leq 100} I_{total}(t; \\mathbf{u}, \\mathbf{Z})/N$$\n", + "\n", + "\n", + "\n", + "\n", + "* **Control**: $\\mathbf{u}\\in \\mathcal{U} \\subseteq \\mathbb{R}^{n_u}$\n", + " * Detection parameter for Infected ($\\epsilon$) assuming that $\\theta=2\\epsilon$\n", + " * Two detection parameters $\\theta, \\epsilon$, constraining $\\theta \\ge 2\\epsilon$.\n", + " \n", + "\n", + "\n", + "* **Risk-based optimization under uncertainty problem formulation**\n", + " * Objective Function - Minimize the magnitude of the parameter interventions.\n", + " * Constraint - Risk of normalized total infections exceeding the prescribed threshold of $1/3$, $\\mathcal{R}( M(\\mathbf{u},\\mathbf{Z}))$, is below the acceptable risk threshold, $\\mathcal{R}_\\text{threshold}$.\n", + "\n", + "\\begin{equation} \n", + "\\begin{split} \n", + "\\mathbf{u}^*= \\underset{\\mathbf{u}\\in\\mathcal{U}}{\\arg\\min}\\ & \\lVert \\mathbf{u} \\rVert_1 \\\\ \\text{s.t.}\\ & \\mathcal{R}( M(\\mathbf{u}, \\theta)) \\le \\mathcal{R}_\\text{threshold} \n", + "\\end{split} \n", + "\\end{equation}\n", + "\n", + "#### Formulation 1: Optimize $u=\\{\\alpha, \\beta, \\gamma, \\delta\\}$\n", + "\\begin{equation} \n", + "\\begin{split} \n", + "u^*= \\underset{\\epsilon\\in\\mathcal{U}}{\\arg\\min}\\ & u\\\\ \\text{s.t.}\\ & \\mathbb{P}( M(u, \\mathbf{Z}) \\ge 1/3) \\le 0.05\n", + "\\end{split} \n", + "\\end{equation}\n", + "\n", + "#### Formulation 2: Optimize $\\epsilon$ and $\\theta$ constraining $\\theta \\ge 2\\epsilon$\n", + "\\begin{equation} \n", + "\\begin{split} \n", + "\\epsilon^\\ast, \\theta^\\ast= \\underset{\\{\\epsilon,\\theta\\}\\in\\mathcal{U}}{\\arg\\min}\\ & \\theta + \\epsilon \\\\ \\text{s.t.}\\ & \\mathbb{P}( M(\\epsilon,\\theta, \\mathbf{Z}) \\ge 1/3) \\le 0.05, \\\\\n", + "& \\theta \\ge 2\\epsilon\n", + "\\end{split} \n", + "\\end{equation}\n", + "\n", + "Instead of probability of exceedance, we will use superquantiles as risk measures." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "97ab7988", + "metadata": {}, + "outputs": [], + "source": [ + "from causal_pyro.query.do_messenger import do\n", + "import time\n", + "import pickle\n", + "\n", + "import numpy as np\n", + "from scipy import stats\n", + "from matplotlib import ticker\n", + "\n", + "from pyciemss.ODE.interventions import parameter_intervention_builder, time_and_state_dependent_intervention_builder, time_dependent_intervention_builder\n", + "from pyciemss.risk.risk_measures import alpha_quantile, alpha_superquantile\n", + "from pyciemss.risk.ouu import computeRisk, solveOUU\n", + "from pyciemss.risk.qoi import max_total_infections_SIDARTHE\n", + "import scipy\n", + "\n", + "\n", + "co = ['#377eb8', '#ff7f00', '#984ea3', '#ffd92f', '#a65628']\n", + "rlabel = ['Q_alpha-based OUU', 'barQ_alpha-based OUU']" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "161b391b", + "metadata": {}, + "outputs": [], + "source": [ + "def delayed_intervention_controller(name, x, init_value):\n", + " def delayed_intervention(t, flux):\n", + " if t<15:\n", + " return flux\n", + " else:\n", + " return flux/init_value*x\n", + " return time_and_state_dependent_intervention_builder(name, delayed_intervention, tspan) \n", + "\n", + "def delayed_intervention_controller_flux(name, x):\n", + " def delayed_intervention(t):\n", + " if t<15:\n", + " return torch.tensor(0.)\n", + " else:\n", + " return x\n", + " return time_dependent_intervention_builder(name, delayed_intervention, tspan) " + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "12a672fa", + "metadata": {}, + "outputs": [], + "source": [ + "alpha_init = 0.57\n", + "# Control action / intervention\n", + "param_intervention = parameter_intervention_builder(\"alpha\", alpha_init)\n", + "control_model = intervene(ode_model,param_intervention)\n", + "\n", + "INTERVENTION = lambda x: delayed_intervention_controller(\"SI_flux\", torch.from_numpy(np.array([x])), alpha_init)" + ] + }, + { + "cell_type": "markdown", + "id": "5fb87509", + "metadata": {}, + "source": [ + "## Exploring the intervention and difference between Quantiles and Superquantiles" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "35ebe5d7", + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Forward UQ took 9.36 seconds total (1.87e-01 seconds per model evaluation).\n", + "0.16319286078214637 0.3144282937049864\n" + ] + } + ], + "source": [ + "pyro.set_rng_seed(0)\n", + "\n", + "POLICY = np.array([0.05])\n", + "N_SAMPLES = 50\n", + "\n", + "RISK = computeRisk(model=control_model,\n", + " intervention_fun=INTERVENTION,\n", + " qoi=lambda y: max_total_infections_SIDARTHE(y, contexts=[\"I_total_obs\"]),\n", + " risk_measure=alpha_superquantile,\n", + " num_samples=N_SAMPLES,\n", + " model_state=initial_state,\n", + " tspan=tspan,\n", + " guide=None)\n", + "\n", + "start_time = time.time()\n", + "sq_dataCube = RISK.propagate_uncertainty(POLICY)\n", + "end_time = time.time()\n", + "forward_time = end_time - start_time\n", + "time_per_eval = forward_time / N_SAMPLES\n", + "print(f\"Forward UQ took {forward_time:.2f} seconds total ({forward_time/N_SAMPLES:.2e} seconds per model evaluation).\")\n", + "sq_qoi = RISK.qoi(sq_dataCube)\n", + "sq_sv = RISK.risk_measure(sq_qoi)\n", + "\n", + "RISK.risk_measure = alpha_quantile\n", + "q_sv = RISK(POLICY)\n", + "print(q_sv, sq_sv)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "b74d9c82", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "No artists with labels found to put in legend. Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAwkAAAHECAYAAABycmbPAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAABMc0lEQVR4nO3de3zU9Z3v8ffMJJN7BiSSyM3gQkUEAbkV9IjHpsRd10ptLbKsUGrr1gUF0lLFVTjV2qgVDl44srpbra0uLLZSZBWLUamtUeRWiyBaRYKB3IDMJJNkrr/zxy8ZGAiQwCS/yczr+XjMI8lvvjPzGX4Bfu/53myGYRgCAAAAgFZ2qwsAAAAAEF8ICQAAAACiEBIAAAAARCEkAAAAAIhCSAAAAAAQhZAAAAAAIAohAQAAAEAUQgIAAACAKIQEAAAAAFEICQAAAACiWB4SVq5cqcLCQqWnp2vixInasmXLKdt+9NFH+ta3vqXCwkLZbDatWLHipDalpaUaP368cnJy1LdvX02bNk179+7twncAAAAAJBZLQ8KaNWtUUlKipUuXavv27Ro1apSKi4tVU1PTbvumpiZddNFFeuihh1RQUNBum82bN2vu3Ll67733tGnTJgUCAU2dOlVer7cr3woAAACQMGyGYRhWvfjEiRM1fvx4Pfnkk5KkcDisgQMH6o477tDdd9992scWFhZqwYIFWrBgwWnb1dbWqm/fvtq8ebOuuuqqDtVlGIYaGhqUk5Mjm83WoccAAAAAicKyngS/369t27apqKjoWDF2u4qKilReXh6z13G73ZKk884775RtfD6fPB5P5FZZWSmXy6WGhoaY1YH40eQPqvDu/1Hh3f+jJn/Q6nIAAADijmUhoa6uTqFQSPn5+VHH8/PzVVVVFZPXCIfDWrBgga644gqNGDHilO1KS0vlcrkit4EDB8bk9QEAAICeyPKJy11p7ty52rVrl1avXn3adosXL5bb7Y7cDhw40E0VAgAAAPEnxaoXzsvLk8PhUHV1ddTx6urqU05K7ox58+Zpw4YN+uMf/6gBAwactm1aWprS0tLO+TUBAACARGBZT4LT6dTYsWNVVlYWORYOh1VWVqZJkyad9fMahqF58+bp5Zdf1ptvvqnBgwfHolwAAAAgaVjWkyBJJSUlmj17tsaNG6cJEyZoxYoV8nq9mjNnjiRp1qxZ6t+/v0pLSyWZk513794d+b6yslI7d+5Udna2hgwZIskcYvTiiy/q97//vXJyciLzG1wulzIyMix4lwAAAEDPYmlImD59umpra7VkyRJVVVVp9OjR2rhxY2Qyc0VFhez2Y50dBw8e1JgxYyI/P/roo3r00Uc1ZcoUvf3225Kkp556SpJ09dVXR73Ws88+q+9+97td+n4AAACArmIYhsLhsMLh8Cnb2O122e32c17G39J9EuKVx+ORy+WS2+1Wbm6u1eUgxpr8QQ1f8rokaff9xcp0WpqVAQAAzigYDKq+vl5+v/+MbZ1Op3r16qWUlLO/xuHqCAAAAIhjhmGotrZWdrtdvXv3lsPhaLenwDAMhUIheTwe1dbWqqCg4Kx7FAgJAAAAQBwLBoMyDEO9e/eW0+k8Y3uHw6G6ujoFg0Glpqae1Wsm9D4JAAAAQKLoaK/Auc5HkAgJAAAAAE5ASAAAAAAQhZAAAAAAIAohAQAAAEAUQgIAAADQA3R0e7NYbINGSAAAAADimMPhkKQObaR2fLu2x50N9kkAAAAAukuLR/J8KfUd3uGH2O12ZWZmyuPxSDJ3VD7VZmp+v18ej0eZmZmy28++P4CQAAAAAHSXhkNSU51kGFIn9jNwuVySFAkKp5OZmRlpf7YICQAAAEB3CPqkhi8lW+c/4bfZbOrVq5dyc3MVCoVO2c7hcJxTD0IbQgIAAADQHZoOSy31UsZ5Z/0Udrs9JiHgjK/T5a8AAAAAJDvDkDyVZm9CD0BIAAAAALqazyM11Urp5zZXoLsQEgAAAICu5q2VQj4pJd3qSjqEkAAAAAB0pVDAXPbUmWN1JR1GSAAAAAC6UtNhyeeW0nKtrqTDCAkAAABAV2o4ZC57aj/7HZC7GyEBAAAA6Cq+BslbLaX3srqSTiEkAAAAAF2lqU4KNEmpmVZX0imEBAAAAKArhEOSu0JyZlldSacREgAAAICu0LbDcg8baiQREgAAAICu0VhlfrWnWFvHWSAkAAAAALHmbzJDQg/sRZAICQAAAEDsNdVJAa+U2vPmI0iEBAAAACC2wiHJfUBKyZBsNqurOSuEBAAAACCWmo9KzYd77FAjiZAAAAAAxFbDIUmG5Ei1upKzRkgAAAAAYsXvlRoP9uheBImQAAAAAMSOt9YMCj10wnIbQgIAAAAQC20Tlp1ZPXbCchtCAgAAABALTYelliM9fqiRREgAAAAAYqPhoCRbj9xh+USEBAAAAOBc+Rolb7WU7rK6kpggJAAAAADnqql1wrIz2+pKYoKQAAAAAJyLUFByVyRMQJAICQAAAMC5aT4sNdcnzFAjiZAAAAAAnBvPQXPJ0wSYsNyGkAAAAACcLV+DOWE5o7fVlcQUIQEAAAA4W94aKdAkpWZaXUlMERIAAACAsxEKSO4vpbQcqyuJOUICAAAAcDaa6qSWo1Ja4kxYbkNIAAAAADrLMMxeBHuKZHdYXU3MERIAAACAzmqpl5pqEm7CchtCAgAAANBZjVXmnISUdKsr6RKEBAAAAKAzAs2SpzKhNk87ESEBAAAA6AxvreTzSM7EW9WoDSEBAAAA6KhwSHJXmPsi2GxWV9NlCAkAAABARzUdlpoPJ+yE5TaWh4SVK1eqsLBQ6enpmjhxorZs2XLKth999JG+9a1vqbCwUDabTStWrDjn5wQAAAA6rOGgJJu59GkCszQkrFmzRiUlJVq6dKm2b9+uUaNGqbi4WDU1Ne22b2pq0kUXXaSHHnpIBQUFMXlOAAAAoENaPOaqRgneiyBZHBKWL1+uH/zgB5ozZ46GDx+uVatWKTMzU7/85S/bbT9+/Hj94he/0M0336y0tLSYPCcAAADQId4aKdBkzkdIcJaFBL/fr23btqmoqOhYMXa7ioqKVF5e3q3P6fP55PF4om4AAABARNBvTlhO4GVPj2dZSKirq1MoFFJ+fn7U8fz8fFVVVXXrc5aWlsrlckVuAwcOPKvXBwAAQIJqqpVa3FJartWVdAvLJy7Hg8WLF8vtdkduBw4csLokAAAAxItwWHIfkFKcki05Lp8tm5adl5cnh8Oh6urqqOPV1dWnnJTcVc+ZlpZ2yjkOAAAASHItR6WmOimzj9WVdBvLopDT6dTYsWNVVlYWORYOh1VWVqZJkybFzXMCAAAgyXkOSkZIcjitrqTbWLrAa0lJiWbPnq1x48ZpwoQJWrFihbxer+bMmSNJmjVrlvr376/S0lJJ5sTk3bt3R76vrKzUzp07lZ2drSFDhnToOQEAAIAO8zVKjQel9F5WV9KtLA0J06dPV21trZYsWaKqqiqNHj1aGzdujEw8rqiokN1+rLPj4MGDGjNmTOTnRx99VI8++qimTJmit99+u0PPCQAAAHSYt1rye6XMPKsr6VY2wzAMq4uINx6PRy6XS263W7m5yTGDPZk0+YMavuR1SdLu+4uV6UzsHRMBAMBZCvqlij9JRjh2G6i11JuTnwuvlmy22DxnF0iO6dkAAABAZ3lrzGVPk2RvhOMREgAAAIAThcOS54CUmp40y54eL/neMQAAAHAmzYclb62UHqNhRj0MIQEAAAA4kafS/OpItbYOixASAAAAgOO1uKXGQ7GbrNwDERIAAACA4zVUScEWKTXT6kosQ0gAAAAA2gSazQnLacm3otHxCAkAAABAG2+N5PNIacm9VxYhAQAAAJCkUFCqr5CcWXG90Vl3ICQAAAAAktRUJzUfkdJ7WV2J5QgJAAAAgGFI7gOS3SHZU6yuxnKEBAAAAKD5qOStTuplT49HSAAAAAA8X0pGSEpJt7qSuEBIAAAAQHJr8UgNB6V0ehHaEBIAAACQ3BoOScFmc1UjSCIkAAAAIJmxeVq7CAkAAABIXo3VbJ7WDkICAAAAklMoINXvl5zZSb952okICQAAAEhO3hqp5Sibp7WDkAAAAIDkEw5J7grJ4TQ3UEMUQgIAAACST1Od2ZOQcZ7VlcQlQgIAAACSi2GYm6fZ7JIj1epq4hIhAQAAAMml+ajUUEUvwmkQEgAAAJBcPJWSEZRS0q2uJG4REgAAAJA8fA1S40FWNDoDQgIAAACSh+eg5PeaeyPglAgJAAAASA7+JnPZU3oRzoiQAAAAgOTQeEjyN0hpuVZXEvcICQAAAEh8gRap/gsp3SXZbFZXE/cICQAAAEh83mqpxS2luayupEcgJAAAACCxBf3S0S/Mycr0InQIIQEAAACJzVsjNR9hwnInEBIAAACQuEJBcy5CaoZkd1hdTY9BSAAAAEDi8tZIzYeljN5WV9KjEBIAAACQmMJhyb1fsqeYN3QYIQEAAACJqalW8tZKGX2srqTHISQAAAAg8RiGVF9hrmbkSLW6mh6HkAAAAIDE03RYaqyiF+EsERIAAACQWAxDch+QFJZS0qyupkciJAAAACCxNB+VGg5KmXlWV9JjERIAAACQOAxDcldI4aCUkm51NT0WIQEAAACJo6VeaqiUMpmLcC4ICQAAAEgcbb0IqRlWV9KjERIAAACQGJqPSp5KVjSKAUICAAAAEoP7gBQO0IsQA4QEAAAA9HzN9eZchIzzrK4kIRASAAAA0PO5D0hBn5SaaXUlCYGQAAAAgJ6txS01fEkvQgwREgAAANCzeb40exGcWVZXkjAICQAAAOi5WjzmUKOM3lZXklAsDwkrV65UYWGh0tPTNXHiRG3ZsuW07deuXathw4YpPT1dI0eO1Kuvvhp1f2Njo+bNm6cBAwYoIyNDw4cP16pVq7ryLQAAAMAqngNSoFlyZltdSUKxNCSsWbNGJSUlWrp0qbZv365Ro0apuLhYNTU17bZ/9913NWPGDN16663asWOHpk2bpmnTpmnXrl2RNiUlJdq4caN+85vfaM+ePVqwYIHmzZun9evXd9fbAgAAQHdo8ZhDjTKZixBrloaE5cuX6wc/+IHmzJkT+cQ/MzNTv/zlL9tt/9hjj+naa6/VokWLdMkll+iBBx7Q5ZdfrieffDLS5t1339Xs2bN19dVXq7CwULfddptGjRp1xh4KAAAA9DCeA5K/iV6ELmBZSPD7/dq2bZuKioqOFWO3q6ioSOXl5e0+pry8PKq9JBUXF0e1nzx5stavX6/KykoZhqG33npLn3zyiaZOnXrKWnw+nzweT9QNAAAAcazFbc5FoBehS1gWEurq6hQKhZSfnx91PD8/X1VVVe0+pqqq6oztn3jiCQ0fPlwDBgyQ0+nUtddeq5UrV+qqq646ZS2lpaVyuVyR28CBA8/hnQEAAKDL1VdIwRZ6EbqI5ROXY+2JJ57Qe++9p/Xr12vbtm1atmyZ5s6dqzfeeOOUj1m8eLHcbnfkduDAgW6sGAAAAJ3SXG8ONcrsY3UlCSvFqhfOy8uTw+FQdXV11PHq6moVFBS0+5iCgoLTtm9ubtY999yjl19+Wdddd50k6bLLLtPOnTv16KOPnjRUqU1aWprS0tLO9S0BAACgqxmG5N4vhQPsrtyFLOtJcDqdGjt2rMrKyiLHwuGwysrKNGnSpHYfM2nSpKj2krRp06ZI+0AgoEAgILs9+m05HA6Fw+EYvwMAAAB0u+aj5opGGfQidCXLehIkc7nS2bNna9y4cZowYYJWrFghr9erOXPmSJJmzZql/v37q7S0VJI0f/58TZkyRcuWLdN1112n1atXa+vWrXr66aclSbm5uZoyZYoWLVqkjIwMXXjhhdq8ebOef/55LV++3LL3CQAAgBgwDMldIYWCUmqG1dUkNEtDwvTp01VbW6slS5aoqqpKo0eP1saNGyOTkysqKqJ6BSZPnqwXX3xR9957r+655x4NHTpU69at04gRIyJtVq9ercWLF2vmzJk6cuSILrzwQj344IP64Q9/2O3vDwAAADHUfETyVEpZeVZXkvBshmEYVhcRbzwej1wul9xut3Jzc60uBzHW5A9q+JLXJUm77y9WptPSrAwAADrCMKRDOyVPhZQ7wOpqzl5LvWSzS4VXSzab1dWcUsKtbgQAAIAE1HS4dXdlehG6AyEBAAAA8S0cNlc0kqSUdGtrSRKEBAAAAMS3pjpzLgL7InQbQgIAAADiVzgs1e8zx++nsK9VdyEkAAAAIH55q6WGKinzfKsrSSqEBAAAAMSnUFA68rnkSDVv6DaEBAAAAMSnxkOSt4a5CBYgJAAAACD+BH1mL4IzU7Kzp1F3IyQAAAAg/ngqpebDUsZ5VleSlAgJAAAAiC+BZunoPikt19ydGN2OP3UAAADEF/cByeeW0ntZXUnSIiQAAAAgfvgapPovpIze5t4IsAQhAQAAAPHDXSEFvOZQI1iGkAAAAID40FxvhoQMljy1GiEBAAAA1jMMc5hRyC85s6yuJukREgAAAGC9pjrJ86WUmWd1JRAhAQAAAFYLh6Sjn0sypJR0q6uBpA5tX7d+/foOP+E3vvGNsy4GAAAASaixyrxlF1hdCVp1KCRMmzYt6mebzSbDMKJ+bhMKhWJTGQAAABJf0C8d+ZvkSJPsHbo0RTfo0HCjcDgcuf3hD3/Q6NGj9dprr6m+vl719fV69dVXdfnll2vjxo1dXS8AAAASiedLqemwlMmKRvGk03FtwYIFWrVqla688srIseLiYmVmZuq2227Tnj17YlogAAAAEpTfa85FSHdJNqbKxpNOn43PPvtMvXr1Oum4y+XSF198EYOSAAAAkBTq90s+j5TmsroSnKDTIWH8+PEqKSlRdXV15Fh1dbUWLVqkCRMmxLQ4AAAAJKjmo5J7vznM6Lj5rYgPnQ4Jv/zlL3Xo0CENGjRIQ4YM0ZAhQzRo0CBVVlbqP//zP7uiRgAAACQSw5COfmFOWnZmW10N2tHpOQlDhgzRhx9+qE2bNunjjz+WJF1yySUqKiqKWuUIAAAAaJe3RvIckLLOt7oSnMJZrTNls9k0depUXXXVVUpLSyMcAAAAoGNCQXOyst0hpaRZXQ1OodPDjcLhsB544AH1799f2dnZ2rdvnyTpvvvuY7gRAAAATq/hoNRQJWXmWV0JTqPTIeFnP/uZnnvuOT3yyCNyOp2R4yNGjNB//Md/xLQ4AAAAJJBAs3TkU8mZxcZpca7TIeH555/X008/rZkzZ8rhcESOjxo1KjJHAQAAADjJ0X1Si1vKOM/qSnAGnQ4JlZWVGjJkyEnHw+GwAoFATIoCAABAgmk+KtV/wZKnPUSnQ8Lw4cP1zjvvnHT8pZde0pgxY2JSFAAAABJIOCwd+UwKB1jytIfo9GCwJUuWaPbs2aqsrFQ4HNbvfvc77d27V88//7w2bNjQFTUCAACgJ2uskjyVUnZfqytBB3W6J+GGG27QK6+8ojfeeENZWVlasmSJ9uzZo1deeUVf//rXu6JGAAAA9FRBnzlZOSVNcjjP3B5x4aymlf+v//W/tGnTpljXAgAAgETjPiA1HZZcA62uBJ3Q6Z6Eiy66SIcPHz7peH19vS666KKYFAUAAIAE0OKRjn4mZfSWbJ2+7ISFOn22vvjiC4VCoZOO+3w+VVZWxqQoAAAA9HCGYe6sHGiW0nKtrgad1OHhRuvXr498//rrr8vlckV+DoVCKisrU2FhYUyLAwAAQA/lrZHcFVLW+VZXgrPQ4ZAwbdo0SZLNZtPs2bOj7ktNTVVhYaGWLVsW0+IAAADQA4UC5pKndoeUkm51NTgLHQ4J4XBYkjR48GB98MEHysvL67KiAAAA0IO5K8xlT3MHWF0JzlKnVzfat29fV9QBAACARNDiMXsR0nuZPQnokTo9cfnOO+/U448/ftLxJ598UgsWLIhFTQAAAOiJ2nZWDjRJ6a4zt0fc6nRI+O1vf6srrrjipOOTJ0/WSy+9FJOiAAAA0AM1VkmeCimLnZV7uk6HhMOHD0etbNQmNzdXdXV1MSkKAAAAPUygxdxZ2ZFm7q6MHq3TIWHIkCHauHHjScdfe+01NlMDAABIVvX7zZ2VM/tYXQlioNMTl0tKSjRv3jzV1tbqmmuukSSVlZVp2bJlWrFiRazrAwAAQLxrOiLVf24GBHZWTgidDgnf+9735PP59OCDD+qBBx6QJBUWFuqpp57SrFmzYl4gAAAA4lg4ZE5WDvmZi5BAOh0SJOn222/X7bffrtraWmVkZCg7OzvWdQEAAKAnaDgoNVRK2QVWV4IYOqv+oGAwqDfeeEO/+93vZBiGJOngwYNqbGyMaXEAAACIY/4m6fAnUmqm5Ei1uhrEUKd7Evbv369rr71WFRUV8vl8+vrXv66cnBw9/PDD8vl8WrVqVVfUCQAAgHhiGNKRv0k+j5Q70OpqEGOd7kmYP3++xo0bp6NHjyojIyNy/Jvf/KbKyspiWhwAAADiVGO15N5vzkOw2ayuBjHW6ZDwzjvv6N5775XT6Yw6XlhYqMrKyk4XsHLlShUWFio9PV0TJ07Uli1bTtt+7dq1GjZsmNLT0zVy5Ei9+uqrJ7XZs2ePvvGNb8jlcikrK0vjx49XRUVFp2sDAABAOwIt0uG9kj1FSkm3uhp0gU6HhHA4rFAodNLxL7/8Ujk5OZ16rjVr1qikpERLly7V9u3bNWrUKBUXF6umpqbd9u+++65mzJihW2+9VTt27NC0adM0bdo07dq1K9Lms88+05VXXqlhw4bp7bff1ocffqj77rtP6en8AgMAAMTE0X2teyLkWV0JuojNaJt53EHTp0+Xy+XS008/rZycHH344Yc6//zzdcMNN2jQoEF69tlnO/xcEydO1Pjx4/Xkk09KMgPIwIEDdccdd+juu+9u97W9Xq82bNgQOfbVr35Vo0ePjsyFuPnmm5Wamqpf//rXnXlbUTwej1wul9xut3Jzc8/6eRCfmvxBDV/yuiRp9/3FynSe1SJfAAAkJ2+tVLlFcuZIziyrq+l5WurNvSQKr47rYVqd7klYtmyZ/vznP2v48OFqaWnRP/3TP0WGGj388MMdfh6/369t27apqKjoWDF2u4qKilReXt7uY8rLy6PaS1JxcXGkfTgc1v/8z//oK1/5ioqLi9W3b19NnDhR69atO20tPp9PHo8n6gYAAIAThALS4U/NScsEhITW6ZAwYMAA/eUvf9G//du/aeHChRozZoweeugh7dixQ337dnwDjbq6OoVCIeXn50cdz8/PV1VVVbuPqaqqOm37mpoaNTY26qGHHtK1116rP/zhD/rmN7+pG2+8UZs3bz5lLaWlpXK5XJHbwIHM0AcAADhJ/X6psYpN05JAh8ZZXH755SorK1Pv3r11//3368c//rFmzpypmTNndnV9nRIOhyVJN9xwgxYuXChJGj16tN59912tWrVKU6ZMafdxixcvVklJSeRnj8dDUAAAADhe81FzydOM8yS7w+pq0MU61JOwZ88eeb1eSdJPf/rTmGyalpeXJ4fDoerq6qjj1dXVKihof8e+goKC07bPy8tTSkqKhg8fHtXmkksuOe3qRmlpacrNzY26AQAAoFUoaG6aFvJJaZ1bqAY9U4d6EkaPHq05c+boyiuvlGEYevTRR5Wdnd1u2yVLlnTohZ1Op8aOHauysjJNmzZNktkTUFZWpnnz5rX7mEmTJqmsrEwLFiyIHNu0aZMmTZoUec7x48dr7969UY/75JNPdOGFF3aoLgAAAJzA86XkOSjl9rO6EnSTDoWE5557TkuXLtWGDRtks9n02muvKSXl5IfabLYOhwRJKikp0ezZszVu3DhNmDBBK1askNfr1Zw5cyRJs2bNUv/+/VVaWirJ3MhtypQpWrZsma677jqtXr1aW7du1dNPPx15zkWLFmn69Om66qqr9L//9//Wxo0b9corr+jtt9/ucF0AAABo1eI290RIzzX3RUBS6NCZvvjii7V69WpJ5gpEZWVlnZqkfCrTp09XbW2tlixZoqqqKo0ePVobN26MTE6uqKiQ3X5sRNTkyZP14osv6t5779U999yjoUOHat26dRoxYkSkzTe/+U2tWrVKpaWluvPOO3XxxRfrt7/9ra688spzrhcAACCphIJS3V5z8zTXAKurQTfq9D4JyYB9EhIb+yQAANBBRz6XqnZKuf3pRYiVHrJPwlmd7U8//VRvvfWWampqIisKtenMcCMAAADEqeaj0pFPpfReBIQk1Okz/swzz+j2229XXl6eCgoKZDsuAXV2TgIAAADiUNtqRsEWKTfP6mpggU6HhJ/97Gd68MEHddddd3VFPQAAALBa/ReSp9IcZoSk1Okdl48ePaqbbrqpK2oBAACA1ZqOtG6a1pthRkms0yHhpptu0h/+8IeuqAUAAABWCgXM5U5DASmNxVuSWafj4ZAhQ3Tffffpvffe08iRI5Wamhp1/5133hmz4gAAANCN6r+QGg4xzAidXwJ18ODBp34ym02ff/75ORdlNZZATWwsgQoAQDu8dVLlFik1U0rLsbqaxJWoS6Du27evK+oAAACAVQItUt3HkhEmIEDSWcxJAAAAQAIxDOnwp5K3WsrOt7oaxIkO9SSUlJTogQceUFZWlkpKSk7bdvny5TEpDAAAAN2g4aBUv0/KyjeHwQDqYEjYsWOHAoFA5PtTscXxuCoAAACcwNdoDjNKSZNSM6yuBnGkQyHhrbfeavd7AAAA9FDhkLncqa9Byh1gdTWIM/QpAQAAJKP6/VJ9hZRdENer7MAahAQAAIBk03REOvyJlO6SHKlnbo+kQ0gAAABIJkH/sV2V011WV4M4RUgAAABIFoYhHfnU3FWZ5U5xGoQEAACAZNFwUDrymZTVV7I7rK4GcaxDqxutX7++w0/4jW9846yLAQAAQBdpcUu1e6SUdJY7xRl1KCRMmzatQ09ms9kUCoXOpR4AAADEWtBvBgS/V3Kx3CnOrEMhIRwOd3UdAAAA6AqGYQ4xaqhkPwR0GHMSAAAAElnDIeno31rnIXTo82GgYz0JJ/J6vdq8ebMqKirk9/uj7rvzzjtjUhgAAADOUYvHHGbkcEqpmVZXgx6k0yFhx44d+od/+Ac1NTXJ6/XqvPPOU11dnTIzM9W3b19CAgAAQDwIBaS6PVKgkWFG6LRODzdauHChrr/+eh09elQZGRl67733tH//fo0dO1aPPvpoV9QIAACAzmibh+CplLILrK4GPVCnQ8LOnTv1ox/9SHa7XQ6HQz6fTwMHDtQjjzyie+65pytqBAAAQGc0HDQ3TcvMYx4CzkqnQ0JqaqrsdvNhffv2VUVFhSTJ5XLpwIEDsa0OAAAAndNcL9XslhxpkjPL6mrQQ3U6Wo4ZM0YffPCBhg4dqilTpmjJkiWqq6vTr3/9a40YMaIragQAAEBHBFqk2t1SsFnK7W91NejBOt2T8POf/1wXXHCBJOnBBx9U7969dfvtt6u2tlb//u//HvMCAQAA0AHhsFT3sdRYxTwEnLNO9ySMGzcu8n3fvn21cePGmBYEAACAs1C/z7xlF0h2h9XVoIfrdE/CNddco/r6+pOOezweXXPNNbGoCQAAAJ3RWGP2IqT3klLSrK4GCaDTIeHtt98+aQM1SWppadE777wTk6IAAADQQb5Gcx6CbFJartXVIEF0eLjRhx9+GPl+9+7dqqqqivwcCoW0ceNG9e/PBBkAAIBuEwqYOyq31LNhGmKqwyFh9OjRstlsstls7Q4rysjI0BNPPBHT4gAAAHAK4bB0+BPJc8Bcychms7oiJJAOh4R9+/bJMAxddNFF2rJli84///zIfU6nU3379pXDwSQZAACAblH/hXTkb1J2PhumIeY6/Bt14YUXSpLC4XCXFQMAAIAOaKiS6vaYcxBS0q2uBgnorGLnZ599phUrVmjPnj2SpOHDh2v+/Pn6u7/7u5gWBwAAgBO0uKWajySbg4nK6DKdXt3o9ddf1/Dhw7VlyxZddtlluuyyy/T+++/r0ksv1aZNm7qiRgAAAEhSoFmq3iUFGqWs88/cHjhLne5JuPvuu7Vw4UI99NBDJx2/66679PWvfz1mxQEAAKBVKCjVfix5qyXXQKurQYLrdE/Cnj17dOutt550/Hvf+552794dk6IAAABwHMMwJynX75NyLpBsnb6EAzql079h559/vnbu3HnS8Z07d6pv376xqAkAAADHcx8wlzvNzJMcTqurQRLo8HCj+++/Xz/+8Y/1gx/8QLfddps+//xzTZ48WZL05z//WQ8//LBKSkq6rFAAAICk1Fgt1X4kObPMG9ANbIZhGB1p6HA4dOjQIZ1//vlasWKFli1bpoMHD0qS+vXrp0WLFunOO++ULQE28vB4PHK5XHK73crNZdWARNPkD2r4ktclSbvvL1amk7WlAQBxqvmodHC7FPZLWYzYSAgt9eZwscKr43oDvA5fHbVlCZvNpoULF2rhwoVqaGiQJOXk5HRNdQAAAMnK721dychr7qgMdKNOfYR6Yi8B4QAAAKALBH1SzS6p+TABAZboVEj4yle+csbhREeOHDmnggAAAJJaKCjV7pE8lWZAYCUjWKBTIeGnP/2pXC5XV9UCAACQ3E5c6tTOvDlYo1O/eTfffDPLnAIAAHSVo/ukur0sdQrLdbj/KhFWLQIAAIhb7i/NYUbpuVJqptXVIMl1OCR0cKVUAAAAdFZjtTlROcUppbH8OqzX4eFG4XC4K+sAAABITk2HpaoPJRlSxnlWVwNI6kRPQldauXKlCgsLlZ6erokTJ2rLli2nbb927VoNGzZM6enpGjlypF599dVTtv3hD38om82mFStWxLhqAACAc9Tilqr/KoV8bJaGuGJ5SFizZo1KSkq0dOlSbd++XaNGjVJxcbFqamrabf/uu+9qxowZuvXWW7Vjxw5NmzZN06ZN065du05q+/LLL+u9995Tv379uvptAAAAdI6v0exB8Lml7AKrqwGiWB4Sli9frh/84AeaM2eOhg8frlWrVikzM1O//OUv223/2GOP6dprr9WiRYt0ySWX6IEHHtDll1+uJ598MqpdZWWl7rjjDr3wwgtKTU3tjrcCAADQMYFmqeavUnOdlNNPYoEYxBlLQ4Lf79e2bdtUVFQUOWa321VUVKTy8vJ2H1NeXh7VXpKKi4uj2ofDYd1yyy1atGiRLr300jPW4fP55PF4om4AAABdIuiXqndJDYekHDZLQ3yy9Leyrq5OoVBI+fn5Ucfz8/NVVVXV7mOqqqrO2P7hhx9WSkqK7rzzzg7VUVpaKpfLFbkNHDiwk+8EAACgA0IBqeYjyXPA3E3Z7rC6IqBdCRddt23bpscee0zPPfdch/d2WLx4sdxud+R24MCBLq4SAAAknVDQDAj1n7ObMuKepSEhLy9PDodD1dXVUcerq6tVUND+BJ6CgoLTtn/nnXdUU1OjQYMGKSUlRSkpKdq/f79+9KMfqbCwsN3nTEtLU25ubtQNAAAgZsIhc6O0o/uk7AvYTRlxz9KQ4HQ6NXbsWJWVlUWOhcNhlZWVadKkSe0+ZtKkSVHtJWnTpk2R9rfccos+/PBD7dy5M3Lr16+fFi1apNdff73r3gwAAEB7wiGp7mPp6N+k7L5SSprVFQFnZHk/V0lJiWbPnq1x48ZpwoQJWrFihbxer+bMmSNJmjVrlvr376/S0lJJ0vz58zVlyhQtW7ZM1113nVavXq2tW7fq6aefliT16dNHffr0iXqN1NRUFRQU6OKLL+7eNwcAAJJbOCzVfWLesvtKKelWVwR0iOUhYfr06aqtrdWSJUtUVVWl0aNHa+PGjZHJyRUVFbLbj3V4TJ48WS+++KLuvfde3XPPPRo6dKjWrVunESNGWPUWAAAATmYY0uFPpcN7paw8AgJ6FJthGIbVRcQbj8cjl8slt9vN/IQE1OQPavgSc+jZ7vuLlem0PCsDABKNYUhH/ibV7pbSe0vOLKsrQrxoqTeXvS28Oq73x+DqCAAAIJbC4daAsEfK6EVAQI9ESAAAAIiVcLh1iNHHUgY9COi5CAkAAACxEA6ZE5QPfyxl9CEgoEcjJAAAAJyrtmVOD38qZeZJqZlWVwSck4TbcRkAAKBbtQWEuk8ICEgY9CQAAACcrVCwdSflv7EPAhIKIQEAAOBsBP3mEqdH9xEQkHAICQAAAJ0VaJaqd0meA1LOBZLDaXVFQEwREgAAADrD1yjV/FVqOCTl9pfsXE4h8fBbDQAA0FEtbqnqQ6m5TsodINkdVlcEdAlCAgAAQEc0HZaq/yr53GZAsLFIJBIXIQEAAOBMGqvNgBBskXL6Szab1RUBXYqQAAAAcCqGIXm+lGp2mT/nXGBtPUA3ISQAAAC0JxyWjn5mbpSWmiml97K6IqDbEBIAAABOFApItR+bm6RlnCc5s62uCOhWhAQAAIDjBZrNTdLq90vZ+WyShqRESAAAAGjjazDnHzQcknL6SY5UqysCLEFIAAAAkCRvnRkQ2pY4ZQ8EJDFCAgAASG5tKxjV7pbCQZY4BURIAAAAySwUlI58Jh3ea65glJ1ndUVAXCAkAACA5BRokWr3SO4vpIw+kjPL6oqAuEFIAAAAyafFLdV8ZO6knFMgOZxWVwTEFUICAABILg1VUu1Hkq9Ryu3PBGWgHYQEAACQHMIh6eg+qW6vZLdLrgFWVwTELUICAABIfIFmMxwc3Sdl9JbScqyuCIhrhAQAAJDYmo+a8w+8tcw/ADqIkAAAABKTYUieSnP/g6DPHF5ks1tdFdAjEBIAAEDiCfrN/Q+OfCqlZki5/ayuCOhRCAkAACCxtLjN/Q8aKqWsvuYmaQA6hZAAAAASQ9vworqPJb9Xyh0g2bnUAc4Gf3MAAEDPF/RJR/5m3lIyWN4UOEeEBAAA0LM1HzV7DxoOtQ4vyrC6IqDHIyQAAICeKRSUPAekw5+YPQm5A9g9GYgRQgIAAOh5mg5Lhz+VGg5K6S4pN8/qioCEQkgAAAA9R9Bn7pp89HMpHJJy+zM5GegC/K0CAADxzzCkxmqz96CpRsrMk5zZVlcFJCxCAgAAiG++RunoZ5K7QrI5JNcgdk4GuhghAQAAxKdQQHIfMHdO9jdK2X2llHSrqwKSAiEBAADEF8OQvLVm70FjlZSWK/UaZHVVQFIhJAAAgPjhazQnJdfvl+x2KacfE5MBC/C3DgAAWC/olzxfmgHB52FTNMBihAQAAGCdcFjyVpvzDrw15p4HrkGSzWZ1ZUBSIyQAAABrNB81ew48X0r2VHZMBuIIIQEAAHQvf5NU/4V5CwfMoUUOp9VVATgOIQEAAHSPoE/yVLbOO2iQMs9jQzQgThESAABA1woFzaVMj3wmNR9unXcwkHkHQBwjJAAAgK4RDktNtWbPQWOVlJrZGg7YLRmId4QEAAAQW4YhNR2W3PvN4UV2B/sdAD0Mf1sBAEDsNB81N0LzfCkZYSkzT0pJs7oqAJ1ESAAAAOeuxX0sHIQDreEg3eqqAJyluBgUuHLlShUWFio9PV0TJ07Uli1bTtt+7dq1GjZsmNLT0zVy5Ei9+uqrkfsCgYDuuusujRw5UllZWerXr59mzZqlgwcPdvXbAAAg+fgapJrd0oFy6ehnUlqOud8BAQHo0SwPCWvWrFFJSYmWLl2q7du3a9SoUSouLlZNTU277d99913NmDFDt956q3bs2KFp06Zp2rRp2rVrlySpqalJ27dv13333aft27frd7/7nfbu3atvfOMb3fm2AABIbC2e1nDwrnR4r5SaYe6UnJppdWUAYsBmGIZhZQETJ07U+PHj9eSTT0qSwuGwBg4cqDvuuEN33333Se2nT58ur9erDRs2RI599atf1ejRo7Vq1ap2X+ODDz7QhAkTtH//fg0aNOiMNXk8HrlcLrndbuXm5p7lO0O8avIHNXzJ65Kk3fcXK9PJqDsA6LAWjzmkyHPA3BSNvQ6AzmmpN1f4Krw6rpcBtrQnwe/3a9u2bSoqKoocs9vtKioqUnl5ebuPKS8vj2ovScXFxadsL0lut1s2m029evVq936fzyePxxN1AwAAx2nrOfiyXKrbaw4n6jWIgAAkKEtDQl1dnUKhkPLz86OO5+fnq6qqqt3HVFVVdap9S0uL7rrrLs2YMeOUvQKlpaVyuVyR28CBA8/i3QAAkGAMw1ytqOqv5rAiwgGQNCyfk9CVAoGAvvOd78gwDD311FOnbLd48WK53e7I7cCBA91YJQAAcaZtn4OqvxybkJyaSTgAkoilg7Hz8vLkcDhUXV0ddby6uloFBQXtPqagoKBD7dsCwv79+/Xmm2+edm5BWlqa0tJYwxkAkOTCYampzpxv0HBIMkJSRh9zUjKApGJpT4LT6dTYsWNVVlYWORYOh1VWVqZJkya1+5hJkyZFtZekTZs2RbVvCwiffvqp3njjDfXp06dr3gAAAIkgFJA8B6XK96Uv3zO/z+htLmVKQACSkuXLupSUlGj27NkaN26cJkyYoBUrVsjr9WrOnDmSpFmzZql///4qLS2VJM2fP19TpkzRsmXLdN1112n16tXaunWrnn76aUlmQPj2t7+t7du3a8OGDQqFQpH5Cuedd56cTqc1bxQAgHgTaJG81VL9F1LzEcnhlLL6So5UqysDYDHLQ8L06dNVW1urJUuWqKqqSqNHj9bGjRsjk5MrKipktx/r8Jg8ebJefPFF3Xvvvbrnnns0dOhQrVu3TiNGjJAkVVZWav369ZKk0aNHR73WW2+9pauvvrpb3hcAAHHL12AOJ3IfkHxuyZkl5fSX7A6rKwMQJyzfJyEesU9CYmOfBABJKRw2ewsaKs2AEGiS0l1Smiuu12oHEk4P2SeBqyMAABJZ0C95a8zJyN5aSYaU3lvKOt/qygDEMUICAACJqMVjhgN3hdTillLSzGDgYG4egDMjJAAAkChCQan5sLk6kbdaCjRLaTmSa4A5vAEAOoiQAABAT+f3mkOJ3BVSy1FJdimjF0OKAJw1QgIAAD1RKGhORG6skhoPmUHBmSVlF0h2/nsHcG74VwQAgJ7E12DuiuyuMFdJkaT0XubOyHG8UgqAnoWQAABAvAv6W5cvPWTONQg2S6n0GgDoOvzLAgBAPAqHzZ4Cb425t4GvwdzsLL0Xcw0AdDlCAgAA8cTXIDUdljxfSs1HJSMspWVLOf3YERlAtyEkAABgtUDzsUnI3lrzZ2emlJXHvgYALEFIAADACm3zDLzVUmONFGg0A0FaLsOJAFiOkAAAQHcJBcwhRE11rcuWNkqyS+m5UsZAVicCEDcICQAAdKVQoHUCcq05nMjXYB5Py5ayL2CeAYC4REgAACDWgn4zGDQfkRoOSv7WYODMlnIIBgDiHyEBAIBYCPrMoUTNh80eA3+jedyZzX4GAHoc/sUCAOBs+ZvMHoOm2tZVibzmcWcOQ4kA9GiEBAAAOsowzDkFLfVSY7XUcsQMCnaHuSpRTj/JZre6SgA4Z4QEAABOJxSQWtySzy01HJJ8HnNoUYrT7DHI6MOqRAASDiEBAIDjGYYUaDKDQdNhqanGnF8QDpsbnKW7pJR0q6sEgC5FSAAAIBQwewh8HnMYkc99bBgRE48BJCH+xQMAJJ9w2Owd8HnM1Yia6iS/VzJCZi+BM5thRACSGiEBAJD42oYQ+RrMYUTeGnPvgqBPcqRIqVlSdj69BQDQin8NAQCJKdBiBoEWt7lEqc8jBZol2aTUDOYWAMBpEBIAAImhLRT4GsyeAp9HCjabvQipGVJqJkOIAKCDCAkAgJ7HMMxeAX+jeWuqNXsM2kJBSlprKOjNvgUAcBYICQCA+BcOm3MK/I1mb4G31vwaaJFEKACAWCMkAADiTyjQGgi85u7GzYfNkBD0mcOFUtJbQ8F5hAIA6AKEBACAtcJhc5hQWyhoPmIOHQo0mUuS2uxmIEjLlTLTmFMAAN2AkAAA6F6BFingNUNAc73UcsScXxDymfMJHE5zonF2X5YkBQCL8K8vAKDrBH2tcwm8Zk9B8xHza7BFCofMPQpSMqS0HMmRRy8BAMQJQgIAIDYCLWYgaJtg3Hyk9efm1mFDrXMJUjKk9F6S3WF1xQCAUyAkAAA6p20OQaD5uEBw1BxCFGw5No8gJd28peUwbAgAehj+1QYAnFrQfywQBJvNlYZa3GYYCPkkIyzZHOYSpCmtuxgTCACgx+NfcgCAFAqaISDYcmyTspb6Y8uOhgNmO0fqsd4BRx+WHwWABEVIAIBkEgqYQaDt1rYPQcBrhoFQQJLROlwozQwEzmwzHAAAkgYhAQASjWFIIf/JYcDnPtYzEAkDNsmRZgaC9F7m8qOsMAQASY+QAAA9VSh4bG5AWxjweSRfQ2sQ8B8bJtTWM+BwEgYAAGdESACAeBYKtF7w+4599TWYcwYCzVLYb4YBo7VXwJ5iBoAUZ+u8AYYJAQA6j5AAAFaKDA06MQg0Sv7WHoHjg4DUGgRSzWFCqbmtvQJMIAYAxA4hAQC6WqQ3wH8sCARbzBDg9x4bFhQKSmoNAo5UyZ5qBgCCAACgmxESACAW2oLA8XMEfI3mHIGQ/+TeAJvNvPB3OM0VhBw5ZihgngAAIA4QEgCgIzo7LOj4+QEOp5SaTm8AAKDHICQAgNQaAgLmhX/IfywQRA0LCrQGgVMNC3KZPxMEAAA9HCEBQHIIBY9d/IcDx74PNJsbiUVCQOvNCEuymRf8jtRjKwY5shkWBABIeIQEAD1bWw9A5MI/cCwIBH3mxX+gyewBCAdb2waPPf7EEGDPojcAAJD0CAkA4lMo2PqpfvC4T/iDx00QbjZ7AUItZlsj2Po1dOw5bPZjy4XaU6XUNCk91TwGAABOif8pAXQ9w5DCIfMi/6Rb68V/0N+6MlDrzsFRbUKtw39atU0KbrulOCV75rGfAQDAOeF/UwAdEw6bn9KHQ8e+hoMnHGu9oI9MAG4bAuRrbdN6fzgkKXxsOVAp+sLf5jC/pjqPO8bwHwAAugshAUhU4bD56bvR+im8ET72ibxxwn1Rx0PHXdwfN9bfCLU+Z7D1MW2PNxRZ6Uc6NqHX5pDsjmNDfuwOye487riDyb8AAMQpQgJgpfYu5M90QX/8rW0Sbjh0bNhO1Kf7RuswneMfZxx3cW9T1AW+ZB6zqfUi3n7cBb1dcqRItta1/o8PAQAAIKHERUhYuXKlfvGLX6iqqkqjRo3SE088oQkTJpyy/dq1a3Xffffpiy++0NChQ/Xwww/rH/7hHyL3G4ahpUuX6plnnlF9fb2uuOIKPfXUUxo6dGh3vB0koraL7fY+dY861s7PkQm4HbmQP+4C3ggrcgFvnHgh38rWukRnezfZWi/iW1fqsdmOfXofaQMAAHAyy0PCmjVrVFJSolWrVmnixIlasWKFiouLtXfvXvXt2/ek9u+++65mzJih0tJS/eM//qNefPFFTZs2Tdu3b9eIESMkSY888ogef/xx/epXv9LgwYN13333qbi4WLt371Z6enp3v0XEk1BQ8jcf+9lzUEq1HbuoP36JzOMv6MPBkz/FP/5TeRmnuJBv+1T+TBfyKe1cwNuOXdwDAAB0I5thnOojyu4xceJEjR8/Xk8++aQkKRwOa+DAgbrjjjt09913n9R++vTp8nq92rBhQ+TYV7/6VY0ePVqrVq2SYRjq16+ffvSjH+nHP/6xJMntdis/P1/PPfecbr755jPW5PF45HK55Ha7lZubG6N3ii7RtmpOZNLscbe2i/2Q/7jNsnxqavFr+PPmSjm7/ymgzNTjnu90n8yf6gKfi3kAANBRLfXmdUPh1XF97WBpT4Lf79e2bdu0ePHiyDG73a6ioiKVl5e3+5jy8nKVlJREHSsuLta6deskSfv27VNVVZWKiooi97tcLk2cOFHl5eXthgSfzyefzxf52ePxnMvbij+nyoEnHTdOc7/RzvETh8IY7Xzf1iZ8ws+t30c+jQ+f/PNJY/SP+2S/bVJt25CeqJV3Wsfot7HZzDXyHa3r46dmSmo078u5wOxJaE+n/uKeqiehu8XvPzbdIo7/sQUAoCexNCTU1dUpFAopPz8/6nh+fr4+/vjjdh9TVVXVbvuqqqrI/W3HTtXmRKWlpfrpT396Vu+hS7R4pCOfxua5OnLh2m6bMwSIqMedGCCM4w6fEApOCgnHfT2+jXFigDhujfxTsh37euJa+UbY3IBLPikgSQ7zeGO1lKpuEA8BAnEpLsKlleI12CX7eQHQpTL6WF3BGVk+JyEeLF68OKp3wuPxaODAgdYV5MyS0lzmJ+ed1tlPxU84HtXOdvrjNls7bWzHtW3v+xO+njR5tosuGI6v3x+S9L75/aDJktNxcvuEunBLpPdyFhLqXMYz/pwBoMMczrjv/bY0JOTl5cnhcKi6ujrqeHV1tQoKCtp9TEFBwWnbt32trq7WBRdcENVm9OjR7T5nWlqa0tLSzvZtxJ7dIfUZYnUVicsRPPZ9Ri/JSVYGAAA4nqVrIDqdTo0dO1ZlZWWRY+FwWGVlZZo0aVK7j5k0aVJUe0natGlTpP3gwYNVUFAQ1cbj8ej9998/5XMCAAAAOMbyj1BLSko0e/ZsjRs3ThMmTNCKFSvk9Xo1Z84cSdKsWbPUv39/lZaWSpLmz5+vKVOmaNmyZbruuuu0evVqbd26VU8//bQkyWazacGCBfrZz36moUOHRpZA7devn6ZNm2bV2wQAAAB6DMtDwvTp01VbW6slS5aoqqpKo0eP1saNGyMTjysqKmS3H+vwmDx5sl588UXde++9uueeezR06FCtW7cuskeCJP3kJz+R1+vVbbfdpvr6el155ZXauHEjeyQAAAAAHWD5PgnxiH0SEluTP6jhS16XJO2+v1iZzEkAAACIYumcBAAAAADxh5AAAAAAIAohAQAAAEAUQgIAAACAKIQEAAAAAFEICQAAAACiEBIAAAAARCEkAAAAAIhCSAAAAAAQhZAAAAAAIEqK1QXEI8MwJEkej8fiStAVmvxBhX1NksxzHHTy1wAAACSXnJwc2Wy2U95vM9quiBHx5ZdfauDAgVaXAQAAAHQJt9ut3NzcU95PSGhHOBzWwYMHz5iwzoXH49HAgQN14MCB054gJCbOP/gdSG6c/+TG+U9u8XL+z3SdyziLdtjtdg0YMKBbXis3N5d/IJIY5x/8DiQ3zn9y4/wnt3g//0xcBgAAABCFkAAAAAAgCiHBImlpaVq6dKnS0tKsLgUW4PyD34HkxvlPbpz/5NZTzj8TlwEAAABEoScBAAAAQBRCAgAAAIAohAQAAAAAUQgJAAAAAKIQEiyycuVKFRYWKj09XRMnTtSWLVusLgldoLS0VOPHj1dOTo769u2radOmae/evVFtWlpaNHfuXPXp00fZ2dn61re+perqaosqRld56KGHZLPZtGDBgsgxzn3iq6ys1D//8z+rT58+ysjI0MiRI7V169bI/YZhaMmSJbrggguUkZGhoqIiffrppxZWjFgJhUK67777NHjwYGVkZOjv/u7v9MADD+j49WI4/4njj3/8o66//nr169dPNptN69ati7q/I+f6yJEjmjlzpnJzc9WrVy/deuutamxs7MZ3EY2QYIE1a9aopKRES5cu1fbt2zVq1CgVFxerpqbG6tIQY5s3b9bcuXP13nvvadOmTQoEApo6daq8Xm+kzcKFC/XKK69o7dq12rx5sw4ePKgbb7zRwqoRax988IH+/d//XZdddlnUcc59Yjt69KiuuOIKpaam6rXXXtPu3bu1bNky9e7dO9LmkUce0eOPP65Vq1bp/fffV1ZWloqLi9XS0mJh5YiFhx9+WE899ZSefPJJ7dmzRw8//LAeeeQRPfHEE5E2nP/E4fV6NWrUKK1cubLd+ztyrmfOnKmPPvpImzZt0oYNG/THP/5Rt912W3e9hZMZ6HYTJkww5s6dG/k5FAoZ/fr1M0pLSy2sCt2hpqbGkGRs3rzZMAzDqK+vN1JTU421a9dG2uzZs8eQZJSXl1tVJmKooaHBGDp0qLFp0yZjypQpxvz58w3D4Nwng7vuusu48sorT3l/OBw2CgoKjF/84heRY/X19UZaWprxX//1X91RIrrQddddZ3zve9+LOnbjjTcaM2fONAyD85/IJBkvv/xy5OeOnOvdu3cbkowPPvgg0ua1114zbDabUVlZ2W21H4+ehG7m9/u1bds2FRUVRY7Z7XYVFRWpvLzcwsrQHdxutyTpvPPOkyRt27ZNgUAg6vdh2LBhGjRoEL8PCWLu3Lm67rrros6xxLlPBuvXr9e4ceN00003qW/fvhozZoyeeeaZyP379u1TVVVV1O+Ay+XSxIkT+R1IAJMnT1ZZWZk++eQTSdJf/vIX/elPf9Lf//3fS+L8J5OOnOvy8nL16tVL48aNi7QpKiqS3W7X+++/3+01S1KKJa+axOrq6hQKhZSfnx91PD8/Xx9//LFFVaE7hMNhLViwQFdccYVGjBghSaqqqpLT6VSvXr2i2ubn56uqqsqCKhFLq1ev1vbt2/XBBx+cdB/nPvF9/vnneuqpp1RSUqJ77rlHH3zwge688045nU7Nnj07cp7b+/+A34Ge7+6775bH49GwYcPkcDgUCoX04IMPaubMmZLE+U8iHTnXVVVV6tu3b9T9KSkpOu+88yz7fSAkAN1k7ty52rVrl/70pz9ZXQq6wYEDBzR//nxt2rRJ6enpVpcDC4TDYY0bN04///nPJUljxozRrl27tGrVKs2ePdvi6tDV/vu//1svvPCCXnzxRV166aXauXOnFixYoH79+nH+0SMw3Kib5eXlyeFwnLSCSXV1tQoKCiyqCl1t3rx52rBhg9566y0NGDAgcrygoEB+v1/19fVR7fl96Pm2bdummpoaXX755UpJSVFKSoo2b96sxx9/XCkpKcrPz+fcJ7gLLrhAw4cPjzp2ySWXqKKiQpIi55n/DxLTokWLdPfdd+vmm2/WyJEjdcstt2jhwoUqLS2VxPlPJh051wUFBSctYBMMBnXkyBHLfh8ICd3M6XRq7NixKisrixwLh8MqKyvTpEmTLKwMXcEwDM2bN08vv/yy3nzzTQ0ePDjq/rFjxyo1NTXq92Hv3r2qqKjg96GH+9rXvqa//vWv2rlzZ+Q2btw4zZw5M/I95z6xXXHFFSctefzJJ5/owgsvlCQNHjxYBQUFUb8DHo9H77//Pr8DCaCpqUl2e/RllsPhUDgclsT5TyYdOdeTJk1SfX29tm3bFmnz5ptvKhwOa+LEid1esyRWN7LC6tWrjbS0NOO5554zdu/ebdx2221Gr169jKqqKqtLQ4zdfvvthsvlMt5++23j0KFDkVtTU1OkzQ9/+ENj0KBBxptvvmls3brVmDRpkjFp0iQLq0ZXOX51I8Pg3Ce6LVu2GCkpKcaDDz5ofPrpp8YLL7xgZGZmGr/5zW8ibR566CGjV69exu9//3vjww8/NG644QZj8ODBRnNzs4WVIxZmz55t9O/f39iwYYOxb98+43e/+52Rl5dn/OQnP4m04fwnjoaGBmPHjh3Gjh07DEnG8uXLjR07dhj79+83DKNj5/raa681xowZY7z//vvGn/70J2Po0KHGjBkzrHpLBiHBIk888YQxaNAgw+l0GhMmTDDee+89q0tCF5DU7u3ZZ5+NtGlubjb+9V//1ejdu7eRmZlpfPOb3zQOHTpkXdHoMieGBM594nvllVeMESNGGGlpacawYcOMp59+Our+cDhs3HfffUZ+fr6RlpZmfO1rXzP27t1rUbWIJY/HY8yfP98YNGiQkZ6eblx00UXGv/3bvxk+ny/ShvOfON566612/7+fPXu2YRgdO9eHDx82ZsyYYWRnZxu5ubnGnDlzjIaGBgvejclmGMdt/QcAAAAg6TEnAQAAAEAUQgIAAACAKIQEAAAAAFEICQAAAACiEBIAAAAARCEkAAAAAIhCSAAAAAAQhZAAANB3v/tdTZs2zbLXv+WWW/Tzn//8tG0KCwu1YsWKbqnH7/ersLBQW7du7ZbXA4B4k2J1AQCArmWz2U57/9KlS/XYY4/Jqr01//KXv+jVV1/VU089Zcnrt8fpdOrHP/6x7rrrLpWVlVldDgB0O0ICACS4Q4cORb5fs2aNlixZor1790aOZWdnKzs724rSJElPPPGEbrrpJktraM/MmTP1ox/9SB999JEuvfRSq8sBgG7FcCMASHAFBQWRm8vlks1mizqWnZ190nCjq6++WnfccYcWLFig3r17Kz8/X88884y8Xq/mzJmjnJwcDRkyRK+99lrUa+3atUt///d/r+zsbOXn5+uWW25RXV3dKWsLhUJ66aWXdP3110cdr6mp0fXXX6+MjAwNHjxYL7zwwkmPXb58uUaOHKmsrCwNHDhQ//qv/6rGxkZJktfrVW5url566aWox6xbt05ZWVlqaGiQ3+/XvHnzdMEFFyg9PV0XXnihSktLI2179+6tK664QqtXr+7wnzUAJApCAgCgXb/61a+Ul5enLVu26I477tDtt9+um266SZMnT9b27ds1depU3XLLLWpqapIk1dfX65prrtGYMWO0detWbdy4UdXV1frOd75zytf48MMP5Xa7NW7cuKjj3/3ud3XgwAG99dZbeumll/T//t//U01NTVQbu92uxx9/XB999JF+9atf6c0339RPfvITSVJWVpZuvvlmPfvss1GPefbZZ/Xtb39bOTk5evzxx7V+/Xr993//t/bu3asXXnhBhYWFUe0nTJigd95552z/CAGg5zIAAEnj2WefNVwu10nHZ8+ebdxwww2Rn6dMmWJceeWVkZ+DwaCRlZVl3HLLLZFjhw4dMiQZ5eXlhmEYxgMPPGBMnTo16nkPHDhgSDL27t3bbj0vv/yy4XA4jHA4HDm2d+9eQ5KxZcuWyLE9e/YYkoz/+3//7ynf29q1a40+ffpEfn7//fcNh8NhHDx40DAMw6iurjZSUlKMt99+2zAMw7jjjjuMa665Juq1T/TYY48ZhYWFp7wfABIVPQkAgHZddtllke8dDof69OmjkSNHRo7l5+dLUuQT/r/85S966623InMcsrOzNWzYMEnSZ5991u5rNDc3Ky0tLWpy9Z49e5SSkqKxY8dGjg0bNky9evWKeuwbb7yhr33ta+rfv79ycnJ0yy236PDhw5GejQkTJujSSy/Vr371K0nSb37zG1144YW66qqrJJm9FTt37tTFF1+sO++8U3/4wx9Oqi8jIyPyfACQTAgJAIB2paamRv1ss9mijrVd2IfDYUlSY2Ojrr/+eu3cuTPq9umnn0YuzE+Ul5enpqYm+f3+TtX2xRdf6B//8R912WWX6be//a22bdumlStXSlLUc33/+9/Xc889J8kcajRnzpxI3Zdffrn27dunBx54QM3NzfrOd76jb3/721Gvc+TIEZ1//vmdqg0AEgEhAQAQE5dffrk++ugjFRYWasiQIVG3rKysdh8zevRoSdLu3bsjx4YNG6ZgMKht27ZFju3du1f19fWRn7dt26ZwOKxly5bpq1/9qr7yla/o4MGDJz3/P//zP2v//v16/PHHtXv3bs2ePTvq/tzcXE2fPl3PPPOM1qxZo9/+9rc6cuRI5P5du3ZpzJgxZ/PHAQA9GiEBABATc+fO1ZEjRzRjxgx98MEH+uyzz/T6669rzpw5CoVC7T7m/PPP1+WXX64//elPkWMXX3yxrr32Wv3Lv/yL3n//fW3btk3f//73lZGREWkzZMgQBQIBPfHEE/r888/161//WqtWrTrp+Xv37q0bb7xRixYt0tSpUzVgwIDIfcuXL9d//dd/6eOPP9Ynn3yitWvXqqCgIGpY0zvvvKOpU6fG4E8HAHoWQgIAICb69eunP//5zwqFQpo6dapGjhypBQsWqFevXrLbT/3fzfe///2Tljh99tln1a9fP02ZMkU33nijbrvtNvXt2zdy/6hRo7R8+XI9/PDDGjFihF544YWo5UuPd+utt8rv9+t73/te1PGcnBw98sgjGjdunMaPH68vvvhCr776aqTW8vJyud3uk4YgAUAysBmGRVtsAgAgc/LyxRdfrDVr1mjSpEkxf/5f//rXWrhwoQ4ePCin09nhx02fPl2jRo3SPffcE/OaACDeseMyAMBSGRkZev7550+76drZaGpq0qFDh/TQQw/pX/7lXzoVEPx+v0aOHKmFCxfGtCYA6CnoSQAAJKT/83/+jx588EFdddVV+v3vf6/s7GyrSwKAHoOQAAAAACAKE5cBAAAARCEkAAAAAIhCSAAAAAAQhZAAAAAAIAohAQAAAEAUQgIAAACAKIQEAAAAAFEICQAAAACiEBIAAAAARPn/v6w09oztmFQAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ax = setup_ax()\n", + "ax = plot_predictive(sq_dataCube, tspan, ax=ax, color=co[1])\n", + "ax.axvline(15)\n", + "sideaxis(ax)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "7fc330e1", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "bins_hist = 50\n", + "fig1 = plt.figure()\n", + "plt.rc('text', usetex=False)\n", + "plt.rc('font', family='serif', size=18.)\n", + "cax = plt.gca()\n", + "sideaxishist(cax)\n", + "cax.hist(sq_qoi, color=co[2], bins=bins_hist, histtype='stepfilled', alpha=0.5, label='total infections')\n", + "miny = min(cax.get_ylim())\n", + "maxy = max(cax.get_ylim())\n", + "cax.vlines(q_sv, miny, maxy, linestyle='--', linewidth=2.5, label='alpha-quantile', color=co[0])\n", + "cax.vlines(sq_sv, miny, maxy, linestyle='--', linewidth=2.5, label='alpha-superquantile', color=co[1])\n", + "cax.set_xlabel('Maximum total infections over 100 days', size=14)\n", + "cax.legend(loc='upper right', prop={'size': 14})" + ] + }, + { + "cell_type": "markdown", + "id": "2a4005a9", + "metadata": {}, + "source": [ + "## Risk-based optimization under uncertainty with intervention on $\\alpha$\n", + "**NOTE:** This is a demonstration of the interface, optimization is not run to convergence nor are enough samples generated to accurately estimate the risk, so take the results with a grain of salt." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "ba6b2d82", + "metadata": {}, + "outputs": [], + "source": [ + "# Define problem specifics\n", + "RISK_BOUND = 1./3.\n", + "RISK_ALPHA = 0.95\n", + "X_MIN = 0.\n", + "X_MAX = 3.\n", + "N_SAMPLES = int(5e2)\n", + "MAXITER = 0\n", + "MAXFEVAL = 30\n", + "\n", + "INIT_GUESS = 0.05\n", + "\n", + "# Objective function\n", + "OBJFUN = lambda x: np.abs(alpha_init-x)\n", + "\n", + "# Define the risk measure.\n", + "RISK = computeRisk(\n", + " model=control_model,\n", + " intervention_fun=INTERVENTION,\n", + " qoi=lambda y: max_total_infections_SIDARTHE(y, contexts=[\"I_total_obs\"]),\n", + " model_state=initial_state,\n", + " tspan=tspan,\n", + " risk_measure=lambda z: alpha_superquantile(z, alpha=RISK_ALPHA),\n", + " num_samples=N_SAMPLES,\n", + " guide=None,\n", + " )\n", + "\n", + "# Define problem constraints\n", + "CONSTRAINTS = (\n", + " # risk constraint\n", + " {'type': 'ineq', 'fun': lambda x: RISK_BOUND - RISK(x)},\n", + "\n", + " # bounds on control\n", + " # NOTE: perhaps use scipy.optimize.LinearConstraint in the future\n", + " {'type': 'ineq', 'fun': lambda x: x - X_MIN},\n", + " {'type': 'ineq', 'fun': lambda x: X_MAX - x}\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "13a9803a", + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Performing risk-based optimization under uncertainty (using alpha-superquantile)...\n", + "Estimated wait time 2807.7 seconds.\n" + ] + } + ], + "source": [ + "print(\"Performing risk-based optimization under uncertainty (using alpha-superquantile)...\")\n", + "print(f\"Estimated wait time {time_per_eval*N_SAMPLES*(MAXITER+1)*MAXFEVAL:.1f} seconds.\")\n", + "start_time = time.time()\n", + "sq_result_1 = solveOUU(\n", + " x0=INIT_GUESS,\n", + " objfun=OBJFUN,\n", + " constraints=CONSTRAINTS,\n", + " maxiter=MAXITER,\n", + " maxfeval=MAXFEVAL,\n", + " ).solve()\n", + "print(f\"Optimization completed in time {time.time()-start_time:.2f} seconds. Optimal solution:\\t{sq_result_1.x}\")" + ] + }, + { + "cell_type": "markdown", + "id": "abfeda8c", + "metadata": {}, + "source": [ + "## Assess the effect of the control policy." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "60c9d1a9", + "metadata": { + "scrolled": false + }, + "outputs": [], + "source": [ + "RISK.num_samples = int(5e2)\n", + "sq_optimal_prediction = RISK.propagate_uncertainty(sq_result_1.x)\n", + "qois_sq = RISK.qoi(sq_optimal_prediction)\n", + "sq_est = RISK.risk_measure(qois_sq)\n", + "print('Estimated risk at optimal policy', sq_est)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c92e52b7", + "metadata": {}, + "outputs": [], + "source": [ + "ax = setup_ax()\n", + "# print(sq_optimal_prediction.shape)\n", + "ax = plot_predictive(sq_optimal_prediction, tspan, ax=ax, color=co[2], ptiles=[0.0,1.])\n", + "plt.title(\"Optimal alpha parameter intervention \\n with risk-based OUU\", size=14)\n", + "sideaxis(ax)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "13bf129e", + "metadata": {}, + "outputs": [], + "source": [ + "bins_hist = 50\n", + "fig1 = plt.figure()\n", + "plt.rc('font', family='serif', size=14.)\n", + "cax = plt.gca()\n", + "sideaxishist(cax)\n", + "cax.hist(qois_sq, color=co[4], bins=bins_hist, histtype='stepfilled', alpha=0.5, density=True)\n", + "miny = min(cax.get_ylim())\n", + "maxy = max(cax.get_ylim())\n", + "cax.set_xlabel('Maximum total infections over 100 days', size=14)" + ] + } + ], + "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.9.7" + }, + "vscode": { + "interpreter": { + "hash": "a3e1d8fdda916c248c87d86618e3945b28961cf939001a0529e724463670a41a" + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/6-month-milestone/evaluation/scenario_2/ta_3/ciemss/scenario2_q2b_SIDARTHEV_beta.ipynb b/6-month-milestone/evaluation/scenario_2/ta_3/ciemss/scenario2_q2b_SIDARTHEV_beta.ipynb new file mode 100644 index 0000000..2de2276 --- /dev/null +++ b/6-month-milestone/evaluation/scenario_2/ta_3/ciemss/scenario2_q2b_SIDARTHEV_beta.ipynb @@ -0,0 +1,802 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "b087c52b-a505-45d3-b643-df44d8c924a5", + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "markdown", + "id": "542b06c1-28fb-47ec-9a34-170acc7d2a84", + "metadata": {}, + "source": [ + "# Load Dependencies" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "84e0bb12-68af-4a6d-a384-db4837c44ac0", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "import torch\n", + "\n", + "import pyro\n", + "import numpy as np\n", + "import pyro.distributions as dist\n", + "# from pyro.poutine import trace, replay, block\n", + "# from pyro.infer.autoguide.guides import AutoDelta, AutoNormal\n", + "# from pyro.infer import SVI, Trace_ELBO, Predictive\n", + "\n", + "import sys\n", + "sys.path.append(\"../../src/\")\n", + "\n", + "from pyciemss.ODE.askem_primitives import sample, infer_parameters, intervene, optimization\n", + "\n", + "# from pyciemss.utils import run_inference, get_tspan\n", + "from pyciemss.utils import get_tspan\n", + "\n", + "import warnings\n", + "warnings.filterwarnings('ignore')" + ] + }, + { + "cell_type": "markdown", + "id": "4855961d-9c38-4050-b6b7-aaae03500fc9", + "metadata": {}, + "source": [ + "# Plotting Utilities" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "260901d9", + "metadata": {}, + "outputs": [], + "source": [ + "def setup_ax(ax=None):\n", + "\n", + " if not ax:\n", + " fig = plt.figure(facecolor='w', figsize=(9, 5))\n", + " ax = fig.add_subplot(111, axisbelow=True)\n", + "\n", + " ax.set_xlabel('Time (days)')\n", + " ax.set_ylabel('Total infected')\n", + " return ax\n", + "\n", + "def plot_predictive(prediction, tspan, tmin=None, ax=None, alpha=0.2, color=\"black\", ptiles=[0.05,0.95], **kwargs):\n", + " vars = [\"I_total_obs\"]\n", + " #infection_total = sum([prediction[x].squeeze().detach().numpy()/1000. for x in ['I_obs', 'D_obs', 'A_obs', 'R_obs', 'T_obs']])\n", + "\n", + " I_low = torch.quantile(prediction[\"I_total_obs\"], ptiles[0], dim=0).detach().numpy()\n", + " I_up = torch.quantile(prediction[\"I_total_obs\"], ptiles[1], dim=0).detach().numpy()\n", + "\n", + " if tmin:\n", + " indeces = tspan >= tmin\n", + " else:\n", + " indeces = torch.ones_like(tspan).bool()\n", + "\n", + " if not ax:\n", + " fig = plt.figure(facecolor='w')\n", + " ax = fig.add_subplot(111, facecolor='#dddddd', axisbelow=True)\n", + " \n", + " ax.fill_between(tspan[indeces], I_low[indeces], I_up[indeces], alpha=alpha, color=color, **kwargs)\n", + "\n", + " legend = ax.legend()\n", + " legend.get_frame().set_alpha(0.5)\n", + "\n", + " return ax\n", + "\n", + "def plot_trajectory(data, tspan, ax=None, color='black', alpha=0.5, lw=0, marker='.', label=None, ind=0):\n", + " # Plot the data on three separate curves for S(t), I(t) and R(t)\n", + " if len(data['I_total_obs'].squeeze().detach().numpy().shape)>1:\n", + " plot_data = data['I_total_obs'].squeeze().detach().numpy()[ind,:]\n", + " else:\n", + " plot_data = data['I_total_obs'].squeeze().detach().numpy()\n", + "\n", + " if not ax:\n", + " fig = plt.figure(facecolor='w')\n", + " ax = fig.add_subplot(111, facecolor='#dddddd', axisbelow=True)\n", + " #infection_total = sum([data[x].squeeze().detach().numpy()/1000. for x in ['I_obs', 'D_obs', 'A_obs', 'R_obs', 'T_obs']])\n", + " ax.plot(tspan, plot_data, color, alpha=alpha, lw=lw, marker=marker, label=label)\n", + " \n", + " return ax\n", + "\n", + "def plot_intervention_line(t, ax=None):\n", + " if not ax:\n", + " fig = plt.figure(facecolor='w')\n", + " ax = fig.add_subplot(111, facecolor='#dddddd', axisbelow=True)\n", + "\n", + " ylim = ax.get_ylim()\n", + "\n", + " ax.vlines(t, min(ylim), max(ylim), color=\"grey\", ls='-')\n", + "\n", + " return ax\n", + "\n", + "def sideaxis(ax):\n", + " ax.spines['top'].set_visible(False)\n", + " ax.spines['right'].set_visible(False)\n", + " return\n", + "\n", + "def sideaxishist(ax):\n", + " ax.spines['top'].set_visible(False)\n", + " ax.spines['right'].set_visible(False)\n", + " ax.spines['left'].set_visible(False)\n", + " # For y-axis\n", + " ax.yaxis.set_major_locator(ticker.NullLocator())\n", + " ax.tick_params(axis='x', labelsize=12) # change fontsize for x-axis tick labels\n", + " # ax.xaxis.major.formatter._useMathText = True\n", + " return" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "f233104e-c29d-4e25-859f-2a328ec7892a", + "metadata": {}, + "outputs": [], + "source": [ + "def LogNormalPrior(mean, variance):\n", + " mu = torch.log(mean**2/torch.sqrt((mean**2 + variance)))\n", + " scale = torch.sqrt(torch.log(1 + variance/mean**2))\n", + " return dist.LogNormal(mu, scale)\n", + "\n", + "def LogNormalPrior_propVar(mean, cov=0.05):\n", + " variance = mean*cov \n", + " return LogNormalPrior(mean, variance)" + ] + }, + { + "cell_type": "markdown", + "id": "3e0c3726-5ec0-475d-8305-f20b5d84e424", + "metadata": {}, + "source": [ + "# Setup Parameters" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "16608500-97b5-4081-9e6b-b7c193c10285", + "metadata": {}, + "outputs": [], + "source": [ + "tspan = get_tspan(1, 100, 100)\n", + "\n", + "num_samples = 50\n", + "\n", + "# Total population, N.\n", + "N = 1\n", + "# Initial number of infected and recovered individuals, I0 and R0.\n", + "I0, D0, A0, R0, T0, H0, E0, V0 = 200/60e6, 20/60e6, 1/60e6, 2/60e6, 0, 0, 0, 0\n", + "\n", + "# Everyone else, S0, is susceptible to infection initially.\n", + "S0 = N - I0 - D0 - A0 - R0 - T0 - H0 - E0 - V0\n", + "\n", + "initial_state = tuple(torch.as_tensor(s) for s in (S0, I0, D0, A0, R0, T0, H0, E0, V0))" + ] + }, + { + "cell_type": "markdown", + "id": "23fc9c9d-f8bc-4e95-a243-865690d3b43b", + "metadata": {}, + "source": [ + "# Probabilistic Forecasting - Passing unit test 1\n", + "There are two ‘unit tests’ we want to pass, to ensure that we understood and can reproduce the published model:\n", + "\n", + "## 1.a Unit Test \\#1:\n", + "\n", + "Set the initial values and parameters, as described in the Supplementary Methods section of the publication (pg. 9 of the pdf): \n", + "\n", + "1. Initial Values: \n", + "* $I = 200/60e6$,\n", + "* $D = 20/60e6$, \n", + "* $A = 1/60e6$, \n", + "* $R = 2/60e6$, \n", + "* $T = 0$, \n", + "* $H = 0$, \n", + "* $E = 0$; \n", + "* $S = 1 – I – D – A – R – T – H – E$. \n", + "\n", + "Let total population = 60e6.\n", + "Parameters: $$\\alpha = 0.570, \\beta = \\delta = 0.011, \\gamma = 0.456, \\epsilon = 0.171, \\theta = 0.371, \\zeta = \\eta = 0.125, \\mu = 0.017, \\nu = 0.027, \\tau = 0.01, \\lambda = \\rho = 0.034$$ and $$\\kappa = \\xi = \\sigma = 0.017$$." + ] + }, + { + "cell_type": "markdown", + "id": "f6228f01", + "metadata": {}, + "source": [ + "### Deterministic forecasting" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "dbd7d430-325f-4f40-9b20-d8a0c0264f62", + "metadata": {}, + "outputs": [], + "source": [ + "from pyciemss.ODE.models import SIDARTHEV\n", + "\n", + "pyro.set_rng_seed(0)\n", + "\n", + "ode_model = SIDARTHEV(N=1,\n", + " alpha_prior=dist.Delta(torch.tensor (0.570)) ,\n", + " beta_prior=dist.Delta(torch.tensor (0.011)) ,\n", + " gamma_prior=dist.Delta(torch.tensor (0.456)) ,\n", + " delta_prior=dist.Delta(torch.tensor (0.011)) ,\n", + " epsilon_prior=dist.Delta(torch.tensor (0.171)) ,\n", + " lamb_prior =dist.Delta(torch.tensor (0.034)) ,\n", + " zeta_prior=dist.Delta(torch.tensor (0.125)) ,\n", + " eta_prior=dist.Delta(torch.tensor (0.125)) ,\n", + " kappa_prior=dist.Delta(torch.tensor (0.017)) ,\n", + " theta_prior=dist.Delta(torch.tensor (0.371)) ,\n", + " rho_prior=dist.Delta(torch.tensor (0.034)) ,\n", + " xi_prior=dist.Delta(torch.tensor (0.017)) ,\n", + " sigma_prior=dist.Delta(torch.tensor (0.017)) ,\n", + " mu_prior=dist.Delta(torch.tensor (0.017)) ,\n", + " nu_prior=dist.Delta(torch.tensor (0.027)) ,\n", + " tau2_prior=dist.Delta(torch.tensor (0.01)) ,\n", + " phi_prior=dist.Delta(torch.tensor (0.)) )" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "31473cdd-9896-42ed-b487-36362c1c9744", + "metadata": { + "scrolled": false + }, + "outputs": [], + "source": [ + "single_prediction = sample(ode_model, 1, initial_state, tspan)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "15f03c6f-d085-4f36-bc7a-312057d82758", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAwAAAAHACAYAAAAV9g8TAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAABUzklEQVR4nO3deVyVdf7//+dhBwVcEHBB0TTJFRU1tLKFpM20xcwsjbYZyzY+M59y5pdOq9WUXz+Vk2VjNaVpappZmoZWluaammmkprIJihuKCsq5fn+8x1MkFtiB6yyP++123Q5c5zqcJ14I1+t6bw7LsiwBAAAA8AsBdgcAAAAAUHcoAAAAAAA/QgEAAAAA+BEKAAAAAMCPUAAAAAAAfoQCAAAAAPAjFAAAAACAH6EAAAAAAPxIkN0B6prT6VRBQYEiIyPlcDjsjgMAAAC4hWVZOnz4sJo1a6aAgDPf5/e7AqCgoEAJCQl2xwAAAABqRW5urlq0aHHG5/2uAIiMjJRk/mGioqJsTgMA9jtaflK9ns6SJK36+2WKCPG7Pw0A4BNKSkqUkJDgut49E7/7LX+q209UVBQFAABICio/qYDQCEnmdyMFAAB4t9/r5s4gYAAAAMCPUAAAAAAAfoQCAAAAAPAjFAAAAACAH6EAAAAAAPyI7QXAxIkTlZiYqLCwMPXu3VurVq36zeMPHjyo++67T02bNlVoaKjOPfdcffLJJ3WUFgAAAPButs71NmPGDGVmZmrSpEnq3bu3JkyYoPT0dGVnZys2Nva048vLy3X55ZcrNjZWs2bNUvPmzbVr1y41aNCg7sMDAAAAXsjWAmD8+PG6++67lZGRIUmaNGmSPv74Y02ZMkWPPvroacdPmTJF+/fv1/LlyxUcHCxJSkxMrMvIAAAAgFezrQtQeXm51q5dq7S0tJ/DBAQoLS1NK1asqPI18+bNU2pqqu677z7FxcWpU6dOeuaZZ1RRUXHG9ykrK1NJSUmlDQAAAPBXthUAxcXFqqioUFxcXKX9cXFxKiwsrPI1P/30k2bNmqWKigp98skneuyxx/Tiiy/qqaeeOuP7jBs3TtHR0a4tISHBrd8HAAAA4E1sHwRcE06nU7GxsXr99dfVo0cPDRkyRH//+981adKkM75m9OjROnTokGvLzc2tw8QAAACAZ7FtDEBMTIwCAwNVVFRUaX9RUZHi4+OrfE3Tpk0VHByswMBA177zzjtPhYWFKi8vV0hIyGmvCQ0NVWhoqHvDAwAAAF7KthaAkJAQ9ejRQ1lZWa59TqdTWVlZSk1NrfI1ffv21bZt2+R0Ol37fvzxRzVt2rTKi38AAAAAldnaBSgzM1OTJ0/W22+/rS1btmjkyJEqLS11zQo0fPhwjR492nX8yJEjtX//fj344IP68ccf9fHHH+uZZ57RfffdZ9e3AAD4HceOSbm50vr10po1UnGxZFl2pwIA/2XrNKBDhgzR3r17NWbMGBUWFio5OVkLFy50DQzOyclRQMDPNUpCQoI+/fRTPfzww+rSpYuaN2+uBx98UI888ohd3wIA4Bcsy1zo5+SYC/19+6SjR39+PiBAcjql6GjpnHPM1qaNFB5uW2QA8DsOy/Kv+zAlJSWKjo7WoUOHFBUVZXccALDd0fKT6jDmU0nS5ifSFRFydveGDhyQPvxQ2rlTatZMiokxW+PGP2+WJe3aJW3fbra9eyWHwxx/wQVSUpL5HABQc9W9zrW1BQAA4P0sS1q3Tvr0UykiQhoxQmrd+szHt2tnNkkqKTGFwKZN0owZUtu20pVXmmIBAFA7KAAAAGetpESaN0/atk3q3l1KT5dqMvFaVJTUrZvZsrOlBQukf/1L6ttXuvBC6b+LvgMA3IgCAABQY5Zl7tp//LG5SL/lFuncc//Y12zf3owH+Oors23caFoD2rd3T2YAgEEBAACosdWrpU8+kTp3lq66yn2DeIODpUsukbp0Ma0B770ndewoDRwoMdszALiHV60EDACwX36+6e/fu7d0ww21M4NP48bSsGHS4MHS1q3SW29Jhw+7/30AwB9RAAAAqu3YMWnmTCk+Xurfv3bfy+Ewd/8zMqQjR6TJk6XCwtp9TwDwBxQAAIBqsSxpzhyprMzcmQ8MrJv3bdpUuusuqV49acoU0yIAADh7FAAAgGpZvlz68UfpuuukBg3q9r2jokxLQOvW0rRp0qpVdfv+AOBLKAAAAL9r1y4pK8ss1vVHZ/s5WyEh0pAh0vnnmwHICxaYVgkAQM0wCxAA4DeVlkqzZkkJCdKll9qbJSDArDXQuLGZgvTkSemaa1g9GABqggIAAHBGTqc0e7Z5vPFGcwHuCVJSpKAgae5c83jFFRQBAFBdFAAAgDP66itpxw5p+HApMtLuNJUlJ5sWgPnzzfoBl11GEQAA1UEBAACo0tGjpgBITTWDbz1RSop04oRZlyA4WOrXz+5EAOD5KAAAAFVaudIMsu3b1+4kvy011bQEZGWZIqBPH7sTAYBnowAAAJzm+HHpm2/MHfZ69exO8/suvNC0BCxaZIqAnj3tTgQAnosCAABwmpUrpYoK77qbfsklpgj4+GMzZWjXrnYnAgDPRAEAAKikrMzc/e/Rw/MG/v4Wh0Pq39/knzdPio6WEhPtTgUAnsdDJnQDAHiK1aul8nLP7/tfFYdDuvpqqVUracYMad8+uxMBgOehAAAAuJSXS8uXS926SVFRdqc5O4GB0k03SfXrS1OnmtmMAAA/owAAALh8+60ZAHzBBXYn+WPCwqRbbjHfy4wZZpYgAIBBAQAAcPnmGzN4tkEDu5P8cQ0bSkOHSvn50kcfmSlNAQAUAACAXygtNVNq+oqEBGngQGnDBmnZMrvTAIBnYBYgAIBLp05So0Z2p3Cvzp2l/fulJUvM99apk92JAMBeFAAAAJe+XjTvf01cdJGZEWjuXKlxY6lpU7sTAYB96AIEAH7O6fz548Yx9uWoTQ6HdO21UmysGRTMzEAA/BkFAAD4uZ9+sjtB3QgKkoYMMVOdzp5dufABAH9CAQAAfu777+1OUHeio6UbbzRFz9KldqcBAHtQAACAHysvl3780e4UdatNGyktzcwKtGWL3WkAoO5RAACAH8vONkWAv+nTR+rQQZozRyoutjsNANQtCgAA8GMbN0otWtidou45HGZ9gOhoafp0qazM7kQAUHcoAADAT5WWStu3+++8+KGhZlDw4cNmelBWCgbgLygAAMBPnRr8e9559uawU0yMdN11ZizA8uV2pwGAukEBAAB+6rvvpLZtpYgIu5PYKylJuuACKStLys21Ow0A1D4KAADwQwcOmIvdzp3tTuIZLrnEjIWYOZNFwgD4PgoAAPBD330nhYRI7dvbncQzBAaa9QFOnjQzAzEeAIAvowAAAD9jWaYASEoyRQCMqCgzHmDrVsYDAPBtFAAA4GcKC6W9e+n+U5V27aQLLzTjAXJy7E4DALWDAgAA/Mx330n16knnnGN3Es90ajzArFmMBwDgmygAAMCPOJ2mAOjYUQrgL0CVAgIYDwDAt/HrHwD8yK5dZuEruv/8tqgo6frrzXiAr7+2Ow0AuBcFAAD4ke++kxo2NF1c8NvatjXjAZYsYX0AAL6FAgAA/MTJk9Lmzebuv8NhdxrvcPHFUvPm0uzZ0vHjdqcBAPegAAAAP7F1q7mI7dLF7iTeIzBQuuEG8+/20UeMBwDgGygAAMBP/PCDFBcnxcTYncS7NGggXXut9P330rp1dqcBgD+OAgAA/IBlSdu3m37tqLkOHaSUFGnBAmnPHrvTAMAfQwEAAH6gqEg6coQC4I9IT5caNTLrA5w4YXcaADh7FAAA4Ae2bZNCQqSWLe1O4r2Cg836APv3S59+ancaADh7FAAA4Ae2bZNatzaDWnH2YmOlK66Q1qwxMyoBgDfyiAJg4sSJSkxMVFhYmHr37q1Vq1ad8di33npLDoej0hYWFlaHaQHAu5SVSTk5dP9xlx49zJiAefOkgwftTgMANWd7ATBjxgxlZmZq7NixWrdunbp27ar09HTt+Y1RVlFRUdq9e7dr27VrVx0mBgDvsmOH5HRSALiLwyENGCCFhkoffGD+bQHAm9heAIwfP1533323MjIy1KFDB02aNEkRERGaMmXKGV/jcDgUHx/v2uLi4uowMQB4l23bpMaNzQrAcI/wcLM+QG6u9OWXdqcBgJqxtQAoLy/X2rVrlZaW5toXEBCgtLQ0rVix4oyvO3LkiFq1aqWEhAQNHDhQ33//fV3EBQCvY1mmADjnHLuT+J6WLaV+/aQvvjBdrADAW9haABQXF6uiouK0O/hxcXEqLCys8jXt27fXlClT9OGHH+rdd9+V0+lUnz59lJeXV+XxZWVlKikpqbQBgL/Yv9/0U6f7T+246CIpIUGaPdusFgwA3sD2LkA1lZqaquHDhys5OVn9+vXTBx98oCZNmui1116r8vhx48YpOjratSUkJNRxYgCwz7ZtZuafxES7k/imgADp+uvNQOuPPjItLgDg6WwtAGJiYhQYGKiioqJK+4uKihQfH1+trxEcHKxu3bpp27ZtVT4/evRoHTp0yLXl5ub+4dwA4C22bZNatTJrAKB2NGhgBgV//720fr3daQDg99laAISEhKhHjx7Kyspy7XM6ncrKylJqamq1vkZFRYW+++47NW3atMrnQ0NDFRUVVWkDAH9w8qS0cyfdf+pCx45St27SggXSvn12pwGA32Z7F6DMzExNnjxZb7/9trZs2aKRI0eqtLRUGRkZkqThw4dr9OjRruOfeOIJLVq0SD/99JPWrVunW2+9Vbt27dJdd91l17cAAB5p1y7pxAkKgLpy5ZVSZKQZD1BRYXcaADizILsDDBkyRHv37tWYMWNUWFio5ORkLVy40DUwOCcnRwEBP9cpBw4c0N13363CwkI1bNhQPXr00PLly9WhQwe7vgUA8EjbtklRUVKTJnYn8Q8hIdKNN0pvvCFlZUn9+9udCACq5rAs/xqyVFJSoujoaB06dIjuQAB82sSJUosW0sCBv33c0fKT6jDmU0nS5ifSFRFi+70hr7Z8ubRokTR8uNSmjd1pAPiT6l7n2t4FCADgfocOSXv30v3HDqmpZt2FOXOk0lK70wDA6SgAAMAHbd8uORzcgbaDwyENGmTGAcybx9SgADwPBQAA+KBt20z3n/Bwu5P4p8hIUwRkZ0urV9udBgAqowAAAB/jdEo//UT3H7ude67Uq5cZD7Bnj91pAOBnFAAA4GPy8qTjxykAPMHll0uNGkmzZpkpWQHAE1AAAICP2bZNioiQzrA+IupQcLCZGnT/fmnxYrvTAIBBAQAAPmbbNjP4N4Df8B4hNtasCbBqlfTjj3anAQAKAADwKWVl0u7dzP7jaXr2NGMC5s6VDh+2Ow0Af0cBAAA+JDfXTDvZqpXdSfBLDodZkC0w0KwPwNSgAOxEAQAAPmTXLqlePTPwFJ6lXj3puuukHTvMasEAYBcKAADwITk5UsuW5o4zPE+bNlKfPlJWlpSfb3caAP6KAgAAfMTJk+aiku4/nu3SS6X4eGn2bDNmAwDqGgUAAPiIggJTBLRsaXcS/JbAQDM16JEj0ief2J0GgD+iAAAAH5GTI4WEmLvL8GyNGklXXy1t2CB9953daQD4GwoAAPARu3ZJCQnM/+8tunaVunSR5s+XDhywOw0Af8KfCQDwAU6nmQKU/v/e5eqrzarNs2dLFRV2pwHgLygAAMAH7NkjHT9O/39vExoq3XCDGb/x+ed2pwHgLygAAMAH5OSYwaXNm9udBDXVooWZGeirr6SffrI7DQB/QAEAAD4gJ0dq1kwKDrY7Cc5G375S69bSBx9IpaV2pwHg6ygAAMDLWZYZAEz3H+/lcJhVgi1LmjvXPAJAbaEAAAAvd/CgdPgwA4C9XWSkKQK2bpW++cbuNAB8GQUAAHi5XbvMY0KCvTnwx7VtK/XpI332mRkYDAC1gQIAALxcTo4UGyuFh9udBO5w2WVmMbdZs6SyMrvTAPBFFAAA4OV27aL7jy8JDDRTg5aWSh9/zHgAAO5HAQAAXuzIEWnfPgYA+5pGjaRrrpE2bpQ2bLA7DQBfQwEAAF4sN9c80gLgezp3lpKTTStAcbHdaQD4EgoAAPBiu3ZJDRpIUVF2J0FtuOoqKTpamjlTOnHC7jQAfAUFAAB4sZwc7v77spAQafBg083r00/tTgPAV1AAAICXKiuTdu+m/7+vi4uTrrxSWrNG2rTJ7jQAfAEFAAB4qbw8M0MMBYDv695d6tRJ+ugjaf9+u9MA8HYUAADgpXbtkiIipJgYu5Ogtjkc0oABUr16Zn2AkyftTgTAm1EAAICXyskxd/8dDruToC6EhprxAEVFZqVgADhbFAAA4IUqKkwXIAYA+5emTaX+/aVvvpF++MHuNAC8FQUAAHihggLTDYT+//6nVy8pKUmaO1c6eNDuNAC8EQUAAHihvDwpKEiKj7c7CeqawyENHCiFhZn1ASoq7E4EwNtQAACAF8rLk5o1kwID7U4CO4SHm/EAhYXS4sV2pwHgbSgAAMAL5edLzZvbnQJ2at5cSk834wE2b7Y7DQBvQgEAAF7myBHT97tFC7uTwG49e0odO0offsj6AACqjwIAALxMfr55pAUADod07bVmfYD332d9AADVQwEAAF4mL0+qX1+KjrY7CTxBaKh0001ScbG0cKHdaQB4AwoAAPAyeXmm+w8LgOGU+HjpqqukNWukjRvtTgPA01EAAIAXcTrNGgB0/8Gvdesmde0qzZ8v7d1rdxoAnowCAAC8SHGxVFbGAGCczuGQrr7adA17/32pvNzuRAA8FQUAAHiR/Hxzodesmd1J4IlCQqQhQ6RDh6R58yTLsjsRAE9EAQAAXiQvT2rSxAz8BKoSE2NWCt60SVq1yu40ADxRkN0BAADVxwJgqI6OHaXcXOnTT01rUUKC3YkAeBJaAADAS5SXS0VF9P9H9Vx+uflZef99s3gcAJxCAQAAXmL3btOnmxYAVEdgoDR4sPmZmT3bzCAFAJKHFAATJ05UYmKiwsLC1Lt3b62qZqfF6dOny+FwaNCgQbUbEAA8QF6eGeQZG2t3EniLyEjpxhulXbukJUvsTgPAU9heAMyYMUOZmZkaO3as1q1bp65duyo9PV179uz5zdft3LlTf/nLX3ThhRfWUVIAsFdenunPHWD7b254k8RE6bLLpK++kn74we40ADyB7X9Gxo8fr7vvvlsZGRnq0KGDJk2apIiICE2ZMuWMr6moqNCwYcP0+OOPq02bNnWYFgDswwBgnK0+faTzzpPmzDFrSQDwb7YWAOXl5Vq7dq3S0tJc+wICApSWlqYVK1ac8XVPPPGEYmNjdeedd9ZFTACwXUmJ2RgAjLPhcEiDBpkuQTNmmMXkAPgvWwuA4uJiVVRUKC4urtL+uLg4FRYWVvmar776Sv/+9781efLkar1HWVmZSkpKKm0A4G3y880jLQA4W6Gh0s03m0Jy7lwWCQP8me1dgGri8OHDuu222zR58mTFxMRU6zXjxo1TdHS0a0tgMmQAXigvT4qKMhtwtmJipOuuk7ZsMWMCAPgnWxcCi4mJUWBgoIqKiirtLyoqUnx8/GnHb9++XTt37tSAAQNc+5z/ndcsKChI2dnZOueccyq9ZvTo0crMzHR9XlJSQhEAwOvQ/x/ukpQkXXSRmRWoaVOpbVu7EwGoa7a2AISEhKhHjx7Kyspy7XM6ncrKylJqauppxyclJem7777T+vXrXdu1116rSy65ROvXr6/ywj40NFRRUVGVNgDwJk6nVFBA/3+4z8UXmwv/2bOlAwfsTgOgrtnaAiBJmZmZGjFihFJSUtSrVy9NmDBBpaWlysjIkCQNHz5czZs317hx4xQWFqZOnTpVen2DBg0k6bT9AOAr9u41qwDTAgB3CQiQrr9emjxZmj5duvNOs8YEAP9gewEwZMgQ7d27V2PGjFFhYaGSk5O1cOFC18DgnJwcBTDpNQA/lpdnZnFp1szuJPAl4eFmUPAbb0gffWQKAofD7lQA6oLtBYAkjRo1SqNGjaryuc8///w3X/vWW2+5PxAAeJC8PCkujju0cL/YWGngQGnmTDMeoE8fuxMBqAseUQAAAM4sP19i7gLUlo4dpd27pcWLTUHAoGDA99G3BgA8WFmZGQPAAGDUpksvldq1k2bNYqVgwB9QAACABysoMAs2MQAYtenUoOD69c2g4OPH7U4EoDZRAACAB8vLMyu4VnPtQ+CshYVJQ4dKR46Y6UH/u8wOAB9EAQAAHiw/38z+w2RoqAuNG0uDB0vbtkm/WKIHgI/hTwoAeDBWAEZdO+ccqX9/6euvpY0b7U4DoDYwCxAAeKjDh81GAYC6dv75UmGhNG+eaRXgZxDwLbQAAICHys83jywAhrrmcEgDBkjx8WZQcEmJ3YkAuBMFAAB4qIICMytLVJTdSeCPgoKkIUNMMTB9unTihN2JALgLBQAAeKhTA4AdDruTwF9FRkq33GLWBpgzx0xJC8D7VWsMwLx586r9Ba+99tqzDgMAMCzLtACcf77dSeDv4uPNGgEzZkhLl5pFwwB4t2oVAIMGDar0ucPhkPWL2wCOX9yeqqiocE8yAPBjBw5Ix47R/x+eISlJSkuTFi82g4K7drU7EYA/olpdgJxOp2tbtGiRkpOTtWDBAh08eFAHDx7UJ598ou7du2vhwoW1nRcA/MKpAcDMvgJP0aeP1K2bmRkoJ8fuNAD+iBpPA/rQQw9p0qRJuuCCC1z70tPTFRERoXvuuUdbtmxxa0AA8EcFBVKDBlJEhN1JAMPhkK65Rtq/33QHuvtu8zMKwPvUeBDw9u3b1aCK//HR0dHauXOnGyIBAFgADJ4oMNDMDBQSIk2bJpWV2Z0IwNmocQHQs2dPZWZmqqioyLWvqKhIf/3rX9WrVy+3hgMAf+R0Srt3UwDAM0VEmJmBSkqk99+XGPoHeJ8aFwBTpkzR7t271bJlS7Vt21Zt27ZVy5YtlZ+fr3//+9+1kREA/MrevWbOdQYAw1M1aWJaAnbulD7+mOlBAW9T4zEAbdu21caNG7V48WL98MMPkqTzzjtPaWlplWYDAgCcnYIC09+6aVO7kwBn1rq1WS147lypYUPpwgvtTgSgumpcAEhm2s/+/fvroosuUmhoKBf+AOBG+flSTIwUGmp3EuC3JSdLBw9KWVmmCOjUye5EAKqjxl2AnE6nnnzySTVv3lz169fXjh07JEmPPfYYXYAAwA0KCuj/D+/Rr59ZF2DOHKYHBbxFjQuAp556Sm+99Zaef/55hYSEuPZ36tRJb7zxhlvDAYC/OXlSKiqi/z+8h8MhXXutlJAgvfeetG+f3YkA/J4aFwD/+c9/9Prrr2vYsGEKDAx07e/atatrTAAA4OwUFZlZVWgBgDc5NT1ovXrS1KlSaandiQD8lhoXAPn5+Wrbtu1p+51Op06cOOGWUADgr/LzzcVUXJzdSYCaCQ+Xhg0zawO8956ZyQqAZ6pxAdChQwctW7bstP2zZs1St27d3BIKAPxVQYG5+A86qykaAHs1bGiKgD17pFmzzJoWADxPjf/EjBkzRiNGjFB+fr6cTqc++OADZWdn6z//+Y/mz59fGxkBwG/k50utWtmdAjh7zZpJgwebVoCPP5auucaMEwDgOWrcAjBw4EB99NFH+uyzz1SvXj2NGTNGW7Zs0UcffaTLL7+8NjICgF8oK5OKi+n/D+/Xrp0ZGLx2rfTll3anAfBrZ9XIfOGFF2rx4sXuzgIAfm33brOiKjMAwRckJ0uHD5s1AiIjpe7d7U4E4JQatwC0adNG+6qY4+vgwYNq06aNW0IBgD8qKJCCg6UmTexOArjHBRdIPXtK8+dLP/5odxoAp9S4ANi5c6cqKipO219WVqb8/Hy3hAIAf5SfLzVtKgXU+Dcz4JkcDunKK6X27aWZM6W8PLsTAZBq0AVo3rx5ro8//fRTRUdHuz6vqKhQVlaWEhMT3RoOAPxJfr503nl2pwDcKyBAuv566Z13pGnTpDvukGJi7E4F+LdqFwCDBg2SJDkcDo0YMaLSc8HBwUpMTNSLL77o1nAA4C9KS6WDBxkADN8UHCwNHSq9+ab0n/9Id94p/eI+IoA6Vu2GZqfTKafTqZYtW2rPnj2uz51Op8rKypSdna1rrrmmNrMCgM8qKDCPDACGrwoPl2691bQIvPMOqwUDdqpxT9MdO3YohrY7AHCrggJzgdSwod1JgNoTFSXddpt07Jg0daqZ+hZA3atxAfDAAw/opZdeOm3/K6+8ooceesgdmQDA7+Tnm7v/LJgEX9e4sWkJ2LdPmj5dOnnS7kSA/6lxATB79mz17dv3tP19+vTRrFmz3BIKAPyJZZkWAPr/w180bSrdcouUmyvNni05nXYnAvxLjQuAffv2VZoB6JSoqCgVFxe7JRQA+JOSEunIEfr/w7+0aiUNHixlZ5t1AizL7kSA/6hxAdC2bVstXLjwtP0LFixgITAAOAunBgDTAgB/0769NHCgtG6dtHgxRQBQV6o9DegpmZmZGjVqlPbu3atLL71UkpSVlaUXX3xREyZMcHc+APB5+flmcGRkpN1JgLrXtat0/Li0YIEUEiJdfLHdiQDfV+MC4I477lBZWZmefvppPfnkk5KkxMREvfrqqxo+fLjbAwKAr8vP5+4//Fvv3lJ5uZSVZYqAPn3sTgT4thoXAJI0cuRIjRw5Unv37lV4eLjq16/v7lwA4BecTtMF6MIL7U4C2OvCC00RsGiRKQJSUuxOBPiuGo8BkKSTJ0/qs88+0wcffCDrvx32CgoKdOTIEbeGAwBft2+fmQudFgBAuvRS0xrw8cfShg12pwF8V41bAHbt2qUrrrhCOTk5Kisr0+WXX67IyEg999xzKisr06RJk2ojJwD4pPx8M/c/MwAB5v/CFVeYloC5c01LwHnn2Z0K8D01bgF48MEHlZKSogMHDig8PNy1/7rrrlNWVpZbwwGAr8vPl2JipNBQu5MAnsHhkAYMkDp2lGbNkrZutTsR4Htq3AKwbNkyLV++XCEhIZX2JyYmKj8/323BAMAfMAAYOF1AgHTdddKJE9KMGWbRMGYaB9ynxi0ATqdTFRUVp+3Py8tTJHPYAUC1nTwpFRZSAABVCQw0C4W1bi299560Y4fdiQDfUeMCoH///pXm+3c4HDpy5IjGjh2rq666yp3ZAMCnFRaaWYAoAICqBQVJQ4ZILVtK06ZJO3fanQjwDTUuAF588UV9/fXX6tChg44fP65bbrnF1f3nueeeq42MAOCT8vPNBU5cnN1JAM8VFCTdfLPUooUpAnJy7E4EeL8ajwFo0aKFNmzYoBkzZmjDhg06cuSI7rzzTg0bNqzSoGAAwG/Lz5fi401XBwBnFhxsxgFMnSq9+650221SQoLdqQDvVa0WgO7du+vAgQOSpCeeeELl5eUaNmyYnn/+ef3rX//SXXfdxcU/ANQQA4CB6jtVBDRtaoqAvDy7EwHeq1oFwJYtW1RaWipJevzxx92+4NfEiROVmJiosLAw9e7dW6tWrTrjsR988IFSUlLUoEED1atXT8nJyXrnnXfcmgcAatuxY2YRMAoAoPpCQkwREBdnigAmHwTOTrW6ACUnJysjI0MXXHCBLMvSCy+8oPr161d57JgxY2oUYMaMGcrMzNSkSZPUu3dvTZgwQenp6crOzlZsbOxpxzdq1Eh///vflZSUpJCQEM2fP18ZGRmKjY1Venp6jd4bAOxSUGAeKQCAmgkNlYYNMwXAf/4j3Xor3YGAmnJYlmX93kHZ2dkaO3astm/frnXr1qlDhw4KCjq9dnA4HFq3bl2NAvTu3Vs9e/bUK6+8IslMM5qQkKD7779fjz76aLW+Rvfu3XX11VfrySef/N1jS0pKFB0drUOHDikqKqpGWQHAXb78Ulq+XHrkEbPwkZ2Olp9UhzGfSpI2P5GuiJAaDw8D6lxZmRkUvHu3KQJatrQ7EWC/6l7nVuu3fPv27TV9+nRJUkBAgLKysqq8O19T5eXlWrt2rUaPHu3aFxAQoLS0NK1YseJ3X29ZlpYsWaLs7OwzzkBUVlamsrIy1+clJSV/ODcA/FGn+v/bffEPeKtTLQHTppnWgFtukRIT7U4FeIezWgjMHRf/klRcXKyKigrF/WoOvLi4OBUWFp7xdYcOHVL9+vUVEhKiq6++Wi+//LIuv/zyKo8dN26coqOjXVsC7YQAbGZZDAAG3CEkxBQBLVqYGYJYLAyonrNq5926dauWLl2qPXv2yOl0VnqupmMAzkZkZKTWr1+vI0eOKCsrS5mZmWrTpo0uvvji044dPXq0MjMzXZ+XlJRQBACwVUmJdOQIBQDgDsHB0tCh0owZpggYOlQ65xy7UwGercYFwOTJkzVy5EjFxMQoPj5ejl+0XzscjhoVADExMQoMDFRRUVGl/UVFRYqPjz/j6wICAtS2bVtJZoDyli1bNG7cuCoLgNDQUIWGhlY7EwDUtlMzlzRrZm8OwFcEB5vFwt5/X3rvPbN6cLt2dqcCPFeNuwA99dRTevrpp1VYWKj169fr22+/dW01HQAcEhKiHj16KCsry7XP6XQqKytLqamp1f46TqezUj9/APBk+flSdLQUGWl3EsB3BAVJN90ktW0rTZ8ubd5sdyLAc9W4BeDAgQMaPHiw2wJkZmZqxIgRSklJUa9evTRhwgSVlpYqIyNDkjR8+HA1b95c48aNk2T69KekpOicc85RWVmZPvnkE73zzjt69dVX3ZYJAGoT/f+B2hEUJA0eLM2dK82cKQ0aJHXtancqwPPUuAAYPHiwFi1apD//+c9uCTBkyBDt3btXY8aMUWFhoZKTk7Vw4ULXwOCcnBwFBPzcUFFaWqp7771XeXl5Cg8PV1JSkt59910NGTLELXkAoDY5nWYNgH797E4C+KbAQOm660y3oDlzpPJyqWdPu1MBnqXGBUDbtm312GOP6ZtvvlHnzp0VHBxc6fkHHnigxiFGjRqlUaNGVfnc559/Xunzp556Sk899VSN3wMAPEFxsbkgoQUAqD0BAdKAAWaWoI8/Nv/n+va1OxXgOWpcALz++uuqX7++vvjiC33xxReVnnM4HGdVAACAv8jPN3P/N21qdxLAtzkcUnq6WS9g8WKzcNgll7D2BiCdRQGwg0l2AeCs5edLTZqYixIAtcvhMBf9ISGmCCgvN0UBRQD8Heu9A0AdYgAwUPf69jVFwCefSMeOSddea8YKAP6qWgVAZmamnnzySdWrV6/SolpVGT9+vFuCAYCvOXFCKiqSevSwOwngf3r2lMLCzMDgY8fMbEG/GsYI+I1qFQDffvutTpw44fr4TBy0qQHAGRUWmlmAaAEA7NG5sxQeblYNfucd6ZZbTFEA+JtqFQBLly6t8mMAQPXl55t5ymNj7U4C+K+2baURI6SpU6U335RuvZVF+eB/arwSMADg7OTlmdl/6HsM2KtFC+mOO0xXoClTpP377U4E1C0KAACoI7m5UkKC3SkASGY2rjvuMGsGTJki7d5tdyKg7lAAAEAdKCmRDh2iAAA8SYMGpgiIijLdgbZvtzsRUDcoAACgDuTmmkcKAMCz1Ksn3X671KqVGRewYYPdiYDaRwEAAHUgL09q2FCqX9/uJAB+LSREGjpUSk4204QuWyZZlt2pgNpTrVmA5s2bV+0veO211551GADwVbm5ZuAhAM8UECANGGC6A2VlmS57V11l9gO+ploFwKBBg6r1xRwOhyoqKv5IHgDwOSdPmgGGXbrYnQTAb3E4pIsvlqKjpY8+kg4flm68kQXD4HuqVdc6nc5qbVz8A8DpCgqkigr6/wPeols30yXop5+kt96SjhyxOxHgXjRsAUAty801fYzj4uxOAqC62rWTMjJMV6A33pD27rU7EeA+1eoC9GulpaX64osvlJOTo/Ly8krPPfDAA24JBgC+IjdXat6cvsSAt2nWTLr7bmnaNFMEDBkitWljdyrgj6txAfDtt9/qqquu0tGjR1VaWqpGjRqpuLhYERERio2NpQAAgF+wLDMDUPfudicBcDaio81aATNnSu++K11zDf+f4f1qfD/q4Ycf1oABA3TgwAGFh4frm2++0a5du9SjRw+98MILtZERALzWwYOm/zAzAAHeKzRUuuUWqUcPad48afFipgmFd6txAbB+/Xr9z//8jwICAhQYGKiysjIlJCTo+eef19/+9rfayAgAXuvUAmAUAIB3Cwgw04Kmp0vLl5sWgRMn7E4FnJ0aFwDBwcEK+G9H1tjYWOXk5EiSoqOjlXvqLx0AQJIpAGJipIgIu5MA+KMcDik11YwF2LpVevNNqaTE7lRAzdW4AOjWrZtWr14tSerXr5/GjBmjqVOn6qGHHlKnTp3cHhAAvFluLtN/Ar4mKUm6806ptFR6/XUzzgfwJjUuAJ555hk1bdpUkvT000+rYcOGGjlypPbu3avXXnvN7QEBwFuVlUlFRRQAgC+KjzczBDVsaNYK2LjR7kRA9dV4FqCUlBTXx7GxsVq4cKFbAwGArygoMAMFKQAA31S/vjRihDR/vvTBB9KePdJll5muQoAnq3ELwKWXXqqDBw+etr+kpESXXnqpOzIBgE/IzZXCwswYAAC+KShIGjhQ6t9f+vprafp00/oHeLIaFwCff/75aYt/SdLx48e1bNkyt4QCAF+Qm2tm/+FuIODbHA6pTx8zVejOndK//y3t22d3KuDMqt0FaOMvOrdt3rxZhYWFrs8rKiq0cOFCNW/e3L3pAMBLnVoA7Pzz7U4CoK60ayfddZdpBZg8WbrhBrMP8DTVLgCSk5PlcDjkcDiq7OoTHh6ul19+2a3hAMBbFRdLx47R/x/wN02amMHBH3wgTZsmXXKJdOGFtATCs1S7ANixY4csy1KbNm20atUqNWnSxPVcSEiIYmNjFRgYWCshAcDb5OaaP/g0jAL+JyxMGjpU+uILackSafduadAgs6Iw4AmqXQC0atVKkuR0OmstDAD4irw8KTaWP/iAv3I4pIsvNtOFzpkjvfGGdPPNUuPGdicDzmIQsCRt375d999/v9LS0pSWlqYHHnhA27dvd3c2APBaLAAGQDKLht19txkX9Prr0g8/2J0IOIsC4NNPP1WHDh20atUqdenSRV26dNHKlSvVsWNHLV68uDYyAoBXOXZM2ruXAgCAERNjioA2bcwA4cWLJTpUwE41Xgjs0Ucf1cMPP6xnn332tP2PPPKILr/8creFAwBvlJdnHikAAJwSGirddJO0YoX02WdSfr50441mMTGgrtW4BWDLli268847T9t/xx13aPPmzW4JBQDeLDdXqldPatjQ7iQAPMmp9QJGjDAzhU2aJO3aZXcq+KMaFwBNmjTR+vXrT9u/fv16xcbGuiMTAHi1U/3/mfYPQFVatZL+/GczIPjtt6Xly80YAaCuVLsL0BNPPKG//OUvuvvuu3XPPffop59+Up8+fSRJX3/9tZ577jllZmbWWlAA8AYVFaZp/6KL7E4CwJPVr29aArKypEWLpJwcaeBAKTzc7mTwB9UuAB5//HH9+c9/1mOPPabIyEi9+OKLGj16tCSpWbNm+sc//qEHHnig1oICgDfYvVsqL5cSE+1OAsDTBQRIl18utWwpzZ0rvfaaGRfQooXdyeDrqt0FyPpv25TD4dDDDz+svLw8HTp0SIcOHVJeXp4efPBBOWjvBuDnduyQQkKkpk3tTgLAW7RvL/3pT1JkpDRlCl2CUPtqNAbg1xf4kZGRioyMdGsgAPBmO3ea/r0sjA6gJho0kG6/XUpNNV2Cpk2Tjh61OxV8VY2mAT333HN/9y7//v37/1AgAPBWFRWmH+/FF9udBIA3Cgw0XYISE83qwZMmSTfcYG4qAO5UowLg8ccfV3R0dG1lAQCvVlAgnThB/38Af0y7dmaWoNmzpbfekvr1MxMLBNR47kagajUqAG6++Wam+gSAM9i50yz2Q/9/AH9UVJSZJWjZMumLL6Tt201rQIMGdieDL6h2LckAXwD4bTt3mtk8uEsHwB0CAszd/4wM6fBh6dVXpU2b7E4FX1DjWYAAAKc71f+f7j8A3C0hwXQJOvdcadYsM2VoWZndqeDNqt0FyOl01mYOAPBq+fn0/wdQe8LCpOuvl9q2lT7+2NxwuP561gzA2aGhGgDcgP7/AGqbwyF17WpaAyIipH//W1q61LRAAjVBAQAAbnBq/n/6/wOobY0aSXfcYaYcXrbMFAJ799qdCt6EP1UA8AedPCnl5tL9B0DdOTVA+K67pPJy6bXXpJUrWUEY1UMBAAB/EPP/A7BLs2bSn/4k9eghLVggvfOOVFJidyp4Oo8oACZOnKjExESFhYWpd+/eWrVq1RmPnTx5si688EI1bNhQDRs2VFpa2m8eDwC17VT///h4u5MA8EfBwdKVV0q33SYVF0v/+pf07be0BuDMbC8AZsyYoczMTI0dO1br1q1T165dlZ6erj179lR5/Oeff66hQ4dq6dKlWrFihRISEtS/f3/l5+fXcXIAMHbsoP8/APudc440cqTUvr304YfStGm0BqBqtv+5Gj9+vO6++25lZGSoQ4cOmjRpkiIiIjRlypQqj586daruvfdeJScnKykpSW+88YacTqeysrLqODkA/Nz/v3Vru5MAgBQeLl13nTR0qFRYaFoDNmygNQCV2VoAlJeXa+3atUpLS3PtCwgIUFpamlasWFGtr3H06FGdOHFCjRo1qvL5srIylZSUVNoAwF3y800RQP9/AJ6kfXvp3nvN4mFz5kjvvWdWEwYkmwuA4uJiVVRUKC4urtL+uLg4FRYWVutrPPLII2rWrFmlIuKXxo0bp+joaNeWkJDwh3MDwCk7d5oFen71awwAbBcebhYLu/lmM1nBxInS+vW0BsADugD9Ec8++6ymT5+uOXPmKCwsrMpjRo8erUOHDrm23NzcOk4JwJcx/z8AT5eUZFoD2reX5s6V3n1XOnDA7lSwk61/smJiYhQYGKiioqJK+4uKihT/O9NpvPDCC3r22We1aNEidenS5YzHhYaGKioqqtIGAO7A/P8AvEVEhBkbcOutP88UtGKF5HTanQx2sLUACAkJUY8ePSoN4D01oDc1NfWMr3v++ef15JNPauHChUpJSamLqABwmrw8+v8D8C5t25rWgO7dpUWLpClTpDNMvAgfZnujdWZmpiZPnqy3335bW7Zs0ciRI1VaWqqMjAxJ0vDhwzV69GjX8c8995wee+wxTZkyRYmJiSosLFRhYaGOHDli17cAwE/R/x+ANwoNNesG3HGHdPy4WUV46VJzQwP+IcjuAEOGDNHevXs1ZswYFRYWKjk5WQsXLnQNDM7JyVHALzrXvvrqqyovL9eNN95Y6euMHTtW//jHP+oyOgA/t3OnuftP/38A3ighQfrzn6Vly6SvvpK++0665hqpTRu7k6G2OSzLv8aCl5SUKDo6WocOHWI8AICzdvKk9OyzUlqadP75dqf5Y46Wn1SHMZ9KkjY/ka6IENvvDQGoY3v3SvPnS7t2SV26SOnpUr16dqdCTVX3Opff8gBwFnJz6f8PwHc0aSLdfrtZNGzRImnrVunyy6Vu3SSHw+50cDcKAAA4C9u3m7tj9P8H4CscDik52SwetmiRNG+eWTfg6qv5Xedr6LkKAGdh61YzmwZ3xgD4mogIadAg0yJw7JgZJLxwoRkwDN9AAQAANXTokFRUJLVrZ3cSAKg9iYlmkPBll0nr1kmvvCJt3MhKwr6AAgAAamjrVjPzzznn2J0EAGpXYKDUt680apRZ9fyDD6S33jI3QeC9KAAAoIa2bjXT54WH250EAOpGVJQ0eLA0fLhUWmq6BS1YYLoIwftQAABADZw8Kf30E91/APinNm2kkSNNt6Bvv5Vefllas0ZyOu1OhppgFiAAqIFdu6QTJygAAPivU92CunSRsrLM+gFr1khXXMHUyN6CFgAAqIGtW01TeGys3UkAwF6RkWa2oLvvloKCzNiAmTOlgwdtDobfRQEAADWwdau5+8/0nwBgNG8u3XmndN11ppX0lVdMy0BZmd3JcCZ0AQKAatq3z2z9+9udBAA8i8Mhde0qJSVJX38trVhhpg695BKpe3czcxo8BwUAAFTT1q2m72vr1nYnAQDPFBoqXXqp1KOHtGSJGR+wcqWUnm4WT4RnoB4DgGrautUMcAsJsTsJAHi26GjTJeiee6R69aR335XeeUcqLLQ7GSQKAAColvJyaedOZv8BgJpo1kwaMUK6+WYzOPi118xiYgwUthddgACgGnbskCoqKAAAoKYcDjM2oF07s3bA559L338v9eolXXihFBFhd0L/QwEAANWwdavUqJHUuLHdSQDAOwUGSikpZv2Ab74xg4XXrZMuuEA6/3wpONjuhP6DAgAAfodlmQIgKcnuJADg/UJCpIsuMgOFly0zLQIrV5p93bubNQVQu/gnBoDfsWePdOiQdO65dicBAN9Rr55ZPbh3b+mLL6QFC6Tly6WLLzatBEwdWnv4pwWA37F1q2mabtXK7iQA4HsaNjQrCt97rxk0PHeu9K9/mXEClmV3Ot9ECwAA/I6tW6U2bWiWBoDa1KSJdNNNUkGBWUNg5kwpPt60CLRvzwrs7kQLAAD8huPHpdxcZv8BgLrSrJl0661SRoYUFiZNny69/rqUnU2LgLtwPwsAfsP27ZLTSQEAAHWtVSvp9tvNGixLl0rvvWeKg4svNr+TaRE4exQAAPAbfvxRio01q1oCAOpeYmLlQmDaNKl5czNr0LnnUgicDQoAADiDkydNk3OvXnYnAQD/5nBIrVubYmDHDjN16HvvmTECF10knXcehUBNUAAAwBls327GAHTqZHcSAIBkLvLbtDHFwK5d0pdfSu+/bwYQX3ih+X3N9KG/jwIAAM5g0ybT/Sc21u4kAIBfcjhMa0BiopmoYdky6YMPTMvABReYdQSYue3M+KcBgCqUl0s//GCalgEAnishQbrlFmn3btMiMG+eGSuQmmpWGw4NtTuh56EAAIAq/PijdOKE1LGj3UkAANXRtKk0ZIi0d69ZUfizz0xB0KuXWW24Xj27E3oOCgAAqMKmTWaWiUaN7E4CAKiJJk2kgQPNdKHffGO2FSukbt1Mq0DDhnYntB8FAAD8yvHjZvXftDS7kwAAzlZ0tJSebgYHr14trVxpHjt0MIVAixZ2J7QPBQAA/MqWLWbxL7r/AID3i4iQ+vWT+vSRNmwwrQFvvCG1bGn2tW/vf1OIUgAAwK9s2mRWoIyKsjsJAMBdgoOllBSpe3czzmv5cmn6dKlxY+n886WuXaWQELtT1g0KAAD4hdJSs8jMVVfZnQQAUBsCAqSkJLPl5ZlC4JNPpKwsM2tQr16+v/o7BQAA/MLmzeaxQwd7cwAAal+LFtJNN0kHD0qrVklr15ouQklJplUgIcE3uwdRAADAL3z3nXTOOabPKADAPzRoIPXvb2YO2rDBzBw0ZYrUrJlpEejY0XQh8hUUAADwX4cOSTk50nXX2Z0EAGCHkBCpZ08zVmDbNjNz0Ny50qJFZuxASoopFrwdBQAA/Nf335ul45OS7E4CALCTwyG1a2e2ffukNWvM9vXX0rnnmlaBNm28t3sQBQAA/NemTeaXPcvGAwBOadzYrCdwySWmm+iqVdI775iFIlNSpORk7+s2SgEAADJ3eAoKpL597U4CAPBEISFmlqDu3U130TVrzMxBWVlmjEBKivcMGqYAAACZu/8hIaZpFwCAM3E4zFoxrVpJV1whrV9vZg/auFGKjTXdg1JS7E752ygAAPg9yzIFQFKSb83yAACoXfXqmZbjPn2kn34yhcCOHRQAAODxdu+W9u6VLr/c7iQAAG/kcJgppM85x9xU8nQBdgcAALutWmVWfWzb1u4kAABv5w1jACgAAPi1o0dN95+ePc3y8AAA+Dr+3AHwa99+ax67dbM3BwAAdYUCAIDfcjql1aulTp3MQC4AAPwBBQAAv7V1q3TwoJmyDQAAf0EBAMBvrVoltWghNWtmdxIAAOqO7QXAxIkTlZiYqLCwMPXu3VurVq0647Hff/+9brjhBiUmJsrhcGjChAl1FxSATykulrZv5+4/AMD/2FoAzJgxQ5mZmRo7dqzWrVunrl27Kj09XXv27Kny+KNHj6pNmzZ69tlnFR8fX8dpAfiS1atNv/8OHexOAgBA3bK1ABg/frzuvvtuZWRkqEOHDpo0aZIiIiI0ZcqUKo/v2bOn/vnPf+rmm29WaGhoHacF4CvKyszS7d27S0EshwgA8DO2FQDl5eVau3at0tLSfg4TEKC0tDStWLHCbe9TVlamkpKSShsA/7Zxo1Re7vlLtQMAUBtsKwCKi4tVUVGhuLi4Svvj4uJUWFjotvcZN26coqOjXVtCQoLbvjYA72NZZvBvUpJZ/RcAAH9j+yDg2jZ69GgdOnTIteXm5todCYCNdu6U9u5l8C8AwH/Z1vs1JiZGgYGBKioqqrS/qKjIrQN8Q0NDGS8AwGXVKqlJEykx0e4kAADYw7YWgJCQEPXo0UNZWVmufU6nU1lZWUpNTbUrFgAfduiQ9MMP5u6/w2F3GgAA7GHr/BeZmZkaMWKEUlJS1KtXL02YMEGlpaXKyMiQJA0fPlzNmzfXuHHjJJmBw5s3b3Z9nJ+fr/Xr16t+/fpq27atbd8HAO+wapUUEiJ16WJ3EgAA7GNrATBkyBDt3btXY8aMUWFhoZKTk7Vw4ULXwOCcnBwFBPzcSFFQUKBu3bq5Pn/hhRf0wgsvqF+/fvr888/rOj4AL3LkiCkAUlMlegUCAPyZ7TNgjxo1SqNGjaryuV9f1CcmJsqyrDpIBcDXfPmlFBgo9eljdxIAAOzl87MAAcDBg9LatdIFF0hhYXanAQDAXhQAAHze559L4eFM/QkAgEQBAMDH7d0rbdggXXSRGQAMAIC/owAA4NOWLjUr/nbvbncSAAA8AwUAAJ9VUCBt3ixdfLEUZPuUBwAAeAYKAAA+a8kSKSaGef8BAPglCgAAPmnnTmnbNunSS6UAftMBAODCn0UAPseyzN3/pk2l886zOw0AAJ6FAgCAz9m2TcrJkS67THI47E4DAIBnoQAA4FOcTikrS2rVSjrnHLvTAADgeSgAAPiU5culoiKpf3/u/gMAUBUKAAA+o7jYrPqbmio1b253GgAAPBMFAACf4HRKc+eaRb8uucTuNAAAeC4KAAA+YeVKKT9fGjhQCg62Ow0AAJ6LAgCA19u3zwz87d1batnS7jQAAHg2CgAAXs2ypHnzpMhIs+gXAAD4bRQAALzaqlXSrl2m609IiN1pAADwfBQAALzWgQPSZ59JvXpJiYl2pwEAwDtQAADwSpYlffihVK+elJZmdxoAALwHBQAAr/T119LOndK119L1BwCAmqAAAOB1tmwxs/5cdJHUpo3daQAA8C4UAAC8yu7d0gcfSB06sOAXAABngwIAgNc4fFiaNk2KjZUGDZIcDrsTAQDgfSgAAHiFEyek994zF/0338xqvwAAnC0KAAAez7KkOXOk4mLpllvMol8AAODsUAAA8HhLlpiBv9dfL8XH250GAADvRgEAwKOtXy8tW2bm+k9KsjsNAADeL8juAABwJmvWSB9/LPXoIfXpY3caAAB8AwUAAI9jWeau/5IlUu/e0hVXMOMPAADuQgEAwKNYlvTpp9I335h5/i+6iIt/AADciQIAgMeoqJDmzZM2bpSuvlrq2dPuRAAA+B4KAAAe4cQJaeZMads26YYbpE6d7E4EAIBvogAAYLsjR8zFf0GBmee/bVu7EwEA4LsoAADYautWae5c8/Hw4VJCgq1xAADweRQAAGxx4oS0eLG0apXUrp00cKBUv77dqQAA8H0UAADqXGGhNHu2dOCAdNVVZrAvM/0AAFA3KAAA1BnLMtN7fvaZFBMj3XOPFBtrdyoAAPwLBQCAOpGTIy1aJOXlmVV9L71UCuI3EAAAdY4/vwBqVXGxueP/ww9S06bS7bdLiYl2pwIAwH9RAACoFYcPS59/Ln37rRQVJV1/vdS5M339AQCwGwUAALc6fFhavVpascJ08bn8cjPIl+4+AAB4Bv4kA/jDLEvatctc+G/ZIgUGSr16SRdcIIWH250OAAD8EgUAgLNWViZt3Ggu/PfsMTP7pKdLXbtKYWF2pwMAAFWhAABQIydOSNu2mTv92dlSebmUlCRdcYXUujV9/AEA8HQUAAB+17Fj0o8/mov+7dtNERAbK6WmSt26SdHRdicEAADVRQEA4DTl5Wa+/l27zJaTIzmdUkKCdPHF0nnnSY0a2Z0SAACcDQoAwM9Zlpm5Z/funy/2CwrMBX9EhNSqlXTllaabT2Sk3WkBAMAfRQEA+JETJ8zCXIWFUlHRz4/Hjpnno6LMBX9ysnmMiaFPPwAAvsYjCoCJEyfqn//8pwoLC9W1a1e9/PLL6tWr1xmPnzlzph577DHt3LlT7dq103PPPaerrrqqDhMDnsnplEpLpZIS6cABaf/+nx/37zd3+iVzUd+okRQXJ51/vhQfbz6OjuaCHwAAX2d7ATBjxgxlZmZq0qRJ6t27tyZMmKD09HRlZ2crNjb2tOOXL1+uoUOHaty4cbrmmms0bdo0DRo0SOvWrVOnTp1s+A6A2lVRYe7QHz1qLu6PHv15O3Wxf/iw2Y4cMUXAKeHh5kK/USMpMdE8Nm5sBvCGhNj2LQEAABs5LMuy7AzQu3dv9ezZU6+88ookyel0KiEhQffff78effTR044fMmSISktLNX/+fNe+888/X8nJyZo0adLvvl9JSYmio6N16NAhRUVFue8bgd9yOqWTJ82F+qnt5MmftxMnKn984oQZZHvq8Zfb8eNmbv3jx3/++MSJ098zIMD0z69Xz/TLj4w03Xd++digAYtwoXqOlp9UhzGfSpI2P5GuiBDb7w0BAM5Cda9zbf0tX15errVr12r06NGufQEBAUpLS9OKFSuqfM2KFSuUmZlZaV96errmzp1b5fFlZWUqKytzfV5SUvLHg/8BmzaZLhnu8kfLt+q8/reO+fVzv/f5r/dV9XF1Hn/9cVWf/9bmdJ758debZZmLeqez6sezOQfBweYO/KnHU1toqLmADwszW2ioeQwP//mCPyLC7KerDgAAOBu2FgDFxcWqqKhQXFxcpf1xcXH64YcfqnxNYWFhlccXFhZWefy4ceP0+OOPuyewG/zwg7RjR92819lcIFb3NVUd9+t91f38l/t/va+qxzPt+/Vzp7aAgNOPCQz8ef8vnw8IOH375fFVPQYGSkFBp38cFGQu8IOCTv84IKB6/84AAADu5vPtvKNHj67UYlBSUqKEhATb8tx4o21vDQAAANhbAMTExCgwMFBFRUWV9hcVFSk+Pr7K18THx9fo+NDQUIWGhronMAAAAODlbO2IEBISoh49eigrK8u1z+l0KisrS6mpqVW+JjU1tdLxkrR48eIzHg8AAADgZ7Z3AcrMzNSIESOUkpKiXr16acKECSotLVVGRoYkafjw4WrevLnGjRsnSXrwwQfVr18/vfjii7r66qs1ffp0rVmzRq+//rqd3wYAAADgFWwvAIYMGaK9e/dqzJgxKiwsVHJyshYuXOga6JuTk6OAX4yY7NOnj6ZNm6b/7//7//S3v/1N7dq109y5c1kDAAAAAKgG29cBqGusAwAAlbEOAAD4hupe5zIZIQAAAOBHKAAAAAAAP0IBAAAAAPgRCgAAAADAj1AAAAAAAH6EAgAAAADwIxQAAAAAgB+hAAAAAAD8CAUAAAAA4EcoAAAAAAA/4nfrvVuWJckslQwAkI6Wn5Sz7Kgk87vxZIjf/WkAAJ9w6vr21PXumTis3zvCx+Tl5SkhIcHuGAAAAECtyM3NVYsWLc74vN8VAE6nUwUFBYqMjJTD4ai19ykpKVFCQoJyc3MVFRVVa+8Dz8T592+cf//G+fdvnH//Zvf5tyxLhw8fVrNmzRQQcOae/n7XzhsQEPCbFZG7RUVF8QvAj3H+/Rvn379x/v0b59+/2Xn+o6Ojf/cYBgEDAAAAfoQCAAAAAPAjFAC1JDQ0VGPHjlVoaKjdUWADzr9/4/z7N86/f+P8+zdvOf9+NwgYAAAA8Ge0AAAAAAB+hAIAAAAA8CMUAAAAAIAfoQAAAAAA/AgFQC2YOHGiEhMTFRYWpt69e2vVqlV2R0ItGDdunHr27KnIyEjFxsZq0KBBys7OrnTM8ePHdd9996lx48aqX7++brjhBhUVFdmUGLXp2WeflcPh0EMPPeTax/n3bfn5+br11lvVuHFjhYeHq3PnzlqzZo3recuyNGbMGDVt2lTh4eFKS0vT1q1bbUwMd6moqNBjjz2m1q1bKzw8XOecc46efPJJ/XJeFc6/7/jyyy81YMAANWvWTA6HQ3Pnzq30fHXO9f79+zVs2DBFRUWpQYMGuvPOO3XkyJE6/C4qowBwsxkzZigzM1Njx47VunXr1LVrV6Wnp2vPnj12R4ObffHFF7rvvvv0zTffaPHixTpx4oT69++v0tJS1zEPP/ywPvroI82cOVNffPGFCgoKdP3119uYGrVh9erVeu2119SlS5dK+zn/vuvAgQPq27evgoODtWDBAm3evFkvvviiGjZs6Drm+eef10svvaRJkyZp5cqVqlevntLT03X8+HEbk8MdnnvuOb366qt65ZVXtGXLFj333HN6/vnn9fLLL7uO4fz7jtLSUnXt2lUTJ06s8vnqnOthw4bp+++/1+LFizV//nx9+eWXuueee+rqWzidBbfq1auXdd9997k+r6iosJo1a2aNGzfOxlSoC3v27LEkWV988YVlWZZ18OBBKzg42Jo5c6brmC1btliSrBUrVtgVE252+PBhq127dtbixYutfv36WQ8++KBlWZx/X/fII49YF1xwwRmfdzqdVnx8vPXPf/7Tte/gwYNWaGio9d5779VFRNSiq6++2rrjjjsq7bv++uutYcOGWZbF+fdlkqw5c+a4Pq/Oud68ebMlyVq9erXrmAULFlgOh8PKz8+vs+y/RAuAG5WXl2vt2rVKS0tz7QsICFBaWppWrFhhYzLUhUOHDkmSGjVqJElau3atTpw4UennISkpSS1btuTnwYfcd999uvrqqyudZ4nz7+vmzZunlJQUDR48WLGxserWrZsmT57sen7Hjh0qLCysdP6jo6PVu3dvzr8P6NOnj7KysvTjjz9KkjZs2KCvvvpKV155pSTOvz+pzrlesWKFGjRooJSUFNcxaWlpCggI0MqVK+s8syQF2fKuPqq4uFgVFRWKi4urtD8uLk4//PCDTalQF5xOpx566CH17dtXnTp1kiQVFhYqJCREDRo0qHRsXFycCgsLbUgJd5s+fbrWrVun1atXn/Yc59+3/fTTT3r11VeVmZmpv/3tb1q9erUeeOABhYSEaMSIEa5zXNXfA86/93v00UdVUlKipKQkBQYGqqKiQk8//bSGDRsmSZx/P1Kdc11YWKjY2NhKzwcFBalRo0a2/TxQAABucN9992nTpk366quv7I6COpKbm6sHH3xQixcvVlhYmN1xUMecTqdSUlL0zDPPSJK6deumTZs2adKkSRoxYoTN6VDb3n//fU2dOlXTpk1Tx44dtX79ej300ENq1qwZ5x9egS5AbhQTE6PAwMDTZvkoKipSfHy8TalQ20aNGqX58+dr6dKlatGihWt/fHy8ysvLdfDgwUrH8/PgG9auXas9e/aoe/fuCgoKUlBQkL744gu99NJLCgoKUlxcHOffhzVt2lQdOnSotO+8885TTk6OJLnOMX8PfNNf//pXPfroo7r55pvVuXNn3XbbbXr44Yc1btw4SZx/f1Kdcx0fH3/aZDAnT57U/v37bft5oABwo5CQEPXo0UNZWVmufU6nU1lZWUpNTbUxGWqDZVkaNWqU5syZoyVLlqh169aVnu/Ro4eCg4Mr/TxkZ2crJyeHnwcfcNlll+m7777T+vXrXVtKSoqGDRvm+pjz77v69u172rS/P/74o1q1aiVJat26teLj4yud/5KSEq1cuZLz7wOOHj2qgIDKl1CBgYFyOp2SOP/+pDrnOjU1VQcPHtTatWtdxyxZskROp1O9e/eu88ySmAXI3aZPn26FhoZab731lrV582brnnvusRo0aGAVFhbaHQ1uNnLkSCs6Otr6/PPPrd27d7u2o0ePuo7585//bLVs2dJasmSJtWbNGis1NdVKTU21MTVq0y9nAbIszr8vW7VqlRUUFGQ9/fTT1tatW62pU6daERER1rvvvus65tlnn7UaNGhgffjhh9bGjRutgQMHWq1bt7aOHTtmY3K4w4gRI6zmzZtb8+fPt3bs2GF98MEHVkxMjPW///u/rmM4/77j8OHD1rfffmt9++23liRr/Pjx1rfffmvt2rXLsqzqnesrrrjC6tatm7Vy5Urrq6++stq1a2cNHTrUrm/JogCoBS+//LLVsmVLKyQkxOrVq5f1zTff2B0JtUBSldubb77pOubYsWPWvffeazVs2NCKiIiwrrvuOmv37t32hUat+nUBwPn3bR999JHVqVMnKzQ01EpKSrJef/31Ss87nU7rscces+Li4qzQ0FDrsssus7Kzs21KC3cqKSmxHnzwQatly5ZWWFiY1aZNG+vvf/+7VVZW5jqG8+87li5dWuXf+xEjRliWVb1zvW/fPmvo0KFW/fr1raioKCsjI8M6fPiwDd+N4bCsXyxbBwAAAMCnMQYAAAAA8CMUAAAAAIAfoQAAAAAA/AgFAAAAAOBHKAAAAAAAP0IBAAAAAPgRCgAAAADAj1AAAICPu/322zVo0CDb3v+2227TM88885vHJCYmasKECXWSp7y8XImJiVqzZk2dvB8AeJoguwMAAM6ew+H4zefHjh2r//u//5Ndaz5u2LBBn3zyiV599VVb3r8qISEh+stf/qJHHnlEWVlZdscBgDpHAQAAXmz37t2uj2fMmKExY8YoOzvbta9+/fqqX7++HdEkSS+//LIGDx5sa4aqDBs2TP/zP/+j77//Xh07drQ7DgDUKboAAYAXi4+Pd23R0dFyOByV9tWvX/+0LkAXX3yx7r//fj300ENq2LCh4uLiNHnyZJWWliojI0ORkZFq27atFixYUOm9Nm3apCuvvFL169dXXFycbrvtNhUXF58xW0VFhWbNmqUBAwZU2r9nzx4NGDBA4eHhat26taZOnXraa8ePH6/OnTurXr16SkhI0L333qsjR45IkkpLSxUVFaVZs2ZVes3cuXNVr149HT58WOXl5Ro1apSaNm2qsLAwtWrVSuPGjXMd27BhQ/Xt21fTp0+v9r81APgKCgAA8ENvv/22YmJitGrVKt1///0aOXKkBg8erD59+mjdunXq37+/brvtNh09elSSdPDgQV166aXq1q2b1qxZo4ULF6qoqEg33XTTGd9j48aNOnTokFJSUirtv/3225Wbm6ulS5dq1qxZ+te//qU9e/ZUOiYgIEAvvfSSvv/+e7399ttasmSJ/vd//1eSVK9ePd1888168803K73mzTff1I033qjIyEi99NJLmjdvnt5//31lZ2dr6tSpSkxMrHR8r169tGzZsrP9JwQA72UBAHzCm2++aUVHR5+2f8SIEdbAgQNdn/fr18+64IILXJ+fPHnSqlevnnXbbbe59u3evduSZK1YscKyLMt68sknrf79+1f6urm5uZYkKzs7u8o8c+bMsQIDAy2n0+nal52dbUmyVq1a5dq3ZcsWS5L1//7f/zvj9zZz5kyrcePGrs9XrlxpBQYGWgUFBZZlWVZRUZEVFBRkff7555ZlWdb9999vXXrppZXe+9f+7//+z0pMTDzj8wDgq2gBAAA/1KVLF9fHgYGBaty4sTp37uzaFxcXJ0muO/MbNmzQ0qVLXWMK6tevr6SkJEnS9u3bq3yPY8eOKTQ0tNJA5S1btigoKEg9evRw7UtKSlKDBg0qvfazzz7TZZddpubNmysyMlK33Xab9u3b52qR6NWrlzp27Ki3335bkvTuu++qVatWuuiiiySZVob169erffv2euCBB7Ro0aLT8oWHh7u+HgD4EwoAAPBDwcHBlT53OByV9p26aHc6nZKkI0eOaMCAAVq/fn2lbevWra6L7l+LiYnR0aNHVV5eXqNsO3fu1DXXXKMuXbpo9uzZWrt2rSZOnChJlb7WXXfdpbfeekuS6f6TkZHhyt29e3ft2LFDTz75pI4dO6abbrpJN954Y6X32b9/v5o0aVKjbADgCygAAAC/q3v37vr++++VmJiotm3bVtrq1atX5WuSk5MlSZs3b3btS0pK0smTJ7V27VrXvuzsbB08eND1+dq1a+V0OvXiiy/q/PPP17nnnquCgoLTvv6tt96qXbt26aWXXtLmzZs1YsSISs9HRUVpyJAhmjx5smbMmKHZs2dr//79ruc3bdqkbt26nc0/BwB4NQoAAMDvuu+++7R//34NHTpUq1ev1vbt2/Xpp58qIyNDFRUVVb6mSZMm6t69u7766ivXvvbt2+uKK67Qn/70J61cuVJr167VXXfdpfDwcNcxbdu21YkTJ/Tyyy/rp59+0jvvvKNJkyad9vUbNmyo66+/Xn/961/Vv39/tWjRwvXc+PHj9d577+mHH37Qjz/+qJkzZyo+Pr5SV6Nly5apf//+bvjXAQDvQgEAAPhdzZo109dff62Kigr1799fnTt31kMPPaQGDRooIODMf0ruuuuu06b5fPPNN9WsWTP169dP119/ve655x7Fxsa6nu/atavGjx+v5557Tp06ddLUqVMrTeH5S3feeafKy8t1xx13VNofGRmp559/XikpKerZs6d27typTz75xJV1xYoVOnTo0GndggDAHzgsy6blIQEAPu/YsWNq3769ZsyYodTUVLd//XfeeUcPP/ywCgoKFBISUu3XDRkyRF27dtXf/vY3t2cCAE/HSsAAgFoTHh6u//znP7+5YNjZOHr0qHbv3q1nn31Wf/rTn2p08V9eXq7OnTvr4YcfdmsmAPAWtAAAALzOP/7xDz399NO66KKL9OGHH6p+/fp2RwIAr0EBAAAAAPgRBgEDAAAAfoQCAAAAAPAjFAAAAACAH6EAAAAAAPwIBQAAAADgRygAAAAAAD9CAQAAAAD4EQoAAAAAwI9QAAAAAAB+5P8HUw95w6Lm7+QAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ax = plot_trajectory(single_prediction, tspan, ax=setup_ax(), color=\"blue\", marker='', lw=1., label=\"Before Seeing Data - Single Forecast\")\n", + "ax.axvline(47)" + ] + }, + { + "cell_type": "markdown", + "id": "7c9b53f3", + "metadata": {}, + "source": [ + "### Probabilistic forecasting" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "a8cebc75-730c-43f8-9081-ba846098f669", + "metadata": {}, + "outputs": [], + "source": [ + "pyro.set_rng_seed(0)\n", + "\n", + "# var_prior = 0.05**2\n", + "mean_values = np.array([])\n", + "\n", + "ode_model = SIDARTHEV(N=1,\n", + " alpha_prior=LogNormalPrior_propVar(torch.tensor(0.570)) ,\n", + " beta_prior=LogNormalPrior_propVar(torch.tensor(0.011)) ,\n", + " gamma_prior=LogNormalPrior_propVar(torch.tensor(0.456)) ,\n", + " delta_prior=LogNormalPrior_propVar(torch.tensor(0.011)) ,\n", + " epsilon_prior=LogNormalPrior_propVar(torch.tensor(0.171)) ,\n", + " lamb_prior =LogNormalPrior_propVar(torch.tensor(0.034)) ,\n", + " zeta_prior=LogNormalPrior_propVar(torch.tensor(0.125)) ,\n", + " eta_prior=LogNormalPrior_propVar(torch.tensor(0.125)) ,\n", + " kappa_prior=LogNormalPrior_propVar(torch.tensor(0.017)) ,\n", + " theta_prior=LogNormalPrior_propVar(torch.tensor(0.371)) ,\n", + " rho_prior=LogNormalPrior_propVar(torch.tensor(0.034)) ,\n", + " xi_prior=LogNormalPrior_propVar(torch.tensor(0.017)) ,\n", + " sigma_prior=LogNormalPrior_propVar(torch.tensor(0.017)) ,\n", + " mu_prior=LogNormalPrior_propVar(torch.tensor(0.017)) ,\n", + " nu_prior=LogNormalPrior_propVar(torch.tensor(0.027)) ,\n", + " tau2_prior=LogNormalPrior_propVar(torch.tensor(0.01)) ,\n", + " phi_prior=dist.Delta(torch.tensor (0.)) )\n", + "\n", + "# interventions = {\"alpha\": SI_alpha_intervention,\n", + "# \"beta\": SD_beta_intervention,\n", + "# \"gamma\": SA_gamma_intervention,\n", + "# \"delta\": SR_delta_intervention,\n", + "# \"epsilon\": ID_epsilon_intervention,\n", + "# \"lambda\": IH_lamb_intervention,\n", + "# \"zeta\": IA_zeta_intervention,\n", + "# \"eta\": DR_eta_intervention,\n", + "# \"kappa\": AH_kappa_intervention,\n", + "# # \"theta\": AR_theta_intervention,\n", + "# \"rho\": DH_rho_intervention,\n", + "# \"xi\": RH_xi_intervention,\n", + "# \"sigma\": TH_sigma_intervention,\n", + "# \"mu\": AT_mu_intervention,\n", + "# \"nu\": RT_nu_intervention}" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "795ecb3a", + "metadata": {}, + "outputs": [], + "source": [ + "prior_prediction = sample(ode_model, num_samples, initial_state, tspan)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "f62475f8", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ax1 = plot_predictive(prior_prediction, tspan, ax=setup_ax(), label=\"probabilistic forecast\", color=\"red\")\n", + "ax1.axvline(30)\n", + "sideaxis(ax1)" + ] + }, + { + "cell_type": "markdown", + "id": "c65bcf10-9d12-4efe-be10-cc313e123d14", + "metadata": {}, + "source": [ + "## 1.d Policies that prevent infections from exceeding 1/3 of the population\n", + "\n", + "Now return to the situation in b.i (constant parameters that don’t change over time). Let’s say we want to increase testing, diagnostics, and contact tracing efforts (implemented by increasing the detection parameters and ). Assume that $\\theta \\ge 2\\epsilon$ , because a symptomatic person is more likely to be tested. What minimum constant values do these parameters need to be over the course of a 100-day simulation, to ensure that the total infected population (sum over all the infected states I, D, A, R, T) never rises above 1/3 of the total population?\n", + "\n", + "\n", + "### Problem Formulation\n", + "* **Quantity of interest**: Total infections out of $N=60,000,000$ population\n", + "$$I_{total}(t; \\mathbf{u}, \\mathbf{Z}) = I(t) + D(t) + A(t) + R(t) + T(t)$$\n", + "\n", + "A conservative estimate for the quantity of interest is\n", + "$$M(u, Z) = \\max_{1\\leq t \\leq 100} I_{total}(t; \\mathbf{u}, \\mathbf{Z})/N$$\n", + "\n", + "\n", + "\n", + "\n", + "* **Control**: $\\mathbf{u}\\in \\mathcal{U} \\subseteq \\mathbb{R}^{n_u}$\n", + " * Detection parameter for Infected ($\\epsilon$) assuming that $\\theta=2\\epsilon$\n", + " * Two detection parameters $\\theta, \\epsilon$, constraining $\\theta \\ge 2\\epsilon$.\n", + " \n", + "\n", + "\n", + "* **Risk-based optimization under uncertainty problem formulation**\n", + " * Objective Function - Minimize the magnitude of the parameter interventions.\n", + " * Constraint - Risk of normalized total infections exceeding the prescribed threshold of $1/3$, $\\mathcal{R}( M(\\mathbf{u},\\mathbf{Z}))$, is below the acceptable risk threshold, $\\mathcal{R}_\\text{threshold}$.\n", + "\n", + "\\begin{equation} \n", + "\\begin{split} \n", + "\\mathbf{u}^*= \\underset{\\mathbf{u}\\in\\mathcal{U}}{\\arg\\min}\\ & \\lVert \\mathbf{u} \\rVert_1 \\\\ \\text{s.t.}\\ & \\mathcal{R}( M(\\mathbf{u}, \\theta)) \\le \\mathcal{R}_\\text{threshold} \n", + "\\end{split} \n", + "\\end{equation}\n", + "\n", + "#### Formulation 1: Optimize $u=\\{\\alpha, \\beta, \\gamma, \\delta\\}$\n", + "\\begin{equation} \n", + "\\begin{split} \n", + "u^*= \\underset{\\epsilon\\in\\mathcal{U}}{\\arg\\min}\\ & u\\\\ \\text{s.t.}\\ & \\mathbb{P}( M(u, \\mathbf{Z}) \\ge 1/3) \\le 0.05\n", + "\\end{split} \n", + "\\end{equation}\n", + "\n", + "#### Formulation 2: Optimize $\\epsilon$ and $\\theta$ constraining $\\theta \\ge 2\\epsilon$\n", + "\\begin{equation} \n", + "\\begin{split} \n", + "\\epsilon^\\ast, \\theta^\\ast= \\underset{\\{\\epsilon,\\theta\\}\\in\\mathcal{U}}{\\arg\\min}\\ & \\theta + \\epsilon \\\\ \\text{s.t.}\\ & \\mathbb{P}( M(\\epsilon,\\theta, \\mathbf{Z}) \\ge 1/3) \\le 0.05, \\\\\n", + "& \\theta \\ge 2\\epsilon\n", + "\\end{split} \n", + "\\end{equation}\n", + "\n", + "Instead of probability of exceedance, we will use superquantiles as risk measures." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "97ab7988", + "metadata": {}, + "outputs": [], + "source": [ + "from causal_pyro.query.do_messenger import do\n", + "import time\n", + "import pickle\n", + "\n", + "import numpy as np\n", + "from scipy import stats\n", + "from matplotlib import ticker\n", + "\n", + "from pyciemss.ODE.interventions import parameter_intervention_builder, time_and_state_dependent_intervention_builder, time_dependent_intervention_builder\n", + "from pyciemss.risk.risk_measures import alpha_quantile, alpha_superquantile\n", + "from pyciemss.risk.ouu import computeRisk, solveOUU\n", + "from pyciemss.risk.qoi import max_total_infections_SIDARTHE\n", + "import scipy\n", + "\n", + "\n", + "co = ['#377eb8', '#ff7f00', '#984ea3', '#ffd92f', '#a65628']\n", + "rlabel = ['Q_alpha-based OUU', 'barQ_alpha-based OUU']" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "161b391b", + "metadata": {}, + "outputs": [], + "source": [ + "def delayed_intervention_controller(name, x, init_value):\n", + " def delayed_intervention(t, flux):\n", + " if t<15:\n", + " return flux\n", + " else:\n", + " return flux/init_value*x\n", + " return time_and_state_dependent_intervention_builder(name, delayed_intervention, tspan) \n", + "\n", + "def delayed_intervention_controller_flux(name, x):\n", + " def delayed_intervention(t):\n", + " if t<15:\n", + " return torch.tensor(0.)\n", + " else:\n", + " return x\n", + " return time_dependent_intervention_builder(name, delayed_intervention, tspan) " + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "12a672fa", + "metadata": {}, + "outputs": [], + "source": [ + "beta_init = 0.011\n", + "# Control action / intervention\n", + "param_intervention = parameter_intervention_builder(\"beta\", beta_init)\n", + "control_model = intervene(ode_model,param_intervention)\n", + "\n", + "INTERVENTION = lambda x: delayed_intervention_controller(\"SD_flux\", torch.from_numpy(np.array([x])), beta_init)" + ] + }, + { + "cell_type": "markdown", + "id": "5fb87509", + "metadata": {}, + "source": [ + "## Exploring the intervention and difference between Quantiles and Superquantiles" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "35ebe5d7", + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Forward UQ took 9.72 seconds total (1.94e-01 seconds per model evaluation).\n", + "0.8429393768310547 0.9140260457992553\n" + ] + } + ], + "source": [ + "pyro.set_rng_seed(0)\n", + "\n", + "POLICY = np.array([0.0])\n", + "N_SAMPLES = 50\n", + "\n", + "RISK = computeRisk(model=control_model,\n", + " intervention_fun=INTERVENTION,\n", + " qoi=lambda y: max_total_infections_SIDARTHE(y, contexts=[\"I_total_obs\"]),\n", + " risk_measure=alpha_superquantile,\n", + " num_samples=N_SAMPLES,\n", + " model_state=initial_state,\n", + " tspan=tspan,\n", + " guide=None)\n", + "\n", + "start_time = time.time()\n", + "sq_dataCube = RISK.propagate_uncertainty(POLICY)\n", + "end_time = time.time()\n", + "forward_time = end_time - start_time\n", + "time_per_eval = forward_time / N_SAMPLES\n", + "print(f\"Forward UQ took {forward_time:.2f} seconds total ({forward_time/N_SAMPLES:.2e} seconds per model evaluation).\")\n", + "sq_qoi = RISK.qoi(sq_dataCube)\n", + "sq_sv = RISK.risk_measure(sq_qoi)\n", + "\n", + "RISK.risk_measure = alpha_quantile\n", + "q_sv = RISK(POLICY)\n", + "print(q_sv, sq_sv)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "b74d9c82", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "No artists with labels found to put in legend. Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ax = setup_ax()\n", + "ax = plot_predictive(sq_dataCube, tspan, ax=ax, color=co[1])\n", + "ax.axvline(15)\n", + "sideaxis(ax)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "7fc330e1", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgkAAAG3CAYAAAA+SsZgAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAABTc0lEQVR4nO3dd3gU1foH8O+m95C6G5IQSEhCT6iCdIJUwSuXYqHrpQheFBFF6YJXfqAIKnCxREBFBIQrIBiQIlVBSgAvvQcSenrZZN/fH7m7sOwkpGx2F/L9PM/+cWZnzrxzZnb33TlnZlQiIiAiIiJ6gJ21AyAiIiLbxCSBiIiIFDFJICIiIkVMEoiIiEgRkwQiIiJSxCSBiIiIFDFJICIiIkVMEoiIiEgRkwQiIiJSxCSBiIiIFDFJICIiIkVMEoiIiEgRkwQiIiJSxCSBiIiIFDFJICIiIkVMEoiIiEgRkwQiIiJS5GDtAIhImVarRUFBgbXDICIbYm9vD0dHR4utj0kCkY1JS0vDzZs3kZuba+1QiMgGOTs7w9/fH15eXhW+LiYJRDYkLS0NSUlJ8PDwgL+/PxwdHaFSqawdFhHZABGBVqtFamoqkpKSAKDCEwWViEiFroGISuzcuXNwdHRESEgIkwMiUiQiuHLlCrRaLcLDwyt0XRy4SGQjtFotcnNz4e3tzQSBiIqkUqng7e2N3NxcaLXaCl0XkwQiG6EfpGjJQUlE9GjSf09U9OBmJglENoZnEYjoYSz1PcEkgYiIiBQxSSAiIiJFvASS6BFyYPkRa4dQpCbPx1g7BHqMaPN1uJuVZyhXcXOCo4OF/9fm5wJZt+6V3fwAB2fLxmBlPJNARFSMTZs2QaPRwNXVFSqVChcuXCjRcgkJCfD29kZ8fLxZ4khKSsKAAQMQGhoKtVqNsLAwjB492ix1l1XHjh1Rt27dCrnxl7ZAh5vpuYaXtkBn9nU8VEEekHH13qsg7+HLPGaYJBCRzahevTqqV69ulrq2b98OlUqFqVOnlqueLl26IDk5Gf369SvVchkZGUhPT0dqamq51q/Xr18/JCQkYO/evUhJSUF8fDzWr19vlrqLMnjw4GITo5s3b+Lu3bsVMsJepQKcHOwML6uM51XZAfYu916qyveTye4GIqIK0KtXL2RlZcHFxaXcdaWlpWH37t3o3bs3QkJCAAAdOnTAvn37yl13efz555/Q6XQVctmuq5MDItSeZq+3VJzcAXU968ZgZUwSiIgqiDkSBAC4ffs2AMDd3d1oukajMUv9ZWVvbw97e3urxkAVq/KdOyEimxMfHw+NRoPLly/j8uXL0Gg0hteZM2cM86Wnp2PixImoVasW1Go1AgMD0alTJ2zZssWovi5duqBXr14AgDlz5hjq6t69u2Gebdu2YdCgQYiMjIRGo4GPjw/i4uKwefPmcm/PkCFDoNFooFKp0K5dO5PtdHJygkqlwvXr1zFgwABUq1YNvr6+6NKlC06ePGmyLU2bNgUArFixwrAtc+bMMcyTkpKCUaNGGeoJDAzE3//+dxw6dEgxvv/85z9o3749AgMDodFoUKtWLfTr1w+rV68GAJw8eRIajQYrVqwAADRt2tSw3qVLl+L48ePQaDTw8PCASqXC9u3bTdaxY8cOdOvWDWq1Gmq1GpGRkXj77beNul/069HXs3nzZkyZMgXR0dHw9PREo0aN8PPPP5vUffv2bbz11luIiopCUFAQQkND0a5dO8yZMwd3794t0T6ikmGSQERWN2TIECQnJyM0NBShoaFITk42vGrWrAmg8JR7y5Yt8eWXXyI+Ph4pKSm4ePEiYmNj0alTJyxYsMBQ36ZNm/Djjz8CAMaNG2eoa8OGDYZ5PvzwQxw4cAA///wzkpOTcenSJdSqVQudO3c2mq8s4uPjkZycXOR2PvnkkwCAESNGYNy4cbh06RL27t2LY8eO4amnnjK61e6mTZuwf/9+AIXjEvTbMm7cOADA5cuX0aRJE+zcuRO//PILbt++jcTEROTk5KBFixYmP+DTp0/H3/72N3Ts2BGXL19GcnIyVqxYgSNHjqB3794AgOjoaKNxGPv37zesd+DAgahbt65RDA/68ssv0aFDB4SHh+PcuXNISUnBihUrsHz5cjRv3txwZkS/Hn09kydPRoMGDfDf//4XV65cga+vL3r27Injx48b1d+zZ09s2LABCQkJuHbtGs6dO4eePXvizTffxOHDh0uzq+ghmCQQ0SNh4sSJOHr0KKZOnYoWLVoAAFxdXTFr1izUrFkTr732Gs6fP1/i+sLDwzF79mxERkYCADw9PTF//nyo1Wq89957FbIND3ruuecQE1N46Wh0dDQGDBiAy5cvY+/evSWuY9SoUbhy5Qq++uor1K5dG0BhN8SSJUugUqnwyiuvGOY9ePAgpkyZgo4dO+Ldd9+Fs3Ph5XwxMTH47LPPzLJNV69exahRo1C1alXMmzfP0EXSqFEjzJw5EydOnMD48eMVl23YsCH+/ve/w87ODt7e3njzzTdRUFBgOMMBANevX8fu3bvRqVMnwyBXR0dHjB07Ft26dYObm5tZtoMKMUkgIpsnIvj2228BAH//+9+N3lOpVOjVqxe0Wi2WL19e4jrnz5+Pbt26GU2zt7dHZGQkEhMTyx90CbRp08aorP/Ru3LlSomWv3PnDjZs2AC1Wo0mTZoYvefv74/IyEj897//NXTZLFu2DADQo0cPk7ratm2LjRs3lnYTTKxcuRK5ubl45plnTMYr6Pfd999/r/hgovvbIy+/AG6+hWMuTp27gLz8wisofHx84O3tja+//hpLly5FVlaWYZkNGzagWbNm5d4Gg/wc4O7Fe6/8HPPV/YhgkkBENu/GjRu4ffs2nJ2d4e/vb/J+cHAwAJj05xfnypUrGDduHBo2bGg0BmLfvn3Izs42W+zFCQwMNCrr/9nn5ZXsevzTp09Dp9Ph1q1bRtugf128eBHu7u6GpEPfPqGhoSZ1OTg4oEuXLuXZHKN16K/CuJ+rqyt8fX2RmZmpmAjd3x75BYLcgsLrHjOzcpBfIAAKzxr88MMPcHNzw6BBgxAQEICnn34aS5YsMUoYzKJAC2TduPcqqNgnLtoiXt1ARI8Mcz3UJjk5GY0bN0ZWVha+//57dOrUyXAZX7t27bBjxw6zrOdh7OzM8z8tPDy8VAlSRdz8yBxK2h6dOnXChQsXkJCQgLVr12LNmjXYsGEDpk2bhoSEBMM4Fio/nkkgIpsXEBAAPz8/5OTk4ObNmybv6/+V1qpVq0T1rVy5EtevX0f//v3RvXv3R/bx3JGRkbCzs0NSUhJExOT9W7duYcuWLYYzE/r2UfoXr9PpcOXKFeTklO+UenHryM7Oxu3bt+Hu7q54pqGkCgoK4ODggG7dumHx4sVISkrCpEmTcP78ecyYMaPM9ZIpJglEZDPc3d2N+qrj4+Pxww8/QKVSoX///gBgNIgNKByvsGbNGjg6OuK5554zqguAob78/HyMHj0aly5dMiQFSmcmLl68aN6NqkA+Pj7o0aMHMjMzFe++OHPmTIwZMwZOTk4AgAEDBkClUpm0IQCsW7cONWrUwJ07dwzTHmzDXbt2YebMmcXG1KdPH7i4uOA///mPyZ0Y9et9/vnny5yYXbhwAV5eXtDp7t2m2cnJyXCFhP7KCTIPJglEZDMaNGiA69ev49q1a8jIyMC//vUvpKSkAADee+89xMTEYOrUqYbR/9nZ2Xjrrbdw5swZfPzxx6hRo4ahrsjISLi4uBgGIf7666/4/PPP4e7ujqeffho+Pj5YtmwZtm7dCqDwFPw777xT4mcz2IpPP/0UoaGheO2113DgwAEAhT/qixYtwqJFizBv3jzDvA0bNsTUqVOxb98+vP/++4Zuh/379+PVV1/FuHHjEBQUZJi/QYMGAIAjR45ARLBw4UIcPHiw2HiCgoKwcOFCXL16FWPGjEFGRgaAwisr3n33XdSqVQuzZs0q1zZnZWVh7NixSEtLAwDk5OQY7hsxcODActVNDxAisgnZ2dny119/SXZ2trVDsZqzZ89Khw4dxM/PT6pWrSoDBw6UnJwcw/vp6ekyceJEiYqKkoCAAAkICJCOHTtKQkKCYn3Lli2TiIgI8ff3l5o1a8rSpUsN7x06dEi6d+8u/v7+UqVKFalTp45Mnz5dWrRoIQBErVbLpEmTZOPGjaJWq8XFxUUAiL+/v3Tr1q3Y7Rg8eLCo1WoBII6OjqJWq2XJkiWybt06UavV4ujoaFjHtGnTRESkfv364uXlJQDEy8tLoqKiRESkc+fO4u/vLwDExcVF1Gq11K9f32h9KSkp8s9//lOqV68uAQEBUq1aNenZs6fs27dPMb41a9ZI27Ztxd/fX9RqtcTGxsqiRYtEp9MZzZednS2DBg2SwMBA0Wg00r59ezlz5owcO3ZM1Gq1uLu7CwDx8fExiWnHjh3StWtXCQgIkMDAQImIiJDx48fL3bt3DfPcunXLpJ7OnTuLiMhLL/9DfHz9BIA4O7tIoFotx44dk9zcXFm8eLF06dJFwsLCRKPRSHBwsHTq1Ek2bdpU7H4ptZw0kaT99145aeatvxws9X2hElHoyCIii8vJycH58+dRo0YNs93Ol+hRlZWbj4s3Mw3lMH93uDlbeKx9bjpw674BoX7RgLOVnyfxP5b6vrCJqxsOLD/y0Hn4rHoiIiLL4pgEIiIiUsQkgYiIiBQxSSAiIiJFTBKIiIhIkU0MXCQiIrqfs6Mdqvm7G5UtztG18IqG+8uVDJMEIiKyOfZ2dnB3tvLJbjsHm7nk0VrY3UBERESKmCQQERGRIiYJREREpIhjEoiIyOYU6AR5+fc96dHBDvZ2pk/trFC6AiD/vkdnO7gAdvaWjcHKmCQQEZHNydUWWP/ZDdosm312g6Wwu4GIHjkdO3ZEQEAAVCoVBg8eXK666tatC19fX6hUKkydOtUs8ZGx+Ph4eHt7IyEhwTBtyJAh0Gg0UKlUaNeunfWCo2IxSSCiR86WLVuwf/9+s9R1/Phx/Pjjj2apq7Lavn17sUlWamoq0tPTkZGRYZgWHx+P5ORkC0VIZcUkgYiIKtRrr72GrKws9OrVy9qhUCkxSSAiogrn4uJi7RCoDJgkEJFNSEtLw7/+9S+0bNkSISEh8PHxQUREBMaNG4f09PQS1TF58mRoNBrY29ujevXq2L9/Pzp16oSQkBB4eHigdevW+O2334qt47vvvkOjRo1QpUoVREVFYfbs2dDpdEbzmCNWvYKCAsycORMRERGoUqUKwsPD8c9//hM//fQTVCoVPDw8oNFocPLkSQwYMEBxLMaWLVug0Wjg5OQElcr0CoC1a9eiT58+CA8PR2BgIPz9/dGzZ08cOHDAaD59Pa6urlCpVDh27BheffVVREREwMvLC61atcLvv/9utEyXLl0MZwjmzJkDjUYDjUaD7t27Ayj7+JG8vDx8/ulc9IxrgeZ1qyNYE4A2bdpg1apVJa6DzEBswP7vDj/0RfS4y87Olr/++kuys7OLnOfanSw5dOF2qV63M3JN6snTFpS6ntPJaYoxnUtJl0MXbsu1O1nl2v79+/cLAJk1a5ZotVrR6XSya9cu0Wg00rx5cykoKDCa//z58wJABg0aZFJXWFiYeHh4SMOGDeXQoUMiIpKSkiJxcXHi6OgoCQkJRvNv27ZNAEhMTIxMmjRJsrOzRavVyrvvvisAZOHCheWKtTj9+/cXAPLxxx+LVquV3NxcWbRokYSEhAgAmTJlSom3u23btqL0tV63bl1p06aNJCUlGdqiV69e4uLiIgcPHjSZf9CgQQJAOnToINu2bROdTidXr16V+vXri4eHh1y/fl2x/R6MtSQxA5C2bdsaTcvLy5N27TuIp5eXLFq6Uo5dui0376TJxIkTBYC8//77iusxu5w0kaT99145yp8BayjJ94U58BJIokfIukNJ+HL72VItM713A3SqH2Q0LTVbixFf/VGqehpW98HCIc1Mpn+25RR2nbyBl9pF4B/ta5aqzvu5ubmhR48eGD9+vGFay5YtMXHiRIwePRoJCQno0qVLievLyMjArFmzEBsbCwAIDAzE0qVLUa1aNYwcORKnTp2CnZ3xyVStVovp06cbyu+88w4++OAD/PDDDxgxYoTZY922bRu++eYbdO3aFWPGjDFMHz58OH777Td89913Jd7e4tSqVQsTJ05E1apVARS2RXx8PHx9fTFr1ix8//33ist17tzZcOVBUFAQRo0ahREjRmDjxo0YOHCgWWJT8sknn2D7tq0YN/E9tOnwFADA1dUV7733HjZt2oQpU6Zg4MCBCA4OrrAYqBC7G4jIJtSpUwc//fSTyfTatWsDABITE0tVn4ODA+Li4oymVa1aFTExMTh79iwOHTpkskzr1q2Nym5ubggICMCVK1cqJNbVq1cDALp27WryXufOnUtUR0msWrXKkCzpeXl5oWrVqsXG2qZNG6Ny9erVAcCkPcxt2bJlAIC2cZ1M3mvRogW0Wi02btxYoTFQIZ5JICKbsWrVKnzxxRc4ffo00tPTYWdnh7y8PABAVlZWqerSaDQmZwoAICQkBAcPHsSZM2fQuHFjo/cCAwNN5nd2djbEUJZY58yZgzlz5hgtO2/ePPTr1w9nzpwxxPQg/b9+czhx4gTmzp2LPXv24Pr164ZxCzdu3EBoaGiRyz3YHs7OzgCg2B7mdPJk4Q2MBvd5GvhfrPZ2Kqj+t253d3dcu3atQmOgQkwSiB4hPRoGo2m4X6mWCfN3N5nm7eqIRUNNuw6K4+Gi/HUxqmMU+resAY13+UavT548Ge+99x769u2LnTt3Gn4kt2/fjvbt25er7vvl5uYW+Z5SUqGkNLGOGzcO48aNU6xH/2OtFJPSAMSHeXCAJQAcO3YMTzzxBKpUqYIffvgBzZs3h7194a2F9WcGilLS9qgoP/6yEwFqDQAr3XGRmCQQPUo0VVyhqeJa7nocHewQG+ZjhoiAGoEeZqnns88+AwDMnz8farW63PWlpKRAp9OZ/NAlJSUBACIjI8tct7lirVmzcAzH1atXTd5TmgYAjo6OAArHTzxI6eZE8fHxyMrKwuTJk9GyZcsyx2pJtWrVwqFDh3DtapIhSdDT6XTYtm0b6tWrZ5bjhIrHMQlEZBP0P34P/oO+cOFCmerTarXYtm2b0bQzZ87g+PHjiIiIMOmjLw1zxdqnTx8AhZcoPuiXX35RXCYwMBBOTk64ePGi0fRLly7h3LlzJY41NzfXbHc8dHcvPFulT1zy8/MxevRoXLp0qUz16QdFbt24Fl6ujvBydTQ83Gn9+vXo0qULCgoKzBD5Q9g5AC6+9152le9/NZMEIrIJAwYMAFB4d77U1FQAhQMA77/aoDR8fX0xY8YMw8C869evY+TIkXBwcMDChQvLdSrdXLG2adMGgwYNws6dOzF//nzk5+dDq9Xiiy++wPHjxxWXcXR0RM+ePbFv3z5s2rQJQOHYgrFjxyIsLMxk/r59+8LJyQnz5883DNZMT0/H8OHDi+16KY3IyEi4uLgY2vrXX3/F559/bkgeSmv06NHo1KkTln71OXYm/ASNtzOcHOywbds2DBs2DJMnTzbrmI0iOboCvuH3Xo7lP4v3yKnQCyxLiPdJILLcdc+2Ki8vT95//32Jjo4WV1dXqVatmnTr1k1mz54tAMTd3V3UarWkpqZKXFyc+Pv7CwBxcXERtVotW7duNdQVFhYmYWFhcurUKenRo4eEhoaKu7u7tGrVSrZv32603rZt24qPj4/ROjIzM2XJkiWiVqvFzs5O7OzsRK1Wy+LFi0sd68Pk5+fL+++/L+Hh4eLt7S2RkZEyceJE+eWXX4q898CdO3fkpZdekqpVq0pAQIC0b99eDhw4YLhPglqtluHDhxvm37Ztm7Rr106qVKki/v7+EhMTI59++qlUq1bNaNsOHz4sarVaXFxcBID4+/vLyy+/LCIi3bp1M2mn+7dv2bJlEhERIf7+/lKzZk1ZunSpiEiR+2rw4MGiVqsFgDg6OoparZYlS5YYHQ+zZ8+W+vXri4+Pj4SEhMiTTz4p3333XQmOpsefpb4vVCIi1kpQ9A4sP/LQeZo8H2OBSIisJycnB+fPn0eNGjV4C9ty0g/IK2tXhS3QD4KcMmUKn05JJiz1fcHuBiIiIlLEJIGIiIgUMUkgoseG/gFPly9fxuXLl6HRaDBz5kxrh1VqDRo0MHlokv4GQ5VFTl4Bzt/IMLxy8ixwNcOD8rKAG3/de+WV7oZej4PKdz0HET22pk+fXuarIWxJaW9B/TjSiRglBjprDJ+TAkCbZVyuZHgmgYiIiBQxSSAiIiJFTBKIiIhIEZMEIiIiUsQkgYiIiBQxSSAiIiJFTBKIiIhIEZMEIiIiUsQkgYiIiBQxSSCiR07Hjh0REBAAlUqFwYMHl6uuunXrwtfXFyqVik9bpDKZNm0a/P39cfToUcM0cx6j1sQkgYgeOVu2bMH+/fvNUtfx48fx448/mqUuejx9vWIdVMFN8fXSbxXfv3PnDtLT05GdnW2YZs5j1JqYJBARkc1xdbJHVJCX4eXqZG/5IJw8AE1DwDussOzgrDjbxx9/jNTUVDRr1syCwVkGH/BEREQ2R6VSwV5l9SAAlT1gZ3evXAQXFxcLBWVZPJNA9Ci5ewm4uKt0r8wbpvXk55W+npSjpvUAwPW/Ct+/e6lcm5aWloZ//etfaNmyJUJCQuDj44OIiAiMGzcO6enpJapD/6hoe3t7VK9eHfv370enTp0QEhICDw8PtG7dGr/99luxdXz33Xdo1KgRqlSpgqioKMyePRs6nc7ssept2rQJcXFxCAkJQVBQEGrXro2XX34Z27dvBwAcOXIEGo0Grq6uUKlUuHDhgmHZLl26KI6nKE87bN26FZ06dYKvry98fX0RHR2NCRMmGG1XfHw8NBoNnJycoFKpcOPGDQwePBg1atSAvb29UZyZmZkYN24cQkJC4Ofnh6ioKEyePBmLFy+GSqWCt7c3NBoNsrKy0K5dO8Xt0a9Pvz0Pio+PR/fu3REWFgZ/f39oNBo8//zzOH36tMl898d9/fp1DBgwANWqVYOvry+6dOli8kjuunXrYsyYMQCAMWPGQKPRQKPRYMSIEQCA6OjoMo1pSUtLw4QJE1CzZk34+vrCz88PXbp0wdatW0tch0WIDdj/3eGHvoged9nZ2fLXX39JdnZ20TNtnSIyBaV7JX5nWk/a1dLX81Vb5Zi+7VH4/tYp5dr+/fv3CwCZNWuWaLVa0el0smvXLtFoNNK8eXMpKCgwmv/8+fMCQAYNGmRSV1hYmHh4eEjDhg3l0KFDIiKSkpIicXFx4ujoKAkJCUbzb9u2TQBITEyMTJo0SbKzs0Wr1cq7774rAGThwoXlirUoCQkJolKpZO7cuaLVakVE5MSJE9KgQQNp27at0byDBg0SAHL+/HnF2KdMmVLudvjiiy9EpVLJmDFjJCMjQ3Q6nWzdulUCAgIkNjZWMjMzjeZv27atAJBu3brJ7t27RafTyeHDh8Xe3l7Onz8v+fn50rZtW3F0dJQVK1aITqeTzMxMmTp1qgQFBQkAiY+PL9X2hIWFmUx3d3eXPn36yO3bt0Wk8Nho1aqV+Pn5yeXLl03m18f97LPPyuHDhb8vJ06ckODgYAkNDZW8vDyj+ePj4xVjfVjMRR2jqampUr9+fQkNDZW9e/eKiMjdu3dl6NChYmdnJ998843ieu5Xou8LM+CZBCKyCW5ubujRowfGjx8PBwcHqFQqtGzZEhMnTsS+ffuQkJBQqvoyMjIwa9YsxMbGAgACAwOxdOlS6HQ6jBw50uTsAABotVpMnz4dLi4ucHBwwDvvvAN7e3v88MMPFRLrmjVrICIYOnQoHBwKe3+jo6PxwQcfoFq1aqXa3qKUtB2uXr2KUaNGoV69evjoo4/g7u4OlUqF9u3bY8qUKTh8+DA+/fRTxXX07dsXTz75JFQqFWJiYvD555/Dz88PS5cuxY4dO/Dyyy+jb9++UKlUcHNzw5QpUxTPCJRVgwYN8Omnn8LHxwcAUL16dSxatAi3bt0qMmYAeO655xATEwOgsN0HDBiAy5cvY+/evWaLTcnEiRNx9OhRfPTRR2jevDkAwNvbGwsXLkRQUBDGjBljNAjSmpgkEJFNqFOnDn766SeT6bVr1wYAJCYmlqo+BwcHxMXFGU2rWrUqYmJicPbsWRw6dMhkmdatWxuV3dzcEBAQgCtXrlRIrPofyiFDhuD48eOG6V27dsXSpUtLVMfDlLQdVq5cidzcXHTt2hV2dsY/DS1atAAAxW0GgKeeesqoPGTIEHh6emL16tWG7XlQly5dio1bpxPczcwzvPILTJM6vT179iAwMNBoWkn2RZs2bYzK+v1h2N8F2sLuutz/dbXoCoqNuSREBN9++y3s7OxM2sDJyQmNGjXCrVu3sHv37nKvyxw4cJHoUdJwKBDesXTL+EebTnP1A4bsLF09Lt7K0zt+ALQcD3iX/5/vqlWr8MUXX+D06dNIT0+HnZ0d8vLyAABZWVmlqkuj0Zj82AFASEgIDh48iDNnzqBx48ZG7z34QwMAzs7OhhjKEuucOXMwZ84co2XnzZuHfv364dVXX8XRo0fx3Xff4ccff0RUVBR69OiBQYMGoX79+qXa3qKUtB30ffELFy7EkiVLjOYVEbi7u+PmzZtFrkPJmTNnDOt6UNWqVYuNu0AnuHb33r/pMH/3Iufdv38/5s2bh4MHD+LmzZtG21vccfPg/nZ2Lrx6wbC/83OA1ItA1v+2u0BbbMwlcePGDdy+fRsqlQo1a9Y0eT83Nxfu7u64evVquddlDkwSiB4lVaoVvsrLwQkIa1X+egAgsI5Zqpk8eTLee+899O3bFzt37jT8iGzfvh3t27c3yzqAwi/hoij9mCopTazjxo3DuHHjFOtxdXXFsmXLMHPmTKxcuRJr1qzBRx99hI8++gjvvPMOZsyY8dBYlLpNSqKodpgwYQImTJhQqrqKajfV/64GUFqXqpgrBYqi0+lM1rV582Z07doVtWvXxvLly1G/fn3DPA9bR0n3d0VwcnJCcnKy1dZfUuxuICKb8NlnnwEA5s+f/9B/mSWRkpKi+AOalJQEAIiMjCxz3eaKVafTQURQrVo1vPHGG9i1axeOHj2K6tWrY+bMmTh//rxhXkdHRwCF4ybu97AfmpK2Q61atQAAly9fVqzn6NGjil00xdH/U1b6V1zUP+WitlNEkJKSYjL/okWLUFBQgIkTJyImJsaqP/wlERAQAD8/P+Tm5uL69esm72dmZmLLli1ITU21QnSmbLs1iajS0P84PPjv7/5L/kpDq9Vi27ZtRtPOnDmD48ePIyIiwjCQryzMFevQoUMxa9Yso2l169bF3/72NwCFd/LT05+yv3jxotH8+ksli1LSdujTpw9cXFywdu1ak+6V3NxcdO7cGVu2bCnpphnqBIC1a9eavPfLL78oLqPfzkuXjLfz9317Fbt9zH3cKHF3cwVwL3FJSUnB6NGjkZGRUeq6VCoV+vfvDwBYsWKFyftffvklnnvuOUPXh7UxSSAimzBgwAAAwGuvvWb4F5WYmIjp06eXqT5fX1/MmDHDMHDt+vXrGDlyJBwcHLBw4cJy/eM0Z6yffPIJfv/9d0P5+PHjWLNmDWJiYowSmV69esHOzg4ffvgh0tPTodPpsGrVqocOkixpOwQFBWHhwoVISUnBsGHDcPv2bQCF//j79esHtVqN4cOHl2rb+vfvjw4dOuD777/HDz/8ABFBdnY23nvvvSL/KYeFhaFJkybYtPFnHDtSeOYi6fJFfDhnNvz8/BTXAQAzZszA2bNnjbbRXOrVioBKpcKR/z2bYe3atVixYgXc3YseJ1Gc9957DzExMZg2bZoh8dLpdFi9ejXeffddfPjhh7Zzc6YKvcCyhHifBCLLXfdsq/Ly8uT999+X6OhocXV1lWrVqkm3bt1k9uzZAkDc3d1FrVZLamqqxMXFib+/vwAQFxcXUavVsnXrVkNd+uvpT506JT169JDQ0FBxd3eXVq1ayfbt243W27ZtW/Hx8TFaR2ZmpixZskTUarXY2dmJnZ2dqNVqWbx4caljLc6RI0fktddek/r160tQUJCo1WqJjo6WCRMmyK1bt0zmX7dunTRs2FA8PDwkMjJSJk2aJAkJCUbrPH36dJnaQW/Hjh3StWtX8fPzk6CgIImKipLx48cbxbNu3TpRq9Xi6OgoAEStVotarZb8/HyT+jIzM+XNN9+U4OBg8fX1ldq1a8tHH30kX331VZH3Hrhy5Yo82+vv4uvnL/6Bamn/VBc5evyEhIWFGfbFjBkzDPOvWrVKmjVrJp6enqLRaOSJJ56Q5cuXCwBxdHQUtVotGzduVIx72rRpIiJSv3598fLyEgDi5eUlUVFRIjlpIkn7RZL2y5xJYyQ0JEQCAwOlXr16smnTJhERiYqKMjl+Tp8+/dBjND09XSZOnChRUVHi6+sroaGhEhcXJxs3biz2mNGz1PeFSkTEOunJPQeWH3noPE2ej7FAJETWk5OTg/Pnz6NGjRq28y/iEaW/lM2cp5wfRbbcDl9//TWGDBmC+Ph4xackZuXm4+LNTEM5zN8dbs4WHmufmw7cuu8OjH7RgLOnZWMogqW+L9jdQERERIqYJBAREZEiJglE9NjQP9jo8uXLuHz5MjQaDWbOnGntsCzOltshNzcXGo3G5KFJpb1ZFlkGxyQQ2QiOSSC6h2MSiscxCURERGRVvC0zERHZHEd7OwR6uRiVLc7eGfAKMS5XMkwSiGyMDfQAElmdo4Md/Dyt/KPs4AR4KD+8ytos9T3B7gYiG2Fvbw/A9J71REQP0n9P6L83KgqTBCIb4ejoCGdnZ6SmpvJsAhEVSUSQmpoKZ2dnw7MrKgq7G4hsiL+/P5KSknDlyhV4e3vD0dGxTI/UJaLHj4hAq9UiNTUVGRkZCA4OrvB1MkkgsiFeXl4AgJs3bxoe5UtEdD9nZ2cEBwcbvi8qEpMEIhvj5eUFLy8vaLVaFBQUWDscIqv4b1Iqpq85aihPfrY+agd7WzaIpD+BNQPvlZ9dCgQ3tmwMD7C3t6/wLob7MUkgslGOjo4W/TIgsiUqh2xcSy+4r+xk+ZuMOQiQcc64XMludMYkgYiIyoV3zX188eoGIiIiUsQkgYiIiBQxSSAiIiJFTBKIiIhIEZMEIiIiUsQkgYiIiBQxSSAiIiJFTBKIiIhIEZMEIiIiUsQ7LhIRkc1xdrBDiK+rUdniHFwAnwjjciXDJIGIiGxO7WBvrBrTxrpBBDcBxpyxbgxWxu4GIiIiUsQkgYiIiBQxSSAiIiJFTBKIiIhIEQcuEhGRzblyOwvL91wwlJ9/sjpCfN0sG8Tts8Dej+6VW4wFfCOKnv8xxCSBiIhszs30XKzef9lQfqp+kOWThPRrwP4F98r1nq90SQK7G4iIiEgRkwQiIiJSxCSBiIiIFDFJICIiIkVMEoiIiEgRkwQiIiJSxCSBiIiIFDFJICIiIkVMEoiIiEgRkwQiIiJSxCSBiIiIFPHZDUREZHMiAj0wf2ATo7LFBdYDBmw2LlcyTBKIiMjmeLo6olmEn3WDcK0CRHS0bgxWxu4GIiIiUsQkgYiIiBQxSSAiIiJFHJNAREQ2JzsvH1duZxvKIb6ucHWy8E9WXiZw++y9sm8E4ORu2RisjEkCERHZnJPX0jHiqz8M5UVDmyE2zMeyQVw7BMS3vlceshMIa2XZGKyM3Q1ERESkiEkCERERKWKSQERERIqYJBAREZEiJglERESkiEkCERERKWKSQERERIqYJBAREZEiJglERESkiEkCERERKWKSQERERIr47AYiIrI53m6O6FBHbVS2ODc/oE5v43IlwySBiIhsTo0AD7zfL9a6QQTUBvqutG4MVsbuBiIiIlLEJIGIiIgUMUkgIiIiRUwSiIiISBEHLhIRkc05nZyGWev+MpTf6lEHkRovywaRfARYP+Je+elFgCbGsjFYGZMEIiKyOZm5BTh2JdWobHG56cCVfcblSobdDURERKSISQIREREpYpJAREREipgkEBERkSImCURERKSISQIREREpYpJAREREipgkEBERkSImCURERKSISQIREREpYpJAREREivjsBiIisjn1Qrzxy1vtDWV3Zyv8XIU8AYy/da/s7Gn5GKyMSQIRkQ05sPzIQ+dp8vzDn0RYknpsmYO9HbzdnKwbhL0j4OZr3RisjN0NREREpIhJAhERESlikkBERESKOCaBiIhszq2MXOw9fdNQbhHpDz8PZ8sGkZECnN54rxzZFfBQWzYGK2OSQERENufyrSzMWHvMUF40tJnlk4Rbp4H/DLlXHrKz0iUJ7G4gIiIiRUwSiIiISBGTBCIiIlLEJIGIiIgUMUkgIiIiRUwSiIiISBGTBCIiIlLEJIGIiIgUMUkgIiIiRUwSiIiISBGTBCIiIlLEZzcQEZHNCarigpFxkUZli6sSBsS9b1yuZJgkEBGRzVF7u2JQm3DrBuEdCrSeYN0YrIzdDURERKSISQIREREpYpJAREREipgkEBERkSIOXCQiIptz5NIdjP56v6H86eCmiKnmY9kgLu0GlnS4Vx60FajW0rIxWBmTBCIisjkigLZAjMpWCaIgz7hcybC7gYiIiBQxSSAiIiJFTBKIiIhIEZMEIiIiUsQkgYiIiBQxSSAiIiJFTBKIiIhIEZMEIiIiUsQkgYiIiBQxSSAiIiJFvC0zERHZHCcHO2iquBiVLc7BGfAOMy5XMkwSiIjI5tQJ9sba19taN4jgpsDrF6wbg5Wxu4GIiIgUMUkgIiIiRUwSiIiISBGTBCIiIlLEgYtERGRzrtzOwop9Fw3lfs3DEOLrZtkgbp8F9s27V24+BvCNsGwMVsYkgYiIbM7N9Fys/P2SoRxXV2P5JCH9GvDHJ/fKdftWuiSB3Q1ERESkiEkCERERKWKSQERERIqYJBAREZEiJglERESkiEkCERERKWKSQERERIqYJBAREZEiJglERESkiEkCERERKWKSQERERIr47AYiIrI54YEe+HhAY6OyxQXWBfpvMi5XMkwSiIjI5ni5OqJ5TX/rBuHqA9TsbN0YrIzdDURERKSISQIREREpYpJAREREijgmgYiIbE52Xj6u3c0xlIOquMDVycI/WXmZwN0L98pVqgNO7paNwcqYJBARkc05eS0dI776w1BeNLQZYsN8LBvEtUNAfOt75SE7gbBWlo3BytjdQERERIqYJBAREZEiJglERESkiEkCERERKWKSQERERIqYJBAREZEiXgJJ9D8Hlh956DxNno+xWD2PIktuuyX3V0k8rvv0UVSZP4PmxjMJREREpIhJAhERESlikkBERESKmCQQERGRIg5cJCIim+Pt5oi2tQONyhbn5gfUeta4XMkwSSAiIptTI8ADs55raN0gAmoDz/1o3RisjN0NREREpIhJAhERESlikkBERESKmCQQERGRIg5cJCIim3M6OR2zN/xlKL/ZvQ4iNZ6WDSI5Edjwyr1y9wWApoFlY7AyJglERGRzMnPzkXjprlHZ4nLTgMu7jcuVDLsbiIiISBGTBCIiIlLEJIGIiIgUMUkgIiIiRUwSiIiISBGTBCIiIlLEJIGIiIgUMUkgIiIiRUwSiIiISBGTBCIiIlLEJIGIiIgU8dkNRERkc+qFeGPj+PaGsqeLFX6uQp4A3rx+r+xSxfIxWBmTBCIisjkO9nbwcXeybhD2joB7gHVjsDJ2NxAREZEiJglERESkiEkCERERKeKYBCIisjm3M3Lx+9lbhvITEX7w9XC2bBAZ14GzCffKEZ0Aj0DLxmBlTBKIiMjmXLqVhWk/HjWUFw1tZvkk4dYpYM2Ae+UhOytdksDuBiIiIlLEJIGIiIgUMUkgIiIiRUwSiIiISBGTBCIiIlLEJIGIiIgUMUkgIiIiRUwSiIiISBGTBCIiIlLEJIGIiIgUMUkgIiIiRXx2AxER2RyNtwuGdahpVLY472pA+/eMy5UMkwQiIrI5miquGNo2wrpBVKkGtJ1o3RisjN0NREREpIhJAhERESlikkBERESKmCQQERGRIg5cJCIim5N46Q7+ufRPQ3n+wMZoUM3HskFc2gMse+peecBmoNqTlo3BypgkEBGRzdEJkKMtMCpbnOgAbZZxuZJhdwMREREpYpJAREREipgkEBERkSImCURERKSISQIREREpYpJAREREipgkEBERkSImCURERKSISQIREREpYpJAREREinhbZiIisjmO9ioEeDkblS3O3gnwDDYuVzJMEoiIyObUDamCdW+0s24QIc2AN65YNwYrY3cDERERKWKSQERERIqYJBAREZEiJglERESkiAMXiYjI5iTdzsLKPy4Zyn2aVUOwr5tlg7h9Dvjj03vlZqMB33DLxmBlj0yScGD5kYfO0+T5GAtEQubaF5asx9aYK+ZHsZ0tub9s7diwtXhszf3tczYrD99fum0oByWlI8LNybLf8+lXgX1z75Vr9ypTkvAo/36xu4GIiIgUMUkgIiIiRUwSiIiISBGTBCIiIlLEJIGIiIgUMUkgIiIiRUwSiIiISBGTBCIiIlLEJIGIiIgUMUkgIiIiRUwSiIiISNEj8+wGIiKqPDTODhgRUsWobHEBdYAX1huXKxkmCUREZHPc7e1Qz8PFukG4+QJR3a0bg5Wxu4GIiIgUMUkgIiIiRUwSiIiISBHHJBARkc3J0wnuaAsMZR9HezjZqSwcRBaQdvle2SsUcHKzbAxWxiSBiIhszuUcLeZeum0ov17NFxFuTpYN4tpBIL71vfKQnUBYK8vGYGXsbiAiIiJFTBKIiIhIEZMEIiIiUsQkgYiIiBQxSSAiIiJFTBKIiIhIEZMEIiIiUsQkgYiIiBQxSSAiIiJFTBKIiIhIEZMEIiIiUsRnNxARkc1xs7dDPQ9no7LFufoCUT2My5UMkwQiIrI5Qc4OGBHiY90gAusAL/xk3RisjN0NREREpIhJAhERESlikkBERESKmCQQERGRIg5cJCIim5OUo8XKlDRDuY/aC8EujpYNIuUo8POr98rdPgHU9S0bg5UxSSAiIpuToxOcydYalS0fRCpwcYdxuZJhdwMREREpYpJAREREipgkEBERkSImCURERKSISQIREREpYpJAREREipgkEBERkSImCURERKSISQIREREpYpJAREREipgkEBERkSI+u4GIiGxOmKsjZtYMMJTd7a3wnza4GfDG1XtlVz/Lx2BlTBKIiMjmOKhU8Hawt3IQToBnkHVjsDJ2NxAREZEiJglERESkiEkCERERKeKYBCIisjnp+TqczMo1lKPdnOHpYOH/tZk3gHNb7pXDOwLuAUXP/xhikkBERDbnel4+vr6aaii/Xs0Xng5Olg3i5klg9Qv3ykN2Vrokgd0NREREpIhJAhERESlikkBERESKmCQQERGRIiYJREREpIhJAhERESlikkBERESKmCQQERGRIiYJREREpIhJAhERESkq0W2ZRQTp6ekVFkRGVoZZ6klLSzNLPVS8kuyvkuwLS9ZjLo9rPLa2XY8iS7bho7i/ShtzVnYe8nMz7ys7IQNOFj3mkZ4J5D5QLsPvjNniKQdPT0+oVKpSL6cSEXnYTGlpafD29i5TYERERGRdqamp8PLyKvVyJUoSKvJMQlpaGkJDQ3H58uUybQCVHtvc8tjmlsc2tzy2ueWVtM3LeiahRN0NKpWqwne4l5cXDyoLY5tbHtvc8tjmlsc2t7yKanMOXCQiIiJFTBKIiIhIkdWTBGdnZ0yZMgXOzs7WDqXSYJtbHtvc8tjmlsc2t7yKbvMSDVwkIiKiysfqZxKIiIjINjFJICIiIkVMEoiIiEgRkwQiGzBhwgSoVCp8/fXX1g6FiGzE3bt38eKLL0KlUuHChQtWiaFCkoScnBy8/fbbiI6ORoMGDdCkSRP89NNPJVr27t27GDFiBKKiolC3bl20bt0ae/bsqYgwHztlbffExESMGjUKderUQf369VG7dm307t0biYmJFoj60VaeY13vzJkz+OijjyoowsdPedv822+/RatWrdC4cWNEREQgNjYW8+bNq8CIH33lafPt27ejY8eOhu+Xxo0b46uvvqrgiB99CQkJaNSoEY4cOVLqZc36OyoVoHfv3lKrVi25ceOGiIj89NNPYm9vL+vWrSt2ufz8fGnevLm0adNGMjMzRUTkk08+ERcXFzlw4EBFhPpYKWu7R0dHS+fOneXOnTsiIpKRkSE9e/YUZ2dn+eOPPyo67EdaWdv8ft27d5dnnnlGAEh8fHwFRfr4KE+bv/vuuxIbGysXL14UkcLvnOHDh0tcXFyFxvyoK2ub79+/X5ycnGTcuHFSUFAgIiJr164VlUolCxYsqPC4H2WtWrWSgwcPypQpUwSAnD9/vkTLmft31OxJwvbt2wWAfP/990bTO3fuLOHh4aLT6Ypc9uuvvxYAsm/fPqPp0dHR0r59e3OH+lgpT7tHR0fLwYMHjaadOnVKAMiAAQMqJN7HQXnaXG/Dhg1Su3Zt2bx5M5OEEihPm+/fv19UKpXJF+X169flt99+q5B4HwflafPx48cLALl165bR9Pr160uLFi0qJN7HhVarFREpdZJg7t9Rs3c3/PDDDwCAuLg4o+lxcXE4d+4cDhw4UOyynp6eaNasmcmy27dvx/Xr180d7mOjPO2emJiIhg0bGk0LCQkBANy5c8fMkT4+ytPmAJCXl4fXXnsN8+bNg4NDiR6jUumVp80XL14MjUaDxo0bG00PCAhA69atzR/sY6I8bW5vbw8AyM/PN5qu1WpRUFBg5kgfL2X9TjD376jZk4TDhw/Dy8sL/v7+RtMjIiIAoNj+lcOHD6NGjRomT6qKiIiAiLCPvBjlaXcnJyeTaSdPngQAdOjQwYxRPl7K0+YAMHfuXNSpUwdPPfVUhcX4uClPm+/atQs1atTA6tWr0aZNG9SqVQvNmjXD/PnzIbynXJHK0+YjR45EcHAw3n77beTk5EBEsHjxYpw6dQqvvfZaRYZdaZn7d9Tsf19u3Lih+CQq/bQbN24Uu2x4eHiZlq3sytPuShYsWICoqCgMHz7cLPE9jsrT5teuXcOcOXPw+++/V1h8j6PytPmlS5dw6dIlzJ49G2vWrIFGo8H69evRu3dvnDx5Ep999lmFxf0oK0+bh4aGYvv27Rg8eDCqVKkCT09PuLm5Yd26dejWrVuFxVyZmft3lJdAkokNGzbgxx9/xOrVq+Hm5mbtcB5L48ePx7BhwxQ/zFQxcnJykJmZiTlz5iAoKAgqlQo9evTAc889h4ULF+LixYvWDvGxs3fvXjzxxBOIjY3F7du3cf36dSxevBiDBg3i5b6PCLMnCf7+/khLSzOZrp8WEBBQIctWduZqu99++w3Dhw/Hxo0bUa9ePbPG+Lgpa5vv2bMH27dvxzvvvFOh8T2OynOce3p6AgBiY2ONpjds2BAigv3795sv0MdIedr8tddeg729PebOnQs3NzeoVCp07twZL774IoYNG2a1a/8fZ+b+HTV7khAbG4u0tDTcunXLaPq5c+cAADExMcUue+HCBZP+wXPnzkGlUqFBgwbmDvexUZ5219u8eTMGDhyI9evXo2nTphUS5+OkrG2+adMmODo6omXLloiNjUVsbCxefvllAMDkyZMRGxuL119/vWKDf0SV5zivU6cOAECn0xlN1w+ue3A6FSpPmycmJqJGjRpwdHQ0mh4dHQ2tVvvQwb1Ueub+HTV7ktC3b18AwK+//mo0/ddff0V4eDiaNGkCACgoKDAZZdm3b1+kpaWZZPRbt25F27ZtERgYaO5wHxvlaXcAWLduneEMgv6f1rVr19CzZ8+KDfwRVtY2nz59Os6dO4fDhw8bXl988YXhvcOHD2Pu3LkW2opHS3mO82eeeQYATAZuHTt2DCqViolxEcrT5mq1GpcvXzZJwPRnEPz8/Coo6srBIr+jpb5osgR69+4ttWvXNtx4Y/369WJvby8//fSTYZ5hw4aJnZ2d7N692zBNfxOIdu3aGW4CsWDBAt5MqYTK2u4rVqwQJycnmTJliixbtszwmjt3roSFhVl6Mx4pZW3zB23bto33SSihsrZ5RkaGREZGSps2bSQtLU1ERH7//Xdxd3eXkSNHWnYjHjFlbfN58+YJAJk6darhfgp//vmnVKlSRRo3biz5+fmW3ZBHUHH3SbDE72iFJAnZ2dny1ltvSVRUlNSvX18aNWok//nPf4zmmTRpkvj6+srRo0eNpt+5c0eGDRsmkZGRUqdOHWnVqpXs2rWrIsJ87JS13X18fASA4otJQvHKc6yLiBw/flxiYmIkIiJCAEhoaKjExMTI5s2bLbUJj5zytPnVq1dl4MCBEhISItHR0VKnTh2ZO3eu4W6ApKw8bb569Wpp3bq1REdHS7169aRu3bry7rvvGu7wSsqmTZsmMTExolarBYDUrl1bYmJi5NChQ4Z5LPE7qhLhBcJERERkipdAEhERkSImCURERKSISQIREREpYpJAREREipgkEBERkSImCURERKSISQIREREpYpJAREREipgkEBERkaJKlSTk5uZCo9EgICAAKpUKKpUKa9eufehyhw4dMsyv0WjQqFGjig8WQHx8PLy9vZGQkGCR9VHxhgwZAo1GA5VKhXbt2pV4uZdeegkhISFISUkxSxw///wznnzySajVaqjVajRs2BA//fSTWeoui6NHj8Lf3x/Tpk2zWgxUKCsrC2+++SYcHBwwderUh87/888/o02bNggMDIRarUbXrl3xxx9/FDn/1atXMXToUFStWhWBgYGoV68e5s+fX+4naC5duhQajQZOTk5QqVTlqovMq1IlCc7OzkhOTjZ6Ota0adNMHqn5oPu//JKTk3Hw4MEKi/F+qampSE9PR0ZGhkXWZyu2b98OlUpVoi+5khg8eDBUKlW5n10fHx+P5OTkUi9369YtpKWlITc3t1zrB4C//voLzz77LGrWrImkpCRcvXoVDRs2rPBjsrjEKDs7G+np6bhz506FxkDF27RpE+rWrYvVq1ejoKDgofN/8cUX6N69Ozp37oyrV6/iwoULqFGjBlq1aoXNmzebzH/p0iU0bdoUJ06cwJ9//onr169j9uzZePvttzF06NByxT5w4EAkJyfjySefLFc9VAHK/PSJR9j58+cFgDRs2FAAyJo1a4qc9+DBg1K1alXRaDRijebKzs62+DqtTf9ExClTppilvkGDBhX5FLWyACBt27Yt8fw6nU5ycnLMsu758+cLAFm/fr1hWmZmpqSmppql/qI8bJsr43FqS/bs2SNhYWGyfv16iY+Pf+jn58qVK+Lq6ipt2rQxmq7VaiU8PFyCg4MlKyvL6L0ePXqISqWSM2fOGE2fNGmSADB54FNZtG3b1irfs1S0SnUm4UGTJk0CUPzZhGnTpuHNN9+Es7OzJUMzcHFxscp6yXxUKpXZjp9bt24BANzd3Q3T3Nzc4OXlZZb6y4rHqXVFRkbi+PHj6N69e4nm//LLL5GdnY3nn3/eaLqDgwN69+6NpKQk/Pjjj4bply5dwrp169CsWTNEREQYLaOv45NPPinnVpAtqtRJwt/+9jc0aNAAhw8fxn/+8x+T9w8dOoTff/8dw4cPL7KOa9euYdKkSWjSpAmCg4NRpUoV1K5dGzNmzEBeXp5hvp07dxr6s1UqFdRqNXbu3Im0tDRoNBo4OzvDy8vLcEq3Y8eOhrETgwcPNtQzffp0aDQa2Nvbo3r16jh9+jS6du2KwMBAaDQajB07FlqtFmlpaRgyZAhCQ0Oh0WgwZMgQpKamGuo5cuQINBoNXF1dTU7Fd+nSBb6+vian/OPj4436DVNSUtCvXz8EBQXB398fgwYNQlpaGrRaLcaNG4fw8HD4+fnh2WefxdWrV0u0T7p06YJevXoBAObMmQONRgONRmPy5Xf48GH06dMHQUFBUKvVqF69Ol555RVcu3bNMM/Jkyeh0WiwYsUKAEDTpk0N9S1duhQAoNVqMX/+fMTFxaFatWrw8/NDaGgo/vGPf5R7DIF+33p7e0OlUuHrr7822s77929CQgJatGgBPz8/1KhRA2+99ZZR94R+W+bMmQMA6NWrl2FbLl++bJhv69at6NSpE3x9feHr64vo6GhMmDAB6enpJvFlZGRg8uTJqFWrFtRqNapWrYqmTZvijTfewIkTJwDcO94AYM+ePYZ1ajQa5ObmYvLkyUbH44O0Wi1mz56NmJgYBAYGIiAgAK1atTLsE70Hj+uzZ8+iZ8+eqFq1KtRqNfr06WO0b/X27duHnj17olq1aggKCkJkZCReeOEFxc9zUc6dO2f4rKjVagQHB2PAgAE4deqUYZ4hQ4bAw8MDKpUK3t7eRtv66aefGj7b/v7+WL9+fan2x4Ofqxs3bmDw4MGoUaMG7O3tS9RV5u/vb5Q4Psyvv/4KAGjcuLHJe/pp93c5FDd/rVq14Obmhh07dkCr1ZZo/UeOHEG3bt3g5eWFkJAQdOjQodixEPHx8ejevTvCwsLg7+8PjUaD559/HqdPnzbMc/z4ccN+sLe3h0ajwaeffmp4v3r16vD09ISLi4vhezYnJwczZ85EnTp1EBQUhODgYLRo0QLTp08v8XfWY8/apzKsQd/dICKycuVKASCxsbGi0+mM5nvmmWdkzpw5IiISFhameBps5cqVYm9vL0uXLhWdTicFBQWybt06cXNzk759+5rMP2LECAEg06ZNM0w7fPiwaDQauXjxomKcgwYNMqknLCxM/Pz8pG/fvnLt2jXR6XTy1VdfCQAZN26cvPLKK3Lq1CkREdmyZYvY2dnJyy+/bFJPUafiizvlrz8l2LdvX8M6Nm/eLHZ2dtKnTx9555135I8//jBsm6enp3Ts2NGknqI8rLth48aN4uzsLL169ZKbN2+KiMjp06clJiZGNBqNnD17tkTbKCJy48YNASD//Oc/DadXExMTpXbt2hIeHi7p6ekmy6CU3Q3607/x8fFG0/X7t27duvLSSy9JWlqaFBQUyIIFCwSAvPXWWyZ1TZkyRQDItm3bTN774osvRKVSyZgxYyQjI0N0Op1s3bpVAgICJDY2VjIzMw3zpqWlGZ5Vv3v3bhEpPNX873//W+zs7EyOuYdtc1hYmISFhRlNy8vLk7i4OHF3dzd0j+Tl5cncuXMFgIwfP16xHj8/P+nZs6dhf+3du1c8PDzkiSeeMJr3+PHj4uTkJG+88Yahu+PKlSsSFxdnEktRDh48KFWqVJFWrVrJpUuXRETk2rVr0rFjR/H09JR9+/YZ5t2wYYMAkGHDhpnU8+eff4qvr69Rt0tp9ofIvc9Vt27dZPfu3aLT6eTw4cNib29fqq6yknQ3BAQECABJSkoyeW/Xrl0CwKi933zzTQEgM2fOVKyvZs2aAkD++9//PjS+Q4cOiYeHh8TExBg+q+fOnZMOHToU+T3r7u4uffr0kdu3b4tI4WenVatW4ufnJ5cvXzaat1mzZmJvb2/Yn/d7+umnDd/pIiIvvviiBAUFSWJiooiIFBQUyLfffisODg4mn9fKqtInCTqdTurVq2cyNuHgwYOiVqsNH+SiDt7NmzfL8OHDTaaPGzdO8UOTlZUltWvXFjs7O/n1118lLS1NIiMj5fvvvy8yzqKSBABy8OBBo+khISFib28vP/74o9H0li1biqurq0k95UkSlNZhZ2cnc+fONZr+4osvCgBJTk42qUtJcevOysoStVotbm5uhi8MvZ07dwoAiYuLK9E2iojcuXNHmjdvLlqt1mj6+vXrBYAsXLjQZBlzJwm+vr4m/b8ajUZq1KhhUldRSUJSUpI4OztL/fr1paCgwOi9Tz/9VADIrFmzDNP++c9/CgD55ptvTNbRv39/syQJH374oQCQt99+22T+uLg4ASA7d+40qQeA/P7770bTn3vuOQFglEjPmjVLAMiRI0eM5j1y5Ih06NChyFj1dDqdNGjQQFQqlcnn9MKFC2Jvby9RUVGSn58vIoU/INWrVxd3d3eTMSAvv/yyvPHGG4ZyafeHyL3P1ddff200/auvvpK0tLSHbo9eSZIER0dHASB37941ee/QoUMCQKKiogzT/vGPfwgA+fjjjxXri4mJEQCyZ8+eh8bXpk0bxX383//+V+zs7BS/Z1u0aCEpKSlG044dO6aYTH/99dcCQN555x2j6efPnxd3d3e5deuWYZqrq6s8++yzJuv7xz/+YfL9VllV6u4GoLC/eOLEiQCMxyZMmzYNY8eOhZubW7HLd+zYEYsWLTKZXrt2bQBAYmKi0XRXV1d89913cHBwwAsvvIAXXngBTz75JPr161fq2F1dXdGwYUOjaaGhoSgoKDAZJRwaGors7GzcuHGj1OspyoPrqFatGnQ6HVq0aGGybqCwX7O8EhISkJKSgvbt28PHx8fovVatWkGtVuPXX38t8anCKlWqYO/evXBwcDCaXtT+qwhNmzaFq6ur0bTq1avjypUrJa5j5cqVyM3NRdeuXWFnZ/yx1u8P/WWSIoJvvvkGAPD000+b1DVjxgy88cYbpdoGJcuWLQMA/P3vfzd5r3fv3gBg6Pa5n4uLC5o1a2Y0TX96//420U979dVXjU5VN2jQwHB6vDiJiYlITExEnTp1UKtWLaP3wsLC0KRJE5w6dQq///47AMDOzg7Dhg1DZmamYduAwm6l77//3qhbsjT740FPPfWUUXnIkCHw9PR86PY8Cm7cuIHffvsNfn5+Jvu4Vq1aCAsLU1xuz549CAwMNJpW1Ge0X79+8PPzwxdffGHU5bto0SL069cPvr6+hmnVq1fHhg0bMH/+fNy9e9cwffHixXj22WfLtI2Pm0qfJABAnz59ULt2bcPYhEOHDmH37t145ZVXHrpsfn4+vvzyS7Rr1w7Vq1eHWq2GRqPB66+/DqDwuuUHxcbG4oMPPkBKSgp2795d5gE//v7+JtOcnJwAAAEBAUbT9QPnMjMzy7QuJQ+uwxLrPnnyJAAgJCRE8f3g4GCj+Upiy5YtePbZZxEVFWUY2/HEE08AUN5/5vbglx9Q2GYl7d8F7m3vwoULjcYNaDQadO3aFe7u7rh58yaAwi/q27dvw8vLC97e3iZ1hYWFoX79+mXcGtOYlPZVcfvpweMHuHcM3f+l36dPH7z++uvYu3cvnnjiCVSrVg0jR47Enj17yh1fUTG+9NJLcHJyMvpjsHTpUjRv3hyRkZEmdZdkfzxIPwakIlWpUgWA8mdSP+3+JLy4+YtaRsnZs2cB3GvbB1WtWlVx+v79+9G/f3/UqVPH8BnVz/vgZ9TFxQVDhw7F9evXsWrVKgCF98j58ssvMWrUKKN5v/nmG4SHh2PMmDEIDAxEXFwcPvvsM6OEobJjkoDCfwj3n02YOnUqxo4dCw8Pj4cuO3ToULz88suIiYnBwYMHkZKSguTkZMybN6/Y5Tp06ACVSoU7d+6UapDVg3GX5b2SKMnNUYpaR3nXbUlfffUVnnrqKdy9exc///yzYf/dfy+NimbO9powYQKSk5ONXikpKcjIyDAMRtS7/wfXlpS0PVQqFT766CMkJSVhwYIFqF27Nj7//HO0bNkSAwcOrJDYAgMD0atXLxw7dgy7du0CUPgPdeTIkYrzl2Z/6Fni86P/F56UlGTynn7a/WdXiptfRHD16lU4OjqaXPnwIP2Nkoq6Z4jSjZQ2b96MFi1a4MiRI1i+fLlRWxZlxIgRsLOzw4IFCwAAP/zwA2rWrGlyI7xGjRrhr7/+wo4dO/DKK6/g1KlTGD16NKKiorBv375it6WyeHS+zSvYc889h6ioKBw+fBi7du3C6NGjH7pMamoqvv32W7i5uWHu3LlGp7GKk52djRdeeAGffPIJ1Go1Ro0ahfPnz5d3E8rE0dERAEz+tZblpkGWoP/iKupUvNIXXHE+++wzAMAHH3yAmjVrPrJ3e9Nv7/1XOtzv6NGjOHToEIDCf+p+fn7IyclR/Debnp5ulpHdxe0r/bSS7iclOp0OOp0OAQEBGDlyJH755RecO3cOTZs2xbJly7B9+/Yyx1dcjCNGjABQeJbgt99+w507d9CzZ0/FukuyP6whLi4OAPDnn3+avKefdn+3R4cOHYqc/8SJE8jKykLbtm0N3ydF0ScR165dU7zsXOm4W7RoEQoKCjBx4kTExMSUKIkKDw9H586dsXv3biQmJmLBggUmZxGAwjPBKpUKbdq0wccff4yLFy9i0aJFuHHjBt5+++2HrqcyYJLwP/efTXj99ddL1Aeo78dW+mEp7pKlsWPHonnz5hg1ahSWLFmC9PR0vPDCC8jPzy9b8OWgP9V68eJFo+kP+4KtSPpLufSJS35+PkaPHo1Lly6hU6dO0Gg02Lp1q8kd/nbt2oWUlBR07NgRQUFBRda3a9cuzJw5E8C9JOnBfVjeuzNaWp8+feDi4oK1a9eanCHIzc1F586dsWXLFgCF29q/f38AwOrVq03qGjhwIIYNG2Y0zc3NzSiR/PDDDx/a76//N6+0Dv20AQMGPGzTijR9+nSTLsFq1aoZtu327dvFLt+gQQPExsbi+PHjJv/qL168iAMHDiA6OtrQ9aTXtm1b1KlTB6tWrcLMmTPx8ssvm4xpKc3+sIahQ4fC1dUVy5cvN5qen5+PVatWITg42KhPPiwsDD169MAff/xh6DLQ09fx6quvPnS9/v7+aN++PdLS0rBt2zaj906dOqX4uSvrZ1R/bLzyyis4e/Ys+vTpo1j3/X+I7OzsMHz4cPj4+Dz0+Kk0rDtu0jruv7rhQQ+Octcr6uqG3r17CwAZO3as4fKnHTt2iI+Pj+KI9rVr10pUVJRkZGQYpr3++usCQCZNmqQYZ1FXNyhd5lXUHcuKGuGfmJgodnZ20qVLF8MleCtXrpQnnnjioVc3lHQdxV22p+TOnTvi4uIiTz/9tIiIbNq0SZycnAyXO/7yyy/i4uJicglkbGys4iWQixYtEgCycuVK0el08sILL0ivXr1E5N5I8w4dOsi1a9dEpPByrMaNGxfZ9jDz1Q1K6yiqjYtry/j4eMPli/oR3ElJSfLMM89IbGys0Yh8/SWQGo3GcAlkXl6efPjhh+Lh4SF//vmnUd3NmzeXwMBAycjIkOTkZKlSpYr89NNPhveVjketViudOnUyugRSq9XKxx9/XOwlkErHtdJ2T5kyRTw8PGTjxo2Gy5cvXLggTZo0keDg4BLdhfLw4cPi4+NT5CWQD47A19Pf+dLe3t7kEjy90uwPEfPdbbAkVzeIiCxevNhwWWN+fr5kZ2fLyJEjxcHBQX755ReT+S9evChBQUHy5JNPGj4rGzduFDc3N8VjuCiJiYni6ekpMTExcu7cOREp/Cy0bt1a/P39Tdpg3bp1AkDq169vuNtjSkqKdOnSpdjPov5qFAAyYcIExXkASL9+/eT69esicu8yYABGl0pWZpUuSYiKijIciGq12uRyuQcNHjxY1Gq14dKcB5dJT0+X8ePHS3h4uLi6ukr16tWlb9++8s477wgA8fLykqioKLl165ao1WpxdnYWd3d36datm4gUXt6kj8fOzk7UarX89ttvEhcXZ5ju4uIiarVatm7dKgsWLDDEo59/yZIlsnXrVlGr1YZLm9RqtcyYMUNOnz4tarVaXFxcBID4+/tL//79jbZx3bp10rBhQ/Hw8JDIyEiZNGmSJCQkCABxd3cXtVotp0+flnXr1pV4HcOHD5ecnBxRq9Xi7u4uAMTHx6fEP67Lli2TiIgI8ff3l5o1a8rSpUuN3j98+LD06dNHNBqNBAYGSmhoqIwYMULxuu/s7GwZNGiQBAYGikajkfbt2xvdWvbf//63NGjQQNzc3CQ4OFjatWtn+KLQt/2xY8cMxwIAcXR0NLR9UVJTU0WtVouXl5fhWFCr1ZKTkyP9+/c32b8nTpxQ3I+TJk2SEydOmLSlvv3vt2PHDunatav4+flJUFCQREVFyfjx440u+9JLT0+XiRMnSlRUlAQEBEhwcLD06NFDDhw4YDLvgQMHpFmzZuLn5ychISEyduxY0el0MmnSJJPj8f6Y8vLyZPbs2VK/fn0JCAgQf39/admypSxfvtyofqXj+quvvlI8hvSfv7Nnz8o777wjjRs3lqpVq4parZaIiAgZNWqU4jXyRTl37pwMGTJEgoODJTAwUIKCguTFF1+UkydPFrnM3bt3xc3NTZ555pli6y7J/lD6XKnVasOllyXVvHlzo+NN/9kNDg4ucpkNGzZIq1atxN/fXwICAqRz585G94Z40JUrV2Tw4MESFBQkAQEBUqdOHfn4449NLvN8mCNHjkjXrl3F09NTgoKCpEWLFvLLL78YEiW1Wm10X5dVq1ZJs2bNxNPTUzQajTzxxBOyfPlyo8/ixo0bTdbzwQcfiL29vck9aPS+/fZbefbZZ6VGjRqi0WikatWq0qpVK/nuu+9KtT2PM5XIQ55uRERE9Aj68MMPsXPnzhI97ZeUcUwCERE9FrKysgxXTogI/v3vfysOWKSSY5JARESPhf/7v//D2LFjARQ+xMrb29vk5lRUOkwSiIjosRAcHIzvv/8egYGB+Pzzz/Htt99aO6RHHsckEBERkSKeSSAiIiJFTBKIiIhIEZMEIiIiUsQkgYiIiBQxSSAiIiJFTBKIiIhIEZMEIiIiUsQkgYiIiBT9Py8mTx5j5LPrAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "bins_hist = 50\n", + "fig1 = plt.figure()\n", + "plt.rc('text', usetex=False)\n", + "plt.rc('font', family='serif', size=18.)\n", + "cax = plt.gca()\n", + "sideaxishist(cax)\n", + "cax.hist(sq_qoi, color=co[2], bins=bins_hist, histtype='stepfilled', alpha=0.5, label='total infections')\n", + "miny = min(cax.get_ylim())\n", + "maxy = max(cax.get_ylim())\n", + "cax.vlines(q_sv, miny, maxy, linestyle='--', linewidth=2.5, label='alpha-quantile', color=co[0])\n", + "cax.vlines(sq_sv, miny, maxy, linestyle='--', linewidth=2.5, label='alpha-superquantile', color=co[1])\n", + "cax.set_xlabel('Maximum total infections over 100 days', size=14)\n", + "cax.legend(loc='upper right', prop={'size': 14})" + ] + }, + { + "cell_type": "markdown", + "id": "2a4005a9", + "metadata": {}, + "source": [ + "## Risk-based optimization under uncertainty with intervention on $\\delta$\n", + "**NOTE:** This is a demonstration of the interface, optimization is not run to convergence nor are enough samples generated to accurately estimate the risk, so take the results with a grain of salt." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "ba6b2d82", + "metadata": {}, + "outputs": [], + "source": [ + "# Define problem specifics\n", + "RISK_BOUND = 1./3.\n", + "RISK_ALPHA = 0.95\n", + "X_MIN = 0.\n", + "X_MAX = 3.\n", + "N_SAMPLES = int(5e2)\n", + "MAXITER = 0\n", + "MAXFEVAL = 30\n", + "\n", + "INIT_GUESS = 0.005\n", + "\n", + "# Objective function\n", + "OBJFUN = lambda x: np.abs(beta_init-x)\n", + "\n", + "# Define the risk measure.\n", + "RISK = computeRisk(\n", + " model=control_model,\n", + " intervention_fun=INTERVENTION,\n", + " qoi=lambda y: max_total_infections_SIDARTHE(y, contexts=[\"I_total_obs\"]),\n", + " model_state=initial_state,\n", + " tspan=tspan,\n", + " risk_measure=lambda z: alpha_superquantile(z, alpha=RISK_ALPHA),\n", + " num_samples=N_SAMPLES,\n", + " guide=None,\n", + " )\n", + "\n", + "# Define problem constraints\n", + "CONSTRAINTS = (\n", + " # risk constraint\n", + " {'type': 'ineq', 'fun': lambda x: RISK_BOUND - RISK(x)},\n", + "\n", + " # bounds on control\n", + " # NOTE: perhaps use scipy.optimize.LinearConstraint in the future\n", + " {'type': 'ineq', 'fun': lambda x: x - X_MIN},\n", + " {'type': 'ineq', 'fun': lambda x: X_MAX - x}\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "13a9803a", + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Performing risk-based optimization under uncertainty (using alpha-superquantile)...\n", + "Estimated wait time 2917.1 seconds.\n" + ] + } + ], + "source": [ + "print(\"Performing risk-based optimization under uncertainty (using alpha-superquantile)...\")\n", + "print(f\"Estimated wait time {time_per_eval*N_SAMPLES*(MAXITER+1)*MAXFEVAL:.1f} seconds.\")\n", + "start_time = time.time()\n", + "sq_result_1 = solveOUU(\n", + " x0=INIT_GUESS,\n", + " objfun=OBJFUN,\n", + " constraints=CONSTRAINTS,\n", + " maxiter=MAXITER,\n", + " maxfeval=MAXFEVAL,\n", + " ).solve()\n", + "print(f\"Optimization completed in time {time.time()-start_time:.2f} seconds. Optimal solution:\\t{sq_result_1.x}\")" + ] + }, + { + "cell_type": "markdown", + "id": "abfeda8c", + "metadata": {}, + "source": [ + "## Assess the effect of the control policy." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "60c9d1a9", + "metadata": { + "scrolled": false + }, + "outputs": [], + "source": [ + "RISK.num_samples = int(5e2)\n", + "sq_optimal_prediction = RISK.propagate_uncertainty(sq_result_1.x)\n", + "qois_sq = RISK.qoi(sq_optimal_prediction)\n", + "sq_est = RISK.risk_measure(qois_sq)\n", + "print('Estimated risk at optimal policy', sq_est)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c92e52b7", + "metadata": {}, + "outputs": [], + "source": [ + "ax = setup_ax()\n", + "# print(sq_optimal_prediction.shape)\n", + "ax = plot_predictive(sq_optimal_prediction, tspan, ax=ax, color=co[2], ptiles=[0.0,1.])\n", + "plt.title(\"Optimal beta parameter intervention \\n with risk-based OUU\", size=14)\n", + "sideaxis(ax)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "13bf129e", + "metadata": {}, + "outputs": [], + "source": [ + "bins_hist = 50\n", + "fig1 = plt.figure()\n", + "plt.rc('font', family='serif', size=14.)\n", + "cax = plt.gca()\n", + "sideaxishist(cax)\n", + "cax.hist(qois_sq, color=co[4], bins=bins_hist, histtype='stepfilled', alpha=0.5, density=True)\n", + "miny = min(cax.get_ylim())\n", + "maxy = max(cax.get_ylim())\n", + "cax.set_xlabel('Maximum total infections over 100 days', size=14)" + ] + } + ], + "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.9.7" + }, + "vscode": { + "interpreter": { + "hash": "a3e1d8fdda916c248c87d86618e3945b28961cf939001a0529e724463670a41a" + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/6-month-milestone/evaluation/scenario_2/ta_3/ciemss/scenario2_q2b_SIDARTHEV_delta.ipynb b/6-month-milestone/evaluation/scenario_2/ta_3/ciemss/scenario2_q2b_SIDARTHEV_delta.ipynb new file mode 100644 index 0000000..37d2bfa --- /dev/null +++ b/6-month-milestone/evaluation/scenario_2/ta_3/ciemss/scenario2_q2b_SIDARTHEV_delta.ipynb @@ -0,0 +1,802 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "b087c52b-a505-45d3-b643-df44d8c924a5", + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "markdown", + "id": "542b06c1-28fb-47ec-9a34-170acc7d2a84", + "metadata": {}, + "source": [ + "# Load Dependencies" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "84e0bb12-68af-4a6d-a384-db4837c44ac0", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "import torch\n", + "\n", + "import pyro\n", + "import numpy as np\n", + "import pyro.distributions as dist\n", + "# from pyro.poutine import trace, replay, block\n", + "# from pyro.infer.autoguide.guides import AutoDelta, AutoNormal\n", + "# from pyro.infer import SVI, Trace_ELBO, Predictive\n", + "\n", + "import sys\n", + "sys.path.append(\"../../src/\")\n", + "\n", + "from pyciemss.ODE.askem_primitives import sample, infer_parameters, intervene, optimization\n", + "\n", + "# from pyciemss.utils import run_inference, get_tspan\n", + "from pyciemss.utils import get_tspan\n", + "\n", + "import warnings\n", + "warnings.filterwarnings('ignore')" + ] + }, + { + "cell_type": "markdown", + "id": "4855961d-9c38-4050-b6b7-aaae03500fc9", + "metadata": {}, + "source": [ + "# Plotting Utilities" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "260901d9", + "metadata": {}, + "outputs": [], + "source": [ + "def setup_ax(ax=None):\n", + "\n", + " if not ax:\n", + " fig = plt.figure(facecolor='w', figsize=(9, 5))\n", + " ax = fig.add_subplot(111, axisbelow=True)\n", + "\n", + " ax.set_xlabel('Time (days)')\n", + " ax.set_ylabel('Total infected')\n", + " return ax\n", + "\n", + "def plot_predictive(prediction, tspan, tmin=None, ax=None, alpha=0.2, color=\"black\", ptiles=[0.05,0.95], **kwargs):\n", + " vars = [\"I_total_obs\"]\n", + " #infection_total = sum([prediction[x].squeeze().detach().numpy()/1000. for x in ['I_obs', 'D_obs', 'A_obs', 'R_obs', 'T_obs']])\n", + "\n", + " I_low = torch.quantile(prediction[\"I_total_obs\"], ptiles[0], dim=0).detach().numpy()\n", + " I_up = torch.quantile(prediction[\"I_total_obs\"], ptiles[1], dim=0).detach().numpy()\n", + "\n", + " if tmin:\n", + " indeces = tspan >= tmin\n", + " else:\n", + " indeces = torch.ones_like(tspan).bool()\n", + "\n", + " if not ax:\n", + " fig = plt.figure(facecolor='w')\n", + " ax = fig.add_subplot(111, facecolor='#dddddd', axisbelow=True)\n", + " \n", + " ax.fill_between(tspan[indeces], I_low[indeces], I_up[indeces], alpha=alpha, color=color, **kwargs)\n", + "\n", + " legend = ax.legend()\n", + " legend.get_frame().set_alpha(0.5)\n", + "\n", + " return ax\n", + "\n", + "def plot_trajectory(data, tspan, ax=None, color='black', alpha=0.5, lw=0, marker='.', label=None, ind=0):\n", + " # Plot the data on three separate curves for S(t), I(t) and R(t)\n", + " if len(data['I_total_obs'].squeeze().detach().numpy().shape)>1:\n", + " plot_data = data['I_total_obs'].squeeze().detach().numpy()[ind,:]\n", + " else:\n", + " plot_data = data['I_total_obs'].squeeze().detach().numpy()\n", + "\n", + " if not ax:\n", + " fig = plt.figure(facecolor='w')\n", + " ax = fig.add_subplot(111, facecolor='#dddddd', axisbelow=True)\n", + " #infection_total = sum([data[x].squeeze().detach().numpy()/1000. for x in ['I_obs', 'D_obs', 'A_obs', 'R_obs', 'T_obs']])\n", + " ax.plot(tspan, plot_data, color, alpha=alpha, lw=lw, marker=marker, label=label)\n", + " \n", + " return ax\n", + "\n", + "def plot_intervention_line(t, ax=None):\n", + " if not ax:\n", + " fig = plt.figure(facecolor='w')\n", + " ax = fig.add_subplot(111, facecolor='#dddddd', axisbelow=True)\n", + "\n", + " ylim = ax.get_ylim()\n", + "\n", + " ax.vlines(t, min(ylim), max(ylim), color=\"grey\", ls='-')\n", + "\n", + " return ax\n", + "\n", + "def sideaxis(ax):\n", + " ax.spines['top'].set_visible(False)\n", + " ax.spines['right'].set_visible(False)\n", + " return\n", + "\n", + "def sideaxishist(ax):\n", + " ax.spines['top'].set_visible(False)\n", + " ax.spines['right'].set_visible(False)\n", + " ax.spines['left'].set_visible(False)\n", + " # For y-axis\n", + " ax.yaxis.set_major_locator(ticker.NullLocator())\n", + " ax.tick_params(axis='x', labelsize=12) # change fontsize for x-axis tick labels\n", + " # ax.xaxis.major.formatter._useMathText = True\n", + " return" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "f233104e-c29d-4e25-859f-2a328ec7892a", + "metadata": {}, + "outputs": [], + "source": [ + "def LogNormalPrior(mean, variance):\n", + " mu = torch.log(mean**2/torch.sqrt((mean**2 + variance)))\n", + " scale = torch.sqrt(torch.log(1 + variance/mean**2))\n", + " return dist.LogNormal(mu, scale)\n", + "\n", + "def LogNormalPrior_propVar(mean, cov=0.05):\n", + " variance = mean*cov \n", + " return LogNormalPrior(mean, variance)" + ] + }, + { + "cell_type": "markdown", + "id": "3e0c3726-5ec0-475d-8305-f20b5d84e424", + "metadata": {}, + "source": [ + "# Setup Parameters" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "16608500-97b5-4081-9e6b-b7c193c10285", + "metadata": {}, + "outputs": [], + "source": [ + "tspan = get_tspan(1, 100, 100)\n", + "\n", + "num_samples = 50\n", + "\n", + "# Total population, N.\n", + "N = 1\n", + "# Initial number of infected and recovered individuals, I0 and R0.\n", + "I0, D0, A0, R0, T0, H0, E0, V0 = 200/60e6, 20/60e6, 1/60e6, 2/60e6, 0, 0, 0, 0\n", + "\n", + "# Everyone else, S0, is susceptible to infection initially.\n", + "S0 = N - I0 - D0 - A0 - R0 - T0 - H0 - E0 - V0\n", + "\n", + "initial_state = tuple(torch.as_tensor(s) for s in (S0, I0, D0, A0, R0, T0, H0, E0, V0))" + ] + }, + { + "cell_type": "markdown", + "id": "23fc9c9d-f8bc-4e95-a243-865690d3b43b", + "metadata": {}, + "source": [ + "# Probabilistic Forecasting - Passing unit test 1\n", + "There are two ‘unit tests’ we want to pass, to ensure that we understood and can reproduce the published model:\n", + "\n", + "## 1.a Unit Test \\#1:\n", + "\n", + "Set the initial values and parameters, as described in the Supplementary Methods section of the publication (pg. 9 of the pdf): \n", + "\n", + "1. Initial Values: \n", + "* $I = 200/60e6$,\n", + "* $D = 20/60e6$, \n", + "* $A = 1/60e6$, \n", + "* $R = 2/60e6$, \n", + "* $T = 0$, \n", + "* $H = 0$, \n", + "* $E = 0$; \n", + "* $S = 1 – I – D – A – R – T – H – E$. \n", + "\n", + "Let total population = 60e6.\n", + "Parameters: $$\\alpha = 0.570, \\beta = \\delta = 0.011, \\gamma = 0.456, \\epsilon = 0.171, \\theta = 0.371, \\zeta = \\eta = 0.125, \\mu = 0.017, \\nu = 0.027, \\tau = 0.01, \\lambda = \\rho = 0.034$$ and $$\\kappa = \\xi = \\sigma = 0.017$$." + ] + }, + { + "cell_type": "markdown", + "id": "f6228f01", + "metadata": {}, + "source": [ + "### Deterministic forecasting" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "dbd7d430-325f-4f40-9b20-d8a0c0264f62", + "metadata": {}, + "outputs": [], + "source": [ + "from pyciemss.ODE.models import SIDARTHEV\n", + "\n", + "pyro.set_rng_seed(0)\n", + "\n", + "ode_model = SIDARTHEV(N=1,\n", + " alpha_prior=dist.Delta(torch.tensor (0.570)) ,\n", + " beta_prior=dist.Delta(torch.tensor (0.011)) ,\n", + " gamma_prior=dist.Delta(torch.tensor (0.456)) ,\n", + " delta_prior=dist.Delta(torch.tensor (0.011)) ,\n", + " epsilon_prior=dist.Delta(torch.tensor (0.171)) ,\n", + " lamb_prior =dist.Delta(torch.tensor (0.034)) ,\n", + " zeta_prior=dist.Delta(torch.tensor (0.125)) ,\n", + " eta_prior=dist.Delta(torch.tensor (0.125)) ,\n", + " kappa_prior=dist.Delta(torch.tensor (0.017)) ,\n", + " theta_prior=dist.Delta(torch.tensor (0.371)) ,\n", + " rho_prior=dist.Delta(torch.tensor (0.034)) ,\n", + " xi_prior=dist.Delta(torch.tensor (0.017)) ,\n", + " sigma_prior=dist.Delta(torch.tensor (0.017)) ,\n", + " mu_prior=dist.Delta(torch.tensor (0.017)) ,\n", + " nu_prior=dist.Delta(torch.tensor (0.027)) ,\n", + " tau2_prior=dist.Delta(torch.tensor (0.01)) ,\n", + " phi_prior=dist.Delta(torch.tensor (0.)) )" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "31473cdd-9896-42ed-b487-36362c1c9744", + "metadata": { + "scrolled": false + }, + "outputs": [], + "source": [ + "single_prediction = sample(ode_model, 1, initial_state, tspan)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "15f03c6f-d085-4f36-bc7a-312057d82758", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ax = plot_trajectory(single_prediction, tspan, ax=setup_ax(), color=\"blue\", marker='', lw=1., label=\"Before Seeing Data - Single Forecast\")\n", + "ax.axvline(47)" + ] + }, + { + "cell_type": "markdown", + "id": "7c9b53f3", + "metadata": {}, + "source": [ + "### Probabilistic forecasting" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "a8cebc75-730c-43f8-9081-ba846098f669", + "metadata": {}, + "outputs": [], + "source": [ + "pyro.set_rng_seed(0)\n", + "\n", + "# var_prior = 0.05**2\n", + "mean_values = np.array([])\n", + "\n", + "ode_model = SIDARTHEV(N=1,\n", + " alpha_prior=LogNormalPrior_propVar(torch.tensor(0.570)) ,\n", + " beta_prior=LogNormalPrior_propVar(torch.tensor(0.011)) ,\n", + " gamma_prior=LogNormalPrior_propVar(torch.tensor(0.456)) ,\n", + " delta_prior=LogNormalPrior_propVar(torch.tensor(0.011)) ,\n", + " epsilon_prior=LogNormalPrior_propVar(torch.tensor(0.171)) ,\n", + " lamb_prior =LogNormalPrior_propVar(torch.tensor(0.034)) ,\n", + " zeta_prior=LogNormalPrior_propVar(torch.tensor(0.125)) ,\n", + " eta_prior=LogNormalPrior_propVar(torch.tensor(0.125)) ,\n", + " kappa_prior=LogNormalPrior_propVar(torch.tensor(0.017)) ,\n", + " theta_prior=LogNormalPrior_propVar(torch.tensor(0.371)) ,\n", + " rho_prior=LogNormalPrior_propVar(torch.tensor(0.034)) ,\n", + " xi_prior=LogNormalPrior_propVar(torch.tensor(0.017)) ,\n", + " sigma_prior=LogNormalPrior_propVar(torch.tensor(0.017)) ,\n", + " mu_prior=LogNormalPrior_propVar(torch.tensor(0.017)) ,\n", + " nu_prior=LogNormalPrior_propVar(torch.tensor(0.027)) ,\n", + " tau2_prior=LogNormalPrior_propVar(torch.tensor(0.01)) ,\n", + " phi_prior=dist.Delta(torch.tensor (0.)) )\n", + "\n", + "# interventions = {\"alpha\": SI_alpha_intervention,\n", + "# \"beta\": SD_beta_intervention,\n", + "# \"gamma\": SA_gamma_intervention,\n", + "# \"delta\": SR_delta_intervention,\n", + "# \"epsilon\": ID_epsilon_intervention,\n", + "# \"lambda\": IH_lamb_intervention,\n", + "# \"zeta\": IA_zeta_intervention,\n", + "# \"eta\": DR_eta_intervention,\n", + "# \"kappa\": AH_kappa_intervention,\n", + "# # \"theta\": AR_theta_intervention,\n", + "# \"rho\": DH_rho_intervention,\n", + "# \"xi\": RH_xi_intervention,\n", + "# \"sigma\": TH_sigma_intervention,\n", + "# \"mu\": AT_mu_intervention,\n", + "# \"nu\": RT_nu_intervention}" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "795ecb3a", + "metadata": {}, + "outputs": [], + "source": [ + "prior_prediction = sample(ode_model, num_samples, initial_state, tspan)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "f62475f8", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ax1 = plot_predictive(prior_prediction, tspan, ax=setup_ax(), label=\"probabilistic forecast\", color=\"red\")\n", + "ax1.axvline(30)\n", + "sideaxis(ax1)" + ] + }, + { + "cell_type": "markdown", + "id": "c65bcf10-9d12-4efe-be10-cc313e123d14", + "metadata": {}, + "source": [ + "## 1.d Policies that prevent infections from exceeding 1/3 of the population\n", + "\n", + "Now return to the situation in b.i (constant parameters that don’t change over time). Let’s say we want to increase testing, diagnostics, and contact tracing efforts (implemented by increasing the detection parameters and ). Assume that $\\theta \\ge 2\\epsilon$ , because a symptomatic person is more likely to be tested. What minimum constant values do these parameters need to be over the course of a 100-day simulation, to ensure that the total infected population (sum over all the infected states I, D, A, R, T) never rises above 1/3 of the total population?\n", + "\n", + "\n", + "### Problem Formulation\n", + "* **Quantity of interest**: Total infections out of $N=60,000,000$ population\n", + "$$I_{total}(t; \\mathbf{u}, \\mathbf{Z}) = I(t) + D(t) + A(t) + R(t) + T(t)$$\n", + "\n", + "A conservative estimate for the quantity of interest is\n", + "$$M(u, Z) = \\max_{1\\leq t \\leq 100} I_{total}(t; \\mathbf{u}, \\mathbf{Z})/N$$\n", + "\n", + "\n", + "\n", + "\n", + "* **Control**: $\\mathbf{u}\\in \\mathcal{U} \\subseteq \\mathbb{R}^{n_u}$\n", + " * Detection parameter for Infected ($\\epsilon$) assuming that $\\theta=2\\epsilon$\n", + " * Two detection parameters $\\theta, \\epsilon$, constraining $\\theta \\ge 2\\epsilon$.\n", + " \n", + "\n", + "\n", + "* **Risk-based optimization under uncertainty problem formulation**\n", + " * Objective Function - Minimize the magnitude of the parameter interventions.\n", + " * Constraint - Risk of normalized total infections exceeding the prescribed threshold of $1/3$, $\\mathcal{R}( M(\\mathbf{u},\\mathbf{Z}))$, is below the acceptable risk threshold, $\\mathcal{R}_\\text{threshold}$.\n", + "\n", + "\\begin{equation} \n", + "\\begin{split} \n", + "\\mathbf{u}^*= \\underset{\\mathbf{u}\\in\\mathcal{U}}{\\arg\\min}\\ & \\lVert \\mathbf{u} \\rVert_1 \\\\ \\text{s.t.}\\ & \\mathcal{R}( M(\\mathbf{u}, \\theta)) \\le \\mathcal{R}_\\text{threshold} \n", + "\\end{split} \n", + "\\end{equation}\n", + "\n", + "#### Formulation 1: Optimize $u=\\{\\alpha, \\beta, \\gamma, \\delta\\}$\n", + "\\begin{equation} \n", + "\\begin{split} \n", + "u^*= \\underset{\\epsilon\\in\\mathcal{U}}{\\arg\\min}\\ & u\\\\ \\text{s.t.}\\ & \\mathbb{P}( M(u, \\mathbf{Z}) \\ge 1/3) \\le 0.05\n", + "\\end{split} \n", + "\\end{equation}\n", + "\n", + "#### Formulation 2: Optimize $\\epsilon$ and $\\theta$ constraining $\\theta \\ge 2\\epsilon$\n", + "\\begin{equation} \n", + "\\begin{split} \n", + "\\epsilon^\\ast, \\theta^\\ast= \\underset{\\{\\epsilon,\\theta\\}\\in\\mathcal{U}}{\\arg\\min}\\ & \\theta + \\epsilon \\\\ \\text{s.t.}\\ & \\mathbb{P}( M(\\epsilon,\\theta, \\mathbf{Z}) \\ge 1/3) \\le 0.05, \\\\\n", + "& \\theta \\ge 2\\epsilon\n", + "\\end{split} \n", + "\\end{equation}\n", + "\n", + "Instead of probability of exceedance, we will use superquantiles as risk measures." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "97ab7988", + "metadata": {}, + "outputs": [], + "source": [ + "from causal_pyro.query.do_messenger import do\n", + "import time\n", + "import pickle\n", + "\n", + "import numpy as np\n", + "from scipy import stats\n", + "from matplotlib import ticker\n", + "\n", + "from pyciemss.ODE.interventions import parameter_intervention_builder, time_and_state_dependent_intervention_builder, time_dependent_intervention_builder\n", + "from pyciemss.risk.risk_measures import alpha_quantile, alpha_superquantile\n", + "from pyciemss.risk.ouu import computeRisk, solveOUU\n", + "from pyciemss.risk.qoi import max_total_infections_SIDARTHE\n", + "import scipy\n", + "\n", + "\n", + "co = ['#377eb8', '#ff7f00', '#984ea3', '#ffd92f', '#a65628']\n", + "rlabel = ['Q_alpha-based OUU', 'barQ_alpha-based OUU']" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "161b391b", + "metadata": {}, + "outputs": [], + "source": [ + "def delayed_intervention_controller(name, x, init_value):\n", + " def delayed_intervention(t, flux):\n", + " if t<15:\n", + " return flux\n", + " else:\n", + " return flux/init_value*x\n", + " return time_and_state_dependent_intervention_builder(name, delayed_intervention, tspan) \n", + "\n", + "def delayed_intervention_controller_flux(name, x):\n", + " def delayed_intervention(t):\n", + " if t<15:\n", + " return torch.tensor(0.)\n", + " else:\n", + " return x\n", + " return time_dependent_intervention_builder(name, delayed_intervention, tspan) " + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "12a672fa", + "metadata": {}, + "outputs": [], + "source": [ + "delta_init = 0.011\n", + "# Control action / intervention\n", + "param_intervention = parameter_intervention_builder(\"delta\", delta_init)\n", + "control_model = intervene(ode_model,param_intervention)\n", + "\n", + "INTERVENTION = lambda x: delayed_intervention_controller(\"SR_flux\", torch.from_numpy(np.array([x])), delta_init)" + ] + }, + { + "cell_type": "markdown", + "id": "5fb87509", + "metadata": {}, + "source": [ + "## Exploring the intervention and difference between Quantiles and Superquantiles" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "35ebe5d7", + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Forward UQ took 9.72 seconds total (1.94e-01 seconds per model evaluation).\n", + "0.8429393768310547 0.9140260457992553\n" + ] + } + ], + "source": [ + "pyro.set_rng_seed(0)\n", + "\n", + "POLICY = np.array([0.0])\n", + "N_SAMPLES = 50\n", + "\n", + "RISK = computeRisk(model=control_model,\n", + " intervention_fun=INTERVENTION,\n", + " qoi=lambda y: max_total_infections_SIDARTHE(y, contexts=[\"I_total_obs\"]),\n", + " risk_measure=alpha_superquantile,\n", + " num_samples=N_SAMPLES,\n", + " model_state=initial_state,\n", + " tspan=tspan,\n", + " guide=None)\n", + "\n", + "start_time = time.time()\n", + "sq_dataCube = RISK.propagate_uncertainty(POLICY)\n", + "end_time = time.time()\n", + "forward_time = end_time - start_time\n", + "time_per_eval = forward_time / N_SAMPLES\n", + "print(f\"Forward UQ took {forward_time:.2f} seconds total ({forward_time/N_SAMPLES:.2e} seconds per model evaluation).\")\n", + "sq_qoi = RISK.qoi(sq_dataCube)\n", + "sq_sv = RISK.risk_measure(sq_qoi)\n", + "\n", + "RISK.risk_measure = alpha_quantile\n", + "q_sv = RISK(POLICY)\n", + "print(q_sv, sq_sv)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "b74d9c82", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "No artists with labels found to put in legend. Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ax = setup_ax()\n", + "ax = plot_predictive(sq_dataCube, tspan, ax=ax, color=co[1])\n", + "ax.axvline(15)\n", + "sideaxis(ax)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "7fc330e1", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "bins_hist = 50\n", + "fig1 = plt.figure()\n", + "plt.rc('text', usetex=False)\n", + "plt.rc('font', family='serif', size=18.)\n", + "cax = plt.gca()\n", + "sideaxishist(cax)\n", + "cax.hist(sq_qoi, color=co[2], bins=bins_hist, histtype='stepfilled', alpha=0.5, label='total infections')\n", + "miny = min(cax.get_ylim())\n", + "maxy = max(cax.get_ylim())\n", + "cax.vlines(q_sv, miny, maxy, linestyle='--', linewidth=2.5, label='alpha-quantile', color=co[0])\n", + "cax.vlines(sq_sv, miny, maxy, linestyle='--', linewidth=2.5, label='alpha-superquantile', color=co[1])\n", + "cax.set_xlabel('Maximum total infections over 100 days', size=14)\n", + "cax.legend(loc='upper right', prop={'size': 14})" + ] + }, + { + "cell_type": "markdown", + "id": "2a4005a9", + "metadata": {}, + "source": [ + "## Risk-based optimization under uncertainty with intervention on $\\delta$\n", + "**NOTE:** This is a demonstration of the interface, optimization is not run to convergence nor are enough samples generated to accurately estimate the risk, so take the results with a grain of salt." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "ba6b2d82", + "metadata": {}, + "outputs": [], + "source": [ + "# Define problem specifics\n", + "RISK_BOUND = 1./3.\n", + "RISK_ALPHA = 0.95\n", + "X_MIN = 0.\n", + "X_MAX = 2.\n", + "N_SAMPLES = int(5e2)\n", + "MAXITER = 0\n", + "MAXFEVAL = 30\n", + "\n", + "INIT_GUESS = 0.005\n", + "\n", + "# Objective function\n", + "OBJFUN = lambda x: np.abs(delta_init-x)\n", + "\n", + "# Define the risk measure.\n", + "RISK = computeRisk(\n", + " model=control_model,\n", + " intervention_fun=INTERVENTION,\n", + " qoi=lambda y: max_total_infections_SIDARTHE(y, contexts=[\"I_total_obs\"]),\n", + " model_state=initial_state,\n", + " tspan=tspan,\n", + " risk_measure=lambda z: alpha_superquantile(z, alpha=RISK_ALPHA),\n", + " num_samples=N_SAMPLES,\n", + " guide=None,\n", + " )\n", + "\n", + "# Define problem constraints\n", + "CONSTRAINTS = (\n", + " # risk constraint\n", + " {'type': 'ineq', 'fun': lambda x: RISK_BOUND - RISK(x)},\n", + "\n", + " # bounds on control\n", + " # NOTE: perhaps use scipy.optimize.LinearConstraint in the future\n", + " {'type': 'ineq', 'fun': lambda x: x - X_MIN},\n", + " {'type': 'ineq', 'fun': lambda x: X_MAX - x}\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "13a9803a", + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Performing risk-based optimization under uncertainty (using alpha-superquantile)...\n", + "Estimated wait time 2917.1 seconds.\n" + ] + } + ], + "source": [ + "print(\"Performing risk-based optimization under uncertainty (using alpha-superquantile)...\")\n", + "print(f\"Estimated wait time {time_per_eval*N_SAMPLES*(MAXITER+1)*MAXFEVAL:.1f} seconds.\")\n", + "start_time = time.time()\n", + "sq_result_1 = solveOUU(\n", + " x0=INIT_GUESS,\n", + " objfun=OBJFUN,\n", + " constraints=CONSTRAINTS,\n", + " maxiter=MAXITER,\n", + " maxfeval=MAXFEVAL,\n", + " ).solve()\n", + "print(f\"Optimization completed in time {time.time()-start_time:.2f} seconds. Optimal solution:\\t{sq_result_1.x}\")" + ] + }, + { + "cell_type": "markdown", + "id": "abfeda8c", + "metadata": {}, + "source": [ + "## Assess the effect of the control policy." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "60c9d1a9", + "metadata": { + "scrolled": false + }, + "outputs": [], + "source": [ + "RISK.num_samples = int(5e2)\n", + "sq_optimal_prediction = RISK.propagate_uncertainty(sq_result_1.x)\n", + "qois_sq = RISK.qoi(sq_optimal_prediction)\n", + "sq_est = RISK.risk_measure(qois_sq)\n", + "print('Estimated risk at optimal policy', sq_est)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c92e52b7", + "metadata": {}, + "outputs": [], + "source": [ + "ax = setup_ax()\n", + "# print(sq_optimal_prediction.shape)\n", + "ax = plot_predictive(sq_optimal_prediction, tspan, ax=ax, color=co[2], ptiles=[0.0,1.])\n", + "plt.title(\"Optimal delta parameter intervention \\n with risk-based OUU\", size=14)\n", + "sideaxis(ax)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "13bf129e", + "metadata": {}, + "outputs": [], + "source": [ + "bins_hist = 50\n", + "fig1 = plt.figure()\n", + "plt.rc('font', family='serif', size=14.)\n", + "cax = plt.gca()\n", + "sideaxishist(cax)\n", + "cax.hist(qois_sq, color=co[4], bins=bins_hist, histtype='stepfilled', alpha=0.5, density=True)\n", + "miny = min(cax.get_ylim())\n", + "maxy = max(cax.get_ylim())\n", + "cax.set_xlabel('Maximum total infections over 100 days', size=14)" + ] + } + ], + "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.9.7" + }, + "vscode": { + "interpreter": { + "hash": "a3e1d8fdda916c248c87d86618e3945b28961cf939001a0529e724463670a41a" + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/6-month-milestone/evaluation/scenario_2/ta_3/ciemss/scenario2_q2b_SIDARTHEV_phiflux.ipynb b/6-month-milestone/evaluation/scenario_2/ta_3/ciemss/scenario2_q2b_SIDARTHEV_phiflux.ipynb new file mode 100644 index 0000000..9085fab --- /dev/null +++ b/6-month-milestone/evaluation/scenario_2/ta_3/ciemss/scenario2_q2b_SIDARTHEV_phiflux.ipynb @@ -0,0 +1,830 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "b087c52b-a505-45d3-b643-df44d8c924a5", + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "markdown", + "id": "542b06c1-28fb-47ec-9a34-170acc7d2a84", + "metadata": {}, + "source": [ + "# Load Dependencies" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "84e0bb12-68af-4a6d-a384-db4837c44ac0", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "import torch\n", + "\n", + "import pyro\n", + "import numpy as np\n", + "import pyro.distributions as dist\n", + "# from pyro.poutine import trace, replay, block\n", + "# from pyro.infer.autoguide.guides import AutoDelta, AutoNormal\n", + "# from pyro.infer import SVI, Trace_ELBO, Predictive\n", + "\n", + "import sys\n", + "sys.path.append(\"../../src/\")\n", + "\n", + "from pyciemss.ODE.askem_primitives import sample, infer_parameters, intervene, optimization\n", + "\n", + "# from pyciemss.utils import run_inference, get_tspan\n", + "from pyciemss.utils import get_tspan\n", + "\n", + "import warnings\n", + "warnings.filterwarnings('ignore')" + ] + }, + { + "cell_type": "markdown", + "id": "4855961d-9c38-4050-b6b7-aaae03500fc9", + "metadata": {}, + "source": [ + "# Plotting Utilities" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "260901d9", + "metadata": {}, + "outputs": [], + "source": [ + "def setup_ax(ax=None):\n", + "\n", + " if not ax:\n", + " fig = plt.figure(facecolor='w', figsize=(9, 5))\n", + " ax = fig.add_subplot(111, axisbelow=True)\n", + "\n", + " ax.set_xlabel('Time (days)')\n", + " ax.set_ylabel('Total infected')\n", + " return ax\n", + "\n", + "def plot_predictive(prediction, tspan, tmin=None, ax=None, alpha=0.2, color=\"black\", ptiles=[0.05,0.95], **kwargs):\n", + " vars = [\"I_total_obs\"]\n", + " #infection_total = sum([prediction[x].squeeze().detach().numpy()/1000. for x in ['I_obs', 'D_obs', 'A_obs', 'R_obs', 'T_obs']])\n", + "\n", + " I_low = torch.quantile(prediction[\"I_total_obs\"], ptiles[0], dim=0).detach().numpy()\n", + " I_up = torch.quantile(prediction[\"I_total_obs\"], ptiles[1], dim=0).detach().numpy()\n", + "\n", + " if tmin:\n", + " indeces = tspan >= tmin\n", + " else:\n", + " indeces = torch.ones_like(tspan).bool()\n", + "\n", + " if not ax:\n", + " fig = plt.figure(facecolor='w')\n", + " ax = fig.add_subplot(111, facecolor='#dddddd', axisbelow=True)\n", + " \n", + " ax.fill_between(tspan[indeces], I_low[indeces], I_up[indeces], alpha=alpha, color=color, **kwargs)\n", + "\n", + " legend = ax.legend()\n", + " legend.get_frame().set_alpha(0.5)\n", + "\n", + " return ax\n", + "\n", + "def plot_trajectory(data, tspan, ax=None, color='black', alpha=0.5, lw=0, marker='.', label=None, ind=0):\n", + " # Plot the data on three separate curves for S(t), I(t) and R(t)\n", + " if len(data['I_total_obs'].squeeze().detach().numpy().shape)>1:\n", + " plot_data = data['I_total_obs'].squeeze().detach().numpy()[ind,:]\n", + " else:\n", + " plot_data = data['I_total_obs'].squeeze().detach().numpy()\n", + "\n", + " if not ax:\n", + " fig = plt.figure(facecolor='w')\n", + " ax = fig.add_subplot(111, facecolor='#dddddd', axisbelow=True)\n", + " #infection_total = sum([data[x].squeeze().detach().numpy()/1000. for x in ['I_obs', 'D_obs', 'A_obs', 'R_obs', 'T_obs']])\n", + " ax.plot(tspan, plot_data, color, alpha=alpha, lw=lw, marker=marker, label=label)\n", + " \n", + " return ax\n", + "\n", + "def plot_intervention_line(t, ax=None):\n", + " if not ax:\n", + " fig = plt.figure(facecolor='w')\n", + " ax = fig.add_subplot(111, facecolor='#dddddd', axisbelow=True)\n", + "\n", + " ylim = ax.get_ylim()\n", + "\n", + " ax.vlines(t, min(ylim), max(ylim), color=\"grey\", ls='-')\n", + "\n", + " return ax\n", + "\n", + "def sideaxis(ax):\n", + " ax.spines['top'].set_visible(False)\n", + " ax.spines['right'].set_visible(False)\n", + " return\n", + "\n", + "def sideaxishist(ax):\n", + " ax.spines['top'].set_visible(False)\n", + " ax.spines['right'].set_visible(False)\n", + " ax.spines['left'].set_visible(False)\n", + " # For y-axis\n", + " ax.yaxis.set_major_locator(ticker.NullLocator())\n", + " ax.tick_params(axis='x', labelsize=12) # change fontsize for x-axis tick labels\n", + " # ax.xaxis.major.formatter._useMathText = True\n", + " return" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "f233104e-c29d-4e25-859f-2a328ec7892a", + "metadata": {}, + "outputs": [], + "source": [ + "def LogNormalPrior(mean, variance):\n", + " mu = torch.log(mean**2/torch.sqrt((mean**2 + variance)))\n", + " scale = torch.sqrt(torch.log(1 + variance/mean**2))\n", + " return dist.LogNormal(mu, scale)\n", + "\n", + "def LogNormalPrior_propVar(mean, cov=0.05):\n", + " variance = mean*cov \n", + " return LogNormalPrior(mean, variance)" + ] + }, + { + "cell_type": "markdown", + "id": "3e0c3726-5ec0-475d-8305-f20b5d84e424", + "metadata": {}, + "source": [ + "# Setup Parameters" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "16608500-97b5-4081-9e6b-b7c193c10285", + "metadata": {}, + "outputs": [], + "source": [ + "tspan = get_tspan(1, 100, 100)\n", + "\n", + "num_samples = 50\n", + "\n", + "# Total population, N.\n", + "N = 1\n", + "# Initial number of infected and recovered individuals, I0 and R0.\n", + "I0, D0, A0, R0, T0, H0, E0, V0 = 200/60e6, 20/60e6, 1/60e6, 2/60e6, 0, 0, 0, 0\n", + "\n", + "# Everyone else, S0, is susceptible to infection initially.\n", + "S0 = N - I0 - D0 - A0 - R0 - T0 - H0 - E0 - V0\n", + "\n", + "initial_state = tuple(torch.as_tensor(s) for s in (S0, I0, D0, A0, R0, T0, H0, E0, V0))" + ] + }, + { + "cell_type": "markdown", + "id": "23fc9c9d-f8bc-4e95-a243-865690d3b43b", + "metadata": {}, + "source": [ + "# Probabilistic Forecasting - Passing unit test 1\n", + "There are two ‘unit tests’ we want to pass, to ensure that we understood and can reproduce the published model:\n", + "\n", + "## 1.a Unit Test \\#1:\n", + "\n", + "Set the initial values and parameters, as described in the Supplementary Methods section of the publication (pg. 9 of the pdf): \n", + "\n", + "1. Initial Values: \n", + "* $I = 200/60e6$,\n", + "* $D = 20/60e6$, \n", + "* $A = 1/60e6$, \n", + "* $R = 2/60e6$, \n", + "* $T = 0$, \n", + "* $H = 0$, \n", + "* $E = 0$; \n", + "* $S = 1 – I – D – A – R – T – H – E$. \n", + "\n", + "Let total population = 60e6.\n", + "Parameters: $$\\alpha = 0.570, \\beta = \\delta = 0.011, \\gamma = 0.456, \\epsilon = 0.171, \\theta = 0.371, \\zeta = \\eta = 0.125, \\mu = 0.017, \\nu = 0.027, \\tau = 0.01, \\lambda = \\rho = 0.034$$ and $$\\kappa = \\xi = \\sigma = 0.017$$." + ] + }, + { + "cell_type": "markdown", + "id": "f6228f01", + "metadata": {}, + "source": [ + "### Deterministic forecasting" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "dbd7d430-325f-4f40-9b20-d8a0c0264f62", + "metadata": {}, + "outputs": [], + "source": [ + "from pyciemss.ODE.models import SIDARTHEV\n", + "\n", + "pyro.set_rng_seed(0)\n", + "\n", + "ode_model = SIDARTHEV(N=1,\n", + " alpha_prior=dist.Delta(torch.tensor (0.570)) ,\n", + " beta_prior=dist.Delta(torch.tensor (0.011)) ,\n", + " gamma_prior=dist.Delta(torch.tensor (0.456)) ,\n", + " delta_prior=dist.Delta(torch.tensor (0.011)) ,\n", + " epsilon_prior=dist.Delta(torch.tensor (0.171)) ,\n", + " lamb_prior =dist.Delta(torch.tensor (0.034)) ,\n", + " zeta_prior=dist.Delta(torch.tensor (0.125)) ,\n", + " eta_prior=dist.Delta(torch.tensor (0.125)) ,\n", + " kappa_prior=dist.Delta(torch.tensor (0.017)) ,\n", + " theta_prior=dist.Delta(torch.tensor (0.371)) ,\n", + " rho_prior=dist.Delta(torch.tensor (0.034)) ,\n", + " xi_prior=dist.Delta(torch.tensor (0.017)) ,\n", + " sigma_prior=dist.Delta(torch.tensor (0.017)) ,\n", + " mu_prior=dist.Delta(torch.tensor (0.017)) ,\n", + " nu_prior=dist.Delta(torch.tensor (0.027)) ,\n", + " tau2_prior=dist.Delta(torch.tensor (0.01)) ,\n", + " phi_prior=dist.Delta(torch.tensor (0.)) )" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "31473cdd-9896-42ed-b487-36362c1c9744", + "metadata": { + "scrolled": false + }, + "outputs": [], + "source": [ + "single_prediction = sample(ode_model, 1, initial_state, tspan)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "15f03c6f-d085-4f36-bc7a-312057d82758", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ax = plot_trajectory(single_prediction, tspan, ax=setup_ax(), color=\"blue\", marker='', lw=1., label=\"Before Seeing Data - Single Forecast\")\n", + "ax.axvline(47)" + ] + }, + { + "cell_type": "markdown", + "id": "7c9b53f3", + "metadata": {}, + "source": [ + "### Probabilistic forecasting" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "a8cebc75-730c-43f8-9081-ba846098f669", + "metadata": {}, + "outputs": [], + "source": [ + "pyro.set_rng_seed(0)\n", + "\n", + "# var_prior = 0.05**2\n", + "mean_values = np.array([])\n", + "\n", + "ode_model = SIDARTHEV(N=1,\n", + " alpha_prior=LogNormalPrior_propVar(torch.tensor(0.570)) ,\n", + " beta_prior=LogNormalPrior_propVar(torch.tensor(0.011)) ,\n", + " gamma_prior=LogNormalPrior_propVar(torch.tensor(0.456)) ,\n", + " delta_prior=LogNormalPrior_propVar(torch.tensor(0.011)) ,\n", + " epsilon_prior=LogNormalPrior_propVar(torch.tensor(0.171)) ,\n", + " lamb_prior =LogNormalPrior_propVar(torch.tensor(0.034)) ,\n", + " zeta_prior=LogNormalPrior_propVar(torch.tensor(0.125)) ,\n", + " eta_prior=LogNormalPrior_propVar(torch.tensor(0.125)) ,\n", + " kappa_prior=LogNormalPrior_propVar(torch.tensor(0.017)) ,\n", + " theta_prior=LogNormalPrior_propVar(torch.tensor(0.371)) ,\n", + " rho_prior=LogNormalPrior_propVar(torch.tensor(0.034)) ,\n", + " xi_prior=LogNormalPrior_propVar(torch.tensor(0.017)) ,\n", + " sigma_prior=LogNormalPrior_propVar(torch.tensor(0.017)) ,\n", + " mu_prior=LogNormalPrior_propVar(torch.tensor(0.017)) ,\n", + " nu_prior=LogNormalPrior_propVar(torch.tensor(0.027)) ,\n", + " tau2_prior=LogNormalPrior_propVar(torch.tensor(0.01)) ,\n", + " phi_prior=dist.Delta(torch.tensor (0.)) )\n", + "\n", + "# interventions = {\"alpha\": SI_alpha_intervention,\n", + "# \"beta\": SD_beta_intervention,\n", + "# \"gamma\": SA_gamma_intervention,\n", + "# \"delta\": SR_delta_intervention,\n", + "# \"epsilon\": ID_epsilon_intervention,\n", + "# \"lambda\": IH_lamb_intervention,\n", + "# \"zeta\": IA_zeta_intervention,\n", + "# \"eta\": DR_eta_intervention,\n", + "# \"kappa\": AH_kappa_intervention,\n", + "# # \"theta\": AR_theta_intervention,\n", + "# \"rho\": DH_rho_intervention,\n", + "# \"xi\": RH_xi_intervention,\n", + "# \"sigma\": TH_sigma_intervention,\n", + "# \"mu\": AT_mu_intervention,\n", + "# \"nu\": RT_nu_intervention}" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "795ecb3a", + "metadata": {}, + "outputs": [], + "source": [ + "prior_prediction = sample(ode_model, num_samples, initial_state, tspan)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "f62475f8", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ax1 = plot_predictive(prior_prediction, tspan, ax=setup_ax(), label=\"probabilistic forecast\", color=\"red\")\n", + "ax1.axvline(30)\n", + "sideaxis(ax1)" + ] + }, + { + "cell_type": "markdown", + "id": "c65bcf10-9d12-4efe-be10-cc313e123d14", + "metadata": {}, + "source": [ + "## 1.d Policies that prevent infections from exceeding 1/3 of the population\n", + "\n", + "Now return to the situation in b.i (constant parameters that don’t change over time). Let’s say we want to increase testing, diagnostics, and contact tracing efforts (implemented by increasing the detection parameters and ). Assume that $\\theta \\ge 2\\epsilon$ , because a symptomatic person is more likely to be tested. What minimum constant values do these parameters need to be over the course of a 100-day simulation, to ensure that the total infected population (sum over all the infected states I, D, A, R, T) never rises above 1/3 of the total population?\n", + "\n", + "\n", + "### Problem Formulation\n", + "* **Quantity of interest**: Total infections out of $N=60,000,000$ population\n", + "$$I_{total}(t; \\mathbf{u}, \\mathbf{Z}) = I(t) + D(t) + A(t) + R(t) + T(t)$$\n", + "\n", + "A conservative estimate for the quantity of interest is\n", + "$$M(u, Z) = \\max_{1\\leq t \\leq 100} I_{total}(t; \\mathbf{u}, \\mathbf{Z})/N$$\n", + "\n", + "\n", + "\n", + "\n", + "* **Control**: $\\mathbf{u}\\in \\mathcal{U} \\subseteq \\mathbb{R}^{n_u}$\n", + " * Detection parameter for Infected ($\\epsilon$) assuming that $\\theta=2\\epsilon$\n", + " * Two detection parameters $\\theta, \\epsilon$, constraining $\\theta \\ge 2\\epsilon$.\n", + " \n", + "\n", + "\n", + "* **Risk-based optimization under uncertainty problem formulation**\n", + " * Objective Function - Minimize the magnitude of the parameter interventions.\n", + " * Constraint - Risk of normalized total infections exceeding the prescribed threshold of $1/3$, $\\mathcal{R}( M(\\mathbf{u},\\mathbf{Z}))$, is below the acceptable risk threshold, $\\mathcal{R}_\\text{threshold}$.\n", + "\n", + "\\begin{equation} \n", + "\\begin{split} \n", + "\\mathbf{u}^*= \\underset{\\mathbf{u}\\in\\mathcal{U}}{\\arg\\min}\\ & \\lVert \\mathbf{u} \\rVert_1 \\\\ \\text{s.t.}\\ & \\mathcal{R}( M(\\mathbf{u}, \\theta)) \\le \\mathcal{R}_\\text{threshold} \n", + "\\end{split} \n", + "\\end{equation}\n", + "\n", + "#### Formulation 1: Optimize $u=\\{\\alpha, \\beta, \\gamma, \\delta\\}$\n", + "\\begin{equation} \n", + "\\begin{split} \n", + "u^*= \\underset{\\epsilon\\in\\mathcal{U}}{\\arg\\min}\\ & u\\\\ \\text{s.t.}\\ & \\mathbb{P}( M(u, \\mathbf{Z}) \\ge 1/3) \\le 0.05\n", + "\\end{split} \n", + "\\end{equation}\n", + "\n", + "#### Formulation 2: Optimize $\\epsilon$ and $\\theta$ constraining $\\theta \\ge 2\\epsilon$\n", + "\\begin{equation} \n", + "\\begin{split} \n", + "\\epsilon^\\ast, \\theta^\\ast= \\underset{\\{\\epsilon,\\theta\\}\\in\\mathcal{U}}{\\arg\\min}\\ & \\theta + \\epsilon \\\\ \\text{s.t.}\\ & \\mathbb{P}( M(\\epsilon,\\theta, \\mathbf{Z}) \\ge 1/3) \\le 0.05, \\\\\n", + "& \\theta \\ge 2\\epsilon\n", + "\\end{split} \n", + "\\end{equation}\n", + "\n", + "Apart from probability of exceedance, we will explore quantiles and superquantiles as risk measures." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "97ab7988", + "metadata": {}, + "outputs": [], + "source": [ + "from causal_pyro.query.do_messenger import do\n", + "import time\n", + "import pickle\n", + "\n", + "import numpy as np\n", + "from scipy import stats\n", + "from matplotlib import ticker\n", + "\n", + "from pyciemss.ODE.interventions import parameter_intervention_builder, time_and_state_dependent_intervention_builder, time_dependent_intervention_builder\n", + "from pyciemss.risk.risk_measures import alpha_quantile, alpha_superquantile\n", + "from pyciemss.risk.ouu import computeRisk, solveOUU\n", + "from pyciemss.risk.qoi import max_total_infections_SIDARTHE\n", + "import scipy\n", + "\n", + "\n", + "co = ['#377eb8', '#ff7f00', '#984ea3', '#ffd92f', '#a65628']\n", + "rlabel = ['Q_alpha-based OUU', 'barQ_alpha-based OUU']" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "161b391b", + "metadata": {}, + "outputs": [], + "source": [ + "def delayed_intervention_controller(name, x, init_value):\n", + " def delayed_intervention(t, flux):\n", + " if t<30:\n", + " return flux\n", + " else:\n", + " return flux/init_value*x\n", + " return time_and_state_dependent_intervention_builder(name, delayed_intervention, tspan) \n", + "\n", + "def delayed_intervention_controller_flux(name, x):\n", + " def delayed_intervention(t):\n", + " if t<15:\n", + " return torch.tensor(0.)\n", + " else:\n", + " return x\n", + " return time_dependent_intervention_builder(name, delayed_intervention, tspan) " + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "12a672fa", + "metadata": {}, + "outputs": [], + "source": [ + "# # Control action / intervention.\n", + "# phi_init = torch.tensor(0.)\n", + "# param_intervention = parameter_intervention_builder(\"phi\", phi_init)\n", + "# control_model = intervene(ode_model,param_intervention)\n", + "\n", + "# # Control action / intervention.\n", + "# alpha_init = torch.tensor(0.57)\n", + "# param_intervention = parameter_intervention_builder(\"alpha\", alpha_init)\n", + "# control_model = intervene(ode_model,param_intervention)\n", + "control_model = ode_model\n", + "\n", + "# # intervened_tspan = tspan[torch.where(tspan > 30, True, False)]\n", + "# INTERVENTION = lambda x: delayed_intervention_controller(\"SV_flux\", torch.from_numpy(np.array([x])), phi_init)\n", + "\n", + "INTERVENTION = lambda x: delayed_intervention_controller_flux(\"SV_flux\", torch.from_numpy(np.array([x])))" + ] + }, + { + "cell_type": "markdown", + "id": "5fb87509", + "metadata": {}, + "source": [ + "## Exploring the intervention and difference between Quantiles and Superquantiles" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "35ebe5d7", + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Forward UQ took 9.23 seconds total (1.85e-01 seconds per model evaluation).\n", + "0.09005817361176013 0.37220816537737816\n" + ] + } + ], + "source": [ + "pyro.set_rng_seed(0)\n", + "\n", + "POLICY = np.array([0.05])\n", + "N_SAMPLES = 50\n", + "\n", + "RISK = computeRisk(model=control_model,\n", + " intervention_fun=INTERVENTION,\n", + " qoi=lambda y: max_total_infections_SIDARTHE(y, contexts=[\"I_total_obs\"]),\n", + " risk_measure=alpha_superquantile,\n", + " num_samples=N_SAMPLES,\n", + " model_state=initial_state,\n", + " tspan=tspan,\n", + " guide=None)\n", + "\n", + "start_time = time.time()\n", + "sq_dataCube = RISK.propagate_uncertainty(POLICY)\n", + "end_time = time.time()\n", + "forward_time = end_time - start_time\n", + "time_per_eval = forward_time / N_SAMPLES\n", + "print(f\"Forward UQ took {forward_time:.2f} seconds total ({forward_time/N_SAMPLES:.2e} seconds per model evaluation).\")\n", + "sq_qoi = RISK.qoi(sq_dataCube)\n", + "sq_sv = RISK.risk_measure(sq_qoi)\n", + "\n", + "RISK.risk_measure = alpha_quantile\n", + "q_sv = RISK(POLICY)\n", + "print(q_sv, sq_sv)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "b74d9c82", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "No artists with labels found to put in legend. Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ax = setup_ax()\n", + "ax = plot_predictive(sq_dataCube, tspan, ax=ax, color=co[1])\n", + "ax.axvline(15)\n", + "sideaxis(ax)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "7fc330e1", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "bins_hist = 50\n", + "fig1 = plt.figure()\n", + "plt.rc('text', usetex=False)\n", + "plt.rc('font', family='serif', size=18.)\n", + "cax = plt.gca()\n", + "sideaxishist(cax)\n", + "cax.hist(sq_qoi, color=co[2], bins=bins_hist, histtype='stepfilled', alpha=0.5, label='total infections')\n", + "miny = min(cax.get_ylim())\n", + "maxy = max(cax.get_ylim())\n", + "cax.vlines(q_sv, miny, maxy, linestyle='--', linewidth=2.5, label='alpha-quantile', color=co[0])\n", + "cax.vlines(sq_sv, miny, maxy, linestyle='--', linewidth=2.5, label='alpha-superquantile', color=co[1])\n", + "cax.set_xlabel('Maximum total infections over 100 days', size=14)\n", + "cax.legend(loc='upper right', prop={'size': 14})" + ] + }, + { + "cell_type": "markdown", + "id": "2a4005a9", + "metadata": {}, + "source": [ + "## Risk-based optimization under uncertainty with intervention on vaccination rate flux\n", + "**NOTE:** This is a demonstration of the interface, optimization is not run to convergence nor are enough samples generated to accurately estimate the risk, so take the results with a grain of salt." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "ba6b2d82", + "metadata": {}, + "outputs": [], + "source": [ + "# Define problem specifics.\n", + "RISK_BOUND = 1./3.\n", + "RISK_ALPHA = 0.95\n", + "X_MIN = 0.\n", + "X_MAX = 2.\n", + "N_SAMPLES = int(5e2)\n", + "MAXITER = 0\n", + "MAXFEVAL = 30\n", + "\n", + "INIT_GUESS = 0.05\n", + "\n", + "# Objective function.\n", + "OBJFUN = lambda x: x # minimize the scalar value itself.\n", + "\n", + "# Define the risk measure.\n", + "RISK = computeRisk(\n", + " model=control_model,\n", + " intervention_fun=INTERVENTION,\n", + " qoi=lambda y: max_total_infections_SIDARTHE(y, contexts=[\"I_total_obs\"]),\n", + " model_state=initial_state,\n", + " tspan=tspan,\n", + " risk_measure=lambda z: alpha_superquantile(z, alpha=RISK_ALPHA),\n", + " num_samples=N_SAMPLES,\n", + " guide=None,\n", + " )\n", + "\n", + "# Define problem constraints.\n", + "CONSTRAINTS = (\n", + " # risk constraint\n", + " {'type': 'ineq', 'fun': lambda x: RISK_BOUND - RISK(x)},\n", + "\n", + " # bounds on control\n", + " # NOTE: perhaps use scipy.optimize.LinearConstraint in the future\n", + " {'type': 'ineq', 'fun': lambda x: x - X_MIN},\n", + " {'type': 'ineq', 'fun': lambda x: X_MAX - x}\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "13a9803a", + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Performing risk-based optimization under uncertainty (using alpha-superquantile)...\n", + "Estimated wait time 2768.5 seconds.\n" + ] + } + ], + "source": [ + "print(\"Performing risk-based optimization under uncertainty (using alpha-superquantile)...\")\n", + "print(f\"Estimated wait time {time_per_eval*N_SAMPLES*(MAXITER+1)*MAXFEVAL:.1f} seconds.\")\n", + "start_time = time.time()\n", + "sq_result_1 = solveOUU(\n", + " x0=INIT_GUESS,\n", + " objfun=OBJFUN,\n", + " constraints=CONSTRAINTS,\n", + " maxiter=MAXITER,\n", + " maxfeval=MAXFEVAL,\n", + " ).solve()\n", + "print(f\"Optimization completed in time {time.time()-start_time:.2f} seconds. Optimal solution:\\t{sq_result_1.x}\")" + ] + }, + { + "cell_type": "markdown", + "id": "abfeda8c", + "metadata": {}, + "source": [ + "## Assess the effect of the control policy." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "99166bc3", + "metadata": {}, + "outputs": [], + "source": [ + "RISK.num_samples = int(5e2)\n", + "sq_optimal_prediction = RISK.propagate_uncertainty(sq_result_1.x)\n", + "qois_sq = RISK.qoi(sq_optimal_prediction)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "60c9d1a9", + "metadata": { + "scrolled": false + }, + "outputs": [], + "source": [ + "sq_est = RISK.risk_measure(qois_sq)\n", + "print('Estimated risk at optimal policy', sq_est)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c92e52b7", + "metadata": { + "scrolled": false + }, + "outputs": [], + "source": [ + "ax = setup_ax()\n", + "# print(sq_optimal_prediction.shape)\n", + "ax = plot_predictive(sq_optimal_prediction, tspan, ax=ax, color=co[2], ptiles=[0.05,0.95])\n", + "plt.title(\"Optimal vaccination rate flux intervention with risk-based OUU\", size=14)\n", + "sideaxis(ax)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "13bf129e", + "metadata": {}, + "outputs": [], + "source": [ + "bins_hist = 50\n", + "fig1 = plt.figure()\n", + "plt.rc('font', family='serif', size=14.)\n", + "cax = plt.gca()\n", + "sideaxishist(cax)\n", + "cax.hist(qois_sq, color=co[4], bins=bins_hist, histtype='stepfilled', alpha=0.5, density=True)\n", + "miny = min(cax.get_ylim())\n", + "maxy = max(cax.get_ylim())\n", + "cax.set_xlabel('Maximum total infections over 100 days', size=14)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4ac0e2cf", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "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.9.7" + }, + "vscode": { + "interpreter": { + "hash": "a3e1d8fdda916c248c87d86618e3945b28961cf939001a0529e724463670a41a" + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From facf3d62ec5b013fe2e6cb1800902ca1d840c425 Mon Sep 17 00:00:00 2001 From: Jeremy Zucker Date: Thu, 2 Feb 2023 09:13:56 -0500 Subject: [PATCH 3/4] Scenario 2, question 2bi: Note that the runs didn't find any optimal solution for \beta and \delta. The runs gave an optimal solution for alpha nd SV_flux. Scenario 2, question 1d: Both the notebooks with epsilon and {theta,epsilon} have a solution. --- .../ciemss/scenario2_q1_thetaepsilon.ipynb | 60 ++++++++++-- .../scenario2_q2b_SIDARTHEV_alpha.ipynb | 75 +++++++++++++-- .../ciemss/scenario2_q2b_SIDARTHEV_beta.ipynb | 95 ++++++++++++++++--- .../scenario2_q2b_SIDARTHEV_delta.ipynb | 83 ++++++++++++++-- .../scenario2_q2b_SIDARTHEV_phiflux.ipynb | 83 +++++++++++++--- 5 files changed, 344 insertions(+), 52 deletions(-) diff --git a/6-month-milestone/evaluation/scenario_2/ta_3/ciemss/scenario2_q1_thetaepsilon.ipynb b/6-month-milestone/evaluation/scenario_2/ta_3/ciemss/scenario2_q1_thetaepsilon.ipynb index a3c2994..2bb78f7 100644 --- a/6-month-milestone/evaluation/scenario_2/ta_3/ciemss/scenario2_q1_thetaepsilon.ipynb +++ b/6-month-milestone/evaluation/scenario_2/ta_3/ciemss/scenario2_q1_thetaepsilon.ipynb @@ -60,7 +60,7 @@ { "cell_type": "code", "execution_count": 3, - "id": "1c7ae081", + "id": "7a3d7329", "metadata": {}, "outputs": [], "source": [ @@ -289,7 +289,7 @@ { "cell_type": "code", "execution_count": 9, - "id": "595205b8", + "id": "2274e2c2", "metadata": {}, "outputs": [], "source": [ @@ -654,7 +654,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "id": "13a9803a", "metadata": { "scrolled": false @@ -665,7 +665,8 @@ "output_type": "stream", "text": [ "Performing risk-based optimization under uncertainty (using alpha-superquantile)...\n", - "Estimated wait time 4897.5 seconds.\n" + "Estimated wait time 4897.5 seconds.\n", + "Optimization completed in time 4739.44 seconds. Optimal solution:\t[0.75017011 1.55161184]\n" ] } ], @@ -693,7 +694,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "id": "60c9d1a9", "metadata": {}, "outputs": [], @@ -705,14 +706,32 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 24, "id": "c92e52b7", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "No artists with labels found to put in legend. Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "ax = setup_ax()\n", "# print(sq_optimal_prediction.shape)\n", - "ax = plot_predictive(sq_optimal_prediction, tspan, ax=ax, color=co[2], ptiles=[0.01,0.98])\n", + "ax = plot_predictive(sq_optimal_prediction, tspan, ax=ax, color=co[2], ptiles=[0.01,0.99])\n", "ax = plot_trajectory(sq_optimal_prediction, tspan, ax=ax, color=\"blue\", marker='', lw=1., ind=1)\n", "plt.title(\"Optimal theta, epsilon parameter intervention (theta>=2*epsilon) \\n with risk-based OUU\", size=14)\n", "sideaxis(ax)" @@ -720,10 +739,31 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 22, "id": "13bf129e", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 0, 'Maximum total infections over 100 days')" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "bins_hist = 50\n", "fig1 = plt.figure()\n", diff --git a/6-month-milestone/evaluation/scenario_2/ta_3/ciemss/scenario2_q2b_SIDARTHEV_alpha.ipynb b/6-month-milestone/evaluation/scenario_2/ta_3/ciemss/scenario2_q2b_SIDARTHEV_alpha.ipynb index 66f7330..cc202b8 100644 --- a/6-month-milestone/evaluation/scenario_2/ta_3/ciemss/scenario2_q2b_SIDARTHEV_alpha.ipynb +++ b/6-month-milestone/evaluation/scenario_2/ta_3/ciemss/scenario2_q2b_SIDARTHEV_alpha.ipynb @@ -687,7 +687,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "id": "13a9803a", "metadata": { "scrolled": false @@ -698,7 +698,8 @@ "output_type": "stream", "text": [ "Performing risk-based optimization under uncertainty (using alpha-superquantile)...\n", - "Estimated wait time 2807.7 seconds.\n" + "Estimated wait time 2807.7 seconds.\n", + "Optimization completed in time 1689.59 seconds. Optimal solution:\t0.06561500000000005\n" ] } ], @@ -716,6 +717,17 @@ "print(f\"Optimization completed in time {time.time()-start_time:.2f} seconds. Optimal solution:\\t{sq_result_1.x}\")" ] }, + { + "cell_type": "code", + "execution_count": 23, + "id": "0010d710", + "metadata": {}, + "outputs": [], + "source": [ + "if sq_result_1.x<0:\n", + " print(\"No solution found\")" + ] + }, { "cell_type": "markdown", "id": "abfeda8c", @@ -726,12 +738,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "id": "60c9d1a9", "metadata": { "scrolled": false }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Estimated risk at optimal policy 0.3450316214561461\n" + ] + } + ], "source": [ "RISK.num_samples = int(5e2)\n", "sq_optimal_prediction = RISK.propagate_uncertainty(sq_result_1.x)\n", @@ -742,10 +762,28 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 21, "id": "c92e52b7", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "No artists with labels found to put in legend. Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "ax = setup_ax()\n", "# print(sq_optimal_prediction.shape)\n", @@ -756,10 +794,31 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 22, "id": "13bf129e", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 0, 'Maximum total infections over 100 days')" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "bins_hist = 50\n", "fig1 = plt.figure()\n", diff --git a/6-month-milestone/evaluation/scenario_2/ta_3/ciemss/scenario2_q2b_SIDARTHEV_beta.ipynb b/6-month-milestone/evaluation/scenario_2/ta_3/ciemss/scenario2_q2b_SIDARTHEV_beta.ipynb index 2de2276..c068a87 100644 --- a/6-month-milestone/evaluation/scenario_2/ta_3/ciemss/scenario2_q2b_SIDARTHEV_beta.ipynb +++ b/6-month-milestone/evaluation/scenario_2/ta_3/ciemss/scenario2_q2b_SIDARTHEV_beta.ipynb @@ -272,7 +272,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 8, @@ -523,8 +523,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "Forward UQ took 9.72 seconds total (1.94e-01 seconds per model evaluation).\n", - "0.8429393768310547 0.9140260457992553\n" + "Forward UQ took 9.60 seconds total (1.92e-01 seconds per model evaluation).\n", + "0.8438474744558334 0.9149215579032898\n" ] } ], @@ -572,7 +572,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -597,7 +597,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 17, @@ -606,7 +606,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -687,7 +687,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "id": "13a9803a", "metadata": { "scrolled": false @@ -698,7 +698,8 @@ "output_type": "stream", "text": [ "Performing risk-based optimization under uncertainty (using alpha-superquantile)...\n", - "Estimated wait time 2917.1 seconds.\n" + "Estimated wait time 2879.9 seconds.\n", + "Optimization completed in time 2783.43 seconds. Optimal solution:\t-0.510594482421875\n" ] } ], @@ -716,6 +717,25 @@ "print(f\"Optimization completed in time {time.time()-start_time:.2f} seconds. Optimal solution:\\t{sq_result_1.x}\")" ] }, + { + "cell_type": "code", + "execution_count": 23, + "id": "e6291958", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "No solution found\n" + ] + } + ], + "source": [ + "if sq_result_1.x<0:\n", + " print(\"No solution found\")" + ] + }, { "cell_type": "markdown", "id": "abfeda8c", @@ -726,12 +746,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "id": "60c9d1a9", "metadata": { "scrolled": false }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Estimated risk at optimal policy 0.9010392951965331\n" + ] + } + ], "source": [ "RISK.num_samples = int(5e2)\n", "sq_optimal_prediction = RISK.propagate_uncertainty(sq_result_1.x)\n", @@ -742,10 +770,28 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 21, "id": "c92e52b7", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "No artists with labels found to put in legend. Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "ax = setup_ax()\n", "# print(sq_optimal_prediction.shape)\n", @@ -756,10 +802,31 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 22, "id": "13bf129e", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 0, 'Maximum total infections over 100 days')" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "bins_hist = 50\n", "fig1 = plt.figure()\n", diff --git a/6-month-milestone/evaluation/scenario_2/ta_3/ciemss/scenario2_q2b_SIDARTHEV_delta.ipynb b/6-month-milestone/evaluation/scenario_2/ta_3/ciemss/scenario2_q2b_SIDARTHEV_delta.ipynb index 37d2bfa..88b60c6 100644 --- a/6-month-milestone/evaluation/scenario_2/ta_3/ciemss/scenario2_q2b_SIDARTHEV_delta.ipynb +++ b/6-month-milestone/evaluation/scenario_2/ta_3/ciemss/scenario2_q2b_SIDARTHEV_delta.ipynb @@ -687,7 +687,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 21, "id": "13a9803a", "metadata": { "scrolled": false @@ -698,7 +698,8 @@ "output_type": "stream", "text": [ "Performing risk-based optimization under uncertainty (using alpha-superquantile)...\n", - "Estimated wait time 2917.1 seconds.\n" + "Estimated wait time 2917.1 seconds.\n", + "Optimization completed in time 2677.98 seconds. Optimal solution:\t-0.0261226708984375\n" ] } ], @@ -716,6 +717,25 @@ "print(f\"Optimization completed in time {time.time()-start_time:.2f} seconds. Optimal solution:\\t{sq_result_1.x}\")" ] }, + { + "cell_type": "code", + "execution_count": 25, + "id": "01c8c67c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "No solution found\n" + ] + } + ], + "source": [ + "if sq_result_1.x<0:\n", + " print(\"No solution found\")" + ] + }, { "cell_type": "markdown", "id": "abfeda8c", @@ -726,12 +746,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 22, "id": "60c9d1a9", "metadata": { "scrolled": false }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Estimated risk at optimal policy 0.8928980088233948\n" + ] + } + ], "source": [ "RISK.num_samples = int(5e2)\n", "sq_optimal_prediction = RISK.propagate_uncertainty(sq_result_1.x)\n", @@ -742,10 +770,28 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 23, "id": "c92e52b7", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "No artists with labels found to put in legend. Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "ax = setup_ax()\n", "# print(sq_optimal_prediction.shape)\n", @@ -756,10 +802,31 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 24, "id": "13bf129e", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 0, 'Maximum total infections over 100 days')" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "bins_hist = 50\n", "fig1 = plt.figure()\n", diff --git a/6-month-milestone/evaluation/scenario_2/ta_3/ciemss/scenario2_q2b_SIDARTHEV_phiflux.ipynb b/6-month-milestone/evaluation/scenario_2/ta_3/ciemss/scenario2_q2b_SIDARTHEV_phiflux.ipynb index 9085fab..a13e220 100644 --- a/6-month-milestone/evaluation/scenario_2/ta_3/ciemss/scenario2_q2b_SIDARTHEV_phiflux.ipynb +++ b/6-month-milestone/evaluation/scenario_2/ta_3/ciemss/scenario2_q2b_SIDARTHEV_phiflux.ipynb @@ -696,7 +696,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "id": "13a9803a", "metadata": { "scrolled": false @@ -707,7 +707,8 @@ "output_type": "stream", "text": [ "Performing risk-based optimization under uncertainty (using alpha-superquantile)...\n", - "Estimated wait time 2768.5 seconds.\n" + "Estimated wait time 2768.5 seconds.\n", + "Optimization completed in time 2022.55 seconds. Optimal solution:\t0.04671354464357809\n" ] } ], @@ -725,6 +726,17 @@ "print(f\"Optimization completed in time {time.time()-start_time:.2f} seconds. Optimal solution:\\t{sq_result_1.x}\")" ] }, + { + "cell_type": "code", + "execution_count": 25, + "id": "f4b79578", + "metadata": {}, + "outputs": [], + "source": [ + "if sq_result_1.x<0:\n", + " print(\"No solution found\")" + ] + }, { "cell_type": "markdown", "id": "abfeda8c", @@ -735,8 +747,8 @@ }, { "cell_type": "code", - "execution_count": null, - "id": "99166bc3", + "execution_count": 20, + "id": "1c28411a", "metadata": {}, "outputs": [], "source": [ @@ -747,12 +759,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 21, "id": "60c9d1a9", "metadata": { "scrolled": false }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Estimated risk at optimal policy 0.326399146914482\n" + ] + } + ], "source": [ "sq_est = RISK.risk_measure(qois_sq)\n", "print('Estimated risk at optimal policy', sq_est)" @@ -760,26 +780,65 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 24, "id": "c92e52b7", "metadata": { "scrolled": false }, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "No artists with labels found to put in legend. Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "ax = setup_ax()\n", "# print(sq_optimal_prediction.shape)\n", - "ax = plot_predictive(sq_optimal_prediction, tspan, ax=ax, color=co[2], ptiles=[0.05,0.95])\n", + "ax = plot_predictive(sq_optimal_prediction, tspan, ax=ax, color=co[2], ptiles=[0.0,1.])\n", "plt.title(\"Optimal vaccination rate flux intervention with risk-based OUU\", size=14)\n", "sideaxis(ax)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 23, "id": "13bf129e", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 0, 'Maximum total infections over 100 days')" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "bins_hist = 50\n", "fig1 = plt.figure()\n", @@ -795,7 +854,7 @@ { "cell_type": "code", "execution_count": null, - "id": "4ac0e2cf", + "id": "f999249d", "metadata": {}, "outputs": [], "source": [] From 42d7be9564717cfd1994671e99c52c0843a25a46 Mon Sep 17 00:00:00 2001 From: Jeremy Zucker Date: Thu, 2 Feb 2023 10:42:19 -0500 Subject: [PATCH 4/4] clarified which optimization was being performed in each notebook --- .../scenario2_q2b_SIDARTHEV_alpha.ipynb | 27 ++++++---------- .../ciemss/scenario2_q2b_SIDARTHEV_beta.ipynb | 27 ++++++---------- .../scenario2_q2b_SIDARTHEV_delta.ipynb | 27 ++++++---------- .../scenario2_q2b_SIDARTHEV_phiflux.ipynb | 31 +++++++------------ 4 files changed, 42 insertions(+), 70 deletions(-) diff --git a/6-month-milestone/evaluation/scenario_2/ta_3/ciemss/scenario2_q2b_SIDARTHEV_alpha.ipynb b/6-month-milestone/evaluation/scenario_2/ta_3/ciemss/scenario2_q2b_SIDARTHEV_alpha.ipynb index cc202b8..11b8d79 100644 --- a/6-month-milestone/evaluation/scenario_2/ta_3/ciemss/scenario2_q2b_SIDARTHEV_alpha.ipynb +++ b/6-month-milestone/evaluation/scenario_2/ta_3/ciemss/scenario2_q2b_SIDARTHEV_alpha.ipynb @@ -389,10 +389,12 @@ "id": "c65bcf10-9d12-4efe-be10-cc313e123d14", "metadata": {}, "source": [ - "## 1.d Policies that prevent infections from exceeding 1/3 of the population\n", + "## 2..b.i Policies that prevent infections from exceeding 1/3 of the population\n", "\n", - "Now return to the situation in b.i (constant parameters that don’t change over time). Let’s say we want to increase testing, diagnostics, and contact tracing efforts (implemented by increasing the detection parameters and ). Assume that $\\theta \\ge 2\\epsilon$ , because a symptomatic person is more likely to be tested. What minimum constant values do these parameters need to be over the course of a 100-day simulation, to ensure that the total infected population (sum over all the infected states I, D, A, R, T) never rises above 1/3 of the total population?\n", + "Let’s say our goal is to ensure that the total infected population (sum over all the infected states I, D, A, R, T) never rises above 1/3 of the total population, over the course of the next 100 days. If you could choose only a single intervention (affecting only one parameter), which intervention would let us meet our goal, with minimal change to the intervention parameter? Assume that the intervention will be implemented after one month (t = day 30), and will stay constant after that, over the remaining time period (i.e. the following 70 days). What are \n", + "equivalent interventions of the other two intervention types, that would have the same impact on total infections?\n", "\n", + "*Note that we started implementing intervention after t=15 days. \n", "\n", "### Problem Formulation\n", "* **Quantity of interest**: Total infections out of $N=60,000,000$ population\n", @@ -405,13 +407,12 @@ "\n", "\n", "* **Control**: $\\mathbf{u}\\in \\mathcal{U} \\subseteq \\mathbb{R}^{n_u}$\n", - " * Detection parameter for Infected ($\\epsilon$) assuming that $\\theta=2\\epsilon$\n", - " * Two detection parameters $\\theta, \\epsilon$, constraining $\\theta \\ge 2\\epsilon$.\n", + " * Transmission parameter $\\alpha$\n", " \n", "\n", "\n", "* **Risk-based optimization under uncertainty problem formulation**\n", - " * Objective Function - Minimize the magnitude of the parameter interventions.\n", + " * Objective Function - Minimize the change in the magnitude of parameter interventions from the initial value $\\alpha\\text{init}=0.57$.\n", " * Constraint - Risk of normalized total infections exceeding the prescribed threshold of $1/3$, $\\mathcal{R}( M(\\mathbf{u},\\mathbf{Z}))$, is below the acceptable risk threshold, $\\mathcal{R}_\\text{threshold}$.\n", "\n", "\\begin{equation} \n", @@ -420,22 +421,14 @@ "\\end{split} \n", "\\end{equation}\n", "\n", - "#### Formulation 1: Optimize $u=\\{\\alpha, \\beta, \\gamma, \\delta\\}$\n", + "#### Formulation 1: Optimize for $u=\\alpha$\n", "\\begin{equation} \n", "\\begin{split} \n", - "u^*= \\underset{\\epsilon\\in\\mathcal{U}}{\\arg\\min}\\ & u\\\\ \\text{s.t.}\\ & \\mathbb{P}( M(u, \\mathbf{Z}) \\ge 1/3) \\le 0.05\n", + "u^*= \\underset{\\epsilon\\in\\mathcal{U}}{\\arg\\min}\\ & \\lvert \\alpha_\\text{init}-u \\rvert \\\\ \\text{s.t.}\\ & \\mathbb{P}( M(u, \\mathbf{Z}) \\ge 1/3) \\le 0.05\n", "\\end{split} \n", "\\end{equation}\n", "\n", - "#### Formulation 2: Optimize $\\epsilon$ and $\\theta$ constraining $\\theta \\ge 2\\epsilon$\n", - "\\begin{equation} \n", - "\\begin{split} \n", - "\\epsilon^\\ast, \\theta^\\ast= \\underset{\\{\\epsilon,\\theta\\}\\in\\mathcal{U}}{\\arg\\min}\\ & \\theta + \\epsilon \\\\ \\text{s.t.}\\ & \\mathbb{P}( M(\\epsilon,\\theta, \\mathbf{Z}) \\ge 1/3) \\le 0.05, \\\\\n", - "& \\theta \\ge 2\\epsilon\n", - "\\end{split} \n", - "\\end{equation}\n", - "\n", - "Instead of probability of exceedance, we will use superquantiles as risk measures." + "Instead of probability of exceedance, we will use superquantiles as risk measures." ] }, { @@ -720,7 +713,7 @@ { "cell_type": "code", "execution_count": 23, - "id": "0010d710", + "id": "89e0a5a0", "metadata": {}, "outputs": [], "source": [ diff --git a/6-month-milestone/evaluation/scenario_2/ta_3/ciemss/scenario2_q2b_SIDARTHEV_beta.ipynb b/6-month-milestone/evaluation/scenario_2/ta_3/ciemss/scenario2_q2b_SIDARTHEV_beta.ipynb index c068a87..b33fc6a 100644 --- a/6-month-milestone/evaluation/scenario_2/ta_3/ciemss/scenario2_q2b_SIDARTHEV_beta.ipynb +++ b/6-month-milestone/evaluation/scenario_2/ta_3/ciemss/scenario2_q2b_SIDARTHEV_beta.ipynb @@ -389,10 +389,12 @@ "id": "c65bcf10-9d12-4efe-be10-cc313e123d14", "metadata": {}, "source": [ - "## 1.d Policies that prevent infections from exceeding 1/3 of the population\n", + "## 2..b.i Policies that prevent infections from exceeding 1/3 of the population\n", "\n", - "Now return to the situation in b.i (constant parameters that don’t change over time). Let’s say we want to increase testing, diagnostics, and contact tracing efforts (implemented by increasing the detection parameters and ). Assume that $\\theta \\ge 2\\epsilon$ , because a symptomatic person is more likely to be tested. What minimum constant values do these parameters need to be over the course of a 100-day simulation, to ensure that the total infected population (sum over all the infected states I, D, A, R, T) never rises above 1/3 of the total population?\n", + "Let’s say our goal is to ensure that the total infected population (sum over all the infected states I, D, A, R, T) never rises above 1/3 of the total population, over the course of the next 100 days. If you could choose only a single intervention (affecting only one parameter), which intervention would let us meet our goal, with minimal change to the intervention parameter? Assume that the intervention will be implemented after one month (t = day 30), and will stay constant after that, over the remaining time period (i.e. the following 70 days). What are \n", + "equivalent interventions of the other two intervention types, that would have the same impact on total infections?\n", "\n", + "*Note that we started implementing intervention after t=15 days. \n", "\n", "### Problem Formulation\n", "* **Quantity of interest**: Total infections out of $N=60,000,000$ population\n", @@ -405,13 +407,12 @@ "\n", "\n", "* **Control**: $\\mathbf{u}\\in \\mathcal{U} \\subseteq \\mathbb{R}^{n_u}$\n", - " * Detection parameter for Infected ($\\epsilon$) assuming that $\\theta=2\\epsilon$\n", - " * Two detection parameters $\\theta, \\epsilon$, constraining $\\theta \\ge 2\\epsilon$.\n", + " * Transmission parameter $\\beta$\n", " \n", "\n", "\n", "* **Risk-based optimization under uncertainty problem formulation**\n", - " * Objective Function - Minimize the magnitude of the parameter interventions.\n", + " * Objective Function - Minimize the change in the magnitude of parameter interventions from the initial value $\\beta_\\text{init}=0.011$.\n", " * Constraint - Risk of normalized total infections exceeding the prescribed threshold of $1/3$, $\\mathcal{R}( M(\\mathbf{u},\\mathbf{Z}))$, is below the acceptable risk threshold, $\\mathcal{R}_\\text{threshold}$.\n", "\n", "\\begin{equation} \n", @@ -420,22 +421,14 @@ "\\end{split} \n", "\\end{equation}\n", "\n", - "#### Formulation 1: Optimize $u=\\{\\alpha, \\beta, \\gamma, \\delta\\}$\n", + "#### Formulation 1: Optimize for $u=\\beta$\n", "\\begin{equation} \n", "\\begin{split} \n", - "u^*= \\underset{\\epsilon\\in\\mathcal{U}}{\\arg\\min}\\ & u\\\\ \\text{s.t.}\\ & \\mathbb{P}( M(u, \\mathbf{Z}) \\ge 1/3) \\le 0.05\n", + "u^*= \\underset{\\epsilon\\in\\mathcal{U}}{\\arg\\min}\\ & \\lvert \\beta_\\text{init}-u \\rvert \\\\ \\text{s.t.}\\ & \\mathbb{P}( M(u, \\mathbf{Z}) \\ge 1/3) \\le 0.05\n", "\\end{split} \n", "\\end{equation}\n", "\n", - "#### Formulation 2: Optimize $\\epsilon$ and $\\theta$ constraining $\\theta \\ge 2\\epsilon$\n", - "\\begin{equation} \n", - "\\begin{split} \n", - "\\epsilon^\\ast, \\theta^\\ast= \\underset{\\{\\epsilon,\\theta\\}\\in\\mathcal{U}}{\\arg\\min}\\ & \\theta + \\epsilon \\\\ \\text{s.t.}\\ & \\mathbb{P}( M(\\epsilon,\\theta, \\mathbf{Z}) \\ge 1/3) \\le 0.05, \\\\\n", - "& \\theta \\ge 2\\epsilon\n", - "\\end{split} \n", - "\\end{equation}\n", - "\n", - "Instead of probability of exceedance, we will use superquantiles as risk measures." + "Instead of probability of exceedance, we will use superquantiles as risk measures." ] }, { @@ -720,7 +713,7 @@ { "cell_type": "code", "execution_count": 23, - "id": "e6291958", + "id": "2f2a90ee", "metadata": {}, "outputs": [ { diff --git a/6-month-milestone/evaluation/scenario_2/ta_3/ciemss/scenario2_q2b_SIDARTHEV_delta.ipynb b/6-month-milestone/evaluation/scenario_2/ta_3/ciemss/scenario2_q2b_SIDARTHEV_delta.ipynb index 88b60c6..e949bfc 100644 --- a/6-month-milestone/evaluation/scenario_2/ta_3/ciemss/scenario2_q2b_SIDARTHEV_delta.ipynb +++ b/6-month-milestone/evaluation/scenario_2/ta_3/ciemss/scenario2_q2b_SIDARTHEV_delta.ipynb @@ -389,10 +389,12 @@ "id": "c65bcf10-9d12-4efe-be10-cc313e123d14", "metadata": {}, "source": [ - "## 1.d Policies that prevent infections from exceeding 1/3 of the population\n", + "## 2..b.i Policies that prevent infections from exceeding 1/3 of the population\n", "\n", - "Now return to the situation in b.i (constant parameters that don’t change over time). Let’s say we want to increase testing, diagnostics, and contact tracing efforts (implemented by increasing the detection parameters and ). Assume that $\\theta \\ge 2\\epsilon$ , because a symptomatic person is more likely to be tested. What minimum constant values do these parameters need to be over the course of a 100-day simulation, to ensure that the total infected population (sum over all the infected states I, D, A, R, T) never rises above 1/3 of the total population?\n", + "Let’s say our goal is to ensure that the total infected population (sum over all the infected states I, D, A, R, T) never rises above 1/3 of the total population, over the course of the next 100 days. If you could choose only a single intervention (affecting only one parameter), which intervention would let us meet our goal, with minimal change to the intervention parameter? Assume that the intervention will be implemented after one month (t = day 30), and will stay constant after that, over the remaining time period (i.e. the following 70 days). What are \n", + "equivalent interventions of the other two intervention types, that would have the same impact on total infections?\n", "\n", + "*Note that we started implementing intervention after t=15 days. \n", "\n", "### Problem Formulation\n", "* **Quantity of interest**: Total infections out of $N=60,000,000$ population\n", @@ -405,13 +407,12 @@ "\n", "\n", "* **Control**: $\\mathbf{u}\\in \\mathcal{U} \\subseteq \\mathbb{R}^{n_u}$\n", - " * Detection parameter for Infected ($\\epsilon$) assuming that $\\theta=2\\epsilon$\n", - " * Two detection parameters $\\theta, \\epsilon$, constraining $\\theta \\ge 2\\epsilon$.\n", + " * Transmission parameter $\\delta$\n", " \n", "\n", "\n", "* **Risk-based optimization under uncertainty problem formulation**\n", - " * Objective Function - Minimize the magnitude of the parameter interventions.\n", + " * Objective Function - Minimize the change in the magnitude of parameter interventions from the initial value $\\delta_\\text{init}=0.011$.\n", " * Constraint - Risk of normalized total infections exceeding the prescribed threshold of $1/3$, $\\mathcal{R}( M(\\mathbf{u},\\mathbf{Z}))$, is below the acceptable risk threshold, $\\mathcal{R}_\\text{threshold}$.\n", "\n", "\\begin{equation} \n", @@ -420,22 +421,14 @@ "\\end{split} \n", "\\end{equation}\n", "\n", - "#### Formulation 1: Optimize $u=\\{\\alpha, \\beta, \\gamma, \\delta\\}$\n", + "#### Formulation 1: Optimize for $u=\\delta$\n", "\\begin{equation} \n", "\\begin{split} \n", - "u^*= \\underset{\\epsilon\\in\\mathcal{U}}{\\arg\\min}\\ & u\\\\ \\text{s.t.}\\ & \\mathbb{P}( M(u, \\mathbf{Z}) \\ge 1/3) \\le 0.05\n", + "u^*= \\underset{\\epsilon\\in\\mathcal{U}}{\\arg\\min}\\ & \\lvert \\delta_\\text{init}-u \\rvert \\\\ \\text{s.t.}\\ & \\mathbb{P}( M(u, \\mathbf{Z}) \\ge 1/3) \\le 0.05\n", "\\end{split} \n", "\\end{equation}\n", "\n", - "#### Formulation 2: Optimize $\\epsilon$ and $\\theta$ constraining $\\theta \\ge 2\\epsilon$\n", - "\\begin{equation} \n", - "\\begin{split} \n", - "\\epsilon^\\ast, \\theta^\\ast= \\underset{\\{\\epsilon,\\theta\\}\\in\\mathcal{U}}{\\arg\\min}\\ & \\theta + \\epsilon \\\\ \\text{s.t.}\\ & \\mathbb{P}( M(\\epsilon,\\theta, \\mathbf{Z}) \\ge 1/3) \\le 0.05, \\\\\n", - "& \\theta \\ge 2\\epsilon\n", - "\\end{split} \n", - "\\end{equation}\n", - "\n", - "Instead of probability of exceedance, we will use superquantiles as risk measures." + "Instead of probability of exceedance, we will use superquantiles as risk measures." ] }, { @@ -720,7 +713,7 @@ { "cell_type": "code", "execution_count": 25, - "id": "01c8c67c", + "id": "f71a01d6", "metadata": {}, "outputs": [ { diff --git a/6-month-milestone/evaluation/scenario_2/ta_3/ciemss/scenario2_q2b_SIDARTHEV_phiflux.ipynb b/6-month-milestone/evaluation/scenario_2/ta_3/ciemss/scenario2_q2b_SIDARTHEV_phiflux.ipynb index a13e220..001595c 100644 --- a/6-month-milestone/evaluation/scenario_2/ta_3/ciemss/scenario2_q2b_SIDARTHEV_phiflux.ipynb +++ b/6-month-milestone/evaluation/scenario_2/ta_3/ciemss/scenario2_q2b_SIDARTHEV_phiflux.ipynb @@ -389,10 +389,12 @@ "id": "c65bcf10-9d12-4efe-be10-cc313e123d14", "metadata": {}, "source": [ - "## 1.d Policies that prevent infections from exceeding 1/3 of the population\n", + "## 2..b.i Policies that prevent infections from exceeding 1/3 of the population\n", "\n", - "Now return to the situation in b.i (constant parameters that don’t change over time). Let’s say we want to increase testing, diagnostics, and contact tracing efforts (implemented by increasing the detection parameters and ). Assume that $\\theta \\ge 2\\epsilon$ , because a symptomatic person is more likely to be tested. What minimum constant values do these parameters need to be over the course of a 100-day simulation, to ensure that the total infected population (sum over all the infected states I, D, A, R, T) never rises above 1/3 of the total population?\n", + "Let’s say our goal is to ensure that the total infected population (sum over all the infected states I, D, A, R, T) never rises above 1/3 of the total population, over the course of the next 100 days. If you could choose only a single intervention (affecting only one parameter), which intervention would let us meet our goal, with minimal change to the intervention parameter? Assume that the intervention will be implemented after one month (t = day 30), and will stay constant after that, over the remaining time period (i.e. the following 70 days). What are \n", + "equivalent interventions of the other two intervention types, that would have the same impact on total infections?\n", "\n", + "*Note that we started implementing intervention after t=15 days. \n", "\n", "### Problem Formulation\n", "* **Quantity of interest**: Total infections out of $N=60,000,000$ population\n", @@ -405,13 +407,12 @@ "\n", "\n", "* **Control**: $\\mathbf{u}\\in \\mathcal{U} \\subseteq \\mathbb{R}^{n_u}$\n", - " * Detection parameter for Infected ($\\epsilon$) assuming that $\\theta=2\\epsilon$\n", - " * Two detection parameters $\\theta, \\epsilon$, constraining $\\theta \\ge 2\\epsilon$.\n", + " * Transmission parameter $\\delta$\n", " \n", "\n", "\n", "* **Risk-based optimization under uncertainty problem formulation**\n", - " * Objective Function - Minimize the magnitude of the parameter interventions.\n", + " * Objective Function - Minimize the magnitude of vaccination rate flux $SV_\\text{flux}$.\n", " * Constraint - Risk of normalized total infections exceeding the prescribed threshold of $1/3$, $\\mathcal{R}( M(\\mathbf{u},\\mathbf{Z}))$, is below the acceptable risk threshold, $\\mathcal{R}_\\text{threshold}$.\n", "\n", "\\begin{equation} \n", @@ -420,22 +421,14 @@ "\\end{split} \n", "\\end{equation}\n", "\n", - "#### Formulation 1: Optimize $u=\\{\\alpha, \\beta, \\gamma, \\delta\\}$\n", + "#### Formulation 1: Optimize for $u=SV_\\text{flux}$\n", "\\begin{equation} \n", "\\begin{split} \n", - "u^*= \\underset{\\epsilon\\in\\mathcal{U}}{\\arg\\min}\\ & u\\\\ \\text{s.t.}\\ & \\mathbb{P}( M(u, \\mathbf{Z}) \\ge 1/3) \\le 0.05\n", + "u^*= \\underset{\\epsilon\\in\\mathcal{U}}{\\arg\\min}\\ & u \\\\ \\text{s.t.}\\ & \\mathbb{P}( M(u, \\mathbf{Z}) \\ge 1/3) \\le 0.05\n", "\\end{split} \n", "\\end{equation}\n", "\n", - "#### Formulation 2: Optimize $\\epsilon$ and $\\theta$ constraining $\\theta \\ge 2\\epsilon$\n", - "\\begin{equation} \n", - "\\begin{split} \n", - "\\epsilon^\\ast, \\theta^\\ast= \\underset{\\{\\epsilon,\\theta\\}\\in\\mathcal{U}}{\\arg\\min}\\ & \\theta + \\epsilon \\\\ \\text{s.t.}\\ & \\mathbb{P}( M(\\epsilon,\\theta, \\mathbf{Z}) \\ge 1/3) \\le 0.05, \\\\\n", - "& \\theta \\ge 2\\epsilon\n", - "\\end{split} \n", - "\\end{equation}\n", - "\n", - "Apart from probability of exceedance, we will explore quantiles and superquantiles as risk measures." + "Instead of probability of exceedance, we will use superquantiles as risk measures." ] }, { @@ -729,7 +722,7 @@ { "cell_type": "code", "execution_count": 25, - "id": "f4b79578", + "id": "7875522b", "metadata": {}, "outputs": [], "source": [ @@ -748,7 +741,7 @@ { "cell_type": "code", "execution_count": 20, - "id": "1c28411a", + "id": "bc8b9444", "metadata": {}, "outputs": [], "source": [ @@ -854,7 +847,7 @@ { "cell_type": "code", "execution_count": null, - "id": "f999249d", + "id": "2241aebb", "metadata": {}, "outputs": [], "source": []