diff --git a/BDA 2.11.13.ipynb b/BDA 2.11.13.ipynb new file mode 100644 index 0000000..4a8ac4d --- /dev/null +++ b/BDA 2.11.13.ipynb @@ -0,0 +1,664 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Problem 2.10.13\n", + "\n", + "Discrete data: Table 2.2 gives the number of fatal accidents and deaths on scheduled airline flights per year over a ten-year period. \n", + "We use these data as a numerical example for fitting discrete data models. \n", + "\n", + "1. Assume that the numbers of fatal accidents in each year are independent with a Poisson(theta) distribution. Set a prior distribution for theta and determine the posterior distribution based on the data from 1976 through 1985. Under this model, give a 95% predictive interval for the number of fatal accidents in 1986. You can use the normal approximation to the gamma and Poisson or compute using simulation.\n", + "2. Assume that the numbers of fatal accidents in each year follow independent Poisson distributions with a constant rate and an exposure in each year proportional to the number of passenger miles flown. Set a prior distribution for theta and determine the posterior distribution based on the data for 1976–1985. (Estimate the number of passenger miles flown in each year by dividing the appropriate columns of Table 2.2 and ignoring round-off errors.) Give a 95% predictive interval for the number of fatal iaccidents in 1986 under the assumption that 8 × 10 11 passenger miles are flown that year.\n", + "3. Repeat (1) above, replacing ‘fatal accidents’ with ‘passenger deaths.’\n", + "4. Repeat (2) above, replacing ‘fatal accidents’ with ‘passenger deaths.’\n", + "5. In which of the cases above does the Poisson model seem more or less reasonable? Why? Discuss based on general principles,without specific reference to the numbers in Table 2.2. Incidentally, in 1986, there were 22 fatal accidents, 546 passenger deaths, and a death rate of 0.06 per 100 million miles flown. We return to this example in Exercises 3.12, 6.2, 6.3, and 8.14.\n", + "\n", + "|Year |Fatal accidents |Passenger deaths |Death rate\n", + "|---|---|---|---| \n", + "|1976 | 24 | 734 | 0.19 \n", + "|1977 |25 |516 |0.12 \n", + "|1978 |31 |754 |0.15 \n", + "|1979 |31 |877 |0.16 \n", + "|1980 |22 |814 |0.14 \n", + "|1981 |21 |362 |0.06 \n", + "|1982 |26 |764 |0.13 \n", + "|1983 |20 |809 |0.13 \n", + "|1984 |16 |223 |0.03 \n", + "|1985 |22 |1066 |0.15 \n", + "\n", + "+ Table 2.2 Worldwide airline fatalities, 1976–1985.\n", + "+ Death rate is passenger deaths per 100 million passenger miles.\n", + "+ Source: Statistical Abstract of the United States.\n", + "\n", + "Gelman, Andrew; Carlin, John B.; Stern, Hal S.; Dunson, David B.; Vehtari, Aki; Rubin, Donald B.. Bayesian Data Analysis, Third Edition (Chapman & Hall/CRC Texts in Statistical Science) (Page 60). CRC Press. Kindle Edition. \n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
DeathsFatalRateyearMiles
0734240.1919763863.0
1516250.1219774300.0
2754310.1519785027.0
3877310.1619795481.0
4814220.1419805814.0
5362210.0619816033.0
6764260.1319825877.0
7809200.1319836223.0
8223160.0319847433.0
91066220.1519857107.0
\n", + "
" + ], + "text/plain": [ + " Deaths Fatal Rate year Miles\n", + "0 734 24 0.19 1976 3863.0\n", + "1 516 25 0.12 1977 4300.0\n", + "2 754 31 0.15 1978 5027.0\n", + "3 877 31 0.16 1979 5481.0\n", + "4 814 22 0.14 1980 5814.0\n", + "5 362 21 0.06 1981 6033.0\n", + "6 764 26 0.13 1982 5877.0\n", + "7 809 20 0.13 1983 6223.0\n", + "8 223 16 0.03 1984 7433.0\n", + "9 1066 22 0.15 1985 7107.0" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from scipy.stats import poisson, gamma, gengamma\n", + "from sklearn.linear_model import LinearRegression\n", + "import pystan\n", + "airline_df=pd.DataFrame(dict({'year':[x for x in range(1976,1986)],'Fatal':[24,25,31,31,22,21,26,20,16,22],'Deaths':[734,516,754,877,814,362,764,809,223,1066],'Rate':[.19,.12,.15,.16,.14,.06,.13,.13,.03,.15]}))\n", + "airline_df.set_index('year')\n", + "airline_df['Miles']=np.round(airline_df['Deaths']/airline_df['Rate'],0)\n", + "airline_df" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Deaths vs miles (out of order -- this is part (3))" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:pystan:COMPILING THE C++ CODE FOR MODEL anon_model_d23d1d0b2e2b2dabfc71364b95c0d024 NOW.\n" + ] + } + ], + "source": [ + "stan_code='''\n", + "data {\n", + " int deaths[10];\n", + "}\n", + "parameters {\n", + " real theta ; \n", + "}\n", + "model {\n", + "\n", + " // this prior tends to say the number of deaths is between 600 and 800\n", + " theta~gamma(691,1);\n", + " deaths~poisson(theta);\n", + "}\n", + "\n", + "'''\n", + "sm_simple=pystan.StanModel(model_code=stan_code)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Inference for Stan model: anon_model_d23d1d0b2e2b2dabfc71364b95c0d024.\n", + "4 chains, each with iter=2000; warmup=1000; thin=1; \n", + "post-warmup draws per chain=1000, total post-warmup draws=4000.\n", + "\n", + " mean se_mean sd 2.5% 25% 50% 75% 97.5% n_eff Rhat\n", + "theta 691.9 0.25 8.18 675.85 686.54 691.81 697.26 708.22 1103 1.0\n", + "lp__ 4.2e4 0.02 0.76 4.2e4 4.2e4 4.2e4 4.2e4 4.2e4 1461 1.0\n", + "\n", + "Samples were drawn using NUTS at Mon Apr 16 10:55:25 2018.\n", + "For each parameter, n_eff is a crude measure of effective sample size,\n", + "and Rhat is the potential scale reduction factor on split chains (at \n", + "convergence, Rhat=1).\n" + ] + } + ], + "source": [ + "print(deaths)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "From the stan output reported above, the 95% interval for the poisson rate is (675,707)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:pystan:COMPILING THE C++ CODE FOR MODEL anon_model_9a1f6e45cdebbb8b75bf8564a74768dd NOW.\n" + ] + } + ], + "source": [ + "stan_code='''\n", + "data {\n", + " int deaths[10];\n", + " vector[10] miles;\n", + "}\n", + "parameters {\n", + " real theta ; \n", + "}\n", + "model {\n", + " // 691 is the average number of deaths\n", + " // 5715 is the averaage number of miles\n", + " // so gamma prior is about 691 deaths per 5715 miles\n", + " theta~gamma(691,5715);\n", + " deaths~poisson(miles*theta);\n", + "}\n", + "generated quantities {\n", + " int predicted[10] ; \n", + " int answer ; \n", + " \n", + " for(i in 1:10)\n", + " predicted[i]=poisson_rng(miles[i]*theta);\n", + " answer=poisson_rng(8000*theta) ; \n", + "}\n", + "\n", + "'''\n", + "sm_weights=pystan.StanModel(model_code=stan_code)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/jteitelbaum/anaconda3/lib/python3.6/site-packages/pystan/misc.py:399: FutureWarning: Conversion of the second argument of issubdtype from `float` to `np.floating` is deprecated. In future, it will be treated as `np.float64 == np.dtype(float).type`.\n", + " elif np.issubdtype(np.asarray(v).dtype, float):\n" + ] + } + ], + "source": [ + "deaths_wtd=sm_weights.sampling(data=dict({'deaths':airline_df['Deaths'],'miles':airline_df['Miles']}))" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Inference for Stan model: anon_model_37d152c75a3e2c95f06248eb3357d905.\n", + "4 chains, each with iter=2000; warmup=1000; thin=1; \n", + "post-warmup draws per chain=1000, total post-warmup draws=4000.\n", + "\n", + " mean se_mean sd 2.5% 25% 50% 75% 97.5% n_eff Rhat\n", + "theta 0.12 3.7e-5 1.4e-3 0.12 0.12 0.12 0.12 0.12 1459 1.0\n", + "predicted[0] 467.72 0.36 22.23 425.0 453.0 468.0 483.0 512.0 3796 1.0\n", + "predicted[1] 520.0 0.41 23.67 474.0 503.0 520.0 536.0 566.0 3272 1.0\n", + "predicted[2] 608.23 0.43 25.42 559.0 591.0 608.0 625.0 658.0 3426 1.0\n", + "predicted[3] 663.18 0.45 26.81 611.0 645.0 663.0 681.0 716.0 3581 1.0\n", + "predicted[4] 704.22 0.47 27.73 651.0 686.0 704.0 722.0 761.0 3537 1.0\n", + "predicted[5] 729.83 0.47 28.63 672.0 710.0 730.0 749.0 787.0 3657 1.0\n", + "predicted[6] 711.57 0.48 28.39 657.4 692.0 711.0 730.0 769.0 3542 1.0\n", + "predicted[7] 753.78 0.46 28.29 698.4 734.0 754.0 773.0 810.59 3732 1.0\n", + "predicted[8] 898.95 0.56 31.12 840.0 877.0 898.0 920.0 962.0 3120 1.0\n", + "predicted[9] 860.63 0.51 30.58 802.0 840.0 860.0 881.0 922.0 3531 1.0\n", + "lp__ 3.6e4 0.02 0.72 3.6e4 3.6e4 3.6e4 3.6e4 3.6e4 1735 1.0\n", + "\n", + "Samples were drawn using NUTS at Mon Apr 16 10:56:28 2018.\n", + "For each parameter, n_eff is a crude measure of effective sample size,\n", + "and Rhat is the potential scale reduction factor on split chains (at \n", + "convergence, Rhat=1).\n" + ] + } + ], + "source": [ + "\n", + "print(deaths_wtd)\n", + "predicted=deaths_wtd.extract()['predicted']\n" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY4AAAEWCAYAAABxMXBSAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzs3Xd4XNWZ+PHvO0Wj3i1bzdhyt2kGuRAwYJppDiaADSEBsiFZErYk2ZDApm3ab5OQ3WyySTabDUkgIUQCjIMpcegdbBljG+OKsVGXLKtLM5pyfn/cK1llxtJYo2a9n+fRo5lzyzn3ajTvvefcc44YY1BKKaWGyjHWBVBKKTWxaOBQSikVFQ0cSimloqKBQymlVFQ0cCillIqKBg6llFJR0cChEBEjIrPHuhzDISJPi8it9uvbROTVsS4T9C1XhOW/F5HvjWaZIhGRQyJyyRDWm2F/ZlyjUa4w+fecMxFZISJ7T3A/vxKRb8S2dJODBo5xxv7n7RSRVhFpEpHXReQOEYnJ30pEXhSR22Oxr9Fgf0HV9v6SEhGXiNSJSE8nJGPMFcaY+8emlJH1Ltd4CmgnC2PMK8aYeYOtF+7cG2PuMMZ8d+RKd/LSwDE+rTbGpACnAD8AvgrcN7ZFGlNNwBW93l8JNI5RWVQMjdVdixoeDRzjmDGm2RjzOLAOuFVETgUQEY+I/FhEPrSvxn8lIgn2sgwReUJE6kWk0X5dYC/7PrAC+LmItInIz3tld4mI7Le3+YWIiL3NbBF5SUSaReSIiJSEK6uI/FVE/qFf2nYR+ZhYfmLfJTSLyI7uYxmiPwC39Hp/C/BAv7wi3kmJyHwReUZEjorIXhFZ22vZlSLynn2HVykiXx6sMCIy074bdNjvfyMidb2W/1FEvtC7XCKyAPgVcI597pt67TJDRJ60y/CWiMyKkG93FdGnRKTc/lvdISJL7HPa1PtvKiIOEfm6iBy2z/0DIpLWa/kn7WUNIvK1fnk5RORuEXnfXl4qIpmDnRt720Mico99XhtF5HciEm8vu1BEKkTkqyJSA/zOTr9aRN7pdZd9eq/9LRaRt+3zUwLE91p2oYhU9HpfKCLr7c9/g4j8PNK5l37VhCLyGRE5YH9OHheRvF7LjH2uT/h/5KRijNGfcfQDHAIuCZP+IfA5+/V/AY8DmUAKsBH4d3tZFnAdkGgvexjY0Gs/LwK399u3AZ4A0oHpQD1wub3sIeBrWBcZ8cB5Ecp9C/Bar/cLse4UPMAqYKu9fwEWALlDPB8GOBWotbdPt1+fan18Bx4XcBvwqv06CSgHPgW4gLOAI8Aie3k1sMJ+nQGcNcRyfQicbb/eCxwEFvRatvh45eq1n98DR4GldvkeBP4cIc8Z9vn4lf23uAzwAhuAHCAfqAMusNf/O+AAUAQkA+uBP/T6+7QB59t/o/8EAtifPeALwJtAgb38f4GH+pXDdZzP8LtAIdZn9DXge/ayC+18fmjvN8H+m9QBywAncKu9Dw8QBxwGvgi4gesBf7/9VdivncB24Cf2373n83qcc9+9n4vsz8VZdr7/Dbwcy/+Rk+lH7zgmjiog077K+QzwRWPMUWNMK/D/gBsBjDENxphHjTEd9rLvAxcMYf8/MMY0GWM+BF4AzrTT/VhVZnnGGK8xJlId/WPAmSJyiv3+ZmC9McZn7yMFmA+IMWa3MaY6imP3YgXHdfZxPm6nDcXVwCFjzO+MMQFjzNvAo1hfQN3Ht1BEUo0xjfbyoXgJuEBEptnvH7HfzwRSsb7Ahmq9MWazMSaAFTjOHGT979p/i78B7Vhf6HXGmErgFWCxvd7NwH8aYw4aY9qAe4Abxaoeuh54whjzsv03+gYQ6pXH3wNfM8ZU2Mv/Dbhehl619HNjTLkx5ijWZ/CmXstCwLeMMT5jTCfW5/l/jTFvGWOCxmoT8gHL7R838F/GGL8x5hFgS4Q8lwJ5wF3GmPZBPq/93Qz81hjztn2892Ddoczotc5w/0dOGho4Jo58rCvTKVh3E1vt2/om4K92OiKSKCL/a1dBtAAvA+ki4hxk/zW9XndgXaECfAXrLmGziOwSkb8Lt7EdpJ7EDmD27wftZc8DPwd+AdSKyK9FJDWKYwerauoWwlRTDeIUYFn3ubLP181A9xf+dVhtJoft6oZzhrjfl7Cuds/HOscvYgXoC4BXjDGhiFsOFOncR1Lb63VnmPfd2+dhXa13O4x1VzPVXlbevcAY0w409Fr3FOCxXudsNxC0tx2K8l6vD9v5das3xvQO/KcA/9Lvb1Rob5MHVBr70r7X/sIpBA7bAThafc6VHWgbsP7vug3rf+RkooFjAhCRJVgf4Fexbqc7sapa0u2fNGNM94f4X4B5wDJjTCrWFxtYH2ywbrmHzBhTY4z5jDEmD+sq9JcS+dHdh4Cb7C/fBKyrsu79/MwYczawCJgL3BVNObCupHOxvriiuaIrB17qda7SjTHJxpjP2eXaYoy5BquqZwNQOsT9voTVXnSh/fpV4FyswPFShG1GeyjqKqwv5W7TsaqJarGq6Aq7F4hIIlY1Z7dy4Ip+5y3evqsZisJer6fbZenW/zyUA9/vl1eiMeYhu5z53e0JvfYXTjkwPcJd0WDnvs+5EpEkrPMx6PFG+T9yUtDAMY6JSKqIXA38GfijMWanfSX7f8BPRCTHXi9fRFbZm6VgBZYmuzHzW/12W4tV5z3UMtwgduM61pNMBuvKM5ynsP75vgOUdF912423y0TEjVW14j3OPsKyrzhXAx/td/U5mCeAuXZDsNv+WSIiC0QkTkRuFpE0Y4wfaOldLrtB9MII5dmPdZ4/gVUX3oJ1bq8jcuCoBQpEJC6K8g/HQ8AXxWrMT8aq0iyxr8gfAa4WkfPs8nyHvt8HvwK+3131KCJTROSaKPK+U0QK7M/gvwLHazD+P+AO+zMiIpIkIleJSArwBlaw+yexHsP+GFaVVDibsQLND+x9xIvIufaywc79n4BPiciZIuLBOldvGWMODXagUf6PnBQ0cIxPG0WkFesK6mtYDZef6rX8q1iNnm/a1VHPYt1lgNVwnoB1Z/ImVjVWbz/FqqtuFJGfDaEsS4C3RKQNq23hn40xH4Rb0a4bXg9cgvWP2C0V68uhEas6oAH4MYCI/KuIPD2EcmCM2WWM2TWUdXtt04rViHwj1lVlDccaZgE+CRyyz+MdWIEA+4ugDdh5nN2/BDTYdd7d7wXYFmH954FdQI2IHInmOE7Qb7GeSHsZ+AArYP8jWOcSuBPr71SN9bep6LXtT7H+3n+zP4tvYjVeD9WfgL9hPTRwEIjYydEYU4bVzvFzuxwHsBqzMcZ0AR+z3zditXOtj7CfINbFxWysBxQq7PVhkHNvjHkOq53nUazzMYtj1a6DGfL/yMlCort4U2pyEJFPYFUH3jPWZZloROQQ1pNkz451WdTI0M43SoVhjPnjWJdBqfFKq6qUUkpFRauqlFJKRUXvOJRSSkXlpGzjyM7ONjNmzBjrYiil1ISydevWI8aYKYOtd1IGjhkzZlBWVjbWxVBKqQlFRCL1yu9Dq6qUUkpFRQOHUkqpqGjgUEopFRUNHEoppaKigUMppVRUTsqnqpRSk8uGbZXcu2kvVU2d5KUncNeqeaxZnD/4huqEaOBQSk1oG7ZVcs/6nXT6rZHMK5s6uWe9NaixBo+RoVVVSqkJ7d5Ne3uCRrdOf5B7N+0doxKd/DRwKKUmtKqmzqjS1fBp4FBKTWh56QlRpavh08ChlJrQ7lo1jwS3s09agtvJXavmRdhCDZc2jiulJrTuBnB9qmr0aOBQSk14axbna6AYRVpVpZRSKioaOJRSSkVFA4dSSqmoaOBQSikVFQ0cSimloqKBQymlVFQ0cCillIqKBg6llFJRGbHAISK/FZE6EXm3V1qmiDwjIvvt3xl2uojIz0TkgIjsEJGzem1zq73+fhG5daTKq5RSamhG8o7j98Dl/dLuBp4zxswBnrPfA1wBzLF/Pgv8D1iBBvgWsAxYCnyrO9gopZQaGyMWOIwxLwNH+yVfA9xvv74fWNMr/QFjeRNIF5FcYBXwjDHmqDGmEXiGgcFIKaXUKBrtNo6pxphqAPt3jp2eD5T3Wq/CTouUPoCIfFZEykSkrL6+PuYFV0opZRkvjeMSJs0cJ31gojG/NsYUG2OKp0yZEtPCKaWUOma0A0etXQWF/bvOTq8ACnutVwBUHSddKaVGzaM1Ryl+fRe5L7xD8eu7eLSmfy385DLageNxoPvJqFuBv/RKv8V+umo50GxXZW0CLhORDLtR/DI7TSmlRsWjNUf58t5yKnx+DFDh8/PlveWTOniM5OO4DwFvAPNEpEJEPg38ALhURPYDl9rvAZ4CDgIHgP8DPg9gjDkKfBfYYv98x05TSqlR8e8Hq+kM9a0h7wwZ/v1g9RiVaOyN2EROxpibIiy6OMy6Brgzwn5+C/w2hkVTSqkhq/T5o0qfDMZL47hSSo1L03xhn8eJmD4ZaOBQSqnj+PweL/HBQJ+0+GCAz+/xjlGJxp4GDqWUOo7r217kR3vvpcBbg5gQBd4afrT3Xq5ve3Gsi9bHgbpWvv/ke/zhjUMjnteItXEopdRo+fqO57m/TvA70nGHmrg1x/C90y+Kyb7jXPeT1NFMZuUOulxOMgNBkjqaiHNtB+6JSR4nqs0X4IntVZSUlbPtwyZcDuGWc2aMeL4aOJRSE9rXdzzPffVJGKcHAL8zg/vqfbDj+ZgEj+edLfyuazrnvpJBktdJe3yQ++amEoorZ/Ww9x49YwxbDzdSsqWcJ3dW09EVZHZOMl+7cgHXnpVPdrJnxMuggUMpNaHdXyc9QaObcXi4v66D78Vg/w95T+Gc3Rk4glbNfrLXxTm7snhogWNUA0ddq5f1b1dSWlbOwfp2kuKcfPSMPNYuKWRxYToi4QbaGBkaOJRSE5rfkR5VerROez+1J2h0cwQdnPZ+akz2fzyBYIgX99ZTUlbO83vqCIYMxadkcMf1s7jqtFySPGPzFa6BQyk1obn8DQTissOmx0JcZ/ivyUjpsfDBkXZKy8p5dGsFda0+spPjuP28mdxQXMjsnOQRy3eoNHAopSa0pe+U8Hrx7eDoVV0V8rH0nRJYdcmw9+9O9pM0tZO8ZXW4kwP421xUvZVDe23CsPfdW0dXgKd21lC6pZzNh47iEFg5L4e1Swq5aH4Obuf4eQhWA4dSakJrSt5MylGhPX0tIWcWjmADSU2lNCVvjsn+C1ZUk5zbidNtdfiLSwlQeEE1bdXDDxzGGLZXNFOypZyN26to8wWYkZXIVy6fx3VnFTA1NX7YeYwEDRxKqQmtPilEfMcbxHe80S89Nvt3TzM9QaOb021wTzvxnuNH27t4bFslpVvK2VvbSrzbwZWn5bKuuJClMzNHtaH7RGjgUEpNaHGhBLqcnWHTYyHBPXDfx0uPJBgyvLK/nofLKvjbezX4g4YzCtL4/rWnsvqMPFLj3bEo7qjQwKGUmtCuTOvC7LqeU2rOpSvkIM4R4vC015BFj8Vk/0ckmykcCZs+FOVHO3i4rJxHtlZQ1ewlI9HNJ5afwrolhcyfNvJPZo0EDRxKqQntnMOrebp+Of+d1EWLw5AaEi6oX84VhwODbzwET/vWsC7u93jk2P58xsXTXWu4McI2Xn+QTbtqKC0r57UDDYjAijlT+NpVC7lkYQ4elzMmZRsrGjiUUhPa3w6dy9OJAQJ2s0CL0/B0YgDnoXO5Mgb7b3pnNyWz3VydFiTDaWgMCk80u2k6sBuu6LvuriqroXvDtkpavAHy0xP44iVzub64gPz02D6FNZY0cCilJrTnPSFmtu3jI41vkRJso9WZzOsZy3g+cV5M9l+bvoODHcLbHX2/+JPSdwDQ3OHnL9srKdlSzq6qFuJcDlYtmsa64kI+MisLh2N8N3SfCA0cSqkJbWrHXi5teBGnCQKQGmzj0oYXeQYgBvcc7QnBAWnGCM2hGfzzn7fx13dr8AVCLMhN5d9WL2TN4nzSE+OGne94poFDKTWhXdj0Wk/Q6OY0QS5seg344rD37+hKJuRpAyDkT8PffDb+prMx/iyer69jbXEh65YUcmp+2rDzmig0cCilJjRPIPyESpHSo9VWdxVmSohASzHSYBBAko/gcH7Alq99jnj3xG7oPhEaOJRSE5o4UiDUGj59GPbVtlKypZxA+2KkDcQjBIuSCeYngmcaznebJmXQAA0cahLZsK2Sezftpaqpk7z0BO5aNY81i/PHulhqmELJZ+JoeQPo/fiti1DymVHvq9Xr54kd1ZRsKeed8ibcToFMD12nJBPK9kCvHt2OOZOnaqo/DRxqUtiwrZJ71u+k02/VhVc2dXLP+p0AGjwmuKy8MpqCKzGdb1p3Ho4UJGE5WXmvDml7YwxbDlkTIz21s5pOf5A5Ocl8/aoFXLs4n0Wb3+sTMLp1JUzOuw3QwKEmiXs37e0JGt06/UHu3bRXA8cEN8PhovGsDSTMaCEuoYmuznQ6D9WQ0TDtuNvVtXp5dGslD5eVc/CINTHSmsV53FDcd2KktI4QzUkDg0RaR2hEjmci0MChJoWqpvDjCkVKVxNHelIrwbkVOFzWF7knsQn33BbSdwwc5TAQDPHC3npKtpTzwl5rYqQlMzL43IWzuOr0XBLjBn4lrtzZwBPF2QRcx4Y1dwVCrNzZAFeP3HGNZxo41KSQl55AZZggkXcS9eadrGrnHiLO1ffq3+EKUTv3UM/7g/VtlJZV8OjbFdS3+shO9nD7ipmsLS5k1pTjT4y0vP1RWvcu5a1ZC2jzJJDs62TZ+7tZ3r4ZuGwEjmj808ChJoW7Vs3r08YBkOB2cteq2PQuVmMnLqmTN6rO5rEDq2nwZpAV38i1szdyVs5OHi4rp7SsnC2HGnE6hJXzprC2uJCVUUyMVNuVhqOmHU9FDQHi8NCFw9VObZc2jit1Uutux9Cnqk4+b+0/mwc+vImukNVbu8GbyW/f/QT3SxC/2cHM7CS+evl8rjsrn5wTmBjpXXc+rwdmEMRq52jHw+uBGeA+8fk4JjoNHGrSWLM4XwPFSejhD9bQJX2H+AjhxBUKUnrHOSyZkTGsiZG2BQt7gka3IE62BQtPeJ8TnQYOpdSEFAwZXt5fT6OEn9OiS9wsnZk57HzaTByEiTtt5uQej+p4NHAopSaUDxs6eHirNTFSdXPkYUWS6IpJflPFQS0Dq6WmytDaSE5Gk/fIlTpZ7CiFn5wK/5Zu/d5ROtYlijmvP8hf3qnk4//3Juff+wI/f+EAc6em8Mubz2JBRh2m3zeZccApmU0xyftz+PD0S/PY6ZOV3nEoNZHtKOWF+57gvc7vYiQVqWph4aHHWPlp4PS1Y126YXu3spnSsmMTIxVkJPClS+dy/dkFPY9S311xCv6j8bj2tyLeICbeSWBOChWZ0TeEh3Od6/eYwOf4FSHqMOQg3IGD61y/B66NSR4TjQYOpSawF+5/lt3ej4MjzqqGlzTr/f3rWfkfEzNwNHf42fCONTHSe9XWxEhXnGpNjLS8aODESPWeDEyeg668vh3+6k1s+uhUu4QbzK+5PHgzQbJxcoQU54NUuYThDaM4cWngUGoC29d2GabfE0VG4tjXdhkrx6hMJyIUMrxxsIGSLeX8dVcNXYEQi/JS+c41i7jmjHzSEt0Rt030dtKeMLCXeKI3NqMCuIJ34jNvMCXuqzjlCEGTTXPgFlzBc2Ky/4lIA4dSMTTaI/AGJD2q9PGmqqmTh8sqeHhrORWNnaTGu7hpSSE3FA99YqQ5+wLsOTWA13ns6yw+GGDOvkAsJgDE3eWhU1bS2dU3FLuD2o9DKTVMYzECb5KjgfbQlLDp45UvEOTZ9+ooKSvnlf31GAPnzs7irlXzWLVoWtRzXHyvxrANP7+Y66A2XpjqNdy5z8/imth8sXcEWkhyDwxiHYGWmOx/ItLAoVSMxGIE3h07dvDcc8/R3NxMWloaF198MaeffnrE9Zcn/4GXWj5PgGMNwS68LE/+A7DuhI5jpOytsSZGemxbBY0dfnLT4vnHlbO5obiQwszEE95vDg6uqAlwRU2gT3ooRg+N7mh6mSVZl+NyHKsuC4T87Gh6mXmTdJTDMQkcIvJF4HbAADuBTwG5wJ+BTOBt4JPGmC4R8QAPAGcDDcA6Y8yhsSi3Uscz3BF4d+zYwcaNG/H7/QA0NzezceNGgIjBIzl+Nyv5JW+0fYK2UDbJjiOck/xHEuN3n8ARxF6r18/G7dWUlJWz3Z4Y6dKFU1lbXMiKOVNwOk68R3e32ngHud6Bdxe18Q6mD3vv8GHbe2AMp2dcQKIrlY5ACzsaX+LD9vFxjsfCqAcOEckH/glYaIzpFJFS4Eas2sifGGP+LCK/Aj4N/I/9u9EYM1tEbgR+yHi7lFKK4Y/A+9xzz1HYmcmSwCySiacNL1sC7/Pcc89FDBw/CqzlBwm/4dbEV3rSOkwcd/tv52cndhjDZoxh8wdHKSmzJkby+kPMm5rCN65eyLWL88lMim2P6zcyDNdWB5Few4IYgryR4WRJDPafkj2FD4/sHhAoUrIHVhFOFmPVAdAFJIiIC0gEqoGLgEfs5fcDa+zX19jvsZdfLMMZeEapEXLXqnkk9Kufj2YE3qyGeFYEFpBCAoKQQgIrAgvIaojcH+EpzuVu/+1UhLIJGaEilM3d/tt5inOHdSwnoq7Fyy9fPMBF//ES6379Jn/bVcu1iwvYcOe5/PULK/j0eTNjHjQALj3S3idoAAhOLj3SHpP9r7jxFlxxfbsAuuI8rLjxlpjsfyIa9TsOY0yliPwY+BDoBP4GbAWajDHdlZQVQHelcD5Qbm8bEJFmIAs4MqoFV2oQ4Ubg/XzRNJofPsQv/ncvyZkezrlmFnOXhZ+ZblloNocddZS5DtImXpJNPMWBIpaFZkfMMzQnlY3eDJ5NLsQRSiTkyKKzLQOJDz9+U6z5gyFe2FNHaVk5L+ytJxgyLJ2ZyZ0rZ3PladPCTowUa8n+8O0jkdKjtWCF9TTVK39+gNaGI6RkZbPixlt60iejsaiqysC6i5gJNAEPA1eEWbW70jLc3cWACk0R+SzwWYDp02NRs6lU9HqPwLvvrRpeeHAPgS5rkqG2oz5eeHAPQNjgUUUje/KeYkHR23g87fh8Sew+eBam6koi3bMEs3fy7T3PclPNh8RxlC7aeSj5Wb5VkAScPxKHCMD79W2Ubinn0bcrOdLmIyfFw2fPL+KGswsoGmRipFgLxDfg9maHTY+VBStWTupA0d9YNI5fAnxgjKkHEJH1wEeAdBFx2XcdBUCVvX4FUAhU2FVbacDR/js1xvwa+DVAcXHx5H3AWo0bb/zlfZ7MDLHD+DC+EOJxcLp4iP/L+2EDx8G8v3Ik1ctvNt/VMyHRmqInOchfWUn4XuDf3vs0iYlpnHvqL6n05JDvq+MrB+/j23ufhtV3xvR42n0BntxZTemWcsoOWxMjXTQ/h3XFhVw4bwquIU6MFGt1sx8l973bcISOVSeFHD7qZj/KzEk6JMhIG4vA8SGwXEQSsaqqLgbKgBeA67GerLoV+Iu9/uP2+zfs5c8bYzQwqHHv0TgfO32dYOzbZl+IndIJHusD3d+HSX4e2rOuz4REf9izjpvmrI+Yhyshjbvm/iM+l9UOUhE/jbvm/gvf3/ffMTkGYwzbypso3VLOxu1VtHcFKcpO4u4r5vOxs/LJSYnNeFDDUZmQDAt/R86B63F5swjEN1A3+xEqEybrgCAjbyzaON4SkUewHrkNANuw7hSeBP4sIt+z0+6zN7kP+IOIHMC607hxtMus1FC1b6ujZdMhgk0+dju99L/EMQZ2+8MPBb7x8GWEkneRNGUT4m7C+NPx1a9i4+HL+HaE/H4049aeoNHN54rnRzNu5RPDOI4jbT42bLPGi9pf10aC28nVp+eybkkhZ58yvImRYm1V0XfYdOAbNK/4Cg4JETIO2o5exKqi74x10U5aY9KPwxjzLeBb/ZIPAkvDrOsFbhiNcik1HO3b6mh8eDeErCobf8CEbaHzB8LfMLfEHeJTnj+xPLML0oGmDt5seZDf8fGIedYlhH8kNFL68QRDhpf31VOypZxnd9cSCBkWT0/nBx87javPyCPZMz77CyctzmEV36Vl06cJNvlwpntIXTWDpMU5Y120k9b4/CQoNQE1b3gXQsd6FwthnuIg/NMeALfFlbJ8URd0P7GaAcuTujDvlgLfCLtNalsTLSkZYdOH6sOGDkrLrImRalq8ZCbFcdtHZrB2SSFzp06M6p6kxTkaKEaRBg6lYiTk6/vvZDCECxMmbDiBc2Z2HAsa3eLs9AiW7NzCS8suItBrgD9XMMCSnVvgo5GfAvL6g/z13RpKtpTzxsEGHAIXzJ3Ct1Yv5OIFU4lz6RxvKjINHGpUjPaosWPBST1Bjl31ZgWDNLgG/oslSCj8DtLB7F5NQcUVJJkE2qWTioKnkfkbI+Y5t9MLe7fxVtEi2jwJJPs6WXZwl5UexruVzZRsKWfDO5W0egNMz0zky5fN5bqzC8hNi838Ferkp4FDjbixGDV2LOxJ+AvUL2XP0dfpCLawsmgGG0KXEZBjvZpdJsjyGTVhtzfbVzOrbg1uuxd0sklkVvka3vdhPXsYbhtniDn1lcypr+yXfux1U0cXG7ZVUlpWwXvVLXjsiZHWLilk+cyBEyMpNRgNHGrExWLU2Ing13KIsxqO4rBvKOIdbVxQ9xKb05fQ6komJdDG0qYt5Lubsfuq9pFff2VP0Ojmxkl+feRJJRxBDyHXwLmvJeDh1f1HKCkrZ5M9MdKp+al895pFfPTMfNISIk+MpNRgNHCoETfcUWMnivnvJ7Kn6HReWXYpLcnpJLe1cMFbm7jtwB/7rNf2wcDZ6gCSTfg+EZHSAaZ25RGa9gLT7d7m1c15bNpzNTs7F/C7+94iLcHNx5dO54biAhblDW1iJKUGo4FDjbjhjho7URwuOItn5l2OvN2Bx1tFV7yT/XlnkpGUSlKXlw63B29nO6fsfyfs9q3iIzVMkGiVgXcU3c7MP0TjnC280zCfVyvPYVfDPAwOTvO08JnrLuCyhVOjnhhJqcFo4IhgMjTmjpa7Vs3r08YB0Y0aO1G8VHQlyewGAAAgAElEQVQhrt0tGGO1GRR11XJu3WFcdmN4kt9HXFwc++cVh93+7WA7nQ74DX7qMOQg3I6bhGA7C8Osv6emhfskwOuvfpM2fzKZ8Ue5umgT5+W/xTSEC864aWQOVE16GjjCmCyNuaMl3KixJ2UgPtTVEzQAznZV9gSNbu5QiFRP+Kqn1zsTeCbJi9+e7aAWw4/wcmlnQk8v8Bavn43bqyjdUs72imZcUszinB2cl/8mC7P24hDrUd8IfQyVigkNHGFMlsbc0dR71NiTVdAPy6Zt4WNzniArvhGfL4mNDet4Nntln0dlZ/d7AqrbS0kd+Pt15PDj4MWkDt482EDplnKeeteaGGn+tBS+efVCsqtuICm7ccC+HC2eAWlKxYoGjjAmS2PuZNO8cSN1P/kvAtXVuHJzyfniF0hbvTpm+z9/2pvcvOhRXM4uALbGL+ap/IvpEusOoy0+kZfnn4nDhG9zaCf8k04duLnx12+S4nHxsbMKWFdcyOkFaYgIWz/RQvMnHJi4Y3c20uUg9dEAOjCsGikaOMKYLI25k0nzxo1Uf+ObGK/VMS5QVUX1N74JELPgcdOcJ3uCBkApN/cEjW5+h5uy2eHbdjzuZnz+9AHpIkF+fP3ZXHlaLglxfYNO3K4M0v7YSOs1EMwE51FI+YsQt2vgMCRKxYqOKxDGcKcAVeNP3U/+qydodDNeL3U/+a+Y5REX39Ln/REGTi4E0BQ3cGa6A3VtFCVX0H90K7d08fG5f+K6swsGBA2AA6flkrTNwdRvxJF3ZxxTvxFH0jYHB07LPfEDUWoQescRxqRpzJ1E/NXVYQcX9FdXxy4TbzokHBtcMJsjHGHgwHtZ1AP2xEg7qikpK2fr4UacsoBTUso56s2g1Z9MVnwj187eyPLcrRGzXDpjB8mODup2pBDocOJKDJJzeisp03fE7riU6kcDRwSToTF3MulISCAt41Q8i65FEjIxnUfx7XqM5sZ3Y5bHwQ/O4JR5r+J0Wg9WrOVBfmM+16e6Ki7UycojL/HVR6bxxA57YqQpSdxzxXzS69aSnTVwVNuu1sj/prnSwOMFH+HeaeuoIos8GrjLVcJH5fWYHZdS/WngUJNC9TmXk5O0EofDetpIErPwnP1JqttfiFkeFUcK6ZLlzJj5Dh5PO0v8mwm5HTzCTRzxZZBafYTEiiY2dnyExLiqnomRzppuTYx039cyyTy/GYf7WHVVyC9UbZ4O14TP8/7AZfwoeBOdWMdVyRTuCXyGRpPMp2J2ZEr1pYFDTQozM5fi8Pd9RNXh8DAzc8DcYSesw+mlvr6I+voiAEIG2lI6mWW20Xl0AV3GSZ7Dy1n1W/nZL38wYGIk3+FLOLjlJQoWl+OJ78DnTaRiWyHBwxdEzPPewDo6pe9xdeLh3sA6DRxqxAwpcIjIj4DvYc0R/lfgDOALxpg/HndDpcaJNH8Gf4z7Gxv8s6k1mUyVo6xxH+Dmrktjlke1M4GiYIi2UAIHgtkcCGbT4YsjPuTl9NadLGzdTaa/CZ87GHY2vYL0vbzdtZTqLb2CWQjOSt8bMc8OwncmjJSuVCwM9Y7jMmPMV0TkWqACayrXFwANHGpC+L3naR70LcFrV+nUmGx+35WC3/M03+D8Ye/f6w+S/EEiz6XPpdLpRjAUSDPntWxh9pF3cWL1swhJiAPZqWH3sT8rY+C8Tw47PYKUQBut7oGz9KUE2k74WJQazFADR3fPpCuBh4wxR8fTZPVKDebJrvk9QaObFw9Pds2PMCnr4Iwx7LQnRnp8exWtWYtIDworOp0s6nKRYhIJ+JoIyvuYUBvx/gBFtUd5P68u7P5aSA775FcLyRHLcGb7dt5IXUbAcazzoCvk58z27cCNJ3hkSh3fUAPHRhHZg1VV9XkRmQKEn2JMqTC2/uw/eevlZ+l0CAkhw7LzL+Hsf/rSqOVfazKjSj+exvYuNrxTScmWcvbUtOJxObjytFzcr9QxPeBEen39uzwLcMXN56KX/qEn7eOvht9vu/GQLF1h0yNpK57DBW++wua0XnN+NG/h6PJFUR+XUkM1pMBhjLlbRH4ItBhjgiLSTsTnPJTqa+vP/pNXXnmWoNPqb9rpFF555VmAUQseOcGj1DoHdsjLCR4d0vahkOHVA9bESM/sqqUrGOL0gjS+t+ZUPnpmHqnxbn7w5gu8m+fmhdMTaE50kNYRYuWOTor39e0rktUSPo99/nROjzvSZ2DEgHGwL0xv8m5L5+7gueCpXLt5I6ltzbQkp/H60pVcPFf7caiRE81TVQuAGSLSe5sHYlwedRJ66+VjQaNb0OHgrZefHbXAsXbP8/zPgo8RcBz7+LpCAdbueR64NeJ2FY0dPFxWwSNbK6hs6iQ90c3Hl01nbXEhC/P6tlVsPaORN/Nn4HdZx9qc5OTJJYk4Ahn4PD/H4zvKrIOP4/DuDpvXpxwb+R//9ZzuqiVJumg3cewITOVzjkeAz4fdZmngCfxzGimdcytHyCabI6zlQZYGXgNi1yteqd6G+lTVH4BZwDtA97CxBg0cagg6I8xpHSl9JLjSXfhPzcAc7EC8QUy8E39RCq7qgQMLev1BnnmvltKycl49cASA82Znc/cV87n0OBMjHZiaTLCuk7j9rT15BOak8NxZGSyqasYXn8WeeR/HmfMs4R6wvci1AwnCvV19O/OtdEa+e4j35HKu71XO5dV+6XlDPzlKRWmodxzFwEJjjI7yr6KWEDL44ufjSliBOFIwoVYCna/giXDlPRJ+c+Mn8SWmQmFqv/RP8M/26/eqWigtK2fDO5U0dfjJT0/gny6aww3FBRRkDBxfqr+6hkTc7zUjIevfRLxB3Luaae01C1PI6cHdujzs9s0kc6VzM2tcx3p9dxkXNWQTadLXollfZs+erxEKHRuU0+FIoGjWlwctr1InaqiB411gGhDDgX3UZJE4Yy2h1lxErKt7cabiTrqMxGmnjVoZjiSE/+o94krhD28epnRLOTsrm4lzOrhs0VTWLSnkI7OycUZxV+Te32L1+utFQoa4/c3Qq1+Fryt8g3xCqIPfT7uGXxWto9ozhVxfPXccLOHammci5pk7zWpqPPj+j/H6qon35FI068s96UqNhOMGDhHZiFUllQK8JyKbgZ4JkI0xHx3Z4qmTgb9jOv2f3hZx4++YPmplyKL+2ICDxuBo7MJZ0Y6ztpNvhGqYPy2Fb61eyJoz88lIijv+ziLxhRjYEaM7/ZhkR33YzX9/2lf5ZWYxnU4ryFTFT+Xf532W5ilncddxss2ddo0GCjWqBrvj+PGolEKd1LpChnBfqF2h0av5vNb/KPcHbyFYFcJZ2Y6jM4hxCXOnHeLHH7uZ0/KtiZGGI9XfSot7YOe+lEA7YFV1ufByZsJDhOtjUVKwkk6fv09apzOekoKVxw0cSo224wYOY8xLACLyQ2PMV3svsx/PfWkEy6ZOEq1iKHcFeSU+QIvDkBoSVnhdFAZGfjqYrkCI5/fU8uobxTi9jTgQghlxeGbBDVMeYdqBLk4vuDMmed2w/xnun//RAZ3xLmhuBGcWyY4jLE16kMyW8BOCVfYLGoOlKzVWhtrGcSnw1X5pV4RJU2qAvyR5qXcKAfuCvsVp2JToZ0rQcPcI5XmgrpWSLeWsf7uShvYuEiSbZSm7WTX/KQrTP8TnS+LQgTOpaJgRszxXV+5AgNI5l9LiSiE10Mra/c+wtuI15qyuwd/hpH5HGq9mX8V1YbbPFSdVJhg2XanxZLA2js9hPUBeJCK9nwlMAXTAfzUkda4QQfp++QXESo+lNl+AJ7ZXUVJWzrYPm3A5hIsX5LBuSSGv/+KrBNyFHN55AYe7NwgFSWk8fLxdRuXgrMtZs2sD1+17oyct6HSya9H1BEvW96Rl1YWfmOnO/T6+O9OJ13msyiw+aLjzAx9cGLNiKjVsg91x/Al4Gvh36HNx2GqMGVqXWzXpBSPMUBwpPRrGGLYebqRkSzlP7qymoyvIrClJ/OuV87l2cQFTUqzhOrbV1dPlDdE1JR/jjkP8XcTVVxLX0jDsMvS4/H32BG6k6P2niPc14vVkcHDWlTgu3wW9LrtyOgdO1gSw6v1OQu0ufjHXQ228MNVruHOfj1U1gdiVUakYGKyNoxloBm4CEJEcrOcKk0Uk2Rjz4cgXUU10Hk8nPt/AfhAeT2eYtYemvtXH+rcrKCkr52B9O4lxzgETI/UmrkTiWo4S13J0QHqspKWW0bwatuz8AoGOLFyJDUw57TEykzcDx57U8qeED5jOdA9X1Pi4ol+gcKZHHqtKqbEw1J7jq4H/BPKAOuAUYDegI6mpQbXPSsG5J9TTMQ7AOIT2WQOHAz+eQDDEi3vrKS0r5/k9dQRChrNPyeBH183iytNzw85x0c3hvoBg4Fmg95eyC4c78iRJ0Xp1+7mc95FXSDtl87FEH6Q8eKyaLuhws7/gDM4Is33qqhk0rd+P8R+rwhO3g9RVM2JWRqViYaiN498DlgPPGmMWi8hK7LsQpQYTKJhKyNmBq99QHKHcoV3tf3CkndKych7dWkFdq4/s5Dj+7ryZrC0uYHbO0IKPK34BIkLA+yqEWsGRgiv+PJye+cM5tD7+6r4Z8zqsOOM1yAghjQ6CL81HdjZgsKuuij5KdXb4PJMWW/1MWjYdItjkw5nuIXXVjJ50pcaLoQYOvzGmQUQcIuIwxrxgP46r1KDiQw1487Lpykvqmx48EnGbzq4gT+2spqSsnM0fHMUhsHJeDjcUF3LxghzczujaRwIOL27PAlyeBX3S/Y4Try7r7++Nh3/338Dvy24A4MtN8dYQ6+f0Xc9B5P4rSYtzNFCocW+ogaNJRJKBV4AHRaSOvvf8SkV0c6CEPzg+TZccG3Yjzni5OVACXNKTZoxhR0UzJWXlbHynilZfgBlZidy1ah7Xn13A1NQTnw51ifePbHfdhunVx0JCfpZ0/RG46oT329slnUKIeP4XH3UY2sWQbAZ2KvQk6iRoamIbauC4BmsSpy8ANwNpwHdGqlDq5LLS/Tweuig1N/cZ+vsjbmtE16PtXTy2rZKHy6yJkeLdDq48NZe1SwpZNjNz2D26Adrr69k/p4qczgJSjINWCVGXXMXs/eGH/zgRznQPlzXBZXZDeHl8kG2dAUyvp8ccTjh/3cJIu1BqQhjqRE7tInIKMMcYc7+IJAIn3CtJRNKB3wCnYo2F9XfAXqAEmAEcAtYaYxrF+tb4Kda0tR3AbcaYt080bzX6Aq0uzk3tO/R3yAjbyxfx2INv88x74SdGiqXSBat4wZFFMO7YDHtOsmhdsIrLYpRH/8btQo8TcQl7jIP2Nj/JmR7OuWYWc5dNi1GOSo2NoT5V9Rngs0Am1rwc+cCvgItPMN+fAn81xlwvInFYA/n8K/CcMeYHInI3Vr+Rr2L1UJ9j/ywD/sf+rSaIys1TmH5BDQ634UhnJq9WLuO1yuUc9WWQnniEm5dbEyMtyB04zlOsvOGYNaATYhAnbzhmxSyPcI3bp62awXJts1AnmaFWVd0JLAXeAjDG7Lf7dERNRFKB84Hb7H11AV0icg3H+sfeD7yIFTiuAR6w5wJ5U0TSRSTXGKNDvE8QDR9MYYd7MXsTZrG3yfqinuEsZ2ldGT/99X/gcY38kBrthB/xNlL6idLGbTUZDDVw+IwxXd11zfb0sSc6tGkRUA/8TkTOALYC/wxM7Q4GxpjqXoEpHyjvtX2FnaaBY5zbVdXMw2UV/HH6bQR8LpJ8Ps5wVTPbeYRk08nhtNxRCRoAyfhoY2DjevKxWQKUUkM01MDxkoj8K5AgIpdijV+1cRh5ngX8ozHmLRH5KRx3rLtwLaMDgpaIfBarOo3p00dvngfVV3Onn8ffqaSkrJx3K1uIczrIdbaywFlHrqPl2Lwc4iQrZeCAfiPls64n+WlgTZ/qKidBPut6EsIOOaiUimSogeNu4NPATuDvgaewGrdPRAVQYYx5y37/iL3/2u4qKBHJxeqh3r1+Ya/tC4Cq/js1xvwa+DVAcXGxTnE7ikIhw5sfNFC6pZyn363BFwixIDeVf1u9kDWL8/nJD78f9smoJBm9q/1PyF/BBf8XuJJW4knBy2dcT1npSqmoDPWpqpCIbAA2GGOG9fyiMaZGRMpFZJ4xZi9WA/t79s+twA/s33+xN3kc+AcR+TNWo3iztm+MDzXNXh7ZWk5pWQUfHu0gJd7FDcUFrCuezqn5qT3BIpUArQx8Sip1FLsCbWtfwB0pG/gn16M9aV3GySuti0/4CQ+lJqvBhlUX4FvAP2BVGYmIBIH/NsYMpx/HP2J1JIwDDgKfAhxAqYh8GvgQuMFe9ymsR3EPYD2O+6lh5DshbNhWyb2b9lLV1EleegJ3rZrHmsX5Y10swJoY6bndtZSUlfPyvnpCBs4pyuKLl87hilNziXcPbLNY4p/JS+4qgnJsDCancbDEP3PUyp137dd57k9f4yMZB0h1+2jxe3i9cTYzPv71USuDUieLwe44vgCcCywxxnwAICJFwP+IyBeNMT85kUyNMe8AxWEWDbj4s5+mis0UbRPAhm2V3LN+J51+q/6/sqmTe9bvBBjT4LG/1poY6bFt1sRI01Lj+fyFs7mhuIBTspKOu21RaC4hfyplroO0iZdkE09xoIii0NRRKj0sWLES+D4lf36A1oYjpGRls+Ljt9jpSqloDBY4bgEuNcb0DCpkjDkoIp8A/gacUOBQkd27aW9P0OjW6Q9y76a9ox442nwBNm6vorTXxEiXLJjKuiWFnD93Ck7H0Hp0h0wbs0O5zO7K7ZfeOhLFjmjBipUaKJSKgcECh7t30OhmjKkXkdh27VUAVDZ2QJiG5MrGjlHJ3xhDWffESDuq6fQHmZ2TzNeuXMC1Z+WTnRz93BD1u0rIWXQrvT8yxvip31XCdK6MZfGVUqNgsMDRdYLL1AnK8jfREJcRNn0k1bV6Wf92JaX2xEhJcU6uOTOPtUsKWVyYPqzxouIPbMbbCZ5F1yIJmZjOo/h2PUZ85ebBN1ZKjTuDBY4zRKQlTLpAmN5UatjObXmT+kUZrJn7NFnxjTR4M9iw7wqm7GoEPhHTvLonRiqxJ0YKhgzFp2Rwx/WzuOq0XJKOMzFSNI6mQHblZgL9AsXR6OZxUkqNE4NNHTs63XpVjzNy3mH6ohocLqsrSnZCI3+36CE+rI/dwHgH69soLavg0bcrqLcnRrr9vJncUFzI7JzkmOXTbd+5QsqzBk+vp299Lit9RcxzU0qNtNhcUqqYKVxe2xM0ujlchsLltcPab0dXgKd21lC6pZzNh47idAgr501hbXEhK+dHPzFSNGas9rLVkcDcV0Jktlp3GvtWOJhxVewmUVJKjR4NHOOMIykUVfrxGGN4p7yJ0rIKNm6vos0XYGZ2El+5fB7XnTW8iZGi0RlKZsbV7XRdDTV22gygMxj7uxul1MjTwBHJjlJ47jvQXAFpBXDxN+H0tSOebdArbG44mw0Hr6bBm0FWfCNrip5gadbWIe/jaHsX69+uoLSsnH21bdbESKflsq64kKUxmhgpGr91fpp1+x6gdksW/jY37mQ/U5c0UDL3Fq4e1ZIopWJBA0c4O0qpfv2LHJznxuvJJN7XRtHrXyQXRjx4vF67hIcOrKUrZA333eDN5A97biQw28Gq42wXDBle2V9PaVk5z7xXiz9oOKMwne9feyqrz4j9xEjRSH0tiYpd+WCsuyZ/WxwVL+aTWp8EF41ZsZRSJ0gDRxjVW7/JnlkeQk7rytwb72TPLAds/Sa5Ixw4Nn54ZU/Q6NYVimPjh1fy7TDrlx/t4OGych7ZWkFVs5eMRDefXD6DtUsKmD9t5CZGisapu5/vCRo9TMhK5/YxKZNS6sRp4Ajj4FQvIWffB8pCTuHgVC+5EbaJlaPegX04+qd7/UE27aqhZEs5r7/fgAismDOFr121kEsW5ozaHBdDJcFwT3RHTldKjW8aOMLwesJ/8UZKj6VUaaPFDOzgkCptvFvZTGlZORu2VdLiDVCQkcAXL5nL9cUF5KcnjHjZTpTDlUooMDBIOFzj445IKRUdDRxhuHwZBOIbw6aPtGlpAZpboNdAshgBnyOBq//7VeJcDi5fNI11Swo5pygLxxDHixpLZ1y6lm1P/x76DKPu4oxLR/5hA6VU7GngCCN73w1syNzO+oNX9DzZ9LGip1lz9AxGemilg2cU4W8I4drbivit6CEGfAkevn3RfK45M4/0xNjOkz3SLrptDQDbnyklFGjB4UrljEvX9qQrpSYWDRxhPFOzmN/WLCSI1SmuwZvJb9+7iSQ8LBrBfKuaOumsCOCq6sDhD2FcQjA3kWBBIibFza0fmTGCuY+si25bo4FCqZOEBo4wfmG8BKVve0YQB78wXr4Q47y6AiGe3V1LyZZyXtlfj9tAMNND1+xUQlMTwH6yK7NlYNWZUkqNBQ0cYfgJP/xGpPQTsa/XxEhH27vITYvnzpWz+du2/2X3mTcSch+rjorzdzF7fwmgc0kopcaeBo5wIrU3D7MdutXrZ+P2akrKytle3oTbKVy6cCo3FBdy/hxrYqTfVT/DFbuyeWvuZdQmOJnaGWTZvmd5bcprw8tcKaViRANHGMbtYHnWZj4254meoc3X77+aNxuWRr8vY9hyyJoY6amd1sRIc6cm8/WrFnDt4nyy+k2MdGHrhXyhbinxtccGAPTKUtzu6mEfl1JKxYIGjjCKz9zFbal/Is5pTeGandDIbYv+RKAliaE+VlXX6uXRrZU8XFbOwSPtJHtcrFmcx9riQs48zsRId9SvIt70DSbxxsMd9ccbcEQppUaPBo4wbkp5sCdodItzBrkp5UHgrojbBYIhXthbT8mWcl7Ya02MtGRGBp+7cBZXnZ5LYtzgpzvNF75TXKR0pZQabRo4wkh3tkaV3n9ipCkpHj6zooi1xQUUTYlu6PBQsAGnMztsulJKjQcaOMJwejN4rbGIxw6s7ukAeO3sjZybcXDAui/vq+eW3262J0bKYd2SQi6cN+WEJ0ZytpYQSr0dh+NYdVUo5MPZWgJce6KHpJRSMaOBI4xd22/ngbapfYY2f+C9m0hPrmXlVX3XXTozk3+9cj5rzswnJwYTIzWk7iC39Vd4425G4rMw3gbiux6kOvU9Coa9d6WUGj4NHGE80FxIV7+2665QHA80F/IP/daNdzv57PmzYpZ34xIfzsAbzDr0HPG+EN50B+/PSKTRNTqz9Sml1GA0cIRRJ4ZwnTas9JEVzIRaiad2ar9AMfJZK6XUkMSuK/TJxBPhtERKjyFne1JU6UopNdo0cITRNScN02+4cuMQuuakjXjeUw7ejPj73giK38WUgzePeN5KKTUUWlUVhmOqB7+k4drfiniDmHgngTkpOHI8g288TJnelbAbjsx5lEB8Ay5vFtn7r7PSlVJqHNDAEcayD97lraJT6co7Vj3kCgZYdvBdoHhE8w4tbyDlb2eTVvORY2kOH6HLtB+HUmp80MARxmlVHxDv9/NW0SLaPAkk+zpZdnAXc+orRjzvQ+7/h3vhdKYcuB6XN4tAfAP1sx/B7/6QfK4Y8fyVUmowGjjCSDXtzKmvZE595YD0keb1VePNq6I1782+C3zjf4pYpdTkoI3jYVzCy7jx90lz4+cSXh7xvOM9uVGlK6XUaNPAEcY0+YDVPEMaLYAhjRZW8wzT5IMRz7to1pdxOBL6pDkcCRTN+vKI562UUkOhVVVh/JCP8l3zOKfL3p60DhPHN+Sj/McI55077RoADr7/Y7y+auI9uRTN+nJPulJKjTUNHGE8470WvyOHr7hKyZMGqkwWPwqs5cXQuaOSf+60azRQKKXGLQ0cYbQiPB46j8e7zuuTrs3TSimlbRxhZUUIEZHSlVJqMhmzwCEiThHZJiJP2O9nishbIrJfREpEJM5O99jvD9jLZ4x02dbkpNK/j7jHTldKqcluLO84/hnY3ev9D4GfGGPmAI3Ap+30TwONxpjZwE/s9UbU1790Hp/MSWMKggBTED6Zk8bXv3TeoNsqpdTJTowZ/fG6RaQAuB/4PvAlYDVQD0wzxgRE5Bzg34wxq0Rkk/36DRFxATXAFHOcghcXF5uysrKRPxCllDqJiMhWY8yg4yqN1R3HfwFfAUL2+yygyRgTsN9XAPn263ygHMBe3myv34eIfFZEykSkrL6+fiTLrpRSk9qoBw4RuRqoM8Zs7Z0cZlUzhGXHEoz5tTGm2BhTPGXKlBiUVCmlVDhj8TjuucBHReRKIB5IxboDSRcRl31XUQBU2etXAIVAhV1VlQYcHf1iK6WUgjG44zDG3GOMKTDGzABuBJ43xtwMvABcb692K/AX+/Xj9nvs5c8fr31DKaXUyBpP/Ti+CnxJRA5gtWHcZ6ffB2TZ6V8C7h6j8imllGKMe44bY14EXrRfHwSWhlnHC9wwqgVTSikVkQ45otQ4smFbJfdu2ktVUyd56QnctWoeaxbnD76hUqNIA4dS48SGbZXcs34nnf4gAJVNndyzfieABg81roynNg6lJrV7N+3tCRrdOv1B7t20N8IWSo0NDRxKjRNVTZ1RpSs1VjRwKDVO5KUnRJWu1FjRwKHUOHHXqnkkuJ190hLcTu5aNW+MSqRUeNo4rtQ40d0Ark9VqfFOA4dS48iaxfkaKNS4p1VVSimloqKBQymlVFQ0cCillIqKBg6llFJR0cChlFIqKho4lFJKRUUDh1JKqaho4FBKKRUVDRxKKaWiooFDKaVUVDRwKKWUiooGDqWUUlHRwKGUUioqGjiUUkpFRQOHUkqpqGjgUEopFRUNHEoppaKigUMppVRUNHAopZSKigYOpZRSUdHAoZRSKioaOJRSSkVFA4dSSqmoaOBQSikVFQ0cSimlouIa6wIopdR4t2FbJfdu2ktVUyd56QnctWoeaxbnj3WxxowGDqWUOo4N2yq5Z/1OOv1BACqbOrln/U6ASRs8tLdY2EIAAAr6SURBVKpKKaWO495Ne3uCRrdOf5B7N+0doxKNPQ0cSil1HFVNnf+/vXMPtrqq4vjnOxdEwOKCoINXB0SRRFReEoSaUwZpDZKDCZMFmqmpM6mlgjqUmhHSlNrDx5hppjw0H0QYOgg6PriGylNFUUlR1KuW5CtRV3/sdbjnXs65hyNwfvexPjO/Ofu39v7t397rnvtbZz9+a5UlbwuE4QiCIGiCPao7liVvC1TccEjaS9IiSU9LWi3pRy7vJuk+Sc/5Z1eXS9JVktZKWiFpcKXbHARB2+Xc0f3o2L6qgaxj+yrOHd0voxZlTxYjjo+BH5vZ/sBw4AxJ/YHJwEIz6wss9HOAo4C+fpwCXF35JgdB0FYZO6iGacceSE11RwTUVHdk2rEHttmFcchgV5WZbQA2ePq/kp4GaoBjgCO82E3AYuB8l//ZzAxYIqlaUk+vJwiCYIczdlBNmzYUjcl0jUNSb2AQUAvsnjMG/rmbF6sBXs67bL3LGtd1iqSlkpbW1dXtyGYHQRC0aTIzHJJ2Af4KnGVmG5sqWkBmWwjMrjOzoWY2tEePHturmUEQBEEjMjEcktqTjMYtZnaHi1+X1NPzewJvuHw9sFfe5XsCr1aqrUEQBEFDsthVJeCPwNNm9uu8rLnARE9PBO7Ok3/Pd1cNB96J9Y0gCILsyMLlyEjgu8BKSctcdgHwS2COpO8DLwHHed584GhgLfA+cGJlmxsEQRDko7RZqXUhqQ74V4Vv2x14s8L3bEmEfkoTOipN6Kg026KjXmZWcpG4VRqOLJC01MyGZt2O5kropzSho9KEjkpTCR2Fy5EgCIKgLMJwBEEQBGURhmP7cV3WDWjmhH5KEzoqTeioNDtcR7HGEQRBEJRFjDiCIAiCsgjDEQRBEJRFGI4mkFQl6UlJ8/x8b0m1HjNktqSdXN7Bz9d6fu+8Oqa4fI2k0dn0ZMchaZ2klZKWSVrqsrJjq0ia6OWfkzSx2P1aGu7N+XZJz3gMmhGhn3ok9fPvTu7YKOms0FFDJJ3t8YtWSZopaedMn0dmFkeRAzgHuBWY5+dzgPGevgb4oadPB67x9Hhgtqf7A8uBDsDewPNAVdb92s46Wgd0byS7HJjs6cnAdE8fDdxDclw5HKh1eTfgBf/s6umuWfdtO+nnJuBkT+8EVId+iuqqCngN6BU6aqCXGuBFoKOfzwEmZfk8ylwpzfUgOVNcCHwFmOdf1DeBdp4/Aljg6QXACE+383ICpgBT8urcXK61HEUMxxqgp6d7Ams8fS0woXE5YAJwbZ68QbmWegCf9394hX62Sl+jgIdDR1voJRdaops/X+YBo7N8HsVUVXGuAM4DPvXzXYH/mNnHfp4fF2RzzBDPf8fLb1UskRaOAfdKelzSKS4rN7ZKa9VTH6AO+JNPeV4vqTOhn2KMB2Z6OnTkmNkrwK9IPvw2kJ4vj5Ph8ygMRwEkfRN4w8wezxcXKGol8rYqlkgLZ6SZDSaF+D1D0uFNlG1remoHDAauNrNBwHvUh0QuRFvTz2Z8fn4McFupogVkrVpHvr5zDGl6aQ+gM+n/rTEVex6F4SjMSGCMpHXALNJ01RVAtaScR+H8uCCbY4Z4fhfgbdpALBEze9U/3wDuBIZRfmyV1qqn9cB6M6v189tJhiT0syVHAU+Y2et+Hjqq50jgRTOrM7NNwB3Al8jweRSGowBmNsXM9jSz3qTh8/1m9h1gETDOizWOGZLbxTHOy5vLx/suh72BvsBjFerGDkdSZ0mfy6VJc9SrKD+2ygJglKSu/utqlMtaNGb2GvCypH4u+irwFKGfQkygfpoKQkf5vAQMl9RJkqj/HmX3PMp64ae5H8AR1O+q6uOKXksaUndw+c5+vtbz++RdfyFp98Ia4Kis+7OdddOHtEtjObAauNDlu5I2Fjznn91cLuD3ro+VwNC8uk5y/a0FTsy6b9tRRwOBpcAK4C7Sjp/QT0MddQLeArrkyUJHDXV0MfAM6YfZzaSdUZk9j8LlSBAEQVAWMVUVBEEQlEUYjiAIgqAswnAEQRAEZRGGIwiCICiLMBxBEARBWYThCCqGJJN0c955O0l1qvc+PEbSZE//TNJPPH2jpHGevl5S/wzaPsO9k85oJJ/kfVgm6SlJP6h023YU/jcwSfvmyc522VA/ny+p2tPvZtXWoLK0K10kCLYb7wEDJHU0sw+ArwGv5DLNbC7pJaWimNnJO7aJRTkV6GFm/yuQN9vMzpS0G7Ba0lyrfwO6xSCpysw+aSReSXoJ9ud+Po708hkAZnZ0hZoXNCNixBFUmnuAb3i6wdvC/uv9d01dLGlx3q/dCUqxQFZJmp5X5l1Jl0laLmmJpN1dfpyXXS7pwQJ1y0cWq7ze410+l+QfqDYnK4QltyvPA70kDZP0iDs3fCT39rikAyQ95iOUFZL6+hv4f/d2rcq77xBJDyg5kFyQ54JjsaTpXs+zkg5zeSdJc7ze2UqxGHK6GiXpUUlPSLpN0i4uXydpqqSHgOMKdOsukp8kJPUhOcyry9PZOkndC+jyXEn/9LZc7LKC/QxaHmE4gkozi+T2YGfgIKC2RPmCSNoDmE7yIzYQOETSWM/uDCwxs4OBB4Hc9NFUYLTLxxSo9liv62CSf6AZknqa2RjgAzMbaGazm2hTH9LbvGtJb/kebsm54VTgF17sNOBKMxsIDCX5D/o68KqZHWxmA4B/SGoP/BYYZ2ZDgBuAy/Ju187MhgFnAT912enAv83sIOBSYIi3qztwEXCkJYeUS0mxZnJ8aGaHmtmsAt3aSHKbMoBk6Iv2P08Po0juLIaR9DlEyfnlFv0sVVfQPAnDEVQUM1sB9CY9hOZvQ1WHAIstOX77GLgFyHnm/YgUswCS++nenn4YuNHXIaoK1HkoMNPMPvGppgf8PqU4XtIy0ujpVDN7m+RY7jZJq4DfAAd42UeBCySdD/TyKbuVwJE+ijjMzN4B+gEDgPu87otITuly3FGgf4eSDDNmtork5gRSwKP+wMNe10RSsKQcpYzBLNJ01ViSI8tSjPLjSeAJ4AskQ1Kon0ELJNY4giyYS4ovcATJJ9FnoZCL6BybrN6Xzif499zMTpP0RdJU2TJJA83sra2ssylmm9mZjWSXAovM7FtKoTsXextulVTrbVgg6WQzu1/SEFJ0u2mS7iU9oFeb2Ygi98yttWzuXxPtF3CfmU0okv9ek72DvwEzgKVmtlEqqSYB08zs2i0yGvXTzC4pVVnQ/IgRR5AFNwCXmNnKbaijFviypO6SqkgjmAeaukDSPmZWa2ZTSVHR9mpU5EHS6KFKUg/SCOazejPuQv3C/6S8NvQBXjCzq0gG9CCfdnvfzP5CMqiDSU7oekga4de1l3QATfMQ8G0v3x840OVLgJHy3VG+FrLf1nbER0Xn03CqrCkWACflraPUSNqtSD+DFkiMOIKKY2brgSu3sY4NkqaQXEsLmG9md5e4bIakvl5+Icmrbz53kkJwLicFuDnPkmv0z8LlwE2SzgHuz5MfD5wgaRMpvvYlpOmwGZI+BTaRYkd/pLQF+SpJXUj/q1eQvBAX4w9+zxWkaaIVJLfjdZImATMldfCyFwHPbm1niqx/FCt7r6T9gUd9dPIucAKwb+N+bm2dQfMivOMGQSvBR17tzexDSfuQjON+ZvZRxk0LWhkx4giC1kMnYJHvyBI+csm4TUErJEYcQRAEQVnE4ngQBEFQFmE4giAIgrIIwxEEQRCURRiOIAiCoCzCcARBEARl8X9EDQOve6MPygAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig,ax=plt.subplots(1)\n", + "ax.scatter(airline_df['Miles'],airline_df['Deaths'] )\n", + "x=np.linspace(4000,8000,10)\n", + "ax.plot(np.linspace(4000,8000,10),(.12)*np.linspace(4000,8000,10))\n", + "for x in range(200):\n", + " ax.scatter(airline_df['Miles'],predicted[x])\n", + "ax.set_title('Deaths vs. Miles, with model predictions')\n", + "ax.set_xlabel(\"Millions of Passenger Miles\")\n", + "ax.set_ylabel(\"Deaths\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The plot above shows that there is far more variation in the deaths per passenger mile than can be accounted for by a poisson model. For example, just look at rows 5 and 7, both had comparable number of miles but the number of deaths is way outside the 95% interval. \n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Now let's look at accidents vs miles." + ] + }, + { + "cell_type": "code", + "execution_count": 101, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:pystan:COMPILING THE C++ CODE FOR MODEL anon_model_9e55af8f55ddc462276e2095df7f3378 NOW.\n" + ] + } + ], + "source": [ + "stan_code='''\n", + "data {\n", + " int accidents[10];\n", + " vector[10] miles;\n", + "}\n", + "parameters {\n", + " real theta ; \n", + "}\n", + "model {\n", + " \n", + " theta~gamma(24,5000);\n", + " accidents~poisson(miles*theta);\n", + "}\n", + "generated quantities {\n", + " int predicted[10] ; \n", + " int answer ; \n", + " \n", + " for(i in 1:10)\n", + " predicted[i]=poisson_rng(miles[i]*theta);\n", + " answer=poisson_rng(8000*theta) ; \n", + "}\n", + "\n", + "'''\n", + "sm_weights=pystan.StanModel(model_code=stan_code)" + ] + }, + { + "cell_type": "code", + "execution_count": 102, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/jteitelbaum/anaconda3/lib/python3.6/site-packages/pystan/misc.py:399: FutureWarning: Conversion of the second argument of issubdtype from `float` to `np.floating` is deprecated. In future, it will be treated as `np.float64 == np.dtype(float).type`.\n", + " elif np.issubdtype(np.asarray(v).dtype, float):\n" + ] + } + ], + "source": [ + "accidents=sm_weights.sampling(data=dict({'accidents':airline_df['Fatal'],'miles':airline_df['Miles']}))" + ] + }, + { + "cell_type": "code", + "execution_count": 103, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Inference for Stan model: anon_model_9e55af8f55ddc462276e2095df7f3378.\n", + "4 chains, each with iter=2000; warmup=1000; thin=1; \n", + "post-warmup draws per chain=1000, total post-warmup draws=4000.\n", + "\n", + " mean se_mean sd 2.5% 25% 50% 75% 97.5% n_eff Rhat\n", + "theta 4.2e-3 6.9e-6 2.6e-4 3.7e-3 4.0e-3 4.2e-3 4.4e-3 4.8e-3 1440 nan\n", + "predicted[0] 16.24 0.07 4.14 9.0 13.0 16.0 19.0 25.0 3615 1.0\n", + "predicted[1] 18.09 0.07 4.38 10.0 15.0 18.0 21.0 27.0 3688 1.0\n", + "predicted[2] 21.16 0.08 4.8 12.0 18.0 21.0 24.0 31.0 3765 1.0\n", + "predicted[3] 23.08 0.08 5.07 14.0 20.0 23.0 26.0 34.0 3623 1.0\n", + "predicted[4] 24.49 0.09 5.17 15.0 21.0 24.0 28.0 35.0 3676 1.0\n", + "predicted[5] 25.42 0.09 5.37 15.0 22.0 25.0 29.0 36.0 3223 1.0\n", + "predicted[6] 24.76 0.08 5.2 16.0 21.0 24.0 28.0 36.0 3796 1.0\n", + "predicted[7] 26.24 0.09 5.39 16.0 23.0 26.0 30.0 38.0 3455 1.0\n", + "predicted[8] 31.27 0.1 5.96 20.0 27.0 31.0 35.0 44.0 3601 1.0\n", + "predicted[9] 29.86 0.1 5.87 19.0 26.0 30.0 34.0 42.0 3581 1.0\n", + "answer 33.7 0.1 6.04 23.0 30.0 33.0 38.0 46.0 3748 1.0\n", + "lp__ 354.66 0.02 0.72 352.61 354.51 354.94 355.11 355.16 1713 1.0\n", + "\n", + "Samples were drawn using NUTS at Mon Apr 16 12:12:57 2018.\n", + "For each parameter, n_eff is a crude measure of effective sample size,\n", + "and Rhat is the potential scale reduction factor on split chains (at \n", + "convergence, Rhat=1).\n" + ] + } + ], + "source": [ + "print(accidents)" + ] + }, + { + "cell_type": "code", + "execution_count": 112, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "predicted range for 8000 is from 23.0 to 46.0\n", + "Gelman says the true number was 22\n" + ] + } + ], + "source": [ + "predicted=accidents.extract()['predicted']\n", + "answer=accidents.extract()['answer']\n", + "fig,ax=plt.subplots(1)\n", + "ax.scatter(airline_df['Miles'],airline_df['Fatal'],color='blue')\n", + "x=np.linspace(3000,8000,10)\n", + "ax.plot(np.linspace(3000,8000,10),(.0042)*np.linspace(3000,8000,10))\n", + "ax.plot(x,.0037*x-6)\n", + "ax.plot(x,.0048*x+6)\n", + "l=np.percentile(predicted,2.5,axis=1)\n", + "ax.scatter(airline_df['Miles'],np.percentile(predicted,2.5,axis=0),color='red')\n", + "ax.scatter(airline_df['Miles'],np.percentile(predicted,97.5,axis=0),color='green')\n", + "ax.scatter([8000],answer.mean(),color='orange')\n", + "ax.scatter([8000],np.percentile(answer,2.5),color='orange')\n", + "ax.scatter([8000],np.percentile(answer,97.5),color='orange')\n", + "ax.set_title('Accidents vs. Miles, with model predictions')\n", + "ax.set_xlabel(\"Miles\")\n", + "ax.set_ylabel(\"Accidents\")\n", + "ax.scatter([8000],[22],color='black')\n", + "plt.show()\n", + "print('predicted range for 8000 is from ',np.percentile(answer,2.5),' to ',np.percentile(answer,97.5))\n", + "print('Gelman says the true number was 22')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This is more promising, because the blue dots lie inside the sampled region.\n" + ] + }, + { + "cell_type": "raw", + "metadata": {}, + "source": [ + "For completeness, here is the Gamma prior we are using. " + ] + }, + { + "cell_type": "code", + "execution_count": 100, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 100, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXoAAAD8CAYAAAB5Pm/hAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzt3Xl0XGed5vHvr7RauyzJsizbkrwkzooDBgIxzIGwBEiTzGnoDs2BMB1O6GmaYek5Q5imZ3pm+vQAc5rtNEMTCNOBQ0No6B7SrBOykDhssbM4CbZjy0ssydps7Xup3vmj7nXKimRJdlXdpZ7POTqqunXr3p+vyo9evfe99zXnHCIiEl+JoAsQEZHcUtCLiMScgl5EJOYU9CIiMaegFxGJOQW9iEjMKehFRGJOQS8iEnMKehGRmCsOugCAxsZG197eHnQZIiKRsm/fvkHnXNNy64Ui6Nvb29m7d2/QZYiIRIqZnVjJeuq6ERGJOQW9iEjMKehFRGJOQS8iEnMKehGRmFPQi4jEnIJeRCTmFPQxtefwIHuPnwm6DBEJgVBcMCXZk5xP8b9+doivPHyUuooS9nz89VSV6ccsUsjUoo+R0+MzvPfrv+UrDx/lTZc3Mzw5x92/PB50WSISMAV9jHzgm/vYe2KIz7zjau587y6u37GOOx8+yuj0XNCliUiAVhz0ZlZkZk+Y2Q+95x1m9hszO2xm95hZqbe8zHt+xHu9PTelS6bB8Rn2nhjiQ6/bxh/s2gTAR994CSNTc/zDo8eDLU5EArWaFv2HgQMZzz8NfM45tx0YAm7zlt8GDDnntgGf89aTHHv0yCAAr73khRvZXdlayxsvb+arjxxlZEqtepFCtaKgN7ONwNuAr3nPDXg98D1vlbuBm73HN3nP8V6/3ltfcuiRw4PUrinhytbac5Z/5A3bGZtOcteeYwFVJiJBW2mL/vPAfwJS3vMGYNg5l/SedwGt3uNW4CSA9/qIt77kiHOOPYcH2b2tkaLEub9Tr9hQy/U71vHdx07inAuoQhEJ0rJBb2Y3Av3OuX2ZixdZ1a3gtczt3m5me81s78DAwIqKlcV1DozTOzrN7u2Ni77+by5tond0mu7hqTxXJiJhsJIW/XXA283sOPAd0l02nwfqzMwfoL0R6PEedwGbALzXa4EXXbnjnLvTObfLOberqWnZCVLkPB5+Lt0/v3vb4kH/srZ6APYeH8pbTSISHssGvXPuE865jc65duAW4AHn3LuBB4F3eKvdCvzAe3yv9xzv9Qec+gxyas+RQToaK9m0tmLR13esr6GqrJjHdKWsSEG6mHH0Hwc+ZmZHSPfB3+Utvwto8JZ/DLjj4kqU85lNpvj10dNLtuYBihLGS9vq2XdCLXqRQrSqa+Odcw8BD3mPjwKvWGSdaeCdWahNVuDx54eYnJ3nNUv0z/te3lbPZ3/+HCOTc9RWlOSpOhEJA10ZG3F7Dg9SlDCu3Xr+gU272tfiXPoXg4gUFgV9xD1yZJCdm+qoKT9/K33npjqKE6Z+epECpKCPsOR8igM9o+zyRtWcz5rSIq5orWWv+ulFCo6CPsJODk0xO59i67qqFa3/8rZ6njo5zExyPseViUiYKOgjrLN/HIBtKwz6Xe1rmUmmeKZ7NJdliUjIKOgjrHMgHfRbm1Ya9P6FU+qnFykkCvoIO9I/TlN1GbVrVjZcsrGqjI7GSvXTixQYBX2EdQ6Ms7WpclXveVlbPU9oiKVIQVHQR5Rzjs6BiRV32/h2rK9mcHyW0+MzOapMRMJGQR9Rg+OzjEzNrfhErO+S5moAnusbz0VZIhJCCvqIWu2JWJ8f9If7x7Jek4iEk4I+os4G/Spb9M01ZVSXF/Ncn4JepFAo6CPqSP84FaVFtNSUr+p9ZsYlzdXquhEpIAr6iOocmGBLUyWJxOqn472kuYrn+sY0taBIgVDQR1Rn//iq++d929dVMzw5x4BG3ogUBAV9BE3OJukenmLbBQb92ROy6r4RKQgK+gg6OjABrP5ErO+S9en36YSsSGFQ0EeQP+JmtWPofU1VZdRVlOiErEiBUNBHUGf/OAmDtobFJwNfjplxybpqDqtFL1IQFPQR1Dkwwea1FZQVF13wNrZr5I1IwVDQR1DnwPgFd9v4LmmuZnQ6Sf+YRt6IxJ2CPmJSKcfRwQm2XOCIG9/2Zp2QFSkUCvqIGRyfYTaZYlP9movajj/E8lCvgl4k7hT0EdM9PAXAhrqLC/rGqjLWVpZqLL1IAVDQR4wf9K0X2aIH2L6uiud0F0uR2FPQR0z3kBf0F9mih3T3zeG+cY28EYk5BX3E9AxPUV1eTHX5yuaJPZ8tTZWMzyR1zxuRmFPQR0z38FRWWvMA7Y3p+WaPD05mZXsiEk4K+ojpGppiYxb65wG2nA36iaxsT0TCSUEfMd3DUxc94sbXWreG4oRx7LSCXiTOFPQRMjo9x9h0MmtdN8VFCTavrVCLXiTmFPQR0pPFoZW+9sZKjinoRWJNQR8h/tDKbHXdALQ3VHLi9KSGWIrEmII+QvwW/cYsBn1HYwVTc/P0jWqIpUhcKegjpGt4itKiBI1VZVnbpj/EUt03IvGloI+Q7qEpWurKSSQsa9tsb1DQi8Sdgj5CerJ4sZRvQ90aSosTHNcQS5HYUtBHSDbH0PuKEkbb2gq16EViTEEfEbPJFP1jM1lv0UO6n15j6UXia9mgN7NyM/utmT1lZs+a2X/zlneY2W/M7LCZ3WNmpd7yMu/5Ee/19tz+EwpD78g0zmV3DL2vo7GSE2cmSaU0xFIkjlbSop8BXu+cewmwE7jBzK4FPg18zjm3HRgCbvPWvw0Ycs5tAz7nrScXqWs4feOxnLToGyqZTaboGZnK+rZFJHjLBr1L86chKvG+HPB64Hve8ruBm73HN3nP8V6/3syyN0ykQGXzPvQLtTdWALqLpUhcraiP3syKzOxJoB+4D+gEhp1zSW+VLqDVe9wKnATwXh8BGrJZdCHyZ5ZqqSvP+rY7/LH0GnkjEksrCnrn3LxzbiewEXgFcNliq3nfF2u9v6jz18xuN7O9ZrZ3YGBgpfUWrJ7hKZqqyygrLsr6tpuryykvSeiErEhMrWrUjXNuGHgIuBaoM7Ni76WNQI/3uAvYBOC9XgucWWRbdzrndjnndjU1NV1Y9QUkmxOOLJRIGO0NGnkjElcrGXXTZGZ13uM1wBuAA8CDwDu81W4FfuA9vtd7jvf6A053zLpo3UNTORlx4+torFTXjUhMraRF3wI8aGb7gceA+5xzPwQ+DnzMzI6Q7oO/y1v/LqDBW/4x4I7sl11YUilHz8h0zlr0kB5Lf/LMJMn5VM72ISLBKF5uBefcfuCaRZYfJd1fv3D5NPDOrFQnAJyemGU2mWJDbfZPxPraGyqYm3ecGplm09qKnO1HRPJPV8ZGQN/oNADrcxj0bd7NzXTPG5H4UdBHQO+IH/S567ppa0i34k+c1lh6kbhR0EdAr9+ir8ldi765upyy4gQn1KIXiR0FfQT0jkyTMGisKs3ZPhIJo62hQi16kRhS0EdA7+g0TdVlFBfl9se1eW2lgl4khhT0EdA3Op3T/nlfe0MFJ85MaKJwkZhR0EdA78g062uyN0/sUtoaKpieS9/3XkTiQ0EfAb2j0zk9Ees7O8RSt0IQiRUFfchNzCQZm07SnMMx9L6zQyzPqJ9eJE4U9CHnD61syUPQt9atoThhGmIpEjMK+pDr8y6Was5D101xUYLW+jUaeSMSMwr6kMvHxVKZ2ho0xFIkbhT0IXdqJPf3ucnUtraC46c1xFIkThT0Idc3Ok1NeTEVpcveaDQr2hoqGJtOMjw5l5f9iUjuKehDrndkOm+teXhhiKVG3ojEh4I+5PpGp/NyItbXfvYulhp5IxIXCvqQOzWSn4ulfP6kIzohKxIfCvoQS86nGByfycsYel95SREtteWagEQkRhT0ITYwPkPKkZerYjO1NVTwvFr0IrGhoA+xszNL5bHrBqBtbSXHFfQisaGgD7HePF4Vm6mtsYLB8RkmZpJ53a+I5IaCPsTyeZ+bTG1rNVG4SJwo6EOsd3Sa0qIEaytzN4XgYtobNfJGJE4U9CHWNzLNupoyzCyv+233Lpo6pvvSi8SCgj7E8j2G3ldZVkxTdZkmIBGJCQV9iKXnis1/0AN06C6WIrGhoA8p51zephBcTHtjBcd0MlYkFhT0ITU6lWR6LhVYi76toZKBsRnGNcRSJPIU9CHlD63M9xh6X0ejdxdLtepFIk9BH1KnRqaA/I+h9/kjb44Pqp9eJOoU9CHVF3CLvs27XbEumhKJPgV9SPWOzADBBX1lWTHrqss0ll4kBhT0IdU7OkVDZSmlxcH9iNobK9VHLxIDCvqQyvcUgotpb6jgmProRSJPQR9SvaMzgY2h97U3VjI4PsPYtCYKF4kyBX1I9Y1O533CkYU6/InCdYWsSKQp6ENoem6eMxOztATcom9r0O2KReJAQR9C/aPeiJug++i92xXr5mYi0aagDyH/qtig++grSotprinTtIIiEbds0JvZJjN70MwOmNmzZvZhb/laM7vPzA573+u95WZmXzSzI2a238xemut/RNz4V8UGPeoG0t03atGLRNtKWvRJ4M+dc5cB1wIfNLPLgTuA+51z24H7vecAbwG2e1+3A1/OetUx518VG4ag72ioVB+9SMQtG/TOuVPOuce9x2PAAaAVuAm421vtbuBm7/FNwDdc2q+BOjNryXrlMdY7MkNFaRHVZcVBl+INsZzVEEuRCFtVH72ZtQPXAL8Bmp1zpyD9ywBY563WCpzMeFuXt2zhtm43s71mtndgYGD1lcdYn3cf+nxPIbiYdv+eN7pwSiSyVhz0ZlYFfB/4iHNu9HyrLrLMvWiBc3c653Y553Y1NTWttIyCcGpkKhTdNgBb11UBcHRwPOBKRORCrSjozayEdMh/yzn3z97iPr9Lxvve7y3vAjZlvH0j0JOdcgtDXwiuivW1NVSQMOjsV9CLRNVKRt0YcBdwwDn32YyX7gVu9R7fCvwgY/l7vdE31wIjfhePLC+VcqG4KtZXVlzE5rUVdA7ohKxIVK3kbN91wHuAp83sSW/ZfwY+BXzXzG4Dngfe6b32Y+CtwBFgEvh3Wa045gYnZkimXGha9ABbm6o4oha9SGQtG/TOuT0s3u8OcP0i6zvggxdZV8Hq8+5DH5Y+eoBt66p45PAg8ylHUSL4E8Qisjq6MjZkwnJVbKatTVXMzqfoGtLIG5EoUtCHTG+ILpbybV2XvrlZ54C6b0SiSEEfMr0jUxQljMaqsqBLOWtLY3qIZWe/TsiKRJGCPmR6R2ZYV10Wqr7w+spSGipL1aIXiSgFfcj0jU4HNiH4+WxtqlLQi0SUgj5kTo1MhepErG/rukoNsRSJKAV9yPSNzoTqRKxva1MVQ5NznJmYDboUEVklBX2IjM8kGZ9JhjPovXveqPtGJHoU9CHSOxK+MfS+bU3+yBsFvUjUKOhDpGc4PbNUSwhb9Bvq1lBWnFCLXiSCFPQh4gd9a/2agCt5saKE0dFYqZubiUSQgj5EuoenSBihHF4J6X56tehFokdBHyLdw+mhlSVF4fyxbGuq4uSZSabn5oMuRURWIZyJUqC6h6bYUBe+bhvf1nVVpByaLFwkYhT0IdIzMhXK/nmfP/LmuT5134hEiYI+JOZTjlPD0yFv0VdSnDAO9Z5vymARCRsFfUgMjKVnlgpz0JcVF7G1qYqDp8aCLkVEVkFBHxLd3tDKjSEOeoAdLdUc7FXQi0SJgj4k/KAPc4seYMf6GrqHpxiZmgu6FBFZIQV9SPScDfpwjqH37WipBuCQWvUikaGgD4nuoSlqyoupLi8JupTzumx9DQAHdUJWJDIU9CHRMzxFa31F0GUsq7mmjLqKEg7ohKxIZCjoQ6J7eIrWkHfbAJgZO9ZXq0UvEiEK+pBIB324T8T6dqyv4VDvGKmUC7oUEVkBBX0IjE7PMTadDP2IG99lLdVMzs7z/JnJoEsRkRVQ0IdAmG9PvJgdOiErEikK+hDoHorGGHrfJc3VmKETsiIRoaAPgZ6IXBXrW1NaREdDpVr0IhGhoA+BruEpSosSNFaVBV3KiulWCCLRoaAPgZ7haVrqykkkLOhSVmzH+hpOnJ5kYiYZdCkisgwFfQj0DE+xoTYa3Ta+Heu9WyH0qVUvEnYK+hDoHgr3hCOLuawlPfLm2e6RgCsRkeUo6AM2N5+ibyzcE44sZmP9GhoqS3nypIJeJOwU9AHrHZnGOSJx+4NMZsbOTXU8eXIo6FJEZBkK+oB1eWPoW+vCf0Ozha7ZXEfnwITuTS8Scgr6gJ04PQFAW0P0gn7npnoA9ncNB1yJiJyPgj5gxwYnKC1KRK6PHuDqTbWYwZPPK+hFwkxBH7BjgxO0NVRQFKEx9L6a8hK2NlXx5EkFvUiYKegDdmxwgo7GyqDLuGDpE7LDOKdbFouE1bJBb2ZfN7N+M3smY9laM7vPzA573+u95WZmXzSzI2a238xemsvio24+5ThxejLyQX96YvbsSWURCZ+VtOj/AbhhwbI7gPudc9uB+73nAG8BtntftwNfzk6Z8dQzPMXsfCryQQ/whLpvREJr2aB3zj0MnFmw+Cbgbu/x3cDNGcu/4dJ+DdSZWUu2io2bY4PpETdRDvod66spL0nohKxIiF1oH32zc+4UgPd9nbe8FTiZsV6Xt+xFzOx2M9trZnsHBgYusIxoOxv0TdEN+uKiBFe11urCKZEQy/bJ2MWGjix6ls45d6dzbpdzbldTU1OWy4iGY4MTVJYW0RSh2xMvZuemOp7pGWU2mQq6FBFZxIUGfZ/fJeN97/eWdwGbMtbbCPRceHnxdmxwgo6mSsyiN7Qy085N9cwmU5qIRCSkLjTo7wVu9R7fCvwgY/l7vdE31wIjfhePvFh6aGVV0GVctJ2b0ydkHz+h7huRMFrJ8MpvA78CLjWzLjO7DfgU8EYzOwy80XsO8GPgKHAE+CrwpzmpOgZmkvN0DUV7aKWvtW4Nm9dW8MvO00GXIiKLKF5uBefcu5Z46fpF1nXABy+2qEJw8swkKQcdjdG7x81irtvWyA/395CcT1FcpOvwRMJE/yMDcmxwEiAWXTcAu7c1Mjad5GlNRCISOgr6gBwbHAegoyH6XTcAr9ragBnsOTwYdCkisoCCPiDHBidoqCyltqIk6FKyYm1lKVdsqGHPEQW9SNgo6ANydGCC9hiciM103bZGHn9+iMnZZNCliEgGBX1Ajp+O9l0rF7N7WyNz847fHlt4xwwRCZKCPgATM0n6RmdiF/Qvb19LaXGCR9V9IxIqCvoA+Pe42RKzoC8vKWJXWz17jmg8vUiYKOgD0DngjbiJ8M3MlnLdtkYOnBplcHwm6FJExKOgD8Az3SOUFifY2hSPMfSZdm9rBFD3jUiIKOgDsL9rhMtbaiiJ4RWkV7bWsraylJ8f6F9+ZRHJi/glTcilUo5nuke4emNt0KXkRFHCuOHK9dx/oI+p2fmgyxERFPR5d3RwnInZea7eWBd0KTlz49UtTM7O88BBtepFwkBBn2f7u9L3golrix7glR0NNFWX8cP9mopAJAwU9Hm2v2uENSVFsTwR6ytKGG+9cj0PHOxnfEZXyYoETUGfZ093j3Blaw1FiWjPKrWcG1+ygZlkivsP9AVdikjBU9DnUXI+xbM9I7Hun/e9bHM962vK+eF+TTAmEjQFfR4d7h9nei4V6/55XyJhvO3qFn5xaIDR6bmgyxEpaAr6PHraOxF7VWv8gx7So29m51Pc96y6b0SCpKDPo6e6hqkuL6Y9JpONLGfnpjraGir49m+fD7oUkYKmoM+jp7tHuKq1lkTMT8T6zIz3vbqdvSeGeOL5oaDLESlYCvo8mUnOc+DUKFcVQP98pnfu2kR1eTFf23Ms6FJECpaCPk8O9Y4xN+94SQGMuMlUVVbMH71yMz95+hQnz0wGXY5IQVLQ58njJ9JdF4VyIjbT+17dTsKMu395POhSRAqSgj5Pfn6gny1NlWysXxN0KXnXUruGt13dwnceO6mhliIBUNDnwfDkLL86epo3X7Ees8I4EbvQ+3dvYXwmyXc0Akck7xT0eXD/gX7mU44brlgfdCmBuWpjLa/Z3siXHuzktGafEskrBX0e/PTZXlpqywviitjz+S83Xs7ETJLP/PRQ0KWIFBQFfY5NziZ5+LmBgu628W1vrua23R3cs/ckj2tcvUjeKOhz7BeHBphJpnjTFc1BlxIKH7p+O+tryvnL//sM8ykXdDkiBUFBn2M/e7aX+ooSXtG+NuhSQqGqrJhP3ngZz/aM8s1fHQ+6HJGCoKDPodlkivsP9vOGy5opjuFE4BfqbVe18NpLmvibnxxUF45IHih9cuhXR08zNp3khisLd7TNYsyML/zhTtbXlHP7N/bRMzwVdEkisaagzxHnHF975Ci1a0q4bltj0OWETn1lKXfduouZuXnef/deJmc15aBIrijoc+ShQwM8cniQD1+/nfKSoqDLCaXtzdV88Y+u4WDvKB/81uMKe5EcUdDnwNx8ir/+0e/Y0ljJe17VFnQ5ofa6S9fxP26+koeeG+APv/Jr+kangy5JJHYU9Dnwj795ns6BCT7x1sso0UnYZb37lW189T276BwY5+YvPcrvekaDLkkkVpRCWTYyOcfnfv4cr97awBsuWxd0OZHxhsub+e4HXoVzcPOXHuUzPz2orhyRLFHQZ9HU7Dx//k9PMTI1xyffdnnBXwm7Wle21vKvH9rNjS9p4X8/1Mn1f/sL/uWJLmaTqaBLE4m0nAS9md1gZofM7IiZ3ZGLfYRN/9g0t9z5K+4/2Md/vfFyLt9QE3RJkdRUXcZn/2An3/uTV1FfUcpH73mKV3/qfj7904McH5wIujyRSDLnsnsZupkVAc8BbwS6gMeAdznnfrfUe3bt2uX27t2b1TryxTnHb4+d4WPffYozE7N84ZadvKmA71KZTfMpx8OHB/jWr5/ngYN9pBx0NFaye1sjr97awOUbathUX1Ewc/CKLGRm+5xzu5ZbrzgH+34FcMQ5d9Qr5DvATcCSQR8lM8l5ekem6R6a4tHOQX7wZA9dQ1M0VZdxzweu5eoCmyowl4oSxusuXcfrLl3HqZEpfvJ0L3uODPL9x7v45q9PAFBRWsT2dVVsrK9gQ10562vX0FBZSm1FCfUVpVSVFVFRWkxlaTFlJQlKixL6xSAFJxdB3wqczHjeBbwyB/vhu4+d5KuPHM3KtjL/rnHOpZ87SDnH3LxjJpliJjnP2PQLJwiLEsbubY189A2X8OYr11NVlovDKZCepeqPd3fwx7s7mE2meLZnhEO9YxzsHeNI/zgHTo1y/8E+pueW788vThglRQmKE0ZxkVGUMBLmf6Wv3E0kwDDMwP+1YGZnH5PxuyLz18Zqz8voV478h+u383sv2ZDTfeQimRb77L6of8jMbgduB9i8efMF7aiuooTtzVUX9N7F2IL/vQnvP3ZJUYKykgRlxQnq1pTSWr+GDXXlXNpcTUNVWdb2LytTWpzgms31XLO5/pzlzjmGJ+c4MznL8OQsw5NzTMzOMzmTZHJ2/uwv65lkivmUY24+RXLeMe8czjnmU46UA+f9gj/7C5/0Mpexn7P7PKeA1f073GrfILFUu6Yk5/vIRdB3AZsynm8Eehau5Jy7E7gT0n30F7KjN12xXv3hcpaZUV9ZSn1ladCliIRKLkbdPAZsN7MOMysFbgHuzcF+RERkBbLeonfOJc3sz4CfAUXA151zz2Z7PyIisjI5OXvonPsx8ONcbFtERFZHV8aKiMScgl5EJOYU9CIiMaegFxGJOQW9iEjMZf2mZhdUhNkAcOIC394IDGaxnGxRXaujulYvrLWprtW5mLranHNNy60UiqC/GGa2dyV3b8s31bU6qmv1wlqb6lqdfNSlrhsRkZhT0IuIxFwcgv7OoAtYgupaHdW1emGtTXWtTs7rinwfvYiInF8cWvQiInI+zp9gIcAv4AbgEHAEuGOR18uAe7zXfwO0Z7z2CW/5IeDNy20T6PC2cdjbZmm+6iJ9n/4HgQPAs8CHM9b/K6AbeNL7emuej9dx4Glv33szlq8F7vOO131AfR6P16UZx+NJYBT4SL6OF9Dg/bzGgb9b8J6XecfrCPBFXvjrOOfHa6m6gArgR8BB7/P1qYzX3gcMZByv9+f5eD3kbdPf/7rlPhN5OF7VCz5fg8Dn83i83gjs8z5H+4DXZ/PzdU4NK1kpl1+kb2XcCWwBSoGngMsXrPOnwN97j28B7vEeX+6tX0Y6wDu97S25TeC7wC3e478H/n0e62oBXprxIXsuo66/Av5jEMfLe+040LjI/j7jf3iBO4BP57OuBdvvJT1uOF/HqxLYDfwJLw6u3wKvIj2j2k+At+TxeC1aF+mgf533uBR4JKOu9y38N+T5eD0E7Fpkf4tuK191LXj/PuC1eTxe1wAbvMdXAt3Z+nwt/ApD183ZycSdc7OAP5l4ppuAu73H3wOut/TknDcB33HOzTjnjpH+7feKpbbpvef13jbwtnlzvupyzp1yzj0O4JwbI92yb13hccpZXcvsL3NbeT1eC957PdDpnFvthXUXXJdzbsI5tweYzlzZzFqAGufcr1z6f9w3eOG45Px4LVWXc27SOfeg93gWeJz0DG+rkfW6lrHUZyKvdZnZdmAd6V+Oq3ExdT3hnPNn33sWKDezsix9vs4RhqBfbDLxheF3dh3nXBIYIf3n2FLvXWp5AzDsbWOpfeWyrrPMrJ30b/TfZCz+MzPbb2ZfN7NzJ0TNfV0O+H9mts+bz9fX7Jw75W3rFOn/DPmsy3cL8O0Fy3J9vJbS6m1nsW3m43gty8zqgN8D7s9Y/Pve8fqemW1a4q25rOv/mNmTZvaXGWG+0m3l9HgB7yLd0s4cnZLP4/X7wBPOuRmy8/k6RxiCfiWTiS+1TraW56uu9JvMqoDvk+5vHvUWfxnYCuwETgF/m+e6rnPOvRR4C/BBM3vtEvtfSi6PVynwduCfMl7Px/FaymrXv9BtXNB+zKyY9C/FLzrnjnqL/5V03/DVwM95oVWYr7re7Zy7CniN9/WeVW4rZ8fLs7CbBIr/AAACbklEQVQhkbfjZWZXAJ8GPrCKba5KGIJ+JZOJn13H+xDXAmfO896llg8Cdd42ltpXLuvCzEpIh/y3nHP/7K/gnOtzzs0751LAV1m6SyUndfl/Qjrn+oF/ydh/n/enpN9l0Z/PujxvAR53zvX5C/J0vJbSxbldIpnbzMfxWs6dwGHn3Of9Bc65015rEdLH62X5rMs51+19HwP+kRd+XivdVs6Ol5m9BCh2zu3LqDcvx8vMNpL+//Ze51xnxvoX+/k6RxiCfiWTid8L3Oo9fgfwgPcn1r3ALV6/VgewnfRJjEW36b3nQW8beNv8Qb7q8v5cvQs44Jz7bOaG/B+e598Cz+Sxrkozq/bqqATelLH/zG3l9XhlvO9dLOi2ydPxWpT3J/OYmV3r/UzfywvHJR/Ha0lm9tekg+QjC5ZnHq+3kz4/lJe6zKzYzBq9xyXAjSz++TrftnJyvDzLfb5ycry87rUfAZ9wzj3qr5ylz9e5ljpLm88v4K2kR6B0An/hLfvvwNu9x+Wk/2w/QjoAtmS89y+89x3COzO91Da95Vu8bRzxtlmWr7pIn/l3wH4WDAsEvkl6ONV+74fZkse6tpAeLfAU6ZNCmcergXQ/72Hv+9o8/xwrgNNA7YJ95et4HSfd+hon3dLyR0ntIh1WncDf8cLwt3wdrxfVRbrl50iH0jnDAoH/6f1snyLd2NmRx7oqSY9o2e/V8AVeGO215Lby8XP0Xju68Hjk43gBnwQmOHeIpz/s9KI/X5lfujJWRCTmwtB1IyIiOaSgFxGJOQW9iEjMKehFRGJOQS8iEnMKehGRmFPQi4jEnIJeRCTm/j+xwD5PR/yRAwAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "rv=gamma(a=24,scale=1/5000)\n", + "plt.plot(np.linspace(0,0.02,100),rv.pdf(np.linspace(0,0.02,100)))" + ] + }, + { + "cell_type": "code", + "execution_count": 99, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "23.8" + ] + }, + "execution_count": 99, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.mean(airline_df['Fatal'])" + ] + }, + { + "cell_type": "code", + "execution_count": 110, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "14.8" + ] + }, + "execution_count": 110, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + ".0037*4000\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/BDA 2.11.13.md b/BDA 2.11.13.md new file mode 100644 index 0000000..2f14a6a --- /dev/null +++ b/BDA 2.11.13.md @@ -0,0 +1,29 @@ +# Problem 2.10.13 + +Discrete data: Table 2.2 gives the number of fatal accidents and deaths on scheduled airline flights per year over a ten-year period. +We use these data as a numerical example for fitting discrete data models. + +1. Assume that the numbers of fatal accidents in each year are independent with a Poisson(θ) distribution. Set a prior distribution forθand determine the posterior distribution based on the data from 1976 through 1985. Under this model, give a 95% predictive interval for the number of fatal accidents in 1986. You can use the normal approximation to the gamma and Poisson or compute using simulation. +2. Assume that the numbers of fatal accidents in each year follow independent Poisson distributions with a constant rate and an exposure in each year proportional to the number of passenger miles flown. Set a prior distribution for θ and determine the posterior distribution based on the data for 1976–1985. (Estimate the number of passenger miles flown in each year by dividing the appropriate columns of Table 2.2 and ignoring round-off errors.) Give a 95% predictive interval for the number of fatal iaccidents in 1986 under the assumption that 8 × 10 11 passenger miles are flown that year. +3. Repeat (1) above, replacing ‘fatal accidents’ with ‘passenger deaths.’ +4. Repeat (2) above, replacing ‘fatal accidents’ with ‘passenger deaths.’ +5. In which of the cases above does the Poisson model seem more or less reasonable? Why? Discuss based on general principles,without specific reference to the numbers in Table 2.2. Incidentally, in 1986, there were 22 fatal accidents, 546 passenger deaths, and a death rate of 0.06 per 100 million miles flown. We return to this example in Exercises 3.12, 6.2, 6.3, and 8.14. + +|Year |Fatal accidents |Passenger deaths |Death rate +|---|---|---|---| +|1976 | 24 | 734 | 0.19 +|1977 |25 |516 |0.12 +|1978 |31 |754 |0.15 +|1979 |31 |877 |0.16 +|1980 |22 |814 |0.14 +|1981 |21 |362 |0.06 +|1982 |26 |764 |0.13 +|1983 |20 |809 |0.13 +|1984 |16 |223 |0.03 +|1985 |22 |1066 |0.15 + ++ Table 2.2 Worldwide airline fatalities, 1976–1985. ++ Death rate is passenger deaths per 100 million passenger miles. ++ Source: Statistical Abstract of the United States. + +Gelman, Andrew; Carlin, John B.; Stern, Hal S.; Dunson, David B.; Vehtari, Aki; Rubin, Donald B.. Bayesian Data Analysis, Third Edition (Chapman & Hall/CRC Texts in Statistical Science) (Page 60). CRC Press. Kindle Edition. \ No newline at end of file diff --git a/BDA 2.11.13.txt b/BDA 2.11.13.txt deleted file mode 100644 index 37d948a..0000000 --- a/BDA 2.11.13.txt +++ /dev/null @@ -1,9 +0,0 @@ -13. Discrete data: Table 2.2 gives the number of fatal accidents and deaths on scheduled airline flights per year over a ten-year period. We use these data as a numerical example for fitting discrete data models. (a) Assume that the numbers of fatal accidents in each year ar e independent with a Poisson(θ) distribution. Set a prior distribution forθand determine the posterior distribution based on the data from 1976 through 1985. Under this model, give a 95% predictive interval for the number of fatal accidents in 1986. You can use the normal approximation to the gamma and Poisson or compute using simulation. (b) Assume that the numbers of fatal accidents in each year fo llow independent Poisson distributions with a constant rate and an exposure in each year proportional to the number of passenger miles flown. Set a prior distribution forθand determine the posterior distribution based on the data for 1976–1985. (Estimate the number of passenger miles flown in each year by dividing the appropriate columns of Table 2.2 and ignoring round-off errors.) Give a 95% predictive interval for the number of fatal iaccidents in 1986 under the assumption that 8 × 10 11 passenger miles are flown that year. (c) Repeat (a) above, replacing ‘fatal accidents’ with ‘passenger deaths.’ (d) Repeat (b) above, replacing ‘fatal accidents’ with ‘passenger deaths.’ (e) In which of the cases (a)–(d) above does the Poisson model seem more or less reasonable? Why? Discuss based on general principles, without specific reference to the numbers in Table 2.2. Incidentally, in 1986, there were 22 fatal accidents, 546 passenger deaths, and a death rate of 0.06 per 100 million miles flown. We return to this example in Exercises 3.12, 6.2, 6.3, and 8.14. - -Year Fatal Passenger Death accidents deaths rate 1976 24 734 0.19 1977 25 516 0.12 1978 31 754 0.15 1979 31 877 0.16 1980 22 814 0.14 1981 21 362 0.06 1982 26 764 0.13 1983 20 809 0.13 1984 16 223 0.03 1985 22 1066 0.15 Table 2.2 Worldwide airline fatalities, 1976–1985. Death rate is passen ger deaths per 100 million passenger miles. Source: Statistical Abstract of the United States. - -Gelman, Andrew; Carlin, John B.; Stern, Hal S.; Dunson, David B.; Vehtari, Aki; Rubin, Donald B.. Bayesian Data Analysis, Third Edition (Chapman & Hall/CRC Texts in Statistical Science) (Page 60). CRC Press. Kindle Edition. - -Gelman, Andrew; Carlin, John B.; Stern, Hal S.; Dunson, David B.; Vehtari, Aki; Rubin, Donald B.. Bayesian Data Analysis, Third Edition (Chapman & Hall/CRC Texts in Statistical Science) (Page 60). CRC Press. Kindle Edition. - -Gelman, Andrew; Carlin, John B.; Stern, Hal S.; Dunson, David B.; Vehtari, Aki; Rubin, Donald B.. Bayesian Data Analysis, Third Edition (Chapman & Hall/CRC Texts in Statistical Science) (Page 59). CRC Press. Kindle Edition. diff --git a/BDA 5.9.1-2-4-5 -Exchangeability and DeFinetti's Theorem.ipynb b/BDA 5.9.1-2-4-5 -Exchangeability and DeFinetti's Theorem.ipynb new file mode 100644 index 0000000..484588f --- /dev/null +++ b/BDA 5.9.1-2-4-5 -Exchangeability and DeFinetti's Theorem.ipynb @@ -0,0 +1,267 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Problem 5.9.1\n", + "\n", + "### Exchangeability with known model parameters\n", + "\n", + "For each of the following three examples, answer: \n", + "1. Are observations $y_1$ and $y_2$ exchangeable? \n", + "2. Are observations $y_1$ and $y_2$ independent? \n", + "3. Can we act as if the two observations are independent? \n", + "\n", + "Examples:\n", + "1. A box has one black ball and one white ball. We pick a ball $y_1$ at random, put it back, and pick another ball $y_2$ at random. \n", + "\n", + "Here the events are clearly independent and exchangeable. \n", + "\n", + "\n", + "2. A box has one black ball and one white ball. We pick a ball $y_1$ at random, we do not put it back, then we pick ball $y_2$.\n", + "\n", + "In this case there are four outcomes: (BB), (BW), (WB), (WW) and of these four only (WB) and (BW) have non-zero probability (1/2). Since the likelihood is symmetric, the observations are exchangeable. Clearly, though,\n", + "the events aren't independent; for example P(B|B)=0 and P(B|W)=1. And you clearly can't act as if they're independent since the second observation is determined by the first.\n", + "\n", + "3. A box has a million black balls and a million white balls. We pick a ball $y_1$ at random, we do not put it back, then we pick ball $y_2$ at random.\n", + "\n", + "These are exchangeable observations since P(BW)=(1/2)(1000000/1999999) =P(WB) and P(BB)=P(WW). They act independent since 1/2(1000000)/1999999) is just about 1/4 and so is 1/2(999999)/(1999999).\n", + "\n", + "\n", + "Gelman, Andrew; Carlin, John B.; Stern, Hal S.; Dunson, David B.; Vehtari, Aki; Rubin, Donald B.. Bayesian Data Analysis, Third Edition (Chapman & Hall/CRC Texts in Statistical Science) (Page 134). CRC Press. Kindle Edition. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Problem 5.9.2\n", + "\n", + "We ask the same questions as in the preceeding problem but under the conditions:\n", + "\n", + "1. A box has $n$ balls colored black and white, but we don't know how many of each. We pick a ball, put it back, then pick another.\n", + "2. Same except we pick a ball, don't put it back, then pick another.\n", + "3. Suppose we know that there are a lot of balls of each color.\n", + "\n", + "In the first case, let $\\theta$ be the proportion of white balls in the urn. Then $P(BW)=(1-\\theta)\\theta$\n", + "and $P(WB)=\\theta(1-\\theta)$. So the events are exchangeable. Also $P(BB)=(1-\\theta)^2=P(B)^2$, $P(BW)=P(WB)=\n", + "P(W)P(B)$, and $P(WW)=P(W)^2$. So they are independent. \n", + "\n", + "In the second case, we have $P(WB)=(\\theta)(n(1-\\theta)/(n-1))$ and $P(BW)=(1-\\theta)(n\\theta)/(n-1)$\n", + "and these are the same, so it's exchangeable. But they are not independent since $P(WB)$ isn't $P(W)P(B)$.\n", + "Also $P(WW)=(\\theta)(n\\theta-1)/(n-1)$ and $P(BB)=(1-\\theta)(n-n\\theta-1)/(n-1)$.\n", + "\n", + "They do get close to independent if $n$ is large.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYYAAAEICAYAAABbOlNNAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzsvXl8FNeV6P892hFoayEJbSAWsW82wuDYsXFAhmxgTzYnmYQJ8fMkk5k3y3tJyOQ5fnbGL+Tl5ZfE45nEDomjzJLNGRvi2AaBjR1vGGH2VWLVvqMFof38/uhqaEktJOilernfz6c+3X3rVtXp7lt17rnn3HNFVTEYDAaDwUWU3QIYDAaDIbgwisFgMBgMQzCKwWAwGAxDMIrBYDAYDEMwisFgMBgMQzCKwWAwGAxDMIrBYDAYDEMwiiECEZECEVER6XTbHrZbLoNhLEQkTkSeFZHzVhteNWy/iMh3RaTZ2v6viIjb/qUisl9EuqzXpQH/EiGAUQyRTaqqTrK2b9stjMEwTt4A/hyo87DvIeA+YAmwGPgI8JfgVCrANuDfgTSgBNhmlRvcMIohBLF6S/9TRA6LSJuI/EZEEuyWy2AYC2/brqr2quoPVfUNYMBDlY3A91W1SlWrge8Df2HtWwXEAD9U1R5VfQIQ4APefKdwxCiG0OWTwDpgOs6e0V+IyFQRuXSd7TPDznFBRKpE5BkRmRzwb2CIVHzRdkdjAXDI7fMhq8y177AOzQN02G2/wSLGbgEMN80TqloDICJ/AJaq6k+A1HEc2wQsBw4C6cC/AP8BrPWTrAaDO9603bGYBLS5fW4DJll+huH7XPuTfHDdsMIohtDFfXy1C8gZ74Gq2gmUWR/rReSvgVoRSVbVdh/KaDB44qbb7jjoBJLdPicDnaqqIjJ8n2t/hw+vHxaYoaQwwjLHO6+zfXaUQ12mtYyy32DwK1603eEcw+l4drHEKnPtW+wepYRzKOsYhiEYiyGMUNWLOM3l6yIiK4BLQDnO6IwngD2qOtzMNhgCwnjbLoCIxHOtExNnOa97LN/BL4F/EJEXcXZ4/gfwz1bdPTgd1v9dRH4C/Der/BWffIkwwlgMkckM4GWcJvRRoAf4tK0SGQzj5xRwBcgFdljvp1n7ngL+ABzB2bb/aJWhqr04Q1k/j7NjtAm4zyo3uCFmoR6DwWAwuGMsBoPBYDAMwSgGg8FgMAzBKAaDwWAwDMEoBoPBYDAMISTDVSdPnqwFBQV2i2EIU/bv39+kqhmBvq5p1wZ/sn///nbgbVVdN1bdkFQMBQUFlJWVjV3RYLgJROSCHdc17drgT0SkfDxKAcxQksFgMBiGYRSDwWAwGIZgFIPBYDAYhmAUg8FgMBiGYBSDwWAwGIbgE8UgIutE5JSIVIjIZg/7460l/CpEZK+IFLjt+4ZVfkpEzEIxBr/x8ssvM2fOHGbNmsWWLVtG7O/p6eFTn/oUwMLxttPR2r6ITLfOUW61fbOusCFk8FoxiEg0zhXAPgjMBz4tIvOHVfsi0Kqqs4AfAN+1jp0PPIBzab11wL9a5zMYfMrAwABf+cpXeOmllzh+/Di/+tWvOH78+JA6P/vZz0hLSwNnVs4x2+kYbf+7wA9UtRBoxXkPGAwhgS8shtuAClU9a6Wv/TWwYVidDUCJ9f5ZYLW1WMYG4NfWwtzngArrfDdMU2cPPyg9zak6sxiTYSTvvvsus2bNYsaMGfzuQC2L7/oQ27ZtG1Jn27ZtbNy40fVxPO3UY9u3jvmAdQ5wtv37blb2tyqa+EHp6Zs93BAhdPb0852XTvjkGegLxZALVLp9rrLKPNZR1X6c66ymj/NYAETkIREpE5GyxsbGEfsHBpUf7S7n7TNNN/s9DGFMdXU1+fn5APzsT+eo6ptAdXX1qHXG2U5HK08HLlnncC8fwVjtGmD/hVZ+tLuczp5+j/sNBoBTde089dpZKlu6vD6XLxSDp+Ughy/yMFqd8RzrLFR9WlWLVLUoI2NktoLMpHhSE2M5VW8sBsNIXOuOdPcNcL75MtkpCQxd4fFaneGHcuPt12ftGmDOFOda9adN2zZch5OWpTA3O8nrc/lCMVQB+W6f84Ca0eqISAyQArSM89hxISLMnZJ09ccxGNzJy8ujsrKS8vpOBhXiui+Rk5PjsQ6Mu52OVt4EpFrncC+/KeZlO9evN8OkhutxsraDpPgYclMneH0uXyiGfUChFYURh9NJt31Yne2Aa/D248Ar1vqs24EHrKil6UAh8O7NCjJ3SjKn6zoYHDSr0hmGsnz5csrLy3l9/1F0oI+9u/7A+vXrh9RZv349JSUuV9i42qnHtm8d86p1DnC2/aEOjRsgN3UCE+OijWIwXJdTdR3MnpI0whK+GbxWDNY46l/jXHv1BPBbVT0mIo+JiOvO+xmQLiIVwD8Am61jjwG/BY7jXIP4K6o6cLOyzJmSxOXeAapar9z8FzKEJTExMTz55JM88lefpXbrl/nMpz/FggUL+Na3vsX27c5+zBe/+EWam5sBFjKOdjpa27cu+XWci9JX4PQ5/OxmZY+KEmZPSeJEbfvNnsIQ5qgqJ+vamTvF+2Ek8FF2VVV9EXhxWNm33N53A58Y5djHgcd9IYdrLPZkXTtT0xN9cUpDGPGhD32IdY/+hrYrfTz8N3cC8Nhjj13dn5CQwO9+9ztE5KiqDomOG62demr7VvlZbjLCzhNzpyTx0tE6VNUnPUJDeFHb1k17d7/PFENYzXyek+X8UYzJbRiNk3UdPrt5AsncKclc6uqjoaPHblEMQYjrmTdnSrJPzhdWimFifAxTHYmcNNEbBg80dfbQ1Nlz1bIMJa5Zw6ZtG0Zy8qpiMBaDR+aasVjDKLh6VXN91KsKJC4rx7RtgydO1rWTk5JAyoRYn5wv/BRDdjLnmy7T3XfTPmxDmOJ6qM7zQZx3oElNjCM7JcEMkxo8crK242pYsy8IO8Uwb0oSgwrl9Z12i2IIMk7WdZCRFE/6pHi7RbkpjDVs8ERP/wBnGjt9MrHNRdgphrmW1jxRZ24gw1B8Gc5nB3OzkznT2Elv/6DdohiCiDMNl+kfVJ8OkYadYpjqSGRCbDQna43JbbhG/8Agp+s7fWpuB5q5U5LoG1DONBpr2HCNk3W+HyINO8UQbU0GOmksBoMb55sv09s/GNIWg0upmbZtcOdkXQdxMVEUpE/02TnDTjEAzM92jsWOkhTNEIGcsCzIULYYZkyeSFx0lLGGDUM4UdvO7KxJxET77nEeloph7pRkWs1kIIMbJ2rbiYkSZmZMsluUmyYmOorCrEkcNw5ogxsnajt8HoIdporBOVxgbiCDixO17czKnERcTGg3+blTkq9aPwZDY4dz0qavh0hD+y4ZhauRSUYxGCxO+DjO2y7mZSfR1NlDo7GGDVx7xs33cdsOS8WQMiGWvLQJpmdlAKD1ci917d0+v3nsYH6O6fQYrnFt0qZRDONiXnayuXkMgP9uHjuYb6xhgxsnatvJTkkgbWKcT88b1orhbGOnSY1huOprCsVUGMNxpcYwisEAzrbtjw5P2CqG+dnO1Bgmt4zheG07mSGcCmM4TmvYtOtIp7tvgDONl/3S4QlbxTDPmNwGi3BxPLuYl53EmcZOevqNNRzJVDR0MjCoxmK4EfLTEpkUH2NCViOc3v5BKhrCSzHMz06hf1BNosgI57gffWdhqxiiooR52SYbZaRT0dBJ34CyICeMFIP1XUynJ7I5XtNOYly0T1NhuAhbxQDOCI7jNe0MDprUGJHKsZo24NrDNByY5kgkMS6a4zVGMUQyx2ud2YKjo3y/Bnh4K4acZC73DnCxpctuUQw2cby2nQmx/ulV2YXTGk42iiGCUVVO1LT7rcMT3oohOwUwJnckc7ymnbnZ/ulV2cmCnGSO1xprOFKpbLlCR08/C3JS/HL+sFYMhVmTiI4S07OKUFSV47XtYTHjeTjzs5Pp7OmnqvWK3aIYbOB4rTVE6qe27ZViEBGHiJSKSLn1mjZKvY1WnXIR2ehW/riIVIqIX8IrEmKjmZUx6eo4syGyqGq9Qkd3f1j5F1y4vpNp25HJ8Zp2ogTm+Gl9EW8ths3AblUtBHZbn4cgIg7gEWAFcBvwiJsC+YNV5jfm5yRzzFgMEYnrfw9Hi2F2lnN4zLTtyOR4bTszMyaREBvtl/N7qxg2ACXW+xLgPg911gKlqtqiqq1AKbAOQFXfUdVaL2W4LgtykmmwUtMaIovjNW1ECT7PVR8MuKxh4z+LTI750fEM3iuGLNeD3XrN9FAnF6h0+1xlld0QIvKQiJSJSFljY+O4j7tmcpsbKNI4VuPsVU2I80+vym4W5CSboaQIpLmzh9q2bhb6yfEM41AMIrJLRI562DaM8xqewkFuOJRCVZ9W1SJVLcrIyBj3cQusyKSj1eYGijSO1rSF1cS24czPSaa+3azNEGm4Orn+bNsxY1VQ1TWj7RORehHJVtVaEckGGjxUqwJWuX3OA/bcoJw3TUqic20GE5kUWTR19lDf3uO3cL5gwPXdjtW0sWqOJ2PdEI5c9Z0F8VDSdsAVZbQR2Oahzg7gXhFJs5zO91plAWNhTooxuSOMq72q3PC2GMAMk0YaR2vayEubQGqib9dgcMdbxbAFKBaRcqDY+oyIFInIVgBVbQG+DeyztsesMkTk/4pIFZAoIlUi8r+9lMcjC3KSOd/cRUd3nz9ObwhCXB2BBdkptLS0UFxcTGFhIcXFxbS2tno8pqSkhMLCQoCFw8Kql4nIERGpEJEnRESsco/h2iKySkTaROSgtX3LH98xZUIsUx2JxhqOMI7XtPt9iNQrxaCqzaq6WlULrdcWq7xMVR90q/dzVZ1lbc+4lX9NVfNUNcp6/d/eyDMarl6jyWEfORyraScvbQIpibFs2bKF1atXU15ezurVq9myZcuI+i0tLTz66KPs3bsX4ARDw6p/DDwEFFrbOqv8euHaf1LVpdb2mH++pXFARxod3X2ca7rs9yHSsJ757MLlvT9iHNARw7Hqa47nbdu2sXGj0wDYuHEjzz///Ij6O3bsoLi4GIfDATCAFVZt+c6SVfVtVVXgl1wLyx5PuLZfWZibwvnmLtqNNRwRuDq3QW0xhAqZyQlkJMWbnlWE0N7dx/nmLhblOjsE9fX1ZGdnA5CdnU1Dw8gYierqavLz892LXGHVudb74eVw/XDt20XkkIi8JCILRpP1ZsOwXbgeEGY4KTJwRVe62ra/GDMqKVxYlJtiQlbDmDVr1lBXVwdAV+8ANa1dfP+/JpD/ve+O63inMTCymJsLt34PmKaqnSLyIeB5nENQnq77NPA0QFFR0Q2HcS/MvRaOvXJG+o0ebggxjla3kZkUT2Zygl+vEzGKYWFOMntONXCldyBsJzxFMrt27br6fuufzvJPfzzBvv+1hsmT4snKyqK2tpbs7Gxqa2vJzBwZ2pmXl8eePXuGFOEMq66y3ruX11jvPYZrq+rV7ruqvigi/yoik1W1ySdf1o3Jk+LJTkkwnZ4I4WhN29XOgD+JiKEkcPasBtWk4I4EjlS3kZ2SwORJ8QCsX7+ekhKnK6CkpIQNG0bOzVy7di07d+50RSxFY4VVW0NEHSKy0opG+jzXwrI9hmuLyBS3yKXbcN5nzf74ruCcz2D8Z+FPV28/FQ2dRjH4EtePafwM4c/R6rYhURubN2+mtLSUwsJCSktL2bzZGTxUVlbGgw86g+ccDgcPP/wwy5cvB5iHW1g18GVgK1ABnAFesso9hmsDHweOisgh4AngAR1lrMoXLMxN5mzTZS739PvrEoYg4ERtB4PqHP3wNxEzlJSdkoBjYhxHqoxiCGc6e/o523SZjy7JuVqWnp7O7t27R9QtKipi69atVz9v2rSJTZs2ISJHh4VVlwELhx+vqs3Aag/lTwJPevtdxsui3BTUsoaXFzgCdVlDgHENFxqLwYeICAtzjckd7hyvaUfV/1EbwYTrQWE6PeHNkeo20ifGkZ3iX8czRJBiAFiUm0x5QyfdfQN2i2LwE0cCFM4XTGRZ4djGAR3eHK12Op4t95VfiTDFkMrAoHLCOKDDlqPVbWQl+z+cL9hYnJvCYaMYwpYrvQOUN3SyOC8wHZ6IUgyuH9UMJ4Uvh6susSg31W4xAs6ivBTONHYaB3SYcry2nYFBDZglHFGKITslgXTjgA5bXI7nSBpGcuFyQJtMq+HJ1RnPxmLwPSLCojzjgA5XjlW3oUrAzO1gwqUMTdsOTw5XtTF5UjxTAjREGlGKAZw3UHlDJ1d6jQM63DgSwHC+YCMzOYGs5HiOVF2yWxSDHzha3cai3OSAOJ4hQhXDwKByvNb0rMIN14znjKR4u0WxhUW5qRw2w6RhR1dvP+UNHSzKC5zvLOIUw5J8549rbqDw43BVW0QOI7lYkpfC2abLJgV3mHGspp1Bdf6/gSLiFEOWZXIbxRBetF1xLmCyOIC9qmBjsdXpOWradlhxqNI5PBgoxzNEoGIAp8l9yIzFhhWuSLNIthhcDmgznyG8OFzlHCLNTArc3JyIVAxL8lI422hM7nDCpegXR+AcBheOiXHkOyZw2HR6worDVZcC3uGJSMVgTO7w43DVJQrSE0lJjLVbFFtZnJfKoUrTrsOFti7naoSBHiKNTMVgmdyHjGIIG5yO58i1FlwsyUuh+tIVmjt77BbF4AMOVzutvyVGMfiftIlxTHUkGpM7TGho76a2rTui/QsuXMrRBFeEB67/MdCz+b1SDCLiEJFSESm3XtNGqbfRqlMuIhutskQR+aOInBSRYyKyxdOx/mJJfupVb78htHFZfkvzjcWwKDeFKIGDpm2HBQcrLzFj8sSAD5F6azFsBnaraiGw2/o8BBFxAI8AK4DbgEfcFMj/U9W5wC3AHSLyQS/lGTdL8lKoaeumob07UJc0+IlDlZeIjpIhq7ZFKhPjYyjMTDJRd2GAqnKw8tLVuVeBxFvFsAEosd6XAPd5qLMWKFXVFlVtBUqBdarapaqvAqhqL/AeQxdd9yu3THX+2MbPEPocqrrE3ClJTIiLtluUoGCpZQ37cTVRQwCoa++msaPHFkvYW8WQZS2WjvWa6aFOLlDp9rnKKruKiKQCH8VpdQSEBTkpREeJGU4KcQYHlUM29aqClSX5qbR29VHZcsVuUQxe4Ho22dG2x1zzWUR2AVM87PrmOK/hKevT1a6MiMQAvwKeUNWz15HjIeAhgKlTp47z0qOTEBvN3ClJZiw2xDnXfJn27n6WmoikqyzJdw6pHahsZWp6os3SGG6Wg5VtxEYL87KTAn7tMS0GVV2jqgs9bNuAehHJBrBeGzycogrId/ucB9S4fX4aKFfVH44hx9OqWqSqRRkZGWOJPS6W5DtnQA8OGpM7VHH1qhbnG/+Ci9lZSSTERplOT4hzqPIS87KTiY8J/BCpt0NJ24GN1vuNwDYPdXYA94pImuV0vtcqQ0T+CUgB/s5LOW6KpfmpdHQ7F3cxhCYHKy8xMS6awszA96qCldjoKBblpphh0hBmYFA5XHWJW2waIvVWMWwBikWkHCi2PiMiRSKyFUBVW4BvA/us7TFVbRGRPJzDUfOB90TkoIg86KU8N4TrRz9wsTWQlzX4kAMXL7E4L5XoqMDkqQ8VluancrSmnd7+QbtFMdwE5Q0dXO4dYOnUEFQMqtqsqqtVtdB6bbHKy1T1Qbd6P1fVWdb2jFVWpaqiqvNUdam1bfXu69wYMzMmkRQfY0zuEKW7b4ATte223TzBzNL8NHr7BzlRa5b6DEUOXHQ+k5bme5wa5ncicuazi6goYUl+qlEMIcqxmjb6B9U2czuYcYVjm7Ydmhy8eInUxFgKbAoeiGjFAE6T+2Rdh1nqMwS52qsyFsMInGma480waYhyoLKVpfmpAVvKczgRrxhumZp61dFjCC0OVF4iN3VCQPPUhwoiwi1TUzlgLIaQo6O7j/KGTm6xaRgJjGK4OqvQ3EChx4ELrcZauA63TE3jQnOXybQaYhyuakPVXks44hVD+qR4pqUn8t4FY3KHEnVt3dS0dXPrVPt6VcHOtag70+kJJVzPIjuTQka8YgC4dWoaB0xumZDCNXZ+q7EYRmVxXioxUcKBStPpCSXeu9hKYeYkUibYt+iUUQw4Hy6NHT1UtZrcMqHCexdbiYuJGldG1ZaWFoqLiyksLKS4uJjWVs8PypKSEgoLCwEWutLDA4jIMhE5IiIVIvKEWB5BEfmElTJ+UESK3M8lIt+w6p8SkbXefNebZUJcNPOyk3nvgrEYQgVV5UDlJdstYaMYcI7FgvNhYwgN3rt4iUW5KcTFjN2Et2zZwurVqykvL2f16tVs2TJy6Y+WlhYeffRR9u7dC3CCoenhf4wzT1ehta2zyo8Cfwa87n4uEZkPPAAssOr+q4jYkvr11qnOtC/9A2aiWyhwtukyl7r6uHWavZawUQzA3ClJJMZFm7HYEKG3f5Aj1W3jHkbatm0bGzc6DYCNGzfy/PPPj6izY8cOiouLcTgcAANY6eGtHGDJqvq2Oscaf4mVXl5VT6jqKQ+X3AD8WlV7VPUcUIFzLZKAc+u0NLp6BzhV32HH5Q03iOsZZCyGICAmOorFeSnsNw7okOBYTRu9/YPjvnnq6+vJzs4GIDs7m4aGkbkeq6uryc93z/V4NT18rvV+ePn1GDPVfKBw/UYmuCI0eO9iK0kJMczMmGSrHGOm3Y4Ulk1L4yevnaWrt5/EOPOzBDMuBb5s2jXFsGbNGurq6kbUffzxx8d1zlECD5Qx0saPwriP8XU6+eHkpU0gIyme/Rda+dztBT4/v8G37D/fyq1T04iyOfeXeQJaFE1zMDB4hkOVbdw+M91ucQzXYf+FVvIdE8hMvjaxbdeuXaPWz8rKora2luzsbGpra8nMHLmeVF5eHnv27BlSBOzB2dvPG1bunjbeE2Olmr+Kqj6NM/U8RUVFPg+LExGKpqWx3/jPgp62K32cbujgI4uz7RbFDCW5cOWWMQ7o4EZVKbvQyrIbGINdv349JSXOFWhLSkrYsGHDiDpr165l586droilaKz08NbKhB0istKKRvo8ntPLu7MdeEBE4kVkOk6H9bvjFtjHLJuWRmXLFbO+eZBz4GIrqkMtYbswisEiNTGOWZmTjJ8hyKlqvUJjR88N3TybN2+mtLSUwsJCSktL2bx5MwBlZWU8+KAzCbDD4eDhhx9m+fLlAPOw0sNbp/gysBWnE/kM8BKAiNwvIlXA7cAfRWQHgKoeA34LHAdeBr6iqrYl47p1mom6CwXeu9BKtJXY027MUJIbRdPSeOloHYODavsYn8Ez1/wLjnEfk56ezu7dI5cTLyoqYuvWa5neN23axKZNmxCRo6708OBMIw8sHH68qj4HPOfpmqr6ODA+B4efWZjjDOstO9/KuoX2D1MYPLP/YivzspOYGG//Y9lYDG7cOi2Ntit9nGnstFsUwyjsv9DKxLho5kwxK7aNl7iYKJbkpVBmrOGgpX9gkAMX7Z/Y5sIoBjeWFzh7oeYGCl72nW/h1mlpZsW2G6SowMGxmjaTXj5IOVHbQVfvwNVnkN0YxeBGQXoikyfFse98y9iVDQGn7Uofp+o7gubmCSWWF6TRN6AcMunlgxLXM6eowFgMQYeIsGxaGmXnjcUQjLxnRW0UBUHURqjhGqIoM52eoKTsQgu5qRPITplgtyiAUQwjWF7g4GJLF/UmtC/oKDvfQnSUmDUYboLUxDhmZ01in+n0BB2qStn5VpYHibUARjGMoMjlZzA3UNCx73wrC3OSzcz0m6SowMF7F1oZGDTp5YOJypYrNHT0XH32BANGMQxjQU4yE2KjjZ8hyOjpH+BQ5aWgunlCjeUFaXT09HOyrt1uUQxuvGs9a4LJd2YUwzBio6O4ZWoq754ziiGYOFLVRk//YFDdPKGG67fbZ9p2ULHvXAspE2IpzLQ3cZ47XikGEXGISKmIlFuvHgfJRGSjVad82AIoL4vIIWuxk5/YlbN+OLdNd3Cirp22K312i2Kw2HvO1asKnnHYUCMvLZHc1AlXe6iG4ODd8y0sL3AE1aRaby2GzcBuVS0EdlufhyAiDuARYAXOnPTuC6B8UlWX4JxVmgF8wkt5fMJt0x2omlTFwcS+8y0UZk4ifVK83aKENLdNd/DuuVazjG2Q0NDRzbmmy6yYHlyWsLeKYQNQYr0vwVrAZBhrgVJVbVHVVqwFUABU1TXYGQPEMXY644BwS34asdFytZdqsJeBQWX/+VaWB9nNE4osL3DQ1NnDuabLdotiAPadc3Y+g61te6sYsqzsk1ivI/MZj7FoiZV4rAHoAJ4d7UIi8pCIlIlIWWNjo5diX58JcdEsyk0xDugg4URtOx09/UHXqwpFbrN+Q9O2g4N3zzWTGBfNgpxku0UZwpiKQUR2ichRD9vI3MWjnMJD2VXLQFXXAtlAPPCB0U6iqk+rapGqFmVkZIzz0jfPbdPTOVx1yaQQCAKu+ReMYvCWmRkTSZ8Yx96zRjEEA3vPtXDr1DRio4MrDmhMaVR1jaou9LBtA+qtNXGxXkeumTiORUtUtRtnDvvxKhu/s2KGg74BNamKg4C9Z5uZ6kgkJzU4ZoWGMiLCihkOM0waBLRe7uVkXQcrZwRfh8dbNbUdcEUZbcTzAiY7gHtFJM1yOt8L7BCRSW5KJQb4EHDSS3l8RtG0NKLE+VAy2MfgoPLu+RYzjORDVkxPp/rSFSpbuuwWJaJxRYetmBF8K0Z6qxi2AMUiUg4UW58RkSIR2QpgLXbybWCftbkWQJkIbBeRw8AhnNbGT7yUx2ckJcSyMDeFd0zPylZO1XdwqasvKG+eUGWF1UN9x3R6bGXv2RbiY6JYnJditygj8Cq3gKo2A6s9lJcBD7p9/jnw82F16oHl3lzf36yckc4v3jxPd98ACbFBMcUi4nBZbMZi8B2zM5NIS4xl77kWPlGUP/YBBr/wztlmlk1LIz4m+J4tweXxCDJWTHfQay2gYbCHd846s07mOxLtFiVsiIoSbpvuMBaDjbRd6eNEXTsrpgenJWwUw3VYPt1BlMDb5gayhcFB5Z1zzaw0w0g+Z+WMdKpajZ/BLvaebUaVoHQ8g1EM1yXZ5Wc4YxSDHZysc/oXbp9EleZ6AAAgAElEQVRpFIOvcf2mptNjD2+fbSY+JipoU8gbxTAGt89I50Blq5nPYAOuh5ZRDL5ndmYSjolxptNjE2+faaaoIDj9C2AUw5jcPjOdvgGl7IKJTgo0b59pZlq6M/GbwbdERQm3z0jn7bPNJm9SgGnu7OFkXQfvmznZblFGxSiGMVhe4CAmSnjb9KwCysCgsvdcM7cb/4LfWDkzndq2bi40Gz9DIHFNLgxm35lRDGMwMT6GxXkpvGUUQ0A5VtNGR3e/GUbyIy6la9p2YHnrTBOJcdFBOX/BhVEM4+COWZM5XHWJ9m6zPkOgeLPC+Bf8zcyMiWQlx/PmmSa7RYko3qpoZsV0R9DlR3IneCULIt43czKDikk8FkDeOtPE7KxJZCYl2C1K2CIi3DFzMm+faWbQrAMdEGrbrnC26TJ3zApe/wIYxTAubp2WSkJsFG9WmJ5VIOjpH2Df+Zagds6FC++bNZmWy72cMOtABwSXJRzsbdsohnEQHxPN8gIHbxmTOyC8d+ES3X2DQd+rCgfumGX5GSqMnyEQvFXRhGNiHHOnJNktynUximGc3DFrMqfrO2lo77ZblLDnrTNNREfJ1WRvBv+RnTKBGRkTecNYw35HVXnzTBO3z0wPqvWdPWEUwzi50+q9mhvI/7xe3sSSvBSSE2LtFiUiuHPWZN4910JPv5nE6U8qGjqpb+/h/SFgCRvFME7mZyfjmBjHG+VGMfiTtq4+jlRd4s5C/6/SZ3Dy/sIMrvQNsP+CWZTKn7xuPTvuLDSKIWyIihLumDWZP1U0mZmifuStM00MKtzlw5unpaWF4uJiCgsLKS4uprXV8wOwpKSEwsJCgIUi4lqAChFZJiJHRKRCRJ4QEbHKPyEix0RkUESK3OoXiMgVETlobUGzzognVs5wEB0lptPjZ94ob2TG5InkpQV/pmCjGG6A98+aTGNHD6fqO+wWJWx5vbyJSfExLMn3XXKxLVu2sHr1asrLy1m9ejVbtmwZUaelpYVHH32UvXv3ApwAHrFWHAT4MfAQUGht66zyo8CfAa97uOwZVV1qbV/y2ZfxA0kJsdw6NdUMk/qR3v5B9p5rCQlrAYxiuCFcf+qfTpsbyB+oKm9UNLJyRrpPJ/9s27aNjRudBsDGjRt5/vnnR9TZsWMHxcXFOBwOgAGgFFhnLT+brKpvq9NU/CVwnyXvCVU95TNBbeTOWRkcqW6j9XKv3aKEJe9dbKWrd+CqrzLYMYrhBshJncCszEm8Xt5otyhhyfnmLipbrnDXbN/ePPX19WRnZwOQnZ1NQ0PDiDrV1dXk5w9ZzawKyLW2Kg/lYzFdRA6IyGsi8v7RKonIQyJSJiJljY32tav3z56Mqgmu8Bevn24kJkpCZia/V0t7RiJ3FWbw73svcKV3gAlxwZkyN1R57ZTzgX337Bt3PK9Zs4a6uroR5Y8//vi4jh/Fb6SAp7jCsZxMtcBUVW0WkWXA8yKyQFVHzCJT1aeBpwGKiopsc14tyUslZUIsr51u5KNLcuwSI2x57XQjt05LIylEIu2MYrhB7p6Twc/fPMfec82smpNptzhhxevlTRSkJzItfeINH7tr165R92VlZVFbW0t2dja1tbVkZo783/Ly8tizZ8+QImAPTgshb1h5zfVkUdUeoMd6v19EzgCzgbLxfBc7iI4S7iyczOunG1FVLP+6wQc0dvRwrKadr66dY7co48YMJd0gK6Y7iI+J4rXTZjjJl/T0D/D2meabshbGYv369ZSUlADOyKMNGzaMqLN27Vp27tzpiliKBu4FdqhqLdAhIiutaKTPA9uudz0RyRCRaOv9DJwO67M+/Ep+4e7ZGTR0ONcKMPiOP1lDz/5o2/7CKIYbJCE2mhUz0o1i8DFl51u50jfAXX64eTZv3kxpaSmFhYWUlpayefNm5zXLynjwwQcBcDgcPPzwwyxfvhxgHvCYqrqyJn4Z2ApUAGeAlwBE5H4RqQJuB/4oIjus+ncBh0XkEPAs8CW3cwUtd1lzR0zb9i2vnW4kfWIc87OT7RZl3JihpJtg1ewMHnvhOJUtXeQ7gj8mORTYc6qBuOgovzjn0tPT2b1794jyoqIitm7devXzpk2b2LRpEyJyVFWfcZWrahmwcPjxqvoc8JyH8t8Dv/eR+AFjSkoCc6ck8dqpRr5090y7xQkLBgaV1083smpOZtCnwXDHK4tBRBwiUioi5dZr2ij1Nlp1yt0nDrnt3y4iR72RJZDcM9c5Rr3n1MjoFsPN8eqpRlbMcJAYZ/oqdnLP3Ez2nW+hw6w94hMOVV2itavv6jMjVPB2KGkzsFtVC4Hd1uchiIgDeARYAdzG0IlDiMifAZ1eyhFQpk+eSEF6Iq+eMia3L6hs6aKioZN7jDPfdu6Zk0n/oJoU8z5iz8kGosS3M/kDgbeKYQNQYr0vwZr4M4y1QKmqtqhqK9bEIQARmQT8A/BPXsoRcFbNyeStM01095nEY97isrxCrVcVjtw6NZWkhBhePWk6Pb7g1VON3Do1jdTEOLtFuSG8VQxZVtQG1qunOzsXqHT77D5B6NvA94ExVyMPlolALlbNyaC7b5C3z5o89t7y6qlGpqUnMn3yjYepGnxLTHQUdxVm8OqpBpMTzEsaOro5Ut3GqjmhE43kYkzFICK7ROSoh21kzN8op/BQpiKyFJhlOfDGRFWfVtUiVS3KyLD/h145I50JsdG8etL4GbzhSu8Ab1Y08QFjLQQNH5ibSUNHD0erzapu3rDHsrpWz8uyWZIbZ0zFoKprVHWhh20bUG/lksF69fSUrALccw24JgjdDiwTkfPAG8BsEdnj3dcJHAmx0dxZOJndJ0zPyhverGiip3+Q1XND7+YJV1bNyUAEdp+st1uUkGbXiXpyrEivUMPboaTtgCvKaCOeJ/7sAO4VkTTL6eyaOPRjVc1R1QLgTuC0qq7yUp6AsnpuJtWXrphsq16w+2QDk+JjuG26Wa0tWEifFM8t+ansPmGs4Zulu2+ANyqa+MC8zJCcRe6tYtgCFItIOVBsfUZEikRkK4A1sefbwD5reywUJvuMB9fwh7mBbg5V5ZWT9dw1ezJxMWauZTCxel4WR6rbqDdL2d4Ue8+10NU7EJLDSOClYlDVZlVdraqF1muLVV6mqg+61fu5qs6ytmc8nOe8qo6YQBTsZCYnsDgvhV0njMl9Mxytbqe+vYcPmGGkoGP1PNPp8YZdx+uZEBvN7TNCI5vqcEw3zUuK52VxsPISDaZndcOUHq8jSjCO5yBkTlYS+Y4JlB4fmbHWcH1UlV0nnJZwQmxoZmA2isFLihdkoQq7TM/qhtl5vJ6iAgeOiaEV4x0JiAjF86bw5plmLvf02y1OSHG0up3atm6K50+xW5SbxigGLzE9q5ujsqWLk3Ud3DvfDCMFK/cuyKK3f5DXTVK9GyIcLGGjGLzEvWfVaXpW42bncadfptgohqClaFoaqYmxV/8rw/gIB0vYKAYfsNbqWZmkeuNnx9E65mQl3dSiPIbAEBMdxZp5Wew+UU9v/6Dd4oQE55suh4UlbBSDDygqcJA+MY6Xj5rhpPHQ2NHDvgstrFsYumOwkcK6BVNo7+7nHZP6ZVzsOOZ8BoR62zaKwQdERwn3Lsji1ZMNJqneOCg9Xo9q6N88kcCdhZNJjIvm5WOm0zMeXjpax6LcFPLSQnudFqMYfMTaBVO4bOX9MVyfl4/VMS09MSRTBUQaCbHR3DM3k53H6hkYNKlfrkdt2xUOVl4Kiw6PUQw+4n0zJ5OUEMOLR0zP6npc6urlrYom1i2YEpKpAiKRdQum0NTZQ9n5sEhY4DdcQ8lrFxjFYLCIi4mieH4WpcfrjKPuOuw8Xk//oPKhRdl2i2IYJx+Ym0l8TBQvHqm1W5Sg5sUjtczJSmJW5iS7RfEaoxh8yIcXZdPe3W+Gk67Di0dqyUubwOK8FLtFMYyTifExrJqTwUtH68xw0ijUtXVTdqE1bDo8RjH4kDsLncNJLxw2PStPXOrq5Y3yJj68KNsMI4UYH16cQ0OHGU4ajZeO1qIKH14c+sNIYBSDT4mPiaZ4fhY7j9fR02+ik4az85gZRgpVVlvDSX80w0ke+eNh1zBSeARUGMXgYz66JIeO7n5eP22Gk4bzh8M1TEtPNMNIIcjE+BhWz8vkxSO19A8YH5o71ZeuUHahlY8uCZ8Oj1EMPubOWZNJS4xl+6Eau0UJKho7enizoomPLs4xw0ghyvolOTR19pp1zofxgnWvf2Rxjs2S+A6jGHxMbHQUH1yUza7j9XT1mtxJLl48UsugOi0qQ2iyak4mk+Jj2H7QdHrc2X6ohiV5KRRMDp/0LkYx+IH1S3K40jdAqUk+dpXth2qYk5XEHDOpLWRJiI3m3gVZvHyszszwtzjT2Mmxmvaw6/AYxeAHbitwkJOSwPMHqu0WJSi42NzF/gut3HdLrt2iGLzk/lty6eju59WTJmEkwPMHqomS8LOEjWLwA1FRwoZbcnm9vInGjh67xbGd5ywFuWFpeN08kcj7Zk4mMyme/zKdHlSV5w5Uc8esyWQlJ9gtjk8xisFP3H9LLgODyguHI3s8VlV5/mA1K2c4yEmdYLc4Bi+JjhI2LM1hz6kGWi/32i2Orey/0EpV6xXuD0NL2CgGPzE7K4n52cn8/r0qu0WxlQOVlzjXdDksb55I5b5bcukbUP4Q4Z2e379XzYTY6LDIjTQcoxj8yMeX5XG0up2Tde12i2Ibz+6vIiE2ytZJbS0tLRQXF1NYWEhxcTGtra0e65WUlFBYWAiwUEQ2uspFZJmIHBGRChF5Qqx4WxH5noicFJHDIvKciKS6HfMNq/4pEVnr568YUBbkpDAvO5ln90dup+dK7wAvHKrhg4umMDE+xm5xfI5XikFEHCJSKiLl1mvaKPU2WnXKh91we6wb56C1he4iqR6475ZcYqOFZ8si8wbq7hvgD4dq+NDCbJISYm2TY8uWLaxevZry8nJWr17Nli1bRtRpaWnh0UcfZe/evQAngEfc2vOPgYeAQmtbZ5WXAgtVdTFwGvgGgIjMBx4AFlh1/1VEov32BW3g48vyOFzVxqm6DrtFsYWdx+vo6OnnE8vy7RbFL3hrMWwGdqtqIbDb+jwEEXEAjwArgNsYesMBfFZVl1pbWIU6OCbG8YG5mTx/sJq+CJwtuuNYHR3d/Xx8WZ6tcmzbto2NG539kY0bN/L888+PqLNjxw6Ki4txOBwAAzgf+utEJBtIVtW3VVWBXwL3AajqTlV1TVZ5B3B90Q3Ar1W1R1XPARU4237YcN/SHGKihGf3V9otii38rqyKvLQJrJjusFsUv+CtYtgAlFjvS7BumGGsBUpVtUVVW7FuOC+vGzJ8siifps5edp8IK503Ln5bVkle2gRWzki3VY76+nqys51DWdnZ2TQ0jPwvqquryc8f0vurAnKtrcpD+XA2AS9Z73MB9yfmaMcgIg+JSJmIlDU2No7r+wQD6ZPiWT0vk/96rzri0sxXtnTxRkUTH1+WR1RUeM7i91YxZKlqLYD16mkoaKyb5BlrGOlh19itJ0L1Brp7dgZZyfH8Zt9Fu0UJKBeaL/NmRTOfKsoPyM2zZs0aFi5cOGLbtm3buI53GgMjiwFPwg+pLCLfBPqB/3AVjXWM23WfVtUiVS3KyMgYl6zBwgPLp9J8uZddJyJrIudvyyqJEmenL1wZ02siIrsAT273b47zGte7ST6rqtUikgT8HvgcTlN95AGqTwNPAxQVFYVMUviY6Cg+WZTPv7xaQc2lKxETsvmbfc6b5xMBunl27do16r6srCxqa2vJzs6mtraWzMyR/Ze8vDz27NkzpAjYg7Mjkzes/Go4juUz+wiwWq9plyogf7RjwoW7ZmeQk5LAr/dVRkzG3P6BQX5bVsndszPC+l4e02JQ1TWqutDDtg2ot8ZgsV49jZeMepOoarX12gH8J2E2Duvik0X5KM6HZSTQNzDI7/ZXcc+cTKak2D/xZ/369ZSUOEc8S0pK2LBhw4g6a9euZefOna6IpWjgXmCHZQl3iMhKy6L9PLANQETWAV8H1qtql9vptgMPiEi8iEzH6bB+129f0Caio4RPFOXzp/JGKlu6xj4gDHj1VCP17T18avlUu0XxK94OJW0HXFFGG7FumGHsAO4VkTTL6XwvsENEYkRkMoCIxOLsdR31Up6gJN+RyF2FGfx638WIcELvPFZPY0cPn10ZHDfP5s2bKS0tpbCwkNLSUjZvdsZIlJWV8eCDDwLgcDh4+OGHWb58OcA84DFVda1K82VgK04n8hmu+RKeBJKAUms49CcAqnoM+C1wHHgZ+IqqhmVyoU8tz0eA/3w3MoZK//2dC2Qlx7NmXlgFUI5EVW96A9JxRiOVW68Oq7wI2OpWbxPOm6oC+IJVNhHYDxwGjgE/AqLHc91ly5ZpqFF6rE6nff0FffFwjd2i+J1PPfWW3rFlt/YPDNotyk0BlKkX98XNbqHYrlVV/1vJPr3lsZ3a3ddvtyh+5XxTpxZsfkF/UHrKblFuihtp115ZDKrarKqrVbXQem2xystU9UG3ej9X1VnW9oxVdllVl6nqYlVdoKp/q2HaqwK4Z24muakT+Ld3Ltgtil+paOjgnbMtfHbFNKLDNGLDMJTP3T6Nlsu9vHSkzm5R/Mp/7r1IlAifvi04LGF/YmY+B4joKOGzK6fy1plmTteH76SgX7x1nriYKD5ZZO/cBUPguGPmZGZMnsgv3jpvtyh+o6u3n1/vq2TtgqywS5jnCaMYAsgDy6cSHxPFM2+et1sUv9DW1cfv91ezYUkO6ZPi7RbHECCiooSN7yvgYOUlDlz0nG4k1HnuQDVtV/r4wh3T7RYlIBjFEEAcE+O4b2kuzx2oCsvMlL8pu8iVvgH+4o4Cu0UxBJiPLcsjKT4mLDs9qsov3jzPgpxkiqZ5zPoTdhjFEGC+cGcB3X2DYRfF0TcwyC/ePM9t0x0syEmxWxxDgJkUH8Mnl+fz4pFaai5dsVscn/La6UbKGzr5wh3TI2a9cqMYAszcKcncNTuDZ948T09/+PjaXzxSS01bN3951wy7RTHYxBfuKECBZ948Z7coPuWnfzpLVnI868NslbbrYRSDDTz0/hk0dfaEzdKfqspTr51lZsZE7pkT5vHdhlHJS0vkI4uz+dW7lbR399ktjk84Wt3GmxXNfOGO6cTFRM7jMnK+aRBxx6x0FuQk89RrZxkYDJnsHqPyenkTx2vbeeiuGWGbVMwwPh66awadPf3829vhEZb949fOMCk+hs+sCP8QVXeMYrABEeGvVs3ibNNlXjpaa7c4XvMvr1SQnZLA/beYENVIZ0FOCqvmZPDzN85xpTe0h0rPNHby4pFaPnf7NJJtXE/EDoxisIl1C6cwM2MiT75SMVpmz5Dg3XMtvHu+hb+8a0ZEmdqG0fnre2bRfLk35AMsfrznDPExUXzxzsgIUXXH3Mk2ER0lfOWeWZys62DHsdBNW/zDXaeZPCmOByJgNqhhfBQVOFg5w8FTr52huy80rYYLzZd57kA1n75tKpMjcE6OUQw2sn5JDjMmT+SHu04zGIK+hrfPNPPWmWa+vGoWCbFhtXKlwUv+bs1sGjp6+PcQTQHzo93lxEYLX141025RbMEoBhuJiY7ib9cUcrKugz8eCS1fg6ryg9LTZCXH89kIc8wZxmbljHTumJXOT147w+We/rEPCCLONHby/IFqPrdyGplJ4Z/+whNGMdjMRxbnMCcrie/vPBVSKblfPdXAu+db+Ot7jLVg8Mz/uHcOTZ29/OyN0JrX8L2XTzEhNpq/vDsyrQUwisF2oqOEr39wDuebu/h1iDjrBgaV7750ioL0RONbMIzKrVPTWLdgCk+9doamzh67xRkX711s5eVjdTx018yI9C24MIohCLhnTia3TXfww13lITEx6Nn9lZyq7+Cra+cSG22akGF0vrpuDt39g/xw12m7RRkTVeXxP55g8qR4Hnx/5EUiuWPu6iBARHj4w/Np6erlyVcq7BbnunR09/G9HacompbGhxZ5WgrcYLjGzIxJ/PmKqfzn3oucrGu3W5zrsv1QDfsvtPLVtbOZGB9jtzi2YhRDkLAoL4VPLMvjmTfPcbax025xRuWfX6mg+XIvj3x0QcQkFDN4x98XzyZ5QiyPbj8etHN2unr72fLSSRbmJvPxZfljHxDmGMUQRPzPtXNIiI3m4W1Hg/IGOlnXzs/eOMcnl+WzKM9kUDWMj9TEOP7HvXN4+2wz2w/V2C2OR360q5zatm4e+egCs/IgRjEEFZlJCXxt7RzerGhm28HguoEGB5VvPneUlAmxbP7gXLvFMYQYn7ltKkvyU/n2C8dp6wouP9rJuna2vnGOTxXls7zAYbc4QYFRDEHGZ1ZMY2l+Ko+9cDyoIjl++fZ59l9o5R8/NI+0iXF2i2MIMaKjhP9z/0Jau/p47IXjdotzlf6BQb727GHT4RmGUQxBRnSU8L2PL6azu5+Hnw+OIaULzZf57sunWDUng4/dmmu3OIYQZUFOCl++eya/f6+KV04GRxqYp14/y+GqNr69YaHp8LhhFEMQUpiVxN8Xz+alo3X8/j1712zoGxjk735zkJho4Tt/tsg4nA1e8TerZzEnK4mvPXvEdov4SFUbP9x1mg8vyubDi7NtlSXYMIohSHnorhmsmO7gW9uOcq7psm1y/GhXOQcuXuL/3L+I7JQJtslhCA/iY6L50aeX0t7dx1d/d8i2HGGXe/r5778+wORJ8Tx+/0JbZAhmvFIMIuIQkVIRKbdePa6ULSIbrTrlIrLRrTxORJ4WkdMiclJEPuaNPOFEdJTwg08tJS4mii//+366egOfb+bVkw38y54KPrEsj49G0LKGBv8yd0oy/+vD83j1VCM/fu1MwK+vqnzt2cNcaL7MDz61lNREM4Q0HG8ths3AblUtBHZbn4cgIg7gEWAFcBvwiJsC+SbQoKqzgfnAa17KE1bkpE7gRw/cwqn6Dr7++yMB9Teca7rM3/76APOmJPPYBtOjMviWz62cxvolOfy/nad49VRDQK/99Otn+eORWr62bi4rZ6QH9NqhgreKYQNQYr0vAe7zUGctUKqqLaraCpQC66x9m4DvAKjqoKo2eSlP2HH37Ay+unYOfzhUww9KA5NWoOVyL1945l2io4SnPreMCXEmSZ7Bt4gIWz62iLlTkvmb/zzA8ZrAzIp+6UgtW14+yYcXZfOXd80IyDVDEW8VQ5aq1gJYr55Wgs8FKt0+VwG5IpJqff62iLwnIr8TkazRLiQiD4lImYiUNTY2eil2aPHlu2fyyaI8nnilgn97+7xfr9XZ08+mX+yjpq2brRuLyHck+vV6hsglMS6Gn/9FEZPiY/jCL97lQrN/fWlvn2nm735zkKX5qXz/k0tMIMV1GFMxiMguETnqYdswzmt4+vUViAHygDdV9VbgbeD/jXYSVX1aVYtUtSgjI2Oclw4PRITH71/EmnmZPLztGL/Z558srC6lcKS6jX/+9C0sm2Ym+xj8S3bKBEo23UZP/yCf+eleKlu6/HKdfedb+GLJPqY6Etn6+SKTKn4MxlQMqrpGVRd62LYB9SKSDWC9ehosrALck4/kATVAM9AFPGeV/w641YvvEtbERkfx5Gdu5a7ZGXz990f46etnfepzaLncy2d/+g77L7Tyg08tZe0CkyDPEBjmTEni3zatoKO7j4//5C1O1XX49Pyvnmzgcz/by5TkBP7jwRWkR3A67fHi7VDSdsAVZbQR2Oahzg7gXhFJs5zO9wI71PlU+wOwyqq3GgieKZFBSEJsND/9/DI+vCibx188wTf+6wg9/d6vqXu8pp31T77ByboOnvrzZawPswiklpYWiouLKSwspLi4mNbWVo/1SkpKKCwsBFg4LHpumYgcEZEKEXlCrDEIEfmeFU13WESecw2PikiBiFwRkYPW9pMAfM2QZlFeCr/90u2owsd+/Balx72fAKeq/PT1s3yxZB+zMifx2y/dTmZyZK7IdsOo6k1vQDrOaKRy69VhlRcBW93qbQIqrO0LbuXTgNeBw9bxU8dz3WXLlmkkMzAwqN97+aRO+/oLuvYHr+mJ2rabOk//wKBu/dNZLfzmi7ri8V168GKrjyUNDr761a/qd77zHVVV/c53vqNf+9rXRtRpbm7W6dOna3NzswIHgLNAmjrb6bvA7TiHRV8CPmiV3wvEWO+/C3zXel8AHNUbvJ8ivV2rqtZc6tKP/vOfdNrXX9BvPX9Eu3r6b+o89e1XdNMz7+q0r7+gX/q3Mu3s7vOxpKEHUKbjbIuiQZBy4UYpKirSsrIyu8Wwnd0n6vn67w/T2tXH51ZO46/umTmuNWpVlbfONPOdl05wtLqd1XMz2fKxxWQkhaeJPWfOHPbs2UN2dja1tbWsWrWKU6dODanzq1/9ij179vDUU08hIvuB/cAea3tVVecCiMingVWq+pfux4vI/cDHVfWzIlIAvKCqNxTna9q1k+6+Ab778kmeefM8OSkJ/M+1c1i/JIeYcSwKdbmnn39/5wJPvlJB78AgX183ly/cUWAczYCI7FfVovHUjezVKEKc1fOy2Pn3d/P/lZ7il2+f5z/3XuSDi6bw4UXZrJieTkpi7NW6qsqZxk72nGrkuQPVHKtpJzslgR89sJT1S3LC+sapr68nO9uZ8iA7O5uGhpGusOrqavLzh+Thr8IZUZdrvR9ePpxNwG/cPk8XkQNAO/C/VPVPnmQTkYeAhwCmTjXLpIJzyPSRjy7gQ4uy+d/bj/EPvz3E93ee5mO35rJ6Xhbzc5KHrBx4pXeAA5Wt7Dhax/MHa2i70sc9czJ4+CPzmZExycZvEroYxRDiOCbG8U/3LeLBO2fwszfOsf1QzdWU3ZMnxZGaGMfAoFLX1s2VPqc/YkFOMt/5s0Xcf0tu2ERnrFmzhrq6uhHljz/++LiOH8VyVkaPqruKiCOWENwAAAatSURBVHwT6Af+wyqqxTks2iwiy4DnRWSBqo4I1lfVp4GnwWkxjEvYCGF5gYM//PWd7D7ZwC/eOseTr1bwxCsVxEYLU1ISSIiJprOnn/r2bgYV4mKiKJ6XxaY7p7NsmsckDIZxYhRDmFAweSLfvm8hD39kPvsvtHKgspXKli7arvQRJcIH5mYyJyuJ26Y7KJg80W5xfc6uXbtG3ZeVlUVtbe3VoaTMzJHTbfLy8tizZ8+QIpzDSFXWe/fyq4tlWE7qjwCrrXFcVLUH6LHe7xeRM8BswIwT3SBRUULx/CyK52fR2NHD3nPNHK1up67tCr0Dg0yIjSE3bQJL81NYXuAgKSF27JMaxsQohjAjLiaK22emc/tMM9Xfxfr16ykpKWHz5s2UlJSwYcPIKThr167lH//xH10RS9E4HcvfUNUWEekQkZXAXuDzwD8DiMg64OvA3ap6NQBfRDKAFlUdEJEZQCFOZ7bBCzKS4vnI4hw+sji8ouaCEZNd1RD2bN68mdLSUgoLCyktLWXzZmdKr7KyMh588EEAHA4HDz/8MMuXLweYBzymqi3WKb4MbMUZVXcGZ2QSwJNAElA6LCz1LuCwiBwCngW+5HYugyHoMVFJBsMwbiR6w5eYdm3wJzfSro3FYDAYDIYhGMVgMBgMhiEYxWAwGAyGIRjFYDAYDIYhGMVgMBgMhiEYxWAwGAyGIYRkuKqINAIXRtk9GQiGJUKDRQ4IHlmCRQ64vizTVDXgq0GFSLuG4JElWOSA0JClEHhbVdd52DeEkFQM10NEyuyIQQ9WOSB4ZAkWOSC4ZBkPwSRvsMgSLHJA+MlihpIMBoPBMASjGAwGg8EwhHBUDE/bLYBFsMgBwSNLsMgBwSXLeAgmeYNFlmCRA8JMlrDzMRgMBoPBO8LRYjAYDAaDFxjFYDAYDIYhhIxiEJF1InJKRCpEZLOH/fEi8htr/15rQXbXvm9Y5adEZG0AZPkHETkuIodFZLeITHPbN2Dl7j8oItv9LMdfiEij2/UedNu3UUTKrW2jN3KMU5YfuMlxWkQuue3z5W/ycxFpEJGjo+wXEXnCkvOwiNzqts+nv8kNyBwUbTtY2vU4ZQlI2w6Wdm2dL3BtW1WDfsO5otYZYAYQBxwC5g+r81fAT6z3DwC/sd7Pt+rHA9Ot80T7WZZ7gETr/ZddslifOwP4m/wF8KSHYx04VxRzAGnW+zR/yjKs/t8AP/f1b2Kd6y7gVuDoKPs/hHOhHQFWAnv98ZuEWtsOlnYdTG07mNp1oNt2qFgMtwEVqnpWVXuBXwPD12fcAJRY758FVouIWOW/VtUeVT2HcxWu2/wpi6q+qteWenyHoWsG+4rx/CajsRYoVdUWVW0FSoExZ0P6UJZPA7/y4nqjoqqvA9dbLW0D8Et18g6QKiLZ+P43GS/B0raDpV2PS5br4Mv/MWjaNQS2bYeKYsgFKt0+V1llHuuoaj/QBqSP81hfy+LOF7m2FCRAgoiUicg7InJfAOT4mGVWPisi+Td4rK9lwRp+mA684lbsq99kPIwmq69/E2/l8VjHj207WNr1jcji77YdSu0afNi2Y3wumn8QD2XD42xHqzOeY30ti7OiyJ8DRcDdbsVTVbVGnIvEvyIiR1T1jJ/k+APwK1XtEZEv4ex1fmCcx/paFhcPAM+q6oBbma9+k/EQqHYyXoKlbQdLux6vLIFo26HUrsGH7SRULIYqIN/tcx5QM1odEYkBUnCaXeM51teyICJrgG8C61W1x1WuqjXW61lgD3CLv+RQ1Wa3a/8UWHYj38GXsrjxAMPMbR/+JuNhNFl9/Zt4K4/HOn5s28HSrsclS4Dadii1a/Bl2/alc8RfG07L5ixOU83lBFowrM5XGOqg+631fgFDHXRn8c75PB5ZbsHptCocVp4GxFvvJwPlXMeZ5QM5st3e3w+8o9ecUecsedKs9w5//iZWvTnAeayJlb7+TdzOWcDoDroPM9RB964/fpNQa9vB0q6DqW0HW7sOZNv2a6P35YbT437aapjftMoew9lzAUgAfofTAfcuMMPt2G9ax50CPhgAWXYB9cBBa9tulb8POGI1sCPAF/0sx3eAY9b1Xv3/27ljE4ShKArDv9s4gAupTcawdAFncCBbe4ewsTCFz1olwvd1IVwIlwPnwYNU65fZ3byra7X99k7m50N1fJv79E7O1a269zwp7aupmub3q+o0f+el2nxrJ/+W7aXkeknZXkquf51tv8QAYPAvdwwA/IhiAGCgGAAYKAYABooBgIFiAGCgGAAYPACVdz2wO7B8QAAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# These graphs show the difference Pnr(WW)-Pr(WW) where Pnr means no replacement and Pr means with replacement.\n", + "x=np.linspace(0,1,100)\n", + "n=5\n", + "fig,ax=plt.subplots(1,2)\n", + "ax[0].plot(x,x*(n*x-1)/(n-1)-x*x)\n", + "ax[0].set_title('n=5')\n", + "n=100\n", + "ax[1].plot(x,x*(n*x-1)/(n-1)-x*x)\n", + "#ax[1].plot(x,x*x)\n", + "ax[1].set_title('n=100')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Problem 5.9.4\n", + "\n", + "Exchangeable prior distributions: suppose it is known a priori that the $2J$ parameters $\\theta_1,\\ldots,\\theta_{2J}$ are clustered into two groups, with exactly half being drawn from a $N(1, 1)$ distribution, and the other half being drawn from a $N(−1 , 1)$ distribution, but we have not observed which parameters come from which distribution. \n", + "\n", + "1. Are $\\theta_1,\\ldots,\\theta_{2J}$ exchangeable under this prior distribution? \n", + "2. Show that this distribution cannot be written as a mixture of independent and identically distributed components.\n", + "3. Why can we not simply take the limit as $J\\to\\infty$ and get a counterexample to de Finetti’s theorem?\n", + "\n", + "Gelman, Andrew; Carlin, John B.; Stern, Hal S.; Dunson, David B.; Vehtari, Aki; Rubin, Donald B.. Bayesian Data Analysis, Third Edition (Chapman & Hall/CRC Texts in Statistical Science) (Page 134). CRC Press. Kindle Edition. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's look at the case J=1. This is very much like the earlier problems, but with a continuous distribution.\n", + "So for example $P(x,y)=(1/2)P(x,N(1,1))P(y,N(-1,1))+(1/2)P(x,N(-1,1))P(y,N(1,1))$ and\n", + "$P(x,x)=P(x,N(1,1))P(x,N(-1,1))$ so it's exchangeable.\n", + "\n", + "After a small amount of cheating (by looking at some solutions by Gelman) the suggestion is to look at the covariance of $y_1$ and $y_2$. Informally, they should have negative covariance because if $y_1$ is large, it suggests that it came from $N(1,1)$; but then $y_2$ comes from $N(-1,1)$ so it should be small.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "from scipy.stats import norm\n", + "y1=norm(loc=1,scale=1)\n", + "y2=norm(loc=-1,scale=1)\n", + "y1_sample=y_1.rvs(500)\n", + "y2_sample=y_2.rvs(500)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "A sample of our situation is $(y_1,y_2)$ or $(y_2,y_1)$ with equal probability. So the mean of each variable is zero. The covariance is $-1=E(y_1y_2)=E(y_1)E(y_2)$. The next problem (5.9.5) shows that mixtures of iid variables have positive covariances." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Covariance= -1.0023058663082174\n" + ] + } + ], + "source": [ + "cov=sum(y1_sample*y2_sample)/500\n", + "print(\"Covariance=\",cov)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In the general case, the joint probablity distribution can be written\n", + "$$\n", + "P(y_1,\\ldots,y_{2J})=(\\binom{2J}{J})^{-1}\\sum_{{S\\subset [2J]}\\atop{|S|=J}} P_{S}(y_1,\\ldots,y_{2J})\n", + "$$\n", + "where $$P_{S}(y_1,\\ldots,y_{2J})=\\prod_{i\\in S} P(y_i,N(1,1))\\prod_{j\\not\\in S} P(y_j,N(-1,1)).$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To understand the covariance of, say $y_1$ and $y_2$, we need to know how often they are chosen from the same distribution and how often they are chosen from different ones. That raises the combinatorial question of how many of the partitions of $[2J]$ have $y_1$ and $y_2$ together, and how many of them separate $y_1$ and $y_2$. To have them together, we first pick $y_1$ and $y_2$, and then choose $J-2$ additional elements from the remaining $2J-2$. So there are $\\binom{2J-2}{J-2}$ subsets of size $J$ that contain both $y_1$ and $y_2$. To split them, we pick $J-1$ elements from the $2J-2$ elements other than $y_1$ and $y_2$ and combine those with $y_1$ (for example) so there are $\\binom{2J-2}{J-1}$ sets that split them. \n", + "\n", + "When computing the covariance, the cases where $y_1$ and $y_2$ are together contribute $+1$, and the cases where they are split contribute $-1$. This gives the following:\n", + "$$\n", + "\\mathrm{cov}(y_1,y_2)=\\frac{2(\\binom{2J-2}{J-2}-\\binom{2J-2}{J-1})}{\\binom{2J}{J}}\n", + "$$\n", + "The two in the numerator comes from the fact that the number of partitions is $1/2$ of $\\binom{2J}{J}$. \n", + "\n", + "Some trial computations gives the explicit formula that the covariance is $-\\frac{1}{(2J-1)}$ and this goes to zero as $J\\to\\infty$.\n", + "\n", + "The next problem (5.9.5) shows that in a mixture, the correlations are non-negative, so this shows we don't have a mixture of iid variables." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1 -1.0\n", + "2 -3.0\n", + "3 -5.0\n", + "4 -7.0\n", + "5 -9.0\n", + "6 -11.0\n", + "7 -13.0\n", + "8 -15.0\n", + "9 -17.0\n" + ] + } + ], + "source": [ + "# an illustration of the last point from the discussion above\n", + "from scipy.special import binom\n", + "for i in range(1,10):\n", + " print(i,(binom(2*i,i)/2/(binom(2*i-2,i-2)-binom(2*i-2,i-1))))\n", + " " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For the last point, I think the way to think of it is that $y_1$ is a combination of $\\binom{2J-1}{J-1}$ copies of $N(1,1)$ -- corresponding to the partitions in which $y_1$ is in the first half -- and $\\binom{2J-1}{J}$ -- corresponding to the partitions in which $y_1$ is in the second half. (Note that since $2J-1$ is odd, these numbers are actually equal). In the limit the correlation between different $y_i$'s drops to zero and so they become independent, and there's no contradiction to deFinetti's theorem." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Problem 5.9.5\n", + "\n", + "Suppose that the distribution of $\\theta=(\\theta_1,\\ldots,\\theta_{J})$ can be written as a mixture of independent and identically distributed components:\n", + "$$\n", + "p(\\theta)=\\int \\prod_{j=1}^{J} p(\\theta_{j}|\\phi)p(\\phi)d\\phi.\n", + "$$\n", + "Prove that the covariances $\\mathrm{cov}(\\theta_{i},\\theta_{j})$ are all non-negative.\n", + "\n", + "Here we apply the formula:\n", + "$$\n", + "\\mathrm{cov}(y_1,y_2)=E_{\\phi}(cov(y_1,y_2|\\phi))+\\mathrm{cov}_{\\phi}(E(y_1|\\phi),E(y_2|\\phi))\n", + "$$\n", + "The first term is zero (since $y_1$ and $y_2$ are independent, conditional on $\\phi$), and the second term is positive since $E(y_1|\\phi)=E(y_2|\\phi)=\\mu(\\phi)$ since the $y_1$ are identically distributed given $\\phi$;\n", + "thus this term is $\\mathrm{var}(\\mu(\\phi))\\ge 0$.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/BDA 5.9.3.ipynb b/BDA 5.9.3.ipynb new file mode 100644 index 0000000..abfbe93 --- /dev/null +++ b/BDA 5.9.3.ipynb @@ -0,0 +1,500 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#Problem 5.9.3\n", + "\n", + "Hierarchical models and multiple comparisons:\n", + "\n", + "1. Reproduce the computations in Section 5.5 for the educational testing example. Use the posterior simulations to estimate:\n", + " * for each school $j$, the probability that it's coaching program is the best of the eight;\n", + " * for each pair of schools $(j,k)$ the probability that the $j$th school is better than the $k$th \n", + "2. Reproduce (1) but for the simpler model where the population variance $\\tau$ is $\\infty$ so the eight schools are independent.\n", + "3. Discuss the differences between 1 and 2.\n", + "4. What happens when $\\tau=0$?" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " effect se\n", + "school \n", + "A 28 15\n", + "B 8 10\n", + "C -3 16\n", + "D 7 11\n", + "E -1 9\n", + "F 1 11\n", + "G 18 10\n", + "H 12 18\n" + ] + } + ], + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "import pystan\n", + "import matplotlib.pyplot as plt\n", + "\n", + "schools=['A','B','C','D','E','F','G','H']\n", + "effects=[28,8,-3,7,-1,1,18,12]\n", + "se=[15,10,16,11,9,11,10,18]\n", + "p55=pd.DataFrame(index=schools)\n", + "p55.index.name='school'\n", + "p55['effect']=np.array(effects)\n", + "p55['se']=np.array(se)\n", + "print(p55)" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "pooled mean= 7.685616724956035\n", + "pooled variance= 16.580525632563663\n" + ] + } + ], + "source": [ + "print('pooled mean=',sum(p55['effect']*1/p55['se']**2)/(sum(1/p55['se']**2)))\n", + "print('pooled variance=',(1/sum(1/p55['se']**2)))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## First part" + ] + }, + { + "cell_type": "code", + "execution_count": 349, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:pystan:COMPILING THE C++ CODE FOR MODEL anon_model_1c0a010b4129370aa04f0b4b9f729b4d NOW.\n" + ] + } + ], + "source": [ + "stan_code='''\n", + "data {\n", + " real means[8];\n", + " real se[8];\n", + "\n", + "}\n", + "\n", + "parameters {\n", + " real theta[8] ; \n", + " real mu ; \n", + " real tau ; \n", + "}\n", + "\n", + "model {\n", + " \n", + " theta~normal(mu,tau) ; \n", + " means~normal(theta,se) ; \n", + " \n", + "}\n", + "\n", + "generated quantities {\n", + " real results[8] ; \n", + " \n", + " \n", + " for(i in 1:8) {\n", + " results[i]=normal_rng(theta[i],tau);\n", + " }\n", + "}\n", + "'''\n", + "sm=pystan.StanModel(model_code=stan_code)" + ] + }, + { + "cell_type": "code", + "execution_count": 350, + "metadata": {}, + "outputs": [], + "source": [ + "answers=sm.sampling(data=dict({'means':p55['effect'],'se':p55['se']}),iter=00)" + ] + }, + { + "cell_type": "code", + "execution_count": 351, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Inference for Stan model: anon_model_1c0a010b4129370aa04f0b4b9f729b4d.\n", + "4 chains, each with iter=500; warmup=250; thin=1; \n", + "post-warmup draws per chain=250, total post-warmup draws=1000.\n", + "\n", + " mean se_mean sd 2.5% 25% 50% 75% 97.5% n_eff Rhat\n", + "theta[0] 12.07 0.66 9.38 -3.89 5.93 11.21 17.23 34.12 200 1.01\n", + "theta[1] 7.54 0.39 6.89 -6.07 3.02 7.48 12.15 21.17 312 1.01\n", + "theta[2] 5.45 0.46 8.58 -12.34 0.2 6.07 10.92 20.96 342 1.0\n", + "theta[3] 7.16 0.37 7.21 -7.68 2.72 7.31 11.83 20.44 383 1.01\n", + "theta[4] 4.51 0.43 6.58 -10.0 0.23 5.07 9.18 15.99 235 1.02\n", + "theta[5] 5.53 0.41 7.27 -10.59 1.01 6.16 10.74 18.24 313 1.01\n", + "theta[6] 11.03 0.53 7.5 -2.83 5.64 11.03 15.77 27.15 199 1.01\n", + "theta[7] 8.3 0.39 7.93 -6.88 3.08 8.28 13.26 24.5 414 1.0\n", + "mu 7.66 0.41 5.62 -3.36 4.06 7.92 11.47 18.73 192 1.02\n", + "tau 7.74 0.71 6.11 0.4 3.91 6.29 9.9 22.49 75 1.05\n", + "results[0] 11.81 0.57 12.82 -9.18 3.71 10.54 17.23 43.38 513 1.01\n", + "results[1] 7.26 0.52 12.33 -16.66 0.94 7.04 13.57 33.52 563 1.01\n", + "results[2] 5.43 0.42 12.64 -22.88 -1.07 5.99 12.55 29.09 902 1.0\n", + "results[3] 7.01 0.41 11.92 -16.05 1.03 7.18 13.39 29.57 861 1.0\n", + "results[4] 4.62 0.46 11.55 -23.93 -1.48 5.45 11.65 26.17 638 1.0\n", + "results[5] 5.83 0.44 11.71 -20.83 0.05 6.61 11.82 28.91 724 1.0\n", + "results[6] 10.76 0.56 11.87 -11.69 3.67 10.23 17.43 36.29 443 1.0\n", + "results[7] 8.01 0.54 12.75 -16.27 1.62 7.82 14.62 31.63 561 1.0\n", + "lp__ -18.65 1.21 5.8 -27.82 -22.04 -19.13 -16.31 0.06 23 1.18\n", + "\n", + "Samples were drawn using NUTS at Sat Apr 21 16:45:21 2018.\n", + "For each parameter, n_eff is a crude measure of effective sample size,\n", + "and Rhat is the potential scale reduction factor on split chains (at \n", + "convergence, Rhat=1).\n" + ] + } + ], + "source": [ + "print(answers)" + ] + }, + { + "cell_type": "code", + "execution_count": 352, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig,ax=plt.subplots(1)\n", + "j=ax.hist(answers['tau'],bins=50,density=True)\n", + "j=ax.set_title('Posterior Distribution of Pop SD')" + ] + }, + { + "cell_type": "code", + "execution_count": 353, + "metadata": {}, + "outputs": [], + "source": [ + "predictions=answers.extract()['results']\n", + "def best_school(x,i):\n", + " return x[i]>=max(x)\n", + "def better_school(x,i,j):\n", + " return x[i]>=x[j]\n" + ] + }, + { + "cell_type": "code", + "execution_count": 354, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Chance is empirical probability that given school is best\n", + " effect se Chance\n", + "school \n", + "A 28 15 0.191\n", + "B 8 10 0.109\n", + "C -3 16 0.105\n", + "D 7 11 0.124\n", + "E -1 9 0.077\n", + "F 1 11 0.088\n", + "G 18 10 0.186\n", + "H 12 18 0.120\n", + "Only thing that worries me is that Gelman has A best with prob=10%\n" + ] + } + ], + "source": [ + "print('Chance is empirical probability that given school is best')\n", + "p55['Chance']=[sum([best_school(x,i) for x in predictions])/len(predictions) for i in range(8)]\n", + "print(p55)\n", + "print(\"Only thing that worries me is that Gelman has A best with prob=10%\")" + ] + }, + { + "cell_type": "code", + "execution_count": 332, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Empirical Probability that school in given row is\n", + " as good as or better than corresponding column\n", + " \n", + " A B C D E F G H\n", + "A 1.00 0.61 0.64 0.60 0.68 0.66 0.53 0.58 \n", + "B 0.39 1.00 0.53 0.50 0.59 0.56 0.41 0.47 \n", + "C 0.36 0.47 1.00 0.47 0.55 0.52 0.37 0.44 \n", + "D 0.40 0.50 0.53 1.00 0.58 0.56 0.42 0.47 \n", + "E 0.32 0.41 0.45 0.42 1.00 0.47 0.33 0.38 \n", + "F 0.34 0.44 0.48 0.44 0.53 1.00 0.35 0.42 \n", + "G 0.47 0.59 0.63 0.58 0.67 0.65 1.00 0.57 \n", + "H 0.42 0.53 0.56 0.53 0.62 0.58 0.43 1.00 \n" + ] + } + ], + "source": [ + "compare=[[sum([better_school(x,i,j) for x in predictions])/len(predictions) for i in range(8)] for j in range(8)]\n", + "l=['A','B','C','D','E','F','G','H']\n", + "print('Empirical Probability that school in given row is\\n as good as or better than corresponding column')\n", + "print(' ',end='')\n", + "print('{0:10}'.format(''))\n", + "for i in range(8):\n", + " print('{0:>10}'.format(l[i]),end='')\n", + "print()\n", + "for j in range(8):\n", + " print('{0:<6}'.format(l[j]),end='')\n", + " for i in range(8):\n", + " print('{0:4.2f} '.format(round(compare[i][j],2)),end=\"\")\n", + " print()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Second part" + ] + }, + { + "cell_type": "code", + "execution_count": 340, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:pystan:COMPILING THE C++ CODE FOR MODEL anon_model_3314be03c6a1d2db4b5293ee7101b10c NOW.\n" + ] + } + ], + "source": [ + "stan_code_2='''\n", + "data {\n", + " real means[8];\n", + " real se[8];\n", + "\n", + "}\n", + "\n", + "parameters {\n", + " real theta[8] ; \n", + "// real mu ; \n", + "// real tau ; \n", + "}\n", + "\n", + "model {\n", + " \n", + " // theta~normal(mu,tau) ; \n", + " means~normal(theta,se) ; \n", + " \n", + "}\n", + "\n", + "generated quantities {\n", + " real results[8] ; \n", + " \n", + " \n", + " for(i in 1:8) {\n", + " results[i]=normal_rng(theta[i],se[i]);\n", + " }\n", + "}\n", + "'''\n", + "sm=pystan.StanModel(model_code=stan_code_2)" + ] + }, + { + "cell_type": "code", + "execution_count": 341, + "metadata": {}, + "outputs": [], + "source": [ + "answers=sm.sampling(data=dict({'means':p55['effect'],'se':p55['se']}),iter=5000)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 342, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Inference for Stan model: anon_model_3314be03c6a1d2db4b5293ee7101b10c.\n", + "4 chains, each with iter=5000; warmup=2500; thin=1; \n", + "post-warmup draws per chain=2500, total post-warmup draws=10000.\n", + "\n", + " mean se_mean sd 2.5% 25% 50% 75% 97.5% n_eff Rhat\n", + "theta[0] 27.97 0.15 14.96 -1.53 17.74 27.93 38.15 57.42 10000 1.0\n", + "theta[1] 8.13 0.1 9.94 -11.16 1.34 8.09 14.73 27.7 10000 1.0\n", + "theta[2] -3.24 0.16 16.22 -34.28 -14.16 -3.11 7.61 28.45 10000 1.0\n", + "theta[3] 7.01 0.11 10.91 -14.33 -0.39 7.0 14.49 28.16 10000 1.0\n", + "theta[4] -0.86 0.09 8.9 -18.45 -6.75 -0.86 4.95 16.99 10000 1.0\n", + "theta[5] 1.02 0.11 11.09 -20.34 -6.62 1.13 8.44 22.73 10000 1.0\n", + "theta[6] 17.89 0.1 10.11 -2.11 11.17 17.83 24.75 37.53 10000 1.0\n", + "theta[7] 11.87 0.18 17.87 -22.34 -0.36 11.86 23.8 46.91 10000 1.0\n", + "results[0] 28.25 0.21 21.3 -13.95 13.99 28.29 42.64 69.78 10000 1.0\n", + "results[1] 8.09 0.14 14.22 -19.52 -1.66 8.04 17.7 36.06 10000 1.0\n", + "results[2] -3.5 0.23 22.91 -47.94 -19.39 -3.27 12.05 40.73 10000 1.0\n", + "results[3] 7.01 0.16 15.6 -23.52 -3.69 7.07 17.64 37.45 10000 1.0\n", + "results[4] -0.83 0.13 12.62 -25.85 -9.24 -0.93 7.68 23.68 10000 1.0\n", + "results[5] 0.86 0.15 15.4 -28.99 -9.4 0.83 11.01 32.07 10000 1.0\n", + "results[6] 17.77 0.14 14.11 -10.2 8.31 17.82 27.31 45.08 10000 1.0\n", + "results[7] 11.77 0.25 25.4 -38.49 -5.21 11.54 28.6 61.73 10000 1.0\n", + "lp__ -4.0 0.03 1.99 -8.74 -5.13 -3.68 -2.53 -1.07 4933 1.0\n", + "\n", + "Samples were drawn using NUTS at Sat Apr 21 16:37:25 2018.\n", + "For each parameter, n_eff is a crude measure of effective sample size,\n", + "and Rhat is the potential scale reduction factor on split chains (at \n", + "convergence, Rhat=1)." + ] + }, + "execution_count": 342, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "answers" + ] + }, + { + "cell_type": "code", + "execution_count": 343, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Chance is empirical probability that given school is best\n", + " effect se Chance\n", + "school \n", + "A 28 15 0.4455\n", + "B 8 10 0.0575\n", + "C -3 16 0.0529\n", + "D 7 11 0.0588\n", + "E -1 9 0.0119\n", + "F 1 11 0.0276\n", + "G 18 10 0.1605\n", + "H 12 18 0.1853\n" + ] + } + ], + "source": [ + "predictions=answers.extract()['results']\n", + "def best_school(x,i):\n", + " return x[i]>=max(x)\n", + "def better_school(x,i,j):\n", + " return x[i]>=x[j]\n", + "print('Chance is empirical probability that given school is best')\n", + "p55['Chance']=[sum([best_school(x,i) for x in predictions])/len(predictions) for i in range(8)]\n", + "print(p55)" + ] + }, + { + "cell_type": "code", + "execution_count": 344, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Empirical Probability that school in given row is\n", + " as good as or better than corresponding column\n", + " \n", + " A B C D E F G H\n", + "A 1.00 0.78 0.84 0.79 0.88 0.85 0.66 0.70 \n", + "B 0.22 1.00 0.67 0.52 0.68 0.64 0.31 0.45 \n", + "C 0.16 0.33 1.00 0.36 0.46 0.45 0.21 0.33 \n", + "D 0.21 0.48 0.64 1.00 0.65 0.61 0.30 0.44 \n", + "E 0.12 0.32 0.54 0.35 1.00 0.47 0.16 0.33 \n", + "F 0.15 0.36 0.55 0.39 0.53 1.00 0.21 0.36 \n", + "G 0.34 0.69 0.79 0.70 0.84 0.79 1.00 0.58 \n", + "H 0.30 0.55 0.67 0.56 0.67 0.64 0.42 1.00 \n" + ] + } + ], + "source": [ + "compare=[[sum([better_school(x,i,j) for x in predictions])/len(predictions) for i in range(8)] for j in range(8)]\n", + "l=['A','B','C','D','E','F','G','H']\n", + "print('Empirical Probability that school in given row is\\n as good as or better than corresponding column')\n", + "print(' ',end='')\n", + "print('{0:10}'.format(''))\n", + "for i in range(8):\n", + " print('{0:>10}'.format(l[i]),end='')\n", + "print()\n", + "for j in range(8):\n", + " print('{0:<6}'.format(l[j]),end='')\n", + " for i in range(8):\n", + " print('{0:4.2f} '.format(round(compare[i][j],2)),end=\"\")\n", + " print()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/BDA 5.9.6.ipynb b/BDA 5.9.6.ipynb new file mode 100644 index 0000000..e75cef4 --- /dev/null +++ b/BDA 5.9.6.ipynb @@ -0,0 +1,144 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Problem 5.9.6. Exchangeable Models\n", + "\n", + "1. In the divorce rate example of Section 5.2, set up a prior distribution for the values $y_1 \\ldots, y_8$ that allows for one low value (Utah) and one high value (Nevada), with independent and identical distributions for the other six values. This prior distribution should be exchangeable, because it is not known which of the eight states correspond to Utah and Nevada. \n", + "\n", + "2. Determine the posterior distribution for $y_8$ under this model given the observed values of $y_1, \\ldots, y_7$ given in the example. This posterior distribution should probably have two or three modes, corresponding to the possibilities that the missing state is Utah, Nevada, or one of the other six. \n", + "\n", + "3. Now consider the entire set of eight data points, including the value for $y_8$ given at the end of the example. Are these data consistent with the prior distribution you gave in part (1) above? In particular, did your prior distribution allow for the possibility that the actual data have an outlier (Nevada) at the high end, but no outlier at the low end?\n", + "\n", + "The states are Arizona, Colorado, Idaho, Montana, Nevada, New Mexico, Utah, and Wyoming.\n", + "\n", + "The rates from seven of these states are 5.8, 6.6,7.8,5.6,7.0,7.1,5.4 divorces per 1000 population per year. \n", + "\n", + "Gelman, Andrew; Carlin, John B.; Stern, Hal S.; Dunson, David B.; Vehtari, Aki; Rubin, Donald B.. Bayesian Data Analysis, Third Edition (Chapman & Hall/CRC Texts in Statistical Science) (Page 135). CRC Press. Kindle Edition. " + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "mean: 6.471428571428571 variance: 0.6877551020408161\n" + ] + } + ], + "source": [ + "from scipy.stats import norm\n", + "from itertools import permutations\n", + "import matplotlib.pyplot as plt\n", + "\n", + "rates=np.array([5.8,6.6,7.8,5.6,7.0,7.1,5.4])\n", + "print('mean:',rates.mean(),'variance:',rates.var())\n" + ] + }, + { + "cell_type": "code", + "execution_count": 74, + "metadata": {}, + "outputs": [], + "source": [ + "s=range(8)\n", + "def prior(x):\n", + " L=0\n", + " for i,j in permutations(s,2):\n", + " L0=1\n", + " L0=L0*norm.pdf(x[i],loc=8.7,scale=.8)\n", + " L0=L0*norm.pdf(x[j],loc=4.3,scale=.8)\n", + " for k in s:\n", + " if k!=i and k!=j:\n", + " L0=L0*norm.pdf(x[k],loc=6.5,scale=.8)\n", + " L=L+L0\n", + " return(L)\n", + "\n", + "def like(x):\n", + " return prior(np.append(x,rates))" + ] + }, + { + "cell_type": "code", + "execution_count": 77, + "metadata": {}, + "outputs": [], + "source": [ + "x=np.linspace(0.0,15.0,1000)\n", + "y=np.array([like(i) for i in x])" + ] + }, + { + "cell_type": "code", + "execution_count": 78, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 78, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(x,y)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "I have a lot of questions about this problem, starting with: have I computed the right thing? I am not sure.\n", + "As far as the last part, No, my prior distribution did not allow for a high value without a low value; it expected one of each." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.4" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/README.md b/README.md index d216ab3..85c4867 100644 --- a/README.md +++ b/README.md @@ -1 +1,6 @@ -# BDA \ No newline at end of file +# BDA +Solutions to some problems from Bayesian Data Analysis, 3rd edition, by Gelman *et. al.* + +They are offered with no warranty and may be wrong. + +Comments welcome. diff --git a/Solutions.pdf b/Solutions.pdf new file mode 100644 index 0000000..8d27cf4 Binary files /dev/null and b/Solutions.pdf differ diff --git a/Untitled1.ipynb b/Untitled1.ipynb deleted file mode 100644 index 1622066..0000000 --- a/Untitled1.ipynb +++ /dev/null @@ -1,91 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 11, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "from scipy.stats import t\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "%matplotlib inline" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": { - "collapsed": false - }, - "outputs": [], - "source": [ - "x=np.linspace(-1,1,100)" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX4AAAD8CAYAAABw1c+bAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nM/8fEdaEYQbasIIAAAAASUVORK5CYII=\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.plot(x,t.pdf(x,4,loc=1,scale=2))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.5.2" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -}