diff --git a/docs/changelog.rst b/docs/changelog.rst index 21ed728..1d146dd 100644 --- a/docs/changelog.rst +++ b/docs/changelog.rst @@ -4,6 +4,13 @@ Change Log ========== +Version 0.3.0 +------------- +- Added full, end-to-end example of package usage to documentation +- Cleaned up documentation +- Added example folder with end-to-end notebook +- Added manuscript to paper folder + Version 0.2.4 ------------- - Strengthened unit tests diff --git a/docs/conf.py b/docs/conf.py index 428b69f..e2324d7 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -22,8 +22,7 @@ author = 'Roni Kobrosly' # The full version, including alpha/beta/rc tags -release = '0.2.4' - +release = '0.3.0' # -- General configuration --------------------------------------------------- diff --git a/docs/full_example.rst b/docs/full_example.rst new file mode 100644 index 0000000..46917fa --- /dev/null +++ b/docs/full_example.rst @@ -0,0 +1,130 @@ +.. _full_example: + +============================================================= +Health data: generating causal curves and examining mediation +============================================================= + +The causal effect of blood lead levels on cognitive performance in children +--------------------------------------------------------------------------- + +To provide an end-to-end example of the sorts of analyses `cause-curve` can be used for, we'll +begin with an epidemiology topic. A notebook containing the pipeline to produce the following +output `is available here `_. +Note: Specific examples of the individual `causal-curve` tools with +code are available elsewhere in this documentation. + +Despite the banning of the use of lead-based paint and the use of lead in gasoline in the United +States, lead exposure remains an enormous public health problem for children and adolescents. This +is particularly true for poorer children living in older homes in inner-city environments. +For children, there is no known safe level of exposure to lead, and even small levels of +lead measured in their blood have been shown to affect IQ and academic achievement. +One of the scariest parts of lead exposure is that its effects are permanent. Blood lead levels (BLLs) +of 5 ug/dL or higher are considered elevated. + +There are much research around and many government programs for lead abatement. In terms of +public policy, it would be helpful to understand how childhood cognitive outcomes would be affected by +reducing BLLs in children. This is the causal question to answer, with blood lead +levels being the continuous treatment, and the cognitive outcomes being the outcome of interest. + +.. image:: https://upload.wikimedia.org/wikipedia/commons/6/69/LeadPaint1.JPG + +(Photo attribution: Thester11 / CC BY (https://creativecommons.org/licenses/by/3.0)) + +To explore that problem, we can analyze data collected from the National Health and Nutrition +Examination Survey (NHANES) III. This was a large, national study of families throughout the United +States, carried out between 1988 and 1994. Participants were involved in extensive interviews, +medical examinations, and provided biological samples. As part of this project, BLLs +were measured, and four scaled sub-tests of the Wechsler Intelligence Scale for Children-Revised +and the Wide Range Achievement Test-Revised (WISC/WRAT) cognitive test were carried out. This data +is de-identified and publicly available on the Centers for Disease Control and Prevention (CDC) +government website. + +When processing the data and missing values were dropped, there were 1,764 children between +6 and 12 years of age with complete data. BLLs among these children were log-normally +distributed, as one would expect: + +.. image:: ../imgs/full_example/BLL_dist.png + +The four scaled sub-tests of the WISC/WRAT included a math test, a reading test, a block design +test (a test of spatial visualization ability and motor skill), and a digit spanning test +(a test of memory). Their distributions are shown here: + +.. image:: ../imgs/full_example/test_dist.png + +Using a well-known study by Bruce Lanphear conducted in 2000 as a guide, we used the following +features as potentially confounding "nuisance" variables: + +- Child age +- Child sex (in 1988 - 1994 the CDC assumed binary sex) +- Child race/ethnicity +- The education level of the guardian +- Whether someone smokes in the child's home +- Whether the child spent time in a neonatal intensive care unit as a baby +- Whether the child is experiencing food insecurity (is food sometimes not available due to lack of resources?). + +In our simulated "experiment", these above confounders will be controlled for. + +By using either the GPS or TMLE tools included in `causal-curve` one can generate the causal +dose-response curves for BLLs in relation to the four outcomes: + +.. image:: ../imgs/full_example/test_causal_curves.png + +Note that the lower limit of detection for the blood lead test in this version of NHANES was +0.7 ug/dL. So lead levels below that value are not possible. + +In the case of the math test, these results indicate that by reducing BLLs in this population +to their lowest value would cause scaled math scores to increase by around 2 points, relative +to the BLLs around 10 ug/dL. Similar results are found for the reading and block design test, +although the digit spanning test causal curve appears possibly flat (although with the sparse +observations at the higher end of the BLL range and the wide confidence intervals it is +difficult to say). + +The above curves differ from standard regression curves in a few big ways: + +- Even though the data that we used to generate these curves are observational, if causal inference assumptions are met, these curves can be interpretted as causal. +- These models were created using the potential outcomes / counterfactual framework, while standard models are not. Also, the approach we used here essentially simulates experimental conditions by balancing out treatment assignment across the various confounders, and controlling for their effects. +- Even if complex interactions between the variables are modelled, these curves average over the various interaction effects and subgroups. In this sense, these are "marginal" curves. +- These curves should not be used to make predictions at the individual level. These are population level estimates and should remain that way. + + + +Do blood lead levels mediate the relationship between poverty and cognitive performance? +---------------------------------------------------------------------------------------- + +There is a well-known link between household income and child academic performance. Now that we +have some evidence of a potentially causal relationship between BLLs and test performance in +children, one might wonder if lead exposure might mediate the relationship between household income +academic performance. In other words, in this population does low income cause one to be +exposed more to lead, which in turn causes lower performance? Or is household income directly +linked with academic performance or through other variables? + +NHANES III captured each household's Poverty Index Ratio (the ratio of total family income to +the federal poverty level for the year of the interview). For this example, let's focus just +on the math test as an outcome. Using `causal-curve`'s mediation tool, +we found that the overall, mediating indirect effect of BLLs are 0.20 (0.17 - 0.23). This means +that lead exposure accounts for 20% of the relationship between low income and low test +performance in this population. The mediation tool also allows you to see how the indirect effect +varies as a function of the treatment. As the plot shows, the mediating effect is relatively flat, +although interesting there is a hint of an increase as income increases relative to the povetry line. + +.. image:: ../imgs/full_example/mediation_curve.png + + +References +---------- + +Centers for Disease Control and Prevention. NHANES III (1988-1994). +https://wwwn.cdc.gov/nchs/nhanes/nhanes3/default.aspx. Accessed on July 2, 2020. + +Centers for Disease Control and Prevention. Blood Lead Levels in Children. +https://www.cdc.gov/nceh/lead/prevention/blood-lead-levels.htm. Accessed on July 2, 2020. + +Environmental Protection Agency. Learn about Lead. https://www.epa.gov/lead/learn-about-lead. +Accessed on July 2, 2020. + +Pirkle JL, Kaufmann RB, Brody DJ, Hickman T, Gunter EW, Paschal DC. Exposure of the +U.S. population to lead, 1991-1994. Environmental Health Perspectives, 106(11), 1998, pp. 745–750. + +Lanphear BP, Dietrich K, Auinger P, Cox C. Cognitive Deficits Associated with +Blood Lead Concentrations <10 pg/dL in US Children and Adolescents. +In: Public Health Reports, 115, 2000, pp.521-529. diff --git a/docs/index.rst b/docs/index.rst index b7aed64..594c9f6 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -9,22 +9,31 @@ Welcome to causal-curve's documentation! install contribute + .. toctree:: - :maxdepth: 1 - :hidden: - :caption: Module details + :maxdepth: 1 + :hidden: + :caption: End-to-end demonstration - modules + full_example .. toctree:: - :maxdepth: 1 - :hidden: - :caption: Tutorial - Examples + :maxdepth: 1 + :hidden: + :caption: Tutorials of Individual Tools + + GPS_example + TMLE_example + Mediation_example + +.. toctree:: + :maxdepth: 1 + :hidden: + :caption: Module details + + modules - GPS_example - TMLE_example - Mediation_example .. toctree:: :maxdepth: 1 diff --git a/examples/NHANES_BLL_example.ipynb b/examples/NHANES_BLL_example.ipynb new file mode 100644 index 0000000..67ea65e --- /dev/null +++ b/examples/NHANES_BLL_example.ipynb @@ -0,0 +1,750 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Full `causal-curve` tutorial: analyzing the causal impact of reducing blood lead levels in children on achievement and cognitive scores\n", + "All NHANES III data obtained here: https://wwwn.cdc.gov/nchs/nhanes/nhanes3/datafiles.aspx#core" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from os.path import expanduser\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd\n", + "from scipy.interpolate import interp1d\n", + "\n", + "from causal_curve import GPS\n", + "from causal_curve import Mediation\n", + "\n", + "%matplotlib inline\n", + "pd.options.mode.chained_assignment = None\n", + "plt.rcParams['figure.dpi'] = 200\n", + "plt.rcParams['figure.figsize'] = [5, 4]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Household Youth Data" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# Location of columns in ASCII text file\n", + "cols = [\n", + " (0,5), # Sequence number, SEQN, columns 1-5, page \n", + " (5,10), # Family sequence number, DMPFSEQ, columns 6-10, page\n", + " (10,11), # Examination/interview status, DMPSTAT, columns 11, page \n", + " (11,12), # Race-ethnicity, DMARETHN, columns 12, page\n", + " (12,13), # Race, DMARACER, columns 13, page\n", + " (13,14), # Ethnicity, DMAETHNR, columns 14, page\n", + " (14,15), # Sex, HSSEX, columns 15, page\n", + " (20,24), # Age in months, HSAITMOR, columns 21-24, page \n", + " (35,41), # Poverty Income Ratio, DMPPIR, columns 36-41, page \n", + " (1291,1292), # persons who smoke cigarettes in home, HFF1, columns 1292, page \n", + " (1312,1313), # Do you have enough food to eat, sometimes not enough to eat, or often not enough to eat?, HFF4, columns 1313, page \n", + " (1358,1360), # Highest grade or yr of school completed, HFHEDUCR, columns 1359-1360, page \n", + " (1378,1379), # Did mother smoke while pregnant with SP, HYA3, columns 1379, page\n", + " (1382,1383), # Did SP receive newborn intensive care, HYA6, columns 1383, page\n", + "]\n", + "\n", + "column_names = [\n", + " 'SEQN',\n", + " 'FAMILY_SEQN',\n", + " 'STATUS',\n", + " 'RACE_ETH',\n", + " 'RACE',\n", + " 'ETH',\n", + " 'SEX',\n", + " 'AGE',\n", + " 'PIR',\n", + " 'SMOKE_HOME',\n", + " 'FOOD',\n", + " 'EDU',\n", + " 'SMOKE_PREG',\n", + " 'BABY_NICU'\n", + "]\n", + "\n", + "raw_youth_file = []\n", + "with open(expanduser('~/Desktop/NHANES_III/youth.dat'), 'r') as f:\n", + " for line in f.readlines():\n", + " raw_youth_file.append([line[c[0]:c[1]] for c in cols])\n", + "\n", + "f.close()\n", + "\n", + "raw_youth_df = pd.DataFrame(raw_youth_file, columns = column_names)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Examination Data" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# NEED TO PARSE THIS ASCII FILE\n", + "# See: https://stackoverflow.com/questions/45286642/reading-values-from-a-text-file-using-specific-column-numbers-in-python\n", + "\n", + "# Location of columns\n", + "cols = [\n", + " (0,5), # Sequence number, SEQN, columns 1-5, page \n", + " (5,10), # Family sequence number, DMPFSEQ, columns 6-10, page\n", + " (10,11), # Examination/interview status, DMPSTAT, columns 11, page \n", + " (4432,4434), # WISC/WRAT Math scaled score, WWPMSCSR, columns 4433-4434, page\n", + " (4434, 4436), # WISC/WRAT Reading scaled score, WWPRSCSR, columns 4435-4436, page\n", + " (4436, 4438), # WISC/WRAT Block design scaled score, WWPBSCSR, columns 4437-4438, page\n", + " (4438, 4440) # WISC/WRAT Digit span scaled score, WWPDSCSR, columns 4439-4440, page\n", + "]\n", + "\n", + "column_names = [\n", + " 'SEQN',\n", + " 'FAMILY_SEQN',\n", + " 'STATUS',\n", + " 'MATH',\n", + " 'READING',\n", + " 'BLOCK',\n", + " 'DIGIT'\n", + "]\n", + "\n", + "raw_exam_file = []\n", + "with open(expanduser('~/Desktop/NHANES_III/exam.dat'), 'r') as f:\n", + " for line in f.readlines():\n", + " raw_exam_file.append([line[c[0]:c[1]] for c in cols])\n", + "\n", + "f.close()\n", + "\n", + "raw_exam_df = pd.DataFrame(raw_exam_file, columns = column_names)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Laboratory Data" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# NEED TO PARSE THIS ASCII FILE\n", + "# See: https://stackoverflow.com/questions/45286642/reading-values-from-a-text-file-using-specific-column-numbers-in-python\n", + "\n", + "# Location of columns\n", + "cols = [\n", + " (0,5), # Sequence number, SEQN, columns 1-5, page \n", + " (5,10), # Family sequence number, DMPFSEQ, columns 6-10, page\n", + " (10,11), # Examination/interview status, DMPSTAT, columns 11, page \n", + " (1422,1426), # Lead (ug/dL), PBP, columns 1423-1426, page \n", + "]\n", + "\n", + "column_names = [\n", + " 'SEQN',\n", + " 'FAMILY_SEQN',\n", + " 'STATUS',\n", + " 'BLL'\n", + "]\n", + "\n", + "raw_lab_file = []\n", + "with open(expanduser('~/Desktop/NHANES_III/lab.dat'), 'r') as f:\n", + " for line in f.readlines():\n", + " raw_lab_file.append([line[c[0]:c[1]] for c in cols])\n", + "\n", + "f.close()\n", + "\n", + "raw_lab_df = pd.DataFrame(raw_lab_file, columns = column_names)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Merge these together" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "raw_merged_df = raw_youth_df.merge(\n", + " raw_exam_df.drop(['FAMILY_SEQN', 'STATUS'], axis = 1), how = \"left\", on = \"SEQN\"\n", + ").merge(\n", + " raw_lab_df.drop(['FAMILY_SEQN', 'STATUS'], axis = 1), how = \"left\", on = \"SEQN\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Column formatting and some subsetting" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# STATUS\n", + "raw_merged_df['STATUS'] = raw_merged_df['STATUS'].str.replace(\"1\", \"No_exam\")\n", + "raw_merged_df['STATUS'] = raw_merged_df['STATUS'].str.replace(\"2\", \"MEC_exam\")\n", + "raw_merged_df['STATUS'] = raw_merged_df['STATUS'].str.replace(\"3\", \"Home_exam\")\n", + "\n", + "# RACE_ETH\n", + "raw_merged_df['RACE_ETH'] = raw_merged_df['RACE_ETH'].str.replace(\"1\", \"NH_White\")\n", + "raw_merged_df['RACE_ETH'] = raw_merged_df['RACE_ETH'].str.replace(\"2\", \"NH_Black\")\n", + "raw_merged_df['RACE_ETH'] = raw_merged_df['RACE_ETH'].str.replace(\"3\", \"Mex_Am\")\n", + "raw_merged_df['RACE_ETH'] = raw_merged_df['RACE_ETH'].str.replace(\"4\", \"Other\")\n", + "\n", + "# RACE\n", + "raw_merged_df['RACE'] = raw_merged_df['RACE'].str.replace(\"1\", \"White\")\n", + "raw_merged_df['RACE'] = raw_merged_df['RACE'].str.replace(\"2\", \"Black\")\n", + "raw_merged_df['RACE'] = raw_merged_df['RACE'].str.replace(\"3\", \"Other\")\n", + "raw_merged_df['RACE'] = raw_merged_df['RACE'].str.replace(\"8\", \"Mex_Am\")\n", + "\n", + "# ETH\n", + "raw_merged_df['ETH'] = raw_merged_df['ETH'].str.replace(\"1\", \"Mex_Am\")\n", + "raw_merged_df['ETH'] = raw_merged_df['ETH'].str.replace(\"2\", \"Other_Hisp\")\n", + "raw_merged_df['ETH'] = raw_merged_df['ETH'].str.replace(\"3\", \"Not_Hisp\")\n", + "\n", + "# SEX\n", + "raw_merged_df['SEX'] = raw_merged_df['SEX'].str.replace(\"1\", \"Male\")\n", + "raw_merged_df['SEX'] = raw_merged_df['SEX'].str.replace(\"2\", \"Female\")\n", + "\n", + "# AGE\n", + "raw_merged_df['AGE'] = raw_merged_df['AGE'].astype(float) / 12\n", + "\n", + "# PIR\n", + "raw_merged_df['PIR'] = raw_merged_df['PIR'].astype(float) \n", + "raw_merged_df['PIR'][raw_merged_df['PIR'] == 888888.000] = np.nan\n", + "\n", + "# EDU\n", + "raw_merged_df['EDU'] = raw_merged_df['EDU'].astype(int)\n", + "raw_merged_df['EDU'][raw_merged_df['EDU'] == 88] = None\n", + "raw_merged_df['EDU'][raw_merged_df['EDU'] == 99] = None\n", + "\n", + "raw_merged_df['EDU_CAT'] = np.where(raw_merged_df['EDU'] < 9, 'LT_HS', \n", + " np.where(\n", + " ((raw_merged_df['EDU'] >= 9) & (raw_merged_df['EDU'] < 12)), 'HS', \n", + " np.where(raw_merged_df['EDU'] == 12, 'GRAD_HS', None)\n", + " )\n", + ")\n", + "\n", + "# SMOKE_HOME\n", + "raw_merged_df['SMOKE_HOME'] = raw_merged_df['SMOKE_HOME'].str.replace(\"1\", \"Yes\")\n", + "raw_merged_df['SMOKE_HOME'] = raw_merged_df['SMOKE_HOME'].str.replace(\"2\", \"No\")\n", + "raw_merged_df['SMOKE_HOME'] = raw_merged_df['SMOKE_HOME'].str.replace(\"8\", \"None\")\n", + "\n", + "# FOOD\n", + "raw_merged_df['FOOD'] = raw_merged_df['FOOD'].str.replace(\"1\", \"Good\")\n", + "raw_merged_df['FOOD'] = raw_merged_df['FOOD'].str.replace(\"2\", \"Sometimes_bad\")\n", + "raw_merged_df['FOOD'] = raw_merged_df['FOOD'].str.replace(\"3\", \"Often_bad\")\n", + "raw_merged_df['FOOD'] = raw_merged_df['FOOD'].str.replace(\"8\", \"None\")\n", + "\n", + "# SMOKE_PREG\n", + "raw_merged_df['SMOKE_PREG'] = raw_merged_df['SMOKE_PREG'].str.replace(\"1\", \"Yes\")\n", + "raw_merged_df['SMOKE_PREG'] = raw_merged_df['SMOKE_PREG'].str.replace(\"2\", \"No\")\n", + "raw_merged_df['SMOKE_PREG'] = raw_merged_df['SMOKE_PREG'].str.replace(\"8\", \"None\")\n", + "raw_merged_df['SMOKE_PREG'] = raw_merged_df['SMOKE_PREG'].str.replace(\" \", \"None\")\n", + "\n", + "# BABY_NICU\n", + "raw_merged_df['BABY_NICU'] = raw_merged_df['BABY_NICU'].str.replace(\"1\", \"Yes\")\n", + "raw_merged_df['BABY_NICU'] = raw_merged_df['BABY_NICU'].str.replace(\"2\", \"No\")\n", + "raw_merged_df['BABY_NICU'] = raw_merged_df['BABY_NICU'].str.replace(\"8\", \"None\")\n", + "raw_merged_df['BABY_NICU'] = raw_merged_df['BABY_NICU'].str.replace(\"9\", \"None\")\n", + "raw_merged_df['BABY_NICU'] = raw_merged_df['BABY_NICU'].str.replace(\" \", \"None\")\n", + "\n", + "# Drop Nans at this point\n", + "raw_merged_df = raw_merged_df.dropna()\n", + "\n", + "# MATH\n", + "raw_merged_df['MATH'] = raw_merged_df['MATH'].str.replace(\"NaN\", \"\")\n", + "raw_merged_df['MATH'] = raw_merged_df['MATH'].str.replace(\" \", \"\")\n", + "raw_merged_df['MATH'] = raw_merged_df['MATH'].str.replace(\"88\", \"\")\n", + "raw_merged_df = raw_merged_df[raw_merged_df['MATH'] != '']\n", + "raw_merged_df['MATH'] = raw_merged_df['MATH'].astype(float)\n", + "\n", + "# READING\n", + "raw_merged_df['READING'] = raw_merged_df['READING'].str.replace(\"NaN\", \"\")\n", + "raw_merged_df['READING'] = raw_merged_df['READING'].str.replace(\" \", \"\")\n", + "raw_merged_df['READING'] = raw_merged_df['READING'].str.replace(\"88\", \"\")\n", + "raw_merged_df = raw_merged_df[raw_merged_df['READING'] != '']\n", + "raw_merged_df['READING'] = raw_merged_df['READING'].astype(float)\n", + "\n", + "# BLOCK\n", + "raw_merged_df['BLOCK'] = raw_merged_df['BLOCK'].str.replace(\"NaN\", \"\")\n", + "raw_merged_df['BLOCK'] = raw_merged_df['BLOCK'].str.replace(\" \", \"\")\n", + "raw_merged_df['BLOCK'] = raw_merged_df['BLOCK'].str.replace(\"88\", \"\")\n", + "raw_merged_df = raw_merged_df[raw_merged_df['BLOCK'] != '']\n", + "raw_merged_df['BLOCK'] = raw_merged_df['BLOCK'].astype(float)\n", + "\n", + "# DIGIT\n", + "raw_merged_df['DIGIT'] = raw_merged_df['DIGIT'].str.replace(\"NaN\", \"\")\n", + "raw_merged_df['DIGIT'] = raw_merged_df['DIGIT'].str.replace(\" \", \"\")\n", + "raw_merged_df['DIGIT'] = raw_merged_df['DIGIT'].str.replace(\"88\", \"\")\n", + "raw_merged_df = raw_merged_df[raw_merged_df['DIGIT'] != '']\n", + "raw_merged_df['DIGIT'] = raw_merged_df['DIGIT'].astype(float)\n", + "\n", + "# BLL\n", + "raw_merged_df = raw_merged_df[raw_merged_df['BLL'] != '']\n", + "raw_merged_df = raw_merged_df[raw_merged_df['BLL'] != '8888']\n", + "raw_merged_df['BLL'] = raw_merged_df['BLL'].str.replace(\"000\", \"\")\n", + "raw_merged_df['BLL'] = raw_merged_df['BLL'].str.replace(\"00\", \"0\")\n", + "raw_merged_df['BLL'] = raw_merged_df['BLL'].str.lstrip(\"0\")\n", + "raw_merged_df['BLL'] = raw_merged_df['BLL'].astype(float, errors = 'ignore') \n", + "raw_merged_df['BLL'] = raw_merged_df['BLL'].str.replace(\".7\", \"0.7\")\n", + "raw_merged_df['BLL'] = raw_merged_df['BLL'].str.replace(\" \", \"\")\n", + "\n", + "raw_merged_df['BLL'] = pd.to_numeric(raw_merged_df['BLL'], errors = 'coerce')\n", + "\n", + "# Once again, remove any 'None' values\n", + "raw_merged_df = raw_merged_df.dropna()\n", + "\n", + "raw_merged_df = raw_merged_df[\n", + " ((raw_merged_df['SMOKE_HOME'] != 'None') & (raw_merged_df['FOOD'] != 'None') & (raw_merged_df['SMOKE_PREG'] != 'None') & (raw_merged_df['BABY_NICU'] != 'None'))\n", + "]\n", + "\n", + "format_merged_df = raw_merged_df.drop(['FAMILY_SEQN', 'STATUS', 'RACE', 'ETH', 'EDU'], axis = 1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Making dummy vars, prepping for causal inference" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "final_df = pd.concat(\n", + " [\n", + " pd.get_dummies(format_merged_df[\"RACE_ETH\"], prefix='Race', drop_first=True),\n", + " pd.get_dummies(format_merged_df[\"EDU_CAT\"], prefix='Edu', drop_first=True),\n", + " pd.get_dummies(format_merged_df[\"SEX\"], prefix='Sex', drop_first=True),\n", + " format_merged_df['AGE'].rename('Age'),\n", + " format_merged_df['PIR'].rename('PIR'),\n", + " pd.get_dummies(format_merged_df[\"SMOKE_HOME\"], prefix='Smoke_Home', drop_first=True),\n", + " pd.get_dummies(format_merged_df[\"FOOD\"], prefix='Food', drop_first=True),\n", + " pd.get_dummies(format_merged_df[\"SMOKE_PREG\"], prefix='Smoke_Preg', drop_first=True),\n", + " pd.get_dummies(format_merged_df[\"BABY_NICU\"], prefix='Baby_NICU', drop_first=True),\n", + " format_merged_df['MATH'].rename('Math'),\n", + " format_merged_df['READING'].rename('Reading'),\n", + " format_merged_df['BLOCK'].rename('Block'),\n", + " format_merged_df['DIGIT'].rename('Digit'),\n", + " format_merged_df['BLL']\n", + " ]\n", + " , axis = 1\n", + ")\n", + "\n", + "\n", + "# Let's only focus on BLLs less than 25 mg/dL. Anything above 5 mg/dL is considered elevated.\n", + "final_df = final_df[final_df['BLL'] <= 25]\n", + "\n", + "# Reset index\n", + "final_df.reset_index(drop = True, inplace = True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Exploring the key distributions" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA9QAAAMMCAYAAACyue/GAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAewgAAHsIBbtB1PgAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAgAElEQVR4nOzdedx19bz/8ddHd3eTikoaddNwMkVUJFQ4QiWlkPE+QobDKWU4HHTED9GhDEeRMhyVoQFFlCYUGTI0SFHuhFSah1v1+f2xvpdrtdvTta6997rvrtfz8ViP9V17fdd3ffe+7q6u9/6u9V2RmUiSJEmSpJm5X9sdkCRJkiRpaWSgliRJkiSpAQO1JEmSJEkNGKglSZIkSWrAQC1JkiRJUgMGakmSJEmSGjBQS5IkSZLUgIFakiRJkqQGDNSSJEmSJDVgoJYkSZIkqQEDtSRJkiRJDRioJUmSJElqwEAtSZIkSVIDBmpJkiRJkhowUEuSJEmS1ICBWpIkSZKkBgzUkiRJkiQ1YKCWJEmSJKkBA7UkSZIkSQ0YqCVJQ4uI7SIiy3JA2/0Zh4i4vLy/y2fZzhlTn9WIurbEGdVnNcpzRsQBtX+j202qX6M06D1ExILa/qMm38PRmQu/UyTdt81ruwOSpPEZIszdAlwN/Ao4ATg6M+8Ye8ekpVREPADYp2yen5kntNmfJU1ELAAWls0zMvOMtvoiSZNgoJakuW0l4KFl2QX4r4jYPTPPb7db0hLrAcB7SvnzVF9EadoCpj8fgDPa6YYkTYaBWpLmjl07toMqHDwGeDHwIGBD4LSIeERm/nXC/ZNmLTMPAA5ouRuzcl94D8MqI9jRdj8kqSkDtSTNEf0uTY2I91KNJD0aWA14M/C2yfRMkiRp6eSkZJIkMvM64N21l7ZrqSuSJElLDQO1JGnKhbXyKrNtLCJWiIh/j4jvRcSfI2JxRFwbEedFxPsiYp0ZtPX4iPjfiLgoIm6IiNsi4oqI+EpE7DaDdtaLiI9GxG8j4taIuCYifhwR+0XECs3e6exFxKqlD6dGxFURcUdEXBcRP4uID0TEukO0sV5EvD4ijomICyPipoj4R+09fiAi1p9Bnyb+WY3inMPO8h0RO0bE0RFxaUTcUj7zP0fEryPixIjYPyLWq9VfUCb5+0OtmVfUzpXdztttFuuI2DgiDo6ICyLi+s4ZrpvMVB4R65af8W8i4say/CIi3h0Rff97jhnM1h4RR9X6tqDzfQKn16q/p8fnc6/jOj+DHuee1e+UiFhYO9fC8tomEfHxiLik/Ju7PiLOiYj/iIj5gz4PSfKSb0nSlDVq5T/OpqGI2BL4OtAZ4FYryxbAvhHxxsz8XJ92lgEOBV7Hve+zfEhZ9oiIs4HnZ+bf+rS1I3A0sHLt5RWA1YGtgIUR8Zwh3t5IRcQewKepPpe6+cADgccB+0TEazPz8z3a2A74Pt3vRV2d6ff45oh4fWYeMaBPE/+sJnXOEsyPBXbusnutsjwKeC7VBFv/Pttzdpz/pcDhVO9tVG1uB3yN6rOqe2xZ9o6InTLzF6M656SN6ndKR5svAw7jnj+LFYAnluWFEfGszLxxtv2XdN9loJYkTXlNrXxq00YiYjOqUaqVyksXAl+kGtlbDXge8ExgReCIiIg+Ae8o4KWl/A/gS8BZwGJgM+CVVJOpPQU4KyK2zMybu/TpicBxVCEV4KfAl4GrgHWoJmXbAvgqsGyT991ERLya6g/6oHpPJ1K9v78C9weeXPq2PHBURCzOzKO7NLV8aeO3VJ/9hcA1wJ1UAfGpVJ/7fOAzEfHXzPxWjz5N/LOa8Dnfz3SY/htVuL4AuJbqc3woVYDfvuO4q6km9luT6mcG1Wd9aJdz/KbHuZ8EvBNIqhnCz6Z6dN1GNP8S6yFUQXM14FtluR7YGHhFaXsd4NSIeFxmXtHwPIP8hurzeRRwYHntWOCYLnWvnknDI/6dMuVZwO7ArcAngfOAO6i+gHgtsCqwNfAR7vm7UZLuKTNdXFxcXO6jC9Uf7ln9ur/XvqD6o/GpVH/4TtW9AFixR3vb1eod0GX//YBf1+p8BpjXpd5ewN2lzi3Agi519qi1cy3wuC511gB+Xqv3qS51lqH6A3yqzv8A9+vS7/+pf17A5bP87M/o9dmX/ZtR/QGfwCXApj3qPRz4U6l3I7BalzobAI8Z0J/HUgX1qfPFkvBZjfqcVLNjT9XZrsu5ri/7LgUe2KdfqwCbd3l9Qa39o4Z4f9t19PuvwGYDjun5Hrr0Iam+ONmzS73lqb6omKr3nR7nu3zYnyPVl1xT7XX777b+fu/1O2Km9Rnt75SFHZ/bb4B1u9TbFLip1FkMPLjpv28XF5f7/uI91JI0R3Tex0j1x+f1wJnAC6hGAw8Fts7MWxueZkeqESqAXwGvzcw7OytlNXo0Ncq3IvAfXdp6e6382sz8eZd2rgF2A24rL70yItbs0qeHl/JPgP0y8+6Odu4G9iv7J+UAqhHZ24HnZObF3Spl5kVUQQCqy6Ff3aXOFZn5y34ny+rZ4u8omxtTjZZ2auOzmuQ5H0T1JRLAcZn5914VM/PGHM8l0ntn5q9G3OYh2eXKhcy8HXgZsKi8tEMZ7V2ajPJ3St2dwG6Z+acubV1MNWoN1RURz2jQb0lzhIFakjTlH1SjMrN5Jmx9grCDM/OuPnU/SDUC1HkcEbEB1b3DAL+nuj+0q8y8nOreW4DlqP4A79Wnj2Zm0kV5/eA+/R2ZiHgAsEvZPD4zL+1XPzO/B/y5bO4wi1P/oFZ+Ypf9bXxWkzxn/Yuix/WsNT5XUF3WP0p30+dzycxbgE/VXtp9xOcft5H8TuniW5l5SZ/936uVH9WzlqQ5z3uoJWnu2LXLaytSXT76XOAJVPd3viQinpGZlzU4xxNq5e/2q5iZV0TExVSjkw+JiLUzcyo01tv5Xq+QVXMK1f3UUAXFI2v7tqqVTxvQzqD9o7IN019q3xERzxvimJuAtYFH9KoQEY+luud8a6pR6FWovmToZr0ur7XxWU3snJl5Y0ScS/Vv5OkR8Q3gE8AZmbl4Nm0P6YdD/FueqQsz86oBdU4FPlDKW/WruAQa1e+UTucMOO+VtfIDB3dT0lxloJakOSIzT+iz+/9FxJuAQ6gC9gllAqN/zPA0a5f1TZn5lyHqX8L05b5rMz0Ku3ZHnWHa6ezDlKlH6dyYfWYBB8jMayPieuABQ5xzNhbUyguZvqR7GJ2zgRMR86guUX01w19h0O1RSm18VpM+5xuoZkRflWpysp2B2yLiPOBHZd/p3S4rHoErB1eZsd/NsM7Qj6tbQozqd0qnawa0c0etvPwQ55U0R3nJtyQJgMw8lOp+aqgucWxyaejUI49uGbJ+fUbulXuUh2mrVztQzZYN97zct59h+z4bswmE3Wa5PoRqJuKgunT/m8C7gH+juj9+17LsXTtmmS7ttPFZTfSc5V78x1BdxTDV1gpUk/O9nWoU9MqI2CciRv130m2Dq8zYMJ9HvU7nfx9LulH9Tul0d599kjQ0R6glSXXfAbYt5X9l+t7kYd1EFRZXGlSxuH+tfFOP8jBt9WoHqj+wV6W6vH0Yw/Z9Nup/9L8pMz/etKGIWJ/qMT9QzQa+fWZ2HbWMiEcO0a9Jf1YTP2dWj456ZUS8juqS4q2pHlG2HdW/pQcDH6UK3v822/ON2TCfR71O538fM9Xti5hxGtXvFEkaC0eoJUl119bK6zY4furyypUj4sFD1N+kVq7fB1q/THPjWbQDVcgEWCUiHtSvkYhYnfFf7g33vPR3/Vm29Qym/3/+wV5hunjogLba+Kxa+/lk5h2ZeVZmfigzd6aaBXxvqlF+gIUR8fhRnW9MNpphnW73W09d3jy/y75OawxRZ5RG9TtFksbCQC1Jqqv/sdzk0tof18rP7FcxIh5C9bxXgD923B9Zb+dfhzhvfebrH3fsqz9q6WkD2nn6EOcahbOZno34WbNsa61aue9s4cCzB+xv47NaYn4+mXl7Zh7OPWfFfkpHtfqlwrOZEX9UHhkRg+6Lrj/2qfO/D4Cpx4c9KCJ6hupyr/6WA8416s9nVL9TJGksDNSSpLrn1MoXNjj+67XyfhHR7/LQtzH9B3f9uKlLcn9WNjeMiJ73c5dHbL2obN4BnNRR5fhaeZ+I6PpHfnl93z79HZnMvBr4dtl8dETsOYvm6l989BytjIiHAa8Y0FYbn9US9/MB/lArd94eV79cfxK3BwxyP/p8LhGxIvD62kvdHkF3QVnPY/qWj25eAaw+oD+j/nxG8jtFksbFQC1JAiAi3kx1HylUo0zHNGjmZODXpfwY4H/LqFbnuRYyfd/vrVSTanX6YK18WERs3qWd1akCwtT9t0eUsFp3EnBRKT8ROKgztJXtg+j+bOZxeScw9aimzw4K1RGxWkS8OSKe0bHrvFp5//KZdB77EKqJygYFnDY+q4mdMyI2j4j3RETnTPD1OisBL6+9dH59f2ZeB9xQNh/b6wuACds3Il7Q+WJELAd8HnhIeek7mfnrznpMf7kD1Yz/97qfPSKeSnVf+SD1LyNG8azvUf5OkaSRc1IySZojejzreAWqRzjtwj2f93pwZv5mpufIzLsj4qVUjx9aieoxTltHxBeBy6ke+bQL97zM+U1lRLqzra9FxJeonqu8GnBu2T6LKog+GtgLWLMccjHw1i7t3BURr6SawXw+sD+wbUR8meoey3WAF1Ndyvpjqnuax/5oocw8PyL2Bo6g+kLgyxHxVqrg+zuqGaFXpRp13opqFup5wMs62jknIn5M9fPbALg4Ig6nCqnLUIXQl1H9PI6izyO62visJnzOVYEDgHdHxI+o/p3+FriR6t7sTYE9a+2fS/UYrU6nAbsBGwJfiYjjgOuZvoz/JyV4T8IZwGbAsRHxEqovKK6n+nezkOk5CK5jOnB2OpHqv59NgS2An0fEZ4ArqP7b+1eq93s11Rc4PS/Nz8y/R8TPqcL09hFxGNVzsOsThJ2ZmUPNeD7K3ymSNBaZ6eLi4uJyH12o/sCfybIYeA8QPdrbrlb3gD7n3RJYNOBctwB7Dej/PKr7We8e0NbZwIMGtLUTVXDq1cavqMLa5WX78ll+9mdMtT2g3g5UE3MN8/O5HXhWlzYWAL8fcOyhVJOSTW0ftaR8VqM8J1Vgnjpmu4592w75OSdVwO/6b4oqwN7S59jtanW3q73e87+ZYd9D7ef9z59jeV/X9OnPVcDjBpxzM+Cvfdq4giokH1V7bUGff9P/6NPWgpl+PozgdwrVFwxTdRcO+Dzu8RnP9t+3i4vLfXdxhFqS5rY7qEazLqIKEEdl5uWzbTQzz4uITYBXUY0ePYpqJOlmquB3CvDJzOw7C29m3gm8PiKOoBqZ2o5q9vFlqUbLfgwcnZnHDdGnb0XEI6hGQJ9DFc5uBS4DjgX+NzNvnfQVvJl5Srm/+cWlX4+nmm16eapRvcuBX1KNlH4zM6/v0sbl5ZL4fahGEqfupf4L1cjeEZl5RkQsGLJPE/+sJnHOzDwzIh5NNeK6NfBIYD2qkc/bqb7Y+ClwTGZ+s087vyqf95uprhx4CNVVBq1c/l3e12OANwI7M32J9++B44CPZeYNvY4vbfyqfDZvofpyYwPgztLG14FPZDX6PEx/TomIrYE3AU8C1mb4x6L1anMkv1MkadQiM9vugyRJkiRJSx0nJZMkSZIkqQEDtSRJkiRJDRioJUmSJElqwEAtSZIkSVIDBmpJkiRJkhowUEuSJEmS1ICBWpIkSZKkBgzUkiRJkiQ1YKCWJEmSJKkBA7UkSZIkSQ0YqCVJkiRJasBALUmSJElSAwZqSZIkSZIaMFBLkiRJktTAvLY7oCVDRMwD1iqbf8nMO9vsjyRJkiQt6Ryh1pS1gEVlWWtAXUmSJEma8xyh1r0sWrRoUdt9kCRJkqQxiFE25gi1JEmSJEkNGKglSZIkSWrAQC1JkiRJUgMGakmSJEmSGjBQS5IkSZLUgIFakiRJkqQGDNSSJEmSJDVgoJYkSZIkqYE5GagjYpWIeFFEHBwRZ0bEpRFxQ0QsjoirI+KMiHhrRKw+ZHtPiogvRcQVEXF7RPwlIk6JiD1n2K89I+K75fjbS3tfioitm71TSZIkSdK4RGa23YeJi4hnAN8bouo1wEsz85Q+bR0AvIveX06cBOyembf3aWMF4GvAc3pUuRt4b2b+9xB9biQi1gMWASxatIj11ltvXKeSJEmSpLbEKBubkyPUxSLgC8B/ALsBWwPbAC8EvgrcBawBfCMiHtOtgYjYG3gP1ed4GbAXsBXwPOD0Um1H4HMD+vI5psP06eX4rUp7l5X2D4iI18z0TUqSJEmSxmOujlAvk5l3DajzPOD4snl8Zu7WsX814PfAqsAfgcdn5jX1c5Tjdy4vbZ+ZZ3Q5z9OA08rmN4Fd632LiDWAnwEPAa4HHpaZfx/yrQ7NEWpJkiRJc4Aj1LM1KEyXOicAvy2bT+lS5VVUYRrgbfUwXTvH66lGugHe0uNU+5f1ncDrO/tW2n1b2XxAOa8kSZIkqWVzMlDPwE1lvXyXfc8r6xuB47odnJlXAqeWzadHxMr1/WX76WXz1FK/m+PKeQB2HaLfkiRJkqQxM1D3EBH/Ajy2bF7csW8+1T3OAOdk5uI+TZ1Z1ssBW3Ts2xKY31HvXkr7504dExHL9u+9JEmSJGncDNQ1EbFiRGwcEW+mCrjzyq6PdVTdBFimlC+mv/r+h3fse0SPev3amQdsPKCuJEmSJGnM5g2uct8WEQuBI/tU+SDw5Y7X6jN29bpMe8qiWnn9EbZz4YD691AmHetnrZm0J0mSJElz3ZwP1H2cD7wmM8/rsq9+L/TNA9q5pVa+/5jaGcaiwVUkSZIkScPykm84AXh0WbYC9qR63NVjgaMjYqcux9QnKet3/zTAHbXyCmNqR5IkSZI0YXN+hDozr6d6vvOU84BjIuJlwOeBEyNir8w8qlbn9lp5Pv0tVyvf1rFvVO0Mo/Ny805rUb13SZIkSdIQ5nyg7iUzv1hGp18AfCIivpGZ15XdN9WqDrr8eqVaufOy7lG1M1CfR3IBEDHS55tLkiRJ0n2el3z3d2JZrwQ8q/Z6PZwOmuyrPjLceR/zqNqRJEmSJE2Ygbq/v9XKG9TKlwB3lfKmA9qo77+oY9+FPer1a+dO4HcD6kqSJEmSxsxA3d+6tfI/L7POzMXAT8rm1hHR7/7nbcv6DuCnHfvOY3oysm3pobT/xKljMvMfA/otSZIkSRozA3V/e9TKv+7Yd0JZrwLs1u3g8uznZ5TN0zKzfs80Zfu0svmMPs+K3q2cB6oZyCVJkiRJLZuTgToiFkbE8gPq7As8p2z+ATi7o8pngRtK+YMRsXrH8csAnwKWKS99uMepPlLW84BPluPq7awBfKhsXl/OK0mSJElqWWRm232YuIi4HFgZ+DrwA+Ayqku6V6Z6HvVLgG1K9cXAjpl5apd29gY+XTYvA95PNZK9DrAPsH3Zd3RmvrhPf44GXlQ2Twc+BlxV+vJOYMOyb+/MPHxm73Y4ZXR8EcCiRYtYb71Bc6RJkiRJ0lJnpI83msuBeoNB9ahm4X5lZn6vT1v/DbyL3j+Yk4HnZ+btPfYTESsAX2N6RLzT3cCBmXnAEH1uxEAtSZIkaQ4wUM9WRPwLsCPVKPRGwIOB1YHbgKuB84FvAV/JzFuHaO9JwBuAp5S2rgd+CRyZmUfPoF8vBhYCjwEeAPyV6lLzT2TmOcO204SBGnY48KSxtHvKu3YcS7uSJEmSZmykgXreKBtbWmTmb4HfAv8zovZ+BPxoBO18Gfjy7HskSZIkSRq3OTkpmSRJkiRJs2WgliRJkiSpAQO1JEmSJEkNGKglSZIkSWrAQC1JkiRJUgMGakmSJEmSGjBQS5IkSZLUgIFakiRJkqQGDNSSJEmSJDVgoJYkSZIkqQEDtSRJkiRJDRioJUmSJElqwEAtSZIkSVIDBmpJkiRJkhowUEuSJEmS1ICBWpIkSZKkBgzUkiRJkiQ1YKCWJEmSJKkBA7UkSZIkSQ0YqCVJkiRJasBALUmSJElSAwZqSZIkSZIamNd2B6RBdjjwpLG1fcq7dhxb25IkSZLu2xyhliRJkiSpAQO1JEmSJEkNGKglSZIkSWrAQC1JkiRJUgMGakmSJEmSGjBQS5IkSZLUgIFakiRJkqQGDNSSJEmSJDVgoJYkSZIkqQEDtSRJkiRJDRioJUmSJElqwEAtSZIkSVIDBmpJkiRJkhowUEuSJEmS1ICBWpIkSZKkBgzUkiRJkiQ1YKCWJEmSJKkBA7UkSZIkSQ0YqCVJkiRJasBALUmSJElSAwZqSZIkSZIaMFBLkiRJktSAgVqSJEmSpAYM1JIkSZIkNWCgliRJkiSpAQO1JEmSJEkNGKglSZIkSWrAQC1JkiRJUgMGakmSJEmSGjBQS5IkSZLUgIFakiRJkqQGDNSSJEmSJDVgoJYkSZIkqQEDtSRJkiRJDRioJUmSJElqwEAtSZIkSVIDBmpJkiRJkhowUEuSJEmS1ICBWpIkSZKkBgzUkiRJkiQ1YKCWJEmSJKkBA7UkSZIkSQ0YqCVJkiRJasBALUmSJElSAwZqSZIkSZIaMFBLkiRJktSAgVqSJEmSpAYM1JIkSZIkNWCgliRJkiSpAQO1JEmSJEkNGKglSZIkSWrAQC1JkiRJUgMGakmSJEmSGjBQS5IkSZLUwJwN1BGxRUS8OyK+GxFXRsQdEXFzRFwSEUdGxJOHaGNhROSQy8Ih2lsxIt4aEedFxHURcUtEXBwRB0fEBiN545IkSZKkkZjXdgfaEBFnAU/psms+sHFZFkbEF4BXZ+biCfRpI+Dkcu66fynLqyLiJZn5rXH3RZIkSZI02JwM1MA6ZX0V8FXgbOCPwDLA1sB+wLrAy4FlgRcP0eYOpb1eruy1IyJWBk5iOkx/BjgGuA3YHvhPYBXg2IjYJjPPH6I/kiRJkqQxmquB+mLgHcDXM/Oujn3nRsQXgR8CmwB7RsSnM/OsAW1ekpmXN+zPW8q5AN6amR+u7TsnIs4AzgRWBD4GbNfwPJIkSZKkEZmT91Bn5k6Z+ZUuYXpq/zVUo9RTdh9XXyJiWeBNZfMi4OAu/fkRcETZ3DYithxXfyRJkiRJw5mTgXpIp9fKG47xPNsDq5by5zPz7h71jqqVdx1jfyRJkiRJQzBQ97Zcrdx1JHtE6rOJn9mn3k+BW0t5m/F1R5IkSZI0DAN1b9vWyhcNUf/IiLgqIhZHxDURcW5EvC8i1h1w3CNq5Yt7VcrMO4FLy+bDh+iPJEmSJGmM5uqkZH1FxP2At9de+soQh21XK69elicA+0XEPpl5WI/j1ivrWzLz+gHnWARsBjwoIpbLzDuG6BcAEbHegCprDduWJEmSJMlA3cu+wFalfFxm/qxP3d8DxwHnUAVegIcBz6eazGx54NMRkZl5eJfjVy7rm4fo1y218v2BoQN1rW+SJEmSpBEwUHeIiG2BD5bNq4HX9al+PNVEYtnx+nlUz4zeiSpsLwt8NCK+kZl/6ai7fFkvHqJ79QC9whD1JUmSJElj4j3UNRHxSKqQPA+4HdgjM6/uVT8zb+gSpuv7vwW8t2yuCOzVpdrtZT1/iC7WJ0q7bYj6desPWHwUlyRJkiTNgIG6iIiHAt8FHkg1q/eLMvOsETR9ODAVurftsv+msr7/EG2tVCsPc4n4P2Xmlf0WoHPkXJIkSZLUh4EaiIh1gFOBdajC7ysz88RRtF1GuK8tm91m/L6yrFeKiAcMaG79sv7bTCYkkyRJkiSN3py/hzoi1gC+RzWRGMAbM/MLIz5Nz8vCgQupJjAD2BQ4t1uliJgHbFg2h3mMl+aoHQ48aWxtn/KuHcfWtiRJkrS0mdMj1BGxKnAK08+CfntmfnLE53gQsEbZvKpLlR/Uyt0uCZ+yBdOXfP9wBF2TJEmSJM3CnA3UEbEicBLwuPLS+zPzQ2M41WuAKOUzu+w/A7ihlF8REdGlDsDCWvn4kfRMkiRJktTYnAzUETGfKpRuU146JDP/a4ZtLIiIzQfU2Ql4d9m8DTiys05mLgYOLZsPB/bv0s7WTM8QfmZmnjeTvkqSJEmSRm+u3kN9NPDMUv4+cEREPKpP/cWZeUnHawuA0yPiHOCbwC+pnlsN1f3Yu5dlasR5/8z8U4/2Pwy8ENgEOCgiNgKOoQrh2wPvoPpZ3QbsM8wblCRJkiSN11wN1LvVyk8DfjWg/hVUAbqbrcvSy63Avpl5eK8KmXlTROwInAxsTHWZ+Gs6qt0IvCQzzx/QV0mSJEnSBMzVQD0KPwNeShWmtwDWppp8bB7wd+AC4DTgs+XRWX1l5qXlEvI3AHsAGwHzgUVUQfuQzLxiDO9DkiRJktTAnAzUmdlr4q+ZtHET8H9lGYnMvAU4qCySJEmSpCXYnJyUTJIkSZKk2TJQS5IkSZLUgIFakiRJkqQGDNSSJEmSJDVgoJYkSZIkqQEDtSRJkiRJDRioJUmSJElqwEAtSZIkSVIDBmpJkiRJkhowUEuSJEmS1ICBWpIkSZKkBgzUkiRJkiQ1YKCWJEmSJKkBA7UkSZIkSQ0YqCVJkiRJasBALUmSJElSA/Pa7oA0l+xw4EljafeUd+04lnYlSZIk9eYItSRJkiRJDRioJUmSJElqwEAtSZIkSVIDBmpJkiRJkhowUEuSJEmS1ICBWpIkSZKkBgzUkiRJkiQ1YKCWJEmSJKkBA7UkSZIkSQ0YqCVJkiRJasBALUmSJElSAwZqSZIkSZIaMFBLkiRJktSAgVqSJEmSpAYM1JIkSZIkNWCgliRJkiSpAQO1JEmSJEkNGKglSZIkSWrAQC1JkiRJUgMGakmSJEmSGjBQS5IkSZLUgIFakiRJkqQGDNSSJEmSJDVgoJYkSZIkqQEDtSRJkiRJDRioJUmSJElqwEAtSZIkSVIDBmpJkiRJkhowUEuSJEmS1ICBWpIkSZKkBgzUkiRJkiQ1YKCWJEmSJKkBA7UkSZIkSQ0YqCVJkiRJasBALUmSJElSAwZqSZIkSZIaMFBLkiRJktSAgVqSJEmSpAYM1JIkSZIkNWCgliRJkiSpAQO1JEmSJEkNGKglSZIkSWrAQC1JkrADr/8AACAASURBVCRJUgMGakmSJEmSGjBQS5IkSZLUgIFakiRJkqQGDNSSJEmSJDVgoJYkSZIkqQEDtSRJkiRJDRioJUmSJElqwEAtSZIkSVIDBmpJkiRJkhowUEuSJEmS1ICBWpIkSZKkBgzUkiRJkiQ1YKCWJEmSJKkBA7UkSZIkSQ0YqCVJkiRJasBALUmSJElSAwZqSZIkSZIamLOBOiK2iIh3R8R3I+LKiLgjIm6OiEsi4siIePIM23t2RBxfa+vKsv3sGbQxLyJeGxFnR8TfIuK2iLgsIg6LiEfO/F1KkiRJksZlXtsdaENEnAU8pcuu+cDGZVkYEV8AXp2Zi/u0dT/gcGCvjl3rluV5EfFZYO/MvLtPO2sAJwNbdux6GPAa4BUR8e+Z+dm+b06SJEmSNBFzdYR6nbK+CjgE2B3YCtgaeDPwp7L/5cBRA9p6P9Nh+hfAnqWtPcs2wKuA9/VqICKWAY5nOkwfBzwbeALwJuBqYDngsJmMeEuSJEmSxmdOjlADFwPvAL6emXd17Ds3Ir4I/BDYBNgzIj6dmWd1NhIRmwD7l82fAk/NzNvK9nkR8Q3gTGAL4C0R8bnMvLRLf14BTF1i/qnMfENt308i4tvAz4BVgEMj4uGZeedM37QkSZIkaXTm5Ah1Zu6UmV/pEqan9l8D7Fd7afceTe3D9JcSb6yF6al2bgXeWDbnAfv2aGcqlF8HvKVLfy4FPlA2NwJ27dGOJEmSJGlC5mSgHtLptfKGnTsjIoBdyubFmXlut0bK678tm7uU4+rtbAI8vGx+pYTwbo6qlQ3UkiRJktQyA3Vvy9XK3UayH8r0vdhnDmhrav+6wIKOfU/uUu9eMvMvwCVlc5sB55MkSZIkjZmBurdta+WLuux/RK188YC26vsf3rGvSTvrR8RKA+pKkiRJksZork5K1ld5FNbbay99pUu19WrlKwc0uahWXn8E7UQ57rd96t5DRKw3oMpaw7YlSZIkSTJQ97Iv1aOvAI7LzJ91qbNyrXzzgPZuqZXvP6Z2Blk0uIokSZIkaVhe8t0hIrYFPlg2rwZe16Pq8rXy4gHN3lErrzCmdiRJkiRJE+QIdU1EPBI4nupzuR3YIzOv7lH99lp5/oCm6xOc3daxr7Od2+mtXzuDdF5q3mkt4LwZtilJkiRJc5aBuoiIhwLfBR5INav3izLzrD6H3FQrD7r8uj6BWOdl3Z3t9AvU/drpKzP73p/d8TQvSZIkSdIAXvINRMQ6wKlUj8FK4JWZeeKAw+oBddCEX/XR4c57mZu0kwyewEySJEmSNEZzPlBHxBrA94CHlZfemJlfGOLQC2vlTQfUre/vfARXk3YWZeYtfWtKkiRJksZqTgfqiFgVOIXpZ0G/PTM/OeThfwCuKuVt+1UEnlrWfwIu79j3g1q5ZzsRsRawSdn84XBdlCRJkiSNy5wN1BGxInAS8Ljy0vsz80PDHp+ZCUxdFr5pRDyxx3meyPTI8onluHo7lzA9av2C0q9uFtbKxw/bT0mSJEnSeMzJQB0R86lC6TblpUMy878aNPUxqgnMAD4eEfd4lFXZ/njZvLPU7+YjZb0acFCX/m4I/GfZvBQDtSRJkiS1bq7O8n008MxS/j5wREQ8qk/9xWUk+R4y85KI+DDwdmAL4IcR8SHgMmBD4G3A5qX6hzPzdz3a/zzwSqqA/4ZyefdngL8DWwHvAlYB7gbelJl3Dv1OJUmSJEljMVcD9W618tOAXw2ofwWwoMe+dwJrUgXizYFjutQ5Aug5Ap6Zd0XE84CTgS2B55el7g7g3zPz2wP6KkmSJEmagDl5yfcoZebdmbkXsCPVPdVXAYvL+kTgOZn5qsy8e0A71wBPAl5PNVHZtVTPpP491Wj14zPzs2N7I5IkSZKkGZmTI9SZGWNo82SqEebZtHEn8L9lkSRJkiQtwRyhliRJkiSpAQO1JEmSJEkNGKglSZIkSWrAQC1JkiRJUgMGakmSJEmSGjBQS5IkSZLUgIFakiRJkqQGDNSSJEmSJDVgoJYkSZIkqQEDtSRJkiRJDUw8UEfE/hGx5qTPK0mSJEnSKLUxQn0QsCgijo+InSPCUXJJkiRJ0lKnrTC7LPBc4ATgTxHxoYjYtKW+SJIkSZI0Y20E6kcDHwOuAQJ4MLA/cEFE/Cgi9oqI+7fQL0mSJEmShjbxQJ2ZF2Tmm4F1gd2AbwJ3UYXrJwCHA3+OiCMj4qmT7p8kSZIkScNo7f7lzLwzM0/IzF2A9YC3AhdRBeuVgJcDp0fEJRHxnxGxTlt9lSRJkiSp0xIxIVhmXp2ZH8nMRwFPpBqlvpEqXG8EvA+4IiJOjojnR8SyLXZXkiRJkqQlI1DXZeZPMvO1wNpUo9R/oQrWywA7AF+hmsjsgxGxVns9lSRJkiTNZUtcoAaIiA2AtwHvpZq0LKd2lWUN4C3AZRGxbyudlCRJkiTNaUtMoI6I5SPipRFxGnAZ8G5gAVWA/h1VwF4HeCZwLNVEZisAH4mIl7bSaUmSJEnSnDWv7Q5ExNbAvwEvAFaeehm4Dfga8NnMPLt2yF+AUyNiw7L/McC+wJcm1mlJkiRJ0pzXSqCOiKn7oxcCm0y9XNa/AD4L/F9m3tirjcy8LCLeBnyn1oYkSZIkSRMx8UAdEScD/0p1uflUiL4B+DLVaPQvZtDc78t6xdH1UJIkSZKkwdoYoX5WrXw21Wj0VzPz9gZt3QqcxfSkZZIkSZIkTUQbgfpq4PNUo9G/m01DmXkVsN0oOiVJkiRJ0ky0EajXy8w7WzivJEmSJEkjM/HHZhmmJUmSJEn3BW1MSjYPeFLZ/GVm3jCg/gOAzcrm2Znp/dKSJEmSpNZNfIQa2AU4A/g68I8h6i8GjgNOB3YcX7ckSZIkSRpeG4F617L+ambeOqhyqXMs1SO2nj/OjkmSJEmSNKw2AvWWVI+5+v4Mjpmq+8TRd0eSJEmSpJlrI1CvX9Z/mMExl3ccK0mSJElSq9oI1FOiQd02HvMlSZIkSdK9tBGo/1bWm87gmKm614y4L5IkSZIkNdJGoD6PasT55TM4ZiHVfdc/H0eHJEmSJEmaqTYC9dfK+ukRsd+gyqXO08rmV8fWK0mSJEmSZqCNQH0s8EuqUeqDIuJrEfHkiPjn/dERMS8inhIRXwcOohqd/g3wpRb6K0mSJEnSvUx8kq/MzIjYFfghsDbVc6l3Bf4REdeVaqsBy5ZyAFcBu2RmTrq/kiRJkiR108os35l5ObA5cEJ5KYD5wFplmc/0zN7HAY8rx0iSJEmStERo7TFUmXk1sFtEbALsSBWw1yi7r6GagOykzPxdS12UJEmSJKmn1p/rnJmXAJe03Q9JkiRJkmailUu+JUmSJEla2hmoJUmSJElqoNVLviPifsAjgIcBKwPLDDomM78w7n5JkiRJkjRIK4E6IlYA/gt4NbD6DA5NwEAtSZIkSWrdxAN1CdPfB7Zi+tFYkiRJkiQtVdoYod4XeEIp/wb4BPAz4Drg7hb6I0mSJEnSjLURqF9Y1j8CnpaZi1vogyRJkiRJs9LGLN8bUt0LfZBhWpIkSZK0tGojUE+F6D+2cG5JkiRJkkaijUB9cVmv1cK5JUmSJEkaiTYC9VFUs3vv0cK5JUmSJEkaiTYC9WeoHpv18ojYs4XzS5IkSZI0a23M8r0+8EaqYP2liNgV+DLVpeC3Djo4M733WpIkSZLUujYC9eVUs3xDden388syjKSdPkuSJEmSdA9thdPoUZYkSZIkaanQRqD+txbOKUmSJEnSSE08UGfm5yd9TkmSJEmSRq2NWb4lSZIkSVrqGaglSZIkSWqg1RmzI+J+wPbA1sBawIrAOzPzz7U686n6eVdm3tFKRyVJkiRJ6tBaoI6InYBDgQ06dn0E+HNt+1XAx4GbI2KdzLxlQl2UJEmSJKmnVi75johXAycCC6gem3UtvR+f9VngBuD+wK6T6J8kSZIkSYNMPFBHxMbAJ8vm94FHZOaavepn5mLg61SB+5nj76EkSZIkSYO1MUK9L9Wl5hcAz8nMi4c45uyy3nxsvZIkSZIkaQbaCNRPAxL4WBl9HsalZb3+eLokSZIkSdLMtBGo1yvrX87gmKmJyFYccV8kSZIkSWqkjUCdZT2TcLx6Wd8w4r5IkiRJktRIG4H6T2X9sBkc8+Sy/v2I+yJJkiRJUiNtBOozqGbsfsUwlSNiVeC1VCPb3x9ftyRJkiRJGl4bgfowqnC8bUQs7FcxIlYHTgDWAu4EPj323kmSJEmSNISJB+rM/AVwCNUo9RERcWxEvKBW5UkR8eKI+CTV7N5PpQrgB2bmFZPuryRJkiRJ3cxr6bz7AcsBrwN2L8vUZGWH1epFWX8sM983ue5JkiRJktRfG5d8k5U3ADtQ3VOdVOG5vgCcA+yYmW9uo5+SJEmSJPXS1gg1AJn5PeB7EbEysDmwJrAMcC1wfmZe02b/JEmSJEnqpdVAPSUzbwLOarsfkiRJkiQNq5VLviVJkiRJWtrN2UAdEWtGxE4R8d6I+HZEXBMRWZajhmxjYe2YQcvCIdpbMSLeGhHnRcR1EXFLRFwcEQdHxAazfc+SJEmSpNGZ+CXfEfG5WRyembnXiLry1xG1MxIRsRFwMrBxx65/KcurIuIlmfmtiXdOkiRJknQvbdxDvZDpR2TNRJTjRhWo6/4IXAw8cxZt7ABc1Wf/lb12lEnZTmI6TH8GOAa4Ddge+E9gFeDYiNgmM8+fRT8lSZIkSSPQRqD+I4MD9UrA6kyH6GuAW0fcj/cC5wHnZeZfI2IB8IdZtHdJZl7e8Ni3AJuU8lsz88O1fedExBnAmcCKwMeA7RqeR5IkSZI0IhMP1Jm5YJh6EfFAYE+q4Hs98NzM/O0I+/GeUbU1GxGxLPCmsnkRcHBnncz8UUQcAewNbBsRW2bmeRPspiRJkiSpwxI7KVlm/j0zPwVsQ/V86m+XkH1fsz2wail/PjPv7lHvqFp517H2SJIkSZI00BIbqKeUUelDgQXAfu32ZiyeXCuf2afeT5m+7H2b8XVHkiRJkjSMJT5QF6eW9W6t9qK/IyPiqohYXB7BdW5EvC8i1h1w3CNq5Yt7VcrMO4FLy+bDZ9tZSZIkSdLstDEpWRM3l/VDWu1Ff9vVyquX5QnAfhGxT2Ye1uO49cr6lsy8fsA5FgGbAQ+KiOUy845hOxcR6w2ostawbUmSJEmSlp5AvXlZ/6PVXnT3e+A44ByqwAvwMOD5wO7A8sCnIyIz8/Aux69c1jd32dfpllr5/sDQgbrWN0mSJEnSCCzxgToiHgocQPX4rCXt+cvHU00k1vkYsPOonhm9E1XYXhb4aER8IzP/0lF3+bJePMT56gF6hSYdliRJkiSNxsQDdUS8fIhq9wMeCGwB7EL1/OUEPj3Grs1YZt4wYP+3IuK9wIFU72Ev4P0d1W4v6/lDnHK5Wvm2YftZrD9g/1pUXwRIkiRJkobQxgj1UVTheFhR1odm5rGj787YHU71LO0AtuXegfqmsr7/EG2tVCsPc4n4P2Xmlf32R0S/3ZIkSZKkDm3N8h1DLjcA3wCelZn7ttPV2cnMq4Fry2a3Gb+ngu5KEfGAAc1NjTL/bSYTkkmSJEmSRq+NEeqHDlHnbuCmIWa9Xlr0G5G/kGoCM4BNgXO7VYqIecCGZfOi0XVNkiRJktTExAN1Zl4x6XO2KSIeBKxRNq/qUuUHtfK29AjUVPeTT13y/cPR9E6SJEmS1FRbl3zPJa9h+j7wM7vsP4Pq0naAV0Tvm5kX1srHj6RnkiRJkqTGDNQNRcSCiNh8QJ2dgHeXzduAIzvrZOZi4NCy+XBg/y7tbE01QzjAmZnpbNySJEmS1LIl/jnU4xIRTwY2qr20Rq28UUQsrNfPzKM6mlgAnB4R5wDfBH4JXF32PQzYvSxTI877Z+afenTnw8ALgU2AgyJiI+AYqhC+PfAOqp/VbcA+Q71BSZIkSdJYtfEc6rvG0Gxm5kzfy6uAV/TYt01Z6o7qUXfrsvRyK7BvZh7eq0Jm3hQROwInAxtTXSb+mo5qNwIvyczz+5xLkiRJkjQhbYxQ31ceePwz4KVUYXoLYG2qUe55wN+BC4DTgM+WR2f1lZmXlkvI3wDsQTV6Ph9YRBW0D5lrE7pJkiRJ0pKsjUD932W9I1UQhSp8/gT4a9l+MLAl8CiqR079lCpUjkxmLuSeE33N9PibgP8ry0hk5i3AQWWRJEmSJC3B2nhs1n9HxLupwvQvgdf0mmQrIrYEDit1T8rM906up5IkSZIk9TbxWb4j4unAAcAlwJP7zVhd9j0FuBR4T0Q8YyKdlCRJkiRpgDYem/Umqsu4P1guce6r1Pkg1b3Xbxxz3yRJkiRJGkobgXrqvulfzeCYX5b1liPuiyRJkiRJjbQRqFcr61VncMwqZf3AEfdFkiRJkqRG2gjUV5X182dwzO5l/ecR90WSJEmSpEbaCNTfobofeu+IeMGgyhGxO7A31X3XI310liRJkiRJTbURqP8fcGM599ERcUJEPC8i1o2IZSNiXik/LyKOB44FlgFuAj7QQn8lSZIkSbqXNp5D/aeI2Bn4JtW90TuXpZegCtO7ZOafJtBFSZIkSZIGamOEmsw8G3g08HXgbqrQ3G25GzgO2Cwzz2yjr5IkSZIkdTPxEeopmbkI2CMiHgxsTxWwp2YA/zvwa+D0zPxLS12UJEmSJKmn1gL1lMz8K3BMWSRJkiRJWiq0csm3JEmSJElLu9ZHqCNiBeDxwFrAisAJmXlju72SJEmSJKm/1gJ1RKxP9QitPYBla7t+ClxYq7cX1XOobwCemZk5yX5KkiRJktRNK5d8R8QTgF8ALwbmMz2rdzffBDYDngY8cyIdlCRJkiRpgImPUEfEA4ATqWb0/jNwIHA21aze95KZV0fEt4HnAjsCp0yoq5J62OHAk8bW9inv2nFsbUuSJEmj1MYl328C1gSuAbbOzD8CRPQaoAbgVGAXYKux906SJEmSpCG0ccn3zkAC/zMVpodwQVlvOJ4uSZIkSZI0M20E6o3K+qwZHPP3sl5lxH2RJEmSJKmRNgL18mX9jxkcs1JZ3zbivkiSJEmS1Egbgfrqsn7oDI55bFlfNeK+SJIkSZLUSBuB+sdl/exhKkc1W9mrqe67PntcnZIkSZIkaSbaCNT/R/XM6ZdExGMHVQYOBh5Typ8fW68kSZIkSZqBiQfqzDwROJ3qkV2nRcTrImLNWpV5EbFOROwREWcD/0E1On1cZv5o0v2VJEmSJKmbNp5DDfB84DRgc+ATZcmy7xcddQM4F1g4qc5JkiRJkjRIG5d8k5nXA1sDHwBupArN3ZbbgIOA7TLzljb6KkmSJElSN22NUJOZi4F3RsT/A7YFtgDWBJYBrqUaqT41M29oq4+SJEmSJPUy8UAdES8vxd9m5o/LyPPJZZEkSZIkaanQxiXfRwFHAhu0cG5JkiRJkkaijUA9dQn371o4tyRJkiRJI9FGoP5DWT+whXNLkiRJkjQSbQTq46lm8N65hXNLkiRJkjQSbQTqQ4ArgNdFxNNbOL8kSZIkSbM28UD9/9u793D7qrpe/O+PAgqopQJewEQlA61+h8I7ilbKMfRoP6tjJ4+SgKaF6aOWpZiKWmaeLnhJ1ETTSs0LJhLe8RIe0Z+noykCCgmionnjfpHx+2PO7Z5s9l5r77n3+q69v/v1ep71rDnXHGvMseZeTL7vNcYcs7X2gyQPTnJWkn+pqhOr6oFVdauqqh3dHgAAABhjHrfN+uFwNclR/WNh+6S3t9ba3O6dDQAAAAvmEU6XJma90gAAAGw58wjUz5/DPgEAAGBDzTRQV9Vj+8V39ddOp7UmUAMAALDlzbqH+qQkLcmnk3xh6caq2jvJk9JdG338jNsCAAAAG2beE3ztk+R56UK3QA0AAMCWMY/7UAMAAMCWJ1ADAADACAI1AAAAjCBQAwAAwAgCNQAAAIwgUAMAAMAIO+q2WU+uqouXeX2fhYWqeu5qKmqtvWDDWgUAAAAj7ahA/aQJ21r//MerrEugBgAAYO52RKCuDayrTS8CAAAAszfrQP2gGdcPAAAAczHTQN1aO32W9QMAAMC8mOUbAAAARhCoAQAAYASBGgAAAEYQqAEAAGAEgRoAAABGEKgBAABgBIEaAAAARhCoAQAAYIRd5t0AgOUcfvwpM6v7tOOOmFndAABsH3qoAQAAYASBGgAAAEYQqAEAAGAEgRoAAABGEKgBAABgBIEaAAAARhCoAQAAYASBGgAAAEYQqAEAAGAEgRoAAABGEKgBAABgBIEaAAAARhCoAQAAYASBGgAAAEYQqAEAAGAEgRoAAABG2LaBuqr2qaqHVdULqurUqvp2VbX+cdKI+h5aVe+sqgur6qr++Z1V9dA11LFLVf12VX2sqr5VVVdU1Zer6tVVdfe1tgkAAIDZ2WXeDZijb25EJVV1oyQnJjlqyaZ9+8cjq+q1SZ7YWrtuQj17JXlvknss2XTnJE9I8riq+t3W2ms3ot0AAACsz7btoV7iq0neN/K9L8pimP5skt9Ics/++bP960cneeFKFVTVjZO8M4th+h1JHprkXkmekuTiJDdJ8uq19HgDAAAwO9u5h/oFSc5McmZr7ZtVtX+S89ZSQVXdNckz+tVPJ3lAa+2Kfv3Mqnp3ktOTHJLkmVX1t621c5ep6nFJDu2XX9la+53Btk9V1alJPpPkFkn+uqoOaq1du5a2AgAAsLG2bQ91a+2PW2vvaa2tZ+j3U7P4o8SxgzC9sI/Lkxzbr+6S5Gkr1LMQyr+T5JnLtPXcJH/Srx6Q5FfW0WYAAAA2wLYN1OtVVZXkEf3qWa21Ty5Xrn/9S/3qI/r3Deu5a5KD+tW39iF8OScNlgVqAACAOROox7tTktv3y6dPKbuwfd8k+y/Zdugy5W6gtfaNJGf3q/dbXRMBAACYFYF6vLsNls+aUna4/aAl28bUc4eq2nNKWQAAAGZoO09Ktl77DZYvnFL2gsHyHTagnurf96UJZa+nqvabUuS2q60LAAAAgXo9bj5YvnRK2csGyzebUT3TXDC9CAAAAKtlyPd4Nx0sXz2l7FWD5d1nVA8AAAA7kB7q8a4cLO82pexNBstXLNm2tJ4rs7JJ9UyzdKj5UrdNd19uAAAAVkGgHu+SwfK04dfDCcSWDuteWs+kQD2pnolaaxOvz15yNy8AAACmMOR7vGFAnTbh17B3eOm1zGPqaZk+gRkAAAAzJFCP94XB8oFTyg63f3ED6rmgtXbZxJIAAADMlEA93nlJLuqXD5tS9gH989eSnL9k28cHyyvWU1W3TXLXfvUTq2siAAAAsyJQj9Raa0lO7lcPrKp7L1euf32hZ/nk/n3Des7OYq/1r1fVHivs8sjB8jtHNRoAAIANI1Cvz18m+WG/fEJVXe9WVv36Cf3qtX355fx5/3yrJH+2dGNV3SXJH/ar50agBgAAmLttO8t3VR2a5IDBS3sNlg+oqiOH5VtrJy2to7V2dlW9NMmzkhyS5BNV9ZIkX05ylyR/kOTgvvhLW2vnrNCcNyR5fJL7Jfmdfnj3a5J8N8k9kxyX5BZJrkvylNbatav/pAAAAMzCtg3USY5O8rgVtt2vfwydtELZZyfZJ10gPjjJPy5T5nVJnrNSQ1prP6yqRyZ5b5J7JHlU/xi6KsnvttZOXakeAAAAdhxDvteptXZda+2oJEeku6b6oiRX988nJ/nl1trRrbXrptTz7ST3TfLkdBOV/We6e1J/JV1v9c+31l47sw8CAADAmmzbHurW2pG5/kRf663vvel6mNdTx7VJXtU/AAAA2MT0UAMAAMAIAjUAAACMIFADAADACAI1AAAAjCBQAwAAwAgCNQAAAIwgUAMAAMAIAjUAAACMIFADAADACAI1AAAAjCBQAwAAwAgCNQAAAIwgUAMAAMAIAjUAAACMsMu8GwAwT4cff8pM6j3tuCNmUi8AAJuHHmoAAAAYQaAGAACAEQRqAAAAGEGgBgAAgBEEagAAABhBoAYAAIARBGoAAAAYQaAGAACAEQRqAAAAGEGgBgAAgBEEagAAABhBoAYAAIARBGoAAAAYQaAGAACAEQRqAAAAGGGXeTcAYGd3+PGnzKTe0447Yib1AgCwOnqoAQAAYASBGgAAAEYQqAEAAGAEgRoAAABGEKgBAABgBIEaAAAARhCoAQAAYASBGgAAAEYQqAEAAGAEgRoAAABGEKgBAABgBIEaAAAARhCoAQAAYASBGgAAAEYQqAEAAGAEgRoAAABGEKgBAABgBIEaAAAARhCoAQAAYASBGgAAAEYQqAEAAGAEgRoAAABGEKgBAABgBIEaAAAARhCoAQAAYASBGgAAAEYQqAEAAGAEgRoAAABGEKgBAABgBIEaAAAARhCoAQAAYASBGgAAAEYQqAEAAGAEgRoAAABGEKgBAABgBIEaAAAARhCoAQAAYASBGgAAAEYQqAEAAGAEgRoAAABGEKgBAABgBIEaAAAARhCoAQAAYASBGgAAAEYQqAEAAGAEgRoAAABGEKjXqaraKh8fWUVdD62qd1bVhVV1Vf/8zqp66A74KAAAAKzBLvNuAElV3SjJiUmOWrJp3/7xyKp6bZInttau29HtAwAA4IYE6o3zqiSvnLD9sgnbXpTFMP3ZJH+W5MtJ7pLk95McnOToJN9K8kfrbikAAADrJlBvnItba59f65uq6q5JntGvfjrJA1prV/TrZ1bVu5OcnuSQJM+sqr9trZ27IS0GAABgNNdQz99Ts/jDxrGDMJ0kaa1dnuTYfnWXJE/bgW0DAABgBQL1HFVVJXlEv3pWa+2Ty5XrX/9Sv/qI/n0AAADMkUA9X3dKcvt++fQpZRe275tk/1k1CAAAgNURqDfOr1XVF6rq8qq6pKrOqao3VNWDJrznboPls6bUP9x+0PhmAgAAsBFMSrZx7rZk/YD+8diqeleSI1tr319SZr/B8oVTYgbRrAAAIABJREFU6r9gsHyHtTauqvabUuS2a60TAABgOxOo1+/yJO9O8sF0vciXJtk7yWFJfjvJrZM8MsnJVfXg1to1g/fefLB86ZT9DG+7dbMR7bxgehEAAABWS6Bev31ba99b5vX3V9UJSU5Ndx/pw5I8KclfD8rcdLB89ZT9XDVY3n1MQwEAANg4AvU6rRCmF7Z9s6p+NV3P9a7pbn81DNRXDpZ3m7KrmwyWr1ix1MqmDRO/bZIzR9QLAACwLQnUM9Za+0pVvT/JLyc5oKpu31q7qN98yaDotGHcew6Wpw0PX64dE6/RdicuAJZz+PGnzKzu0447YmZ1A8COYJbvHeMLg+V9B8vDkDtt0rBhD7ProQEAAOZMoN4x2gqvD4P2gVPqGG7/4vqaAwAAwHoJ1DvG8JZaFw2WzxusHzaljgf0z19Lcv7GNAsAAICxBOoZq6o7JXlwv/rl1trXFra11lqSk/vVA6vq3ivUce8s9lCf3L8PAACAORKo16GqHl5VK07sVlW3SfL2LM7g/cpliv1lkh/2yydU1fVuidWvn9CvXtuXBwAAYM7M8r0+JyTZtarenuSMdEOxr0iyV5IHJnliv5wkH0/yiqUVtNbOrqqXJnlWkkOSfKKqXpLky0nukuQP0t3HOkle2lo7Z1YfBgAAgNUTqNfv9unuL33shDJvT3J0a+2qFbY/O8k+SR6fLjz/4zJlXpfkOetoJwAAABtIoF6fx6WbTOw+Se6crjf6FunuE31Bkn9N8obW2hmTKmmtXZfkqL6n+wlJ7tHX9e0kZyZ5dWvt1Fl9CAAAANZOoF6H1trpSU7fwPrem+S9G1UfAAAAsyNQA+wEDj/+lJnVfdpxR8ysbgCArcws3wAAADCCQA0AAAAjCNQAAAAwgkANAAAAIwjUAAAAMIJADQAAACMI1AAAADCCQA0AAAAjCNQAAAAwwi7zbgAAAAA3dPjxp8yk3tOOO2Im9W5HeqgBAABgBIEaAAAARhCoAQAAYASBGgAAAEYQqAEAAGAEgRoAAABGEKgBAABgBIEaAAAARhCoAQAAYASBGgAAAEYQqAEAAGAEgRoAAABGEKgBAABgBIEaAAAARhCoAQAAYASBGgAAAEYQqAEAAGAEgRoAAABGEKgBAABghF3m3QAAWHD48afMrO7TjjtiZnUDANuTHmoAAAAYQaAGAACAEQRqAAAAGEGgBgAAgBEEagAAABhBoAYAAIARBGoAAAAYQaAGAACAEQRqAAAAGGGXeTcAgK3h8ONPmVndpx13xMzqBgCYFT3UAAAAMIIeagC2FT3tAMBG0UMNAAAAI+ihBoAtala97XraAWB19FADAADACAI1AAAAjCBQAwAAwAgCNQAAAIwgUAMAAMAIAjUAAACMIFADAADACAI1AAAAjCBQAwAAwAgCNQAAAIwgUAMAAMAIAjUAAACMIFADAADACAI1AAAAjCBQAwAAwAi7zLsBALAzOvz4U2ZS72nHHTGTegGAtdNDDQAAACMI1AAAADCCQA0AAAAjCNQAAAAwgkANAAAAIwjUAAAAMIJADQAAACMI1AAAADCCQA0AAAAj7DLvBgAA7CwOP/6UmdR72nFHzKReANZHDzUAAACMIFADAADACAI1AAAAjOAaagBgpzera5sT1zcDbGd6qAEAAGAEPdQAwFzpPQZgq9JDvclU1R2r6mVVdVZVXVZV36mqM6vqmVW1x7zbBwAAQEcP9SZSVQ9P8qYktxi8vEeSQ/rH0VV1RGvt3Hm0DwAAgEV6qDeJqjo4yVvShelLkzw7yX2T/GKS1/TF7prklKq6+VwaCQAAwI/ood48/irJ7kmuTfKQ1toZg20fqqpzkvxZulD99CTP2+EtBADYQlyfD8yaQL0JVNU9k9y/X33dkjC94GVJfivJQUl+r6pe1Fq7Zke1EQDYPgRRgNUx5HtzeORg+fXLFWitXZfkjf3qjyd50KwbBQAAwMr0UG8Oh/bPlyX5zIRypw+W75fkfTNrEQCwKc2q93hH9xzvLL3gO8vn2FF2luO1s3yOZOc5p8yLHurN4aD++dzW2rUTyp21zHsAAACYAz3Uc1ZVN02yV7964aSyrbXvVtVlSfZMcoc17me/KUX2XVj4+te/vpaqZ+7K7397ZnVfeOHiIZ/VfnaWfQz3s7PsY5b72Vn2MdyPfax+H7Pcz86yj+F+dpZ9zHI/O8s+hvuxj9XvY0f5zb/84EzqffNTf/FHyzvL8XJOWds+NpM73OEO+yX5xpSOzFWr1tpG1MNIVbV3kov71be01h49pfw3k+yT5POttZ9Zw378oQEAAJI7tNY2JPEb8j1/Nx0sX72K8lf1z7vPoC0AAACskiHf83flYHm3VZS/Sf98xRr3M22I+G5JDkzXW/6tJD+cUPa2Sc7sl++R5BtrbAvMm+8wW5nvL1ud7zBbme/vzmHD/m4C9fxdMli+2SrK79k/X7qWnaxySMNXVlNXVQ1Xv7FRwyVgR/EdZivz/WWr8x1mK/P9ZSlDvuestXZlkv/sVydOHFZVt8xioL5glu0CAABgMoF6c/hC/3xAVU0aNXDgYPmLM2wPAAAAUwjUm8PH++c9k/z8hHKHDZY/MbvmAAAAMI1AvTm8a7D8W8sVqKobJXlsv/q9JB+edaMAAABYmUC9CbTWPpXkY/3qUVV1n2WKPT3JQf3yX7XWrtkhjQMAAGBZZvnePH4v3TDu3ZO8r6penK4Xevckj07yhL7c2UleNpcWAgAA8CMC9SbRWvtsVf33JG9KcoskL16m2NlJjmitXbLMNgAAAHagaq3Nuw0MVNUd0/VWH5HuNlpXJzk3yduSvLy1dvkcmwcAAEBPoAYAAIARTEoGAAAAIwjUAAAAMIJADQAAACMI1AAAADCCQA0AAAAjCNQAAAAwgkANAAAAIwjUAAAAMIJADQAAACMI1KxJVd2xql5WVWdV1WVV9Z2qOrOqnllVe8y7fbCcqmqrfHxk3m1l+6mqfarqYVX1gqo6taq+PfhOnjSivodW1Tur6sKquqp/fmdVPXQGzWeb24jvb1UduYbz9JGz/URsN1V1SFU9t6reNzhvXlpVZ1fV66vq0DXW5xy8zewy7wawdVTVw5O8KcktBi/vkeSQ/nF0VR3RWjt3Hu0D2KK+uRGVVNWNkpyY5Kglm/btH4+sqtcmeWJr7bqN2Cdkg76/MA9V9dEk919m025JfrJ/HFlVb0xyTGvt6gl1OQdvUwI1q1JVByd5S5Ldk1ya5E+SfLhff3SSY5LcNckpVXVIa+2SebUVJnhVkldO2H7ZjmoIrOCrSc5K8pAR731RFv8h99kkf5bky0nukuT3kxyc5Ogk30ryR+tuKdzQer6/Cw5PctGE7Reuo25Y6vb980VJ3pbkY+m+xzdOcp8kT08Xhh+bZNck/2NCXc7B21S11ubdBraAwS941yZ5QGvtjCXbn5nuxJEkz2+tPW/HthBWVlULJzrfTTadqnp+kjOTnNla+2ZV7Z/kvH7zG1prR66ijrsm+fd0P5R/Ot15+orB9j2SnJ5uNNG1SQ4ymoiNsEHf3yOTvL5fvVNr7fwNbygso6rek+SNSd7eWvvhMtv3SvKJdJ1GSXJYa+2jy5RzDt7GXEPNVFV1zywOh3nd0jDde1mSL/bLv1dVu+6QxgFsca21P26tvae1tp6hs0/N4qizY4f/kOv3cXmSY/vVXZI8bR37gh/ZoO8vzEVr7WGttbcuF6b77d9O10u94FdXqMo5eBsTqFmNRw6WX79cgf5akDf2qz+e5EGzbhQASVVVkkf0q2e11j65XLn+9S/1q4/o3wfAZB8eLN9l6UbnYARqVmNhdsPLknxmQrnTB8v3m11zABi4UxavAzx9UsHB9n2T7D+rBgHsRG4yWF6uJ9s5eJsTqFmNg/rnc1tr104od9Yy74HN5Neq6gtVdXlVXVJV51TVG6rKiAq2srsNls9asdQNtztPsxm9vqouqqqr+1twfbKqXlhV+867YWxbhw2Wv7jMdufgbU6gZqKqummSvfrViTNrtta+m8VZku8wy3bBSHdL9z+w3ZPcLMkB6Wbu/FB/j8gfm2fjYKT9BsvTZkC+YLDsPM1m9MAkt0s3o/Ktk9wrybOTnFtVT5xju9iG+lthPWvw0luXKeYcvM25bRbT3HywfOkqyl+WZM90YQU2i8uTvDvJB9P9Onxpkr3T/er82+n+0fbIJCdX1YNba9fMq6EwwlrO08NbwzlPs5l8Jck7kpyRxdBx5ySPSjcR1E2T/E1VtdbaifNpItvQ05Lcs19+R2ttuUsfnYO3OYGaaW46WF7xZvYDV/XPu8+gLTDWvq217y3z+vur6oQkp6a7P+RhSZ6U5K93ZONgndZynr5qsOw8zWbxznS32Fp6L9czk7ylqh6WLmzvmuQvqurdrbVv7OhGsr1U1WFJ/rRfvTjdvw+W4xy8zRnyzTRXDpZ3W0X5hYkbrphYCnagFcL0wrZvpuv9WOiVPnalsrBJreU8PZxcx3maTaG19v1lwvRw+3uSvKBf3SPJUTukYWxbVXX3dD/07JLuHPtrrbWLVyjuHLzNCdRMc8lgeTVDU/bsn1czPBw2hdbaV5K8v189oKpuP6k8bDJrOU/vOVh2nmYrOTHJQug+bFJBWI+qulOS9yW5ZbpZvR/dWvvohLc4B29zAjUTtdauTPKf/ep+k8pW1S2zeKK4YFJZ2IS+MFg2myxbyXASnInn6Vx/EhznabaMvndw4d8jztHMRP+D+gfS3QarJXl8a+3kKW9zDt7mBGpWYyFoHFBVk667P3CwvNxtBWAzW3G4IWxywx+DDlyx1A23O0+z1ThPMzNVtVe60Wp37l86trX2xlW81Tl4mxOoWY2P9897Jvn5CeWGQ7A+MbvmwEwM7yN50dxaAWt3Xha/s9OGwj6gf/5akvNn1SDYaFW1dxZv4+kczYbqb5t5Whb/LfCs1torVvl25+BtTqBmNd41WP6t5Qr09+l7bL/6vSQfnnWjYKP010s9uF/9cmvta/NsD6xFP5nTwpDEA6vq3suV619f6B05edIkULAJPSFJ9cunz7Mh7Fyqao8kpyT5uf6lF7XWXrLa9zsHI1AzVWvtU0k+1q8eVVX3WabY05Mc1C//lfv4sllU1cMnXapQVbdJ8vYszsz5yh3SMNhYf5lu8pwkOaGqrnc7ln79hH712r48zF1V7V9VB08p87Akz+1Xr0jy+pk3jG2hqnZLN5v3/fqX/qq19pwRVTkHb2PuQ81q/V66Ydy7J3lfVb04XS/07kkene6X4yQ5O8nL5tJCWN4JSXatqrcnOSPdEKsr0g0dfGCSJ2ZxGOHHk6x2iBdsiKo6NMkBg5f2GiwfUFVHDsu31k5aWkdr7eyqemmSZyU5JMknquolSb6c5C5J/iDdvdaT5KWttXM27AOwrW3A93f/JB+uqjOS/HOSf0t3z9+ku5b1V/vHQu/0M4wiYgP9Q5KH9MsfSvK6qvrpCeWvbq2dvfRF5+DtrYw2YLWq6uFJ3pTkFisUOTvJEa21c3dcq2Cyqjo/yR1XUfTtSY6edM9qmIWqOinJ41ZbvrVWy73eX3rzmiSPn/D21yV5QmvturW0EVay3u9vVT0wq7tM7PIkT2utnbiW9sEkVbXWIPQfrbX9V6jLOXib0kPNqrXW/rmqfjZdb/UR6W4NcHWSc5O8LcnLW2uXz7GJsJzHpZsk5D7pejv2Svej0KXpblnxr0ne0Fo7Y24thA3Q/wPtqH40xhOS3CPd9/3bSc5M8urW2qlzbCIs5zNJHpPuHH1Iktul+97ukuS7Sf49yQeTvLa/dRZsSs7B25ceagAAABjBpGQAAAAwgkANAAAAIwjUAAAAMIJADQAAACMI1AAAADCCQA0AAAAjCNQAAAAwgkANAAAAIwjUAAAAMIJADQAAACMI1AAAADCCQA0AAAAjCNQAAAAwgkANAAAAIwjUAAAAMIJADQAAACMI1ADslKrqgVXV+scD592e9aqqj/Sf5SMj37+zHY/nLXyeDarvBX1979mI+raKqjqp/9znz6DuU/q6n7/RdQNsFgI1AJvGktC33OPSqjq7qv6uqn5h3u1l51BVP5Hkmf3qlgt/VfW+/r+Pv5pB3eevI3Af3z8/o6r228BmAWwaAjUAW8meSX4yyWOSfLCq3lBVN55zm9j6npPkpkn+pbV25rwbsxZVdfMkh/Wr/zzPtizVWvtkkvcn2SPJH825OQAzIVADsFm9KsnPDB4/m+SBSf4wycV9mcdmC/YosnlU1b5JjuxXXzbHpox1eJLdkvwgyelzbstyFo7pUVV1u7m2BGAGBGoANquLW2ufHzw+11o7vbX2p0kelOTKvtxTqmq3ObaTre3JSXZNclGSD825LWM8vH8+rbV2zVxbsrwPpPsBbLckT5xzWwA2nEANwJbTWvtCklP61ZsnOXCOzWGLqqobZbF3+h9ba9fNsTlr1rf/l/vVTTmZWmvth0ne0q/+VlXVPNsDsNEEagC2qvMGyzcZW0lV3ayqnlVVZ1TVd6rqqqq6sKr+qaoetso69q6qF1bVZ6vqe1V1ZT+Z099V1aGrrOPeVfW2qvpG//7zqurEqvqpsZ9trKp6ZN+Wr/Zt+V5Vfbqq/riqbjnlvffuj8VH+s9ydVX9oKq+UFWvqqq7rbIN+1XVK6rqK30bLqqqd1fVL23Mp0ySHJrk9v3y2ye0ZVUziq92JvWq+umqemP/PbuyP85vqqqf67evdubteyfZK8l1Sd67wr4O6uu7oN/XBVX191V1jyl1b6SFY/sTSe63A/cLMHO7zLsBADDSHQfLXx1TQVUdnK5n7/ZLNu2b5FFJHlVV70jym621K5e+v6/jIUneluQWy7TvjkkeU1WvSPKUlXpAq+ppSf481/+he/8kxyT5H1X162v5XGP1YfmfkiydQf0mSX6+fzy5qh7RTzi19P1HJnn9MlXvmuSg/nFMVT2ltfbKCe24f7q/y/CY3i7d8OaHV9XzVvuZpnhQ/3xNks9sUJ0TVdVjkvxtumOy4A5JfjPJr1fVMWuobmG49xmttW8vs69fT/LGXP8Hp/2S/EaSX6uq315L29fhzCQ/THLjJA9N8vEdtF+AmdNDDcCWU1UHJlnoPf5ka+2bI+rYN8kH04Xpli4IHp7kkHSTnf1bX/T/TXLSCnX8l3QzK98iXSj7i3Qh7Z7prhdd6EX/nSR/skIdv5Lkf6X7f/L3082GfN/+8Zx0QeTNuWHo31BVdZN017v+Qr/Pv0sXvO6d5P5Jnp3kP5Psk+S9VXXHZarZJcl30x2vx/fv+7l0f6vnJvl2ulD18pVue9bfwmohTF+X5G+S/FKSeyQ5Ksk5SZ6X5Ij1feKkb1+SfK61dtUG1DdRVd033bHZNcnlSV6Y5AFJ7pXuO/LNJCemm4BvNRYC9Q1m9+57oN+cLkxfleRPB/t6Srq/xauS/JdRH2YNWmuXJ/n3fvWwSWUBtho91ABsVvtU1U8P1ivJjye5T5KnJdk9XQB92sj6/zLJwvDlY1prrxts+0xVvTXJqekC8n+vqje01k5dUseJ6SZb+mGSh7XW3jfYdmZVvS1db9zd0t2L942ttYVgkX4ytZf3q99Pcp/W2hcHdZxRVScn+US624XN0nPThd/vJfml1trSHtuPV9Wbk5yRrrf4xel6VYdOTfL3fYAa+mySU6rqr5N8NF1gfH6WnwTsZVnsmX5Ma+0fBts+3R/Tj6X74WO0/lreew/atyO8It0PClcl+YXW2v8ebPtUVf1TuuN78LSKqupOSe7ery53/fQr0/0775okD2mtfXTJvt6R5JNJ/p81f4pxPpPu735wVVVrbeLweYCtQg81AJvVk5J8bvD4v+nC2EvS9ZL+TZJ7Ljf0eJqqun2SX+lX/2VJmE6S9D2Wj09ybf/S7y6p457pek2T5DVLwvRCHd9N8oR+9UbpZpQeekQWe56PXxKmF+r4fJIXTftM61FVN0vXQ5okxy0Tphfa8h9Jju9Xf62q9lyy/WvLhOnh9u+nC+5JcmhV3XpJO26bxb/Le5aE6YU6LsniMV2PW6a7r3myeBu2mamqe2WxN/iEJWE6SdJauzir/4FoYYTGecMfafp93SOLPzi8ekmYXtjX15I8fZX72ggLx3iPJLfdgfsFmCmBGoCt6EZJHp3kSf1Q5bV6YLqewiS5QZhe0Fo7P8n7F95TVTcebB5OjjWpjk8kWQjKSyfUWlhvSd4wob2v78vMymFJfqxf/qcpZRfC2a7prqleUVXtWVX7V9Xd+4m4fjpdj+mCpb2jD8ri32W5a7GTJK21T2VxCPFYew+Wv7vOulZj+Lf/uwnlTkk3tH6aFYd7L9nXiscxyTvTjUjYEb4zWBaogZ2GQA3AZvX81loNH+l6t342yUuT3CzJU5N8oKr2WGPdw6HkN+gpXGJh+x5J7rxMHVcn+T+rrOMn6/r3zP6Z/vm85SaVWtBa+1aS86fsYz2Gw6e/Ppip+gaPJJ8flL1BMKqqvarqxVX1pSSXpLuO/PNZHGlwyqD4Xkve/jOD5TOntPlTU7ZPc6vB8o4I1Avfl6sy4ceA/jZTE79PVXXzLF6LvFygXjiOV2dxLoDl9nVNdtxw9+Ex3nPFUgBbjEANwJbRWruitfa51trvZ3H49KHpJvJai2GYmjbc9xsrvG9h+TuttWsz2UIdlcXrtod1rGbI8ZonXluDfUa+73o/ZFTVzyc5K8kfJrlrus87ye5L1tfyd1nv8RjO2r60HbOw8Hf/Th+aJ/nWlO2Hp7t2/5Ikpy+zffjdnLavWX6vhobH+JoVSwFsMSYlA2Crel26mYtvle5a5+eMrGe9Q6k3Yij2vCdoGg5l/7msPvBcuLDQ97y/Ncmt+/efkOTkJGcn+e7CLNpVdeckX15424S6Z31MhqH1ViuW2pwWrp8+re9lXsm8v1dDw2O8o4aZA8ycQA3AltRau66qzkl3G6DbVdWtW2urufY0uf71nLdJcsGEssNhzd9ZZvnWVbXLlF7qhTparj/0dWH5NhPeO2znrAyP27daaxeuWHJlv5DFIfFPbq29doVyk8Lr8NhM+7us93gMA/UtVyzV+dH9w6vqRivdTzyThzIvfLZbVdWNp/Qc773Shqq6UZJf7leXG+493NetV7GvWX6vhobHeNLfFWBLMeQbgK1slxWWpxleB3yvKWXv2T9fnuQry9SxW6bfy3ehjnNaa1cPXv9c/3ynpTNeD1XV3kn2n7KP9RheR3u/kXXcfbD8lgnlJt3u6nOD5XusWGp12yfqe8zP6VfvOqX4JYPlSeF7Uj0L103fJNc/VtfTT3w36ft073SB+7ok712hzMJx3C0TbotVVbtM2ddGWjg2502aCR5gqxGoAdiS+onI7tavXpFkxUm9lvGRdPeOTrrh4ivt4yeSPHjhPUt6+j4wWJ5Ux30G7fzAks0L65XksRPae2SmX4+8Hh9I94NBkjylv0fzWg1/0Fi2p7bvXT1mQh0fzuLf5XErFepvC/XTK21fg4/1z9PC+XmD5Uk/CDx6wrYPDpb/54RyR6QbNr+Shdm9z5gwkd3we7bicUx3i7JpvfMbZeG4TZsEEGBLEagB2Kqel8WJjk5bxeRLP9JauyjdLYOS5KFVdYPQ0V8T/Lfpbg+VJC9fUsenkny6Xz2mqn5xmTp+LMmr+9XrkrxqSZF3Jfl6v3xcVf3UMnXcLcmzp32m9WitfS+Ln+++Sf6iD7/LqqrbVNXRS14+Z7B85Apv/ZN012iv1I6vp7vuOkn+W1X9+jL7vlkWj+l6LQTqvarqThPK/WsW70f+tOV+cKiqZ2ZxJMINtNbOSHcv9SQ5tr8v9dI69k7yF1PavBCo3zNhX59K8v/1q0+qqkOX2dftkvz5lH1tiP66+YUZ3W9wv3aArcw11ABsVvv09y0eummSn0zXm/tf+9euTPLcEfU/Lckvpuuh+9s+dLwl3fWnByZ5RhaHw761tXbqMnUck67Hbbck762qE9Jd13pZkoOTPCuL1xX/eWttONQ8rbWrq+rYdPd+vmWST1bVS9L1oFe6+2X/QV/83CQHjPicq/XcdLdiuleS30t33+3XpLuF02V9++6e7h7HD003rHh4nfRp6Wbm3ifJC6tq/3Q/Wny7b/cx6Y73JzJ5WPnT040KuHmSv6+qw9Idnx+ku2Xas9INH/50JvcWr8Z7002gtmvftmWv+26tXVxVb0vyG+lm2H53Vb0i3QzZP5Gux/lR6YL3fSfs73fSzcp9kyQfqqr/le64XdV/lj9Md739/0n33bvepGL9MV0YLr7S9dMLnpzk4/1ne39V/UX/ea9K9zf+o3Qh998yYVj4wM2q6shVlPtqa+1DS15b+LHp2kz4IQBgS2qteXh4eHh4bIpHugDZ1vC4OMlDVlHXA1coc3CSr03Zx9uT3HRCmx+S5PtT6nh5khtNqOMZ6Xqwl3vvZemGAX+kX//IBhzblY7HzfvPu5pj/6Fl3n94uuH3K73nw+kC4cL6kRPa+oMJ9Tw/3QiF1v1TZl3fuX9a6fMsKXebdDOWr9Smf0gXHKcd48eluz/0cnVck+ToJG/s17+45L3H9q9/ZZWf7TfSBeiV9nVMkpP69fNXqOP8VX4fFh7vWqaOD/fb3jOvc4uHh4fHrB6GfAOwlVyd7p7OH0zXk/lTrbXRQ0hba59N8lPpegb/d7rb+Vyd5KIk70jy31prj2qtXTmhjvel64F9cbqexR+kCzFfTfLmJPdvrf1uW3lm6LTW/jzd/bTfke5HgquS/Ee6IeeHtNZOGfsZ16K1dklr7VFJ7p+ut/ZL6SbkujbdrOZnJnlFulmmH7zM+09L19P6pnTH8Jp0s2mfnuQJ6QLnZatox0fSBe9XpTsOV6frDT4lyX9trf3xOj7mUif2z4dV1e0ntOmb6Xp2X5JuePtV6Y7JR5M8prX2G1m8/ntFrbU3pDtGb05tkU4dAAAB60lEQVR3jK5O96POW5Mc2rrZ0W/RF//+krcvDPee1ju9sK9/SPej0d+tsK/XrKae9aiqfZM8oF995az3B7CjVWub6RaFAAA7Tn899OfSBfjntNZeNOcmparOTXKXJG9qrf3P/rWbpxs+v1u6URnvn2MTV62qnpPk+CRfTHL35h+ewE5GDzUAsG31Ae8P+9WnVtWke0nPXD+D+V361U8ONj0kXZi+JF2P/6bXTyD31H71+cI0sDMSqAGAba219s/pZvzeK93EYTNTVStOLNffi3xhGPZVuf79vC9Jd+34se369zLfzH4n3S3APpVumDnATscs3wAAXfh7VJJLZ7yf91fVeelmQP+/6a6TvmW6mc+fnOR2fbkXtsF9pvtr9bfaLacWfgR4h95pYGflGmoAgB2kqs5PcscpxV6Zrid6xYnsANgcBGoAgB2kv6/2w9PNfH27JHunm0X9G+nuG31ia+1f59dCANZCoAYAAIARTEoGAAAAIwjUAAAAMIJADQAAACMI1AAAADCCQA0AAAAjCNQAAAAwgkANAAAAIwjUAAAAMIJADQAAACMI1AAAADCCQA0AAAAjCNQAAAAwgkANAAAAIwjUAAAAMIJADQAAACMI1AAAADCCQA0AAAAjCNQAAAAwgkANAAAAI/z/lZQPHsea9yUAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Blood lead levels are log-normally distributed (an expected result...)\n", + "\n", + "ax = plt.subplot(111) \n", + "final_df['BLL'].plot.hist(bins = 30, rwidth=0.9, color = 'steelblue')\n", + "ax.spines[\"top\"].set_visible(False) \n", + "ax.spines[\"right\"].set_visible(False) \n", + "ax.get_xaxis().tick_bottom() \n", + "ax.get_yaxis().tick_left()\n", + "ax.set_ylabel('Frequency')\n", + "ax.set_xlabel('Blood lead (ug/dL)')\n", + "ax.set_title(\"Blood lead distribution\", fontsize = 11)\n", + "plt.tight_layout()\n", + "plt.savefig('BLL_dist.png', bbox_inches='tight', dpi = 300)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# See distribution of the scaled test scores\n", + "\n", + "fig, axs = plt.subplots(2, 2)\n", + "final_df['Math'].plot.hist(ax=axs[0,0], bins = 15, rwidth=0.9, color = 'steelblue')\n", + "final_df['Reading'].plot.hist(ax=axs[0,1], bins = 15, rwidth=0.9, color = 'steelblue')\n", + "final_df['Block'].plot.hist(ax=axs[1,0], bins = 15, rwidth=0.9, color = 'steelblue')\n", + "final_df['Digit'].plot.hist(ax=axs[1,1], bins = 15, rwidth=0.9, color = 'steelblue')\n", + "axs[0,0].set_ylabel('Frequency')\n", + "axs[0,1].set_ylabel('')\n", + "axs[1,0].set_ylabel('Frequency')\n", + "axs[1,1].set_ylabel('')\n", + "axs[1,0].set_xlabel('Blood Lead (ug/dL)')\n", + "axs[1,1].set_xlabel('Blood Lead (ug/dL)')\n", + "axs[0,0].set_title(\"Math\", fontsize = 8)\n", + "axs[0,1].set_title(\"Reading\", fontsize = 8)\n", + "axs[1,0].set_title(\"Block\", fontsize = 8)\n", + "axs[1,1].set_title(\"Digit\", fontsize = 8)\n", + "\n", + "for i in [0,1]:\n", + " for j in [0,1]:\n", + " axs[i,j].spines[\"top\"].set_visible(False)\n", + " axs[i,j].spines[\"right\"].set_visible(False)\n", + " axs[i,j].tick_params(axis='both', which='major', labelsize=6)\n", + "\n", + "fig.tight_layout(rect=[0, 0.03, 1, 0.95])\n", + "plt.suptitle(\"Distributions of scaled test scores\", fontsize = 10)\n", + "fig.savefig('test_dist.png', bbox_inches='tight', dpi = 300)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Perform causal inference" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "# Dictionary to store model results\n", + "results_dict = {}\n", + "\n", + "# Potential confounders\n", + "potential_confounders = [\n", + " 'Age', 'Sex_Male', 'Race_NH_Black', 'Race_NH_White', 'Race_Other', \n", + " 'Edu_HS', 'Edu_LT_HS', 'Smoke_Home_Yes', 'Baby_NICU_Yes', 'Food_Often_bad', 'Food_Sometimes_bad'\n", + "]\n", + "\n", + "\n", + "# Try the MATH model\n", + "math_gps = GPS(gps_family='normal', lower_grid_constraint = 0.0, upper_grid_constraint = 0.99, n_splines=10, verbose=False)\n", + "math_gps.fit(\n", + " T=final_df['BLL'], \n", + " X=final_df[potential_confounders], \n", + " y=final_df['Math']\n", + ")\n", + "\n", + "results_dict['math_CDRC'] = math_gps.calculate_CDRC()\n", + "\n", + "\n", + "# Try the READING model\n", + "reading_gps = GPS(gps_family='normal', lower_grid_constraint = 0.0, upper_grid_constraint = 0.99, n_splines=10, verbose=False)\n", + "\n", + "reading_gps.fit(\n", + " T=final_df['BLL'], \n", + " X=final_df[potential_confounders], \n", + " y=final_df['Reading']\n", + ")\n", + "\n", + "results_dict['reading_CDRC'] = reading_gps.calculate_CDRC()\n", + "\n", + "\n", + "\n", + "# Try the Block model\n", + "block_gps = GPS(gps_family='normal', lower_grid_constraint = 0.0, upper_grid_constraint = 0.99, n_splines=10, verbose=False)\n", + "\n", + "block_gps.fit(\n", + " T=final_df['BLL'], \n", + " X=final_df[potential_confounders], \n", + " y=final_df['Block']\n", + ")\n", + "\n", + "results_dict['block_CDRC'] = block_gps.calculate_CDRC()\n", + "\n", + "\n", + "\n", + "# Try the Digit model\n", + "digit_gps = GPS(gps_family='normal', lower_grid_constraint = 0.0, upper_grid_constraint = 0.99, n_splines=10, verbose=False)\n", + "\n", + "digit_gps.fit(\n", + " T=final_df['BLL'], \n", + " X=final_df[potential_confounders], \n", + " y=final_df['Digit']\n", + ")\n", + "\n", + "results_dict['digit_CDRC'] = digit_gps.calculate_CDRC()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Plot causal inference results" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "result_class = [['math_CDRC', 'reading_CDRC'], ['block_CDRC', 'digit_CDRC']]\n", + "\n", + "result_name = [['Math', 'Reading'], ['Block Design', 'Digit Spanning']]\n", + "\n", + "def plot_mean_and_CI(axs, i, j, treatment, mean, lb, ub, color_mean=None, color_shading=None):\n", + " # plot the shaded range of the confidence intervals\n", + " axs[i,j].fill_between(treatment, lb, ub, color=color_shading, alpha=0.3)\n", + " # plot the mean on top\n", + " axs[i,j].plot(treatment, mean, color_mean, linewidth=0.75)\n", + "\n", + "plt.rcParams['figure.dpi'] = 200\n", + "plt.rcParams['figure.figsize'] = [6, 5]\n", + "\n", + "fig, axs = plt.subplots(2, 2)\n", + "\n", + "for i in [0,1]:\n", + " for j in [0,1]:\n", + "\n", + " # Plotting quantities\n", + " treat = results_dict[result_class[i][j]]['Treatment']\n", + " mean = results_dict[result_class[i][j]]['CDRC']\n", + " lb = results_dict[result_class[i][j]]['Lower_CI']\n", + " ub = results_dict[result_class[i][j]]['Upper_CI']\n", + " plot_mean_and_CI(axs, i, j, treat, mean, lb, ub, color_mean='b', color_shading='b')\n", + "\n", + " # Labels\n", + " axs[0,0].set_ylabel('Scaled Test Score', fontsize = 8)\n", + " axs[0,1].set_ylabel('')\n", + " axs[1,0].set_ylabel('Scaled Test Score', fontsize = 8)\n", + " axs[1,1].set_ylabel('')\n", + " axs[1,0].set_xlabel('Blood Lead (ug/dL)', fontsize = 8)\n", + " axs[1,1].set_xlabel('Blood Lead (ug/dL)', fontsize = 8)\n", + "\n", + " axs[i,j].set_title(result_name[i][j], fontsize = 8)\n", + " axs[i,j].set_title(result_name[i][j], fontsize = 8)\n", + " axs[i,j].set_title(result_name[i][j], fontsize = 8)\n", + " axs[i,j].set_title(result_name[i][j], fontsize = 8)\n", + "\n", + " axs[i,j].spines[\"top\"].set_visible(False)\n", + " axs[i,j].spines[\"right\"].set_visible(False)\n", + "\n", + " axs[i,j].set_xlim(0, 10)\n", + " axs[i,j].set_ylim(0, 15)\n", + " \n", + " axs[i,j].tick_params(axis='both', which='major', labelsize=6)\n", + "\n", + "\n", + "fig.tight_layout(rect=[0, 0.03, 1, 0.95])\n", + "plt.suptitle(\"Test Performance Causal Curves (with 95% CIs)\", fontsize = 10)\n", + "fig.savefig('test_causal_curves.png', bbox_inches='tight', dpi = 300)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Exploring how BLLs mediate the relationship between income and cognitive outcomes" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Using the following params for the mediation analysis:\n", + "{ 'bootstrap_draws': 500,\n", + " 'bootstrap_replicates': 100,\n", + " 'lower_grid_constraint': 0.01,\n", + " 'max_iter': 100,\n", + " 'n_splines': 5,\n", + " 'random_seed': None,\n", + " 'spline_order': 3,\n", + " 'treatment_grid_num': 10,\n", + " 'upper_grid_constraint': 0.99,\n", + " 'verbose': True}\n", + "Beginning main loop through treatment bins...\n", + "***** Starting iteration 1 of 9 *****\n", + "***** Starting iteration 2 of 9 *****\n", + "***** Starting iteration 3 of 9 *****\n", + "***** Starting iteration 4 of 9 *****\n", + "***** Starting iteration 5 of 9 *****\n", + "***** Starting iteration 6 of 9 *****\n", + "***** Starting iteration 7 of 9 *****\n", + "***** Starting iteration 8 of 9 *****\n", + "***** Starting iteration 9 of 9 *****\n", + "\n", + "\n", + "Mean indirect effect proportion:\n", + " 0.1952 (0.1663 - 0.2295)\n", + " \n" + ] + } + ], + "source": [ + "med = Mediation(\n", + " bootstrap_draws=500,\n", + " bootstrap_replicates=100,\n", + " spline_order=3,\n", + " n_splines=5,\n", + " verbose=True,\n", + ")\n", + "\n", + "med.fit(\n", + " T=final_df[\"PIR\"],\n", + " M=final_df[\"BLL\"],\n", + " y=final_df[\"Math\"],\n", + ")\n", + "\n", + "med_results = med.calculate_mediation(ci = 0.95)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "# Use cubic interpolation to create plot of relationship between poverty-income ratio and the proportion of mediation by BLLs\n", + "f = interp1d(med_results['Treatment_Value'], med_results['Proportion_Indirect_Effect'], kind='cubic')\n", + "PIR_grid = np.linspace(0.23, 3.10, num=100, endpoint=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "ax = plt.subplot(111) \n", + "ax.plot(PIR_grid, f(PIR_grid), color = 'steelblue')\n", + "ax.spines[\"top\"].set_visible(False) \n", + "ax.spines[\"right\"].set_visible(False) \n", + "ax.get_xaxis().tick_bottom() \n", + "ax.get_yaxis().tick_left()\n", + "ax.set_ylabel('Proportion Indirect Effect', fontsize = 8)\n", + "ax.set_xlabel('Poverty to Income Ratio', fontsize = 8)\n", + "ax.set_ylim(0,1)\n", + "ax.set_title(\"Mediation effect of blood lead on PIR\", fontsize = 10)\n", + "ax.tick_params(axis='both', which='major', labelsize=8)\n", + "plt.savefig('mediation_curve.png', bbox_inches='tight', dpi = 300)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "ADRF", + "language": "python", + "name": "adrf" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.6" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/imgs/full_example/BLL_dist.png b/imgs/full_example/BLL_dist.png new file mode 100644 index 0000000..382a6db Binary files /dev/null and b/imgs/full_example/BLL_dist.png differ diff --git a/imgs/full_example/lead_paint_can.jpeg b/imgs/full_example/lead_paint_can.jpeg new file mode 100644 index 0000000..d72283a Binary files /dev/null and b/imgs/full_example/lead_paint_can.jpeg differ diff --git a/imgs/full_example/mediation_curve.png b/imgs/full_example/mediation_curve.png new file mode 100644 index 0000000..d2f6361 Binary files /dev/null and b/imgs/full_example/mediation_curve.png differ diff --git a/imgs/full_example/test_causal_curves.png b/imgs/full_example/test_causal_curves.png new file mode 100644 index 0000000..62bde1f Binary files /dev/null and b/imgs/full_example/test_causal_curves.png differ diff --git a/imgs/full_example/test_dist.png b/imgs/full_example/test_dist.png new file mode 100644 index 0000000..b9a1c13 Binary files /dev/null and b/imgs/full_example/test_dist.png differ diff --git a/paper/paper.bib b/paper/paper.bib new file mode 100644 index 0000000..12c9f85 --- /dev/null +++ b/paper/paper.bib @@ -0,0 +1,61 @@ + + +@book{Galagate:2016, + Adsurl = {https://drum.lib.umd.edu/handle/1903/18170}, + Author = {{Galagate}, D.}, + Title = {Causal Inference with a Continuous Treatment and Outcome: Alternative Estimators for Parametric Dose-Response function with Applications.}, + Booktitle = {Causal Inference with a Continuous Treatment and Outcome: Alternative Estimators for Parametric Dose-Response function with Applications.}, + Publisher = {Digital Repository at the University of Maryland}, + Year = 2016 +} + +@article{Moodie:2010, + author = {{Moodie}, E. and {Stephen}, D.}, + title = "{Estimation of dose–response functions for longitudinal data using the generalised propensity score.}", + journal = {Statistical Methods in Medical Research}, + year = 2010, + volume = 21, + doi = {10.1177/0962280209340213}, +} + +@book{Hirano:2004, + Author = {{Hirano}, K. and {Imbens}, G.}, + Booktitle = {Applied bayesian modeling and causal inference from incomplete-data perspectives, by Gelman A and Meng XL. ~Published by Wiley, Oxford, UK.}, + Publisher = {Wiley}, + Title = {{The propensity score with continuous treatments}}, + Year = 2004 +} + +@article{van_der_Laan:2010, + author = {{van der Laan}, M. and {Gruber}, S.}, + title = "{Collaborative double robust penalized targeted maximum likelihood estimation.}", + journal = {The International Journal of Biostatistics}, + year = 2010, + volume = 6, + doi = {10.2202/1557-4679.1181}, +} + +@article{van_der_Laan:2006, + author = {{van der Laan}, M. and {Rubin}, D.}, + title = "{Targeted maximum likelihood learning.}", + journal = {The International Journal of Biostatistics}, + year = 2006, + volume = 2, +} + +@article{Imai:2010, + author = {{Imai}, K., {Keele}, L., and {Tingley}, D.}, + title = "{A General Approach to Causal Mediation Analysis.}", + journal = {Psychological Methods}, + year = 2010, + volume = 15, + doi = {10.1037/a0020761} +} + +@book{Hernán:2020, + Author = {{Hernán}, M. and {Robins}, J.}, + Booktitle = {Causal Inference: What If.}, + Publisher = {Chapman & Hall}, + Title = {{Causal Inference: What If.}}, + Year = 2020 +} diff --git a/paper/paper.md b/paper/paper.md new file mode 100644 index 0000000..7a4b647 --- /dev/null +++ b/paper/paper.md @@ -0,0 +1,123 @@ +--- +title: 'causal-curve: A Python Causal Inference Package to Estimate Causal Dose-Response Curves' +tags: + - Python + - causal inference + - causality + - machine learning + +authors: + - name: Roni W. Kobrosly^[Custom footnotes for e.g. denoting who the corresspoinding author is can be included like this.] + orcid: 0000-0003-0363-9662 + affiliation: "1, 2" # (Multiple affiliations must be quoted) +affiliations: + - name: Department of Environmental Medicine and Public Health, Icahn School of Medicine at Mount Sinai, New York, NY, USA + index: 1 + - name: Flowcast, 44 Tehama St, San Francisco, CA, USA + index: 2 +date: 1 July 2020 +bibliography: paper.bib + +--- + +# Summary + +In academia and industry, randomized controlled experiments (colloquially "A/B tests") +are considered the gold standard approach for assessing the impact of a treatment or intervention. +However, for ethical or financial reasons, these experiments may not always be feasible to carry out. +"Causal inference" methods are a set of approaches that attempt to estimate causal effects +from observational rather than experimental data, correcting for the biases that are inherent +to analyzing observational data (e.g. confounding and selection bias) [@Hernán:2020]. + +Although much significant research and implementation effort has gone towards methods in +causal inference to estimate the effects of binary treatments (e.g. did the population receive +treatment "A" or "B"), much less has gone towards estimating the effects of continuous treatments. +This is unfortunate because there are there are a large number of use cases in research +and industry that could benefit from tools to estimate the effect of +continuous treatments, such as estimating how: + +- the number of minutes per week of aerobic exercise causes positive health outcomes, +after controlling for confounding effects. +- increasing or decreasing the price of a product would impact demand (price elasticity). +- changing neighborhood income inequality (as measured by the continuous Gini index) +might or might not be causally related to the neighborhood crime rate. +- blood lead levels are causally related to neurodevelopment delays in children. + +`causal-curve` is a Python package created to address this gap; it is designed to perform +causal inference when the treatment of interest is continuous in nature. +From the observational data that is provided by the user, it estimates the +"causal dose-response curve" (or simply the "causal curve"). + +In the current release of the package there are two unique model classes for +constructing the causal dose-response curve: the Generalized Propensity Score (GPS) and the +Targetted Maximum Likelihood Estimation (TMLE) tools. There is also tool +to assess causal mediation effects in the presence of a continuous mediator and treatment. + +`causal-curve` attempts to make the user-experience as painless as possible: + +- This package's API was designed to resemble that of `scikit-learn`, as this is a commonly +used Python predictive modeling framework that most machine learning practioners are familiar with. +- All of the major classes contained in `causal-curve` readily use Pandas DataFrames and Series as +inputs, to make this package more easily integrate with the standard Python data analysis tools. +- A full, end-to-end example of applying the package to a causal inference problem (the analysis of health data) +is provided. In addition to this, there are shorter tutorials for each of the three major classes are available online in the documentation, along with full documentation of all of their parameters, methods, and attributes. + +This package includes a suite of unit and integration tests made using the pytest framework. The +repo containing the latest project code is integrated with TravisCI for continuous integration. Code +coverage is monitored via codecov and is presently above 90%. + + +# Methods + +The `GPS` method was originally described by Hirano [@Hirano:2004], +and expanded by Moodie [@Moodie:2010] and more recently by Galagate [@Galagate:2016]. GPS is +an extension of the standard propensity tool method. It is the treatment assignment density calculated +at a particular treatment (and covariate) value. Similar to the standard propensity score approach, +the GPS random variable is used to balance covariates. At the core of this tool, generalized linear +models are used to estimate the GPS, and generalized additive models are used to estimate the +final causal curve. Compared with the package’s TMLE method, +this GPS method is more computationally efficient, better suited for large datasets, +but produces significantly wider confidence intervals. + + +![Example of a causal curve generated by the GPS tool.\label{fig:example}](welcome_plot.png) + + +The `TMLE` method is based on van der Laan's work on an approach to causal inference that would +employ powerful machine learning approaches to estimate a causal effect [@van_der_Laan:2010] [@van_der_Laan:2006]. +TMLE involves, predicting the outcome from the treatment and covariates using a machine learning model, +then predicting treatment assignment from the covariates, and employs a substitution “targeting” +step correct for covariate imbalance and to estimate an unbiased causal effect. +Currently, there is no implementation of TMLE that is suitable for continuous treatments, so the +implemention in `causal-curve` constructs as series of binary treatment comparisons across the +user-specified range of treatment values, and then connects these binary estimates to construct +the final causal curve. Compared with the package’s GPS method, this TMLE method is double robust +against model misspecification, incorporates more powerful machine learning techniques internally, produces significantly +smaller confidence intervals, however it is less computationally efficient. + +`causal-curve` allows for continuous mediation assessment with the `Mediation` tool. As described +by Imai this approach provides a general approach to mediation analysis that invokes the +potential outcomes / counterfactual framework [@Imai:2010]. While this approach can handle a +continuous mediator and outcome, as put forward by Imai it only allows for a binary treatment. As +mentioned above with the `TMLE` approach, the tool creates a series of binary treatment comparisons +and connects them to show the user how mediation varies as a function of the treatment. An interpretable, +overall mediation percentage is provided as well. + + +# Statement of Need + +While there are a few established Python packages related to causal inference, to the best of +the author's knowledge, there is no Python package available that can provide support for +continuous treatments as `causal-curve` does. Similarly, the author isn't aware of any Python +implementation of a causal mediation analysis for continuous treatments and mediators. Finally, +the tutorials available in the documentation introduce the concept of continuous treatments +and are instructive as to how the results of their analysis should be interpretted. + + +# Acknowledgements + +We acknowledge contributions from Miguel-Angel Luque, Erica Moodie, and Mark van der Laan +during the creation of this project. + + +# References diff --git a/paper/welcome_plot.png b/paper/welcome_plot.png new file mode 100644 index 0000000..ca5a59a Binary files /dev/null and b/paper/welcome_plot.png differ diff --git a/setup.py b/setup.py index 1c15218..b05d47c 100644 --- a/setup.py +++ b/setup.py @@ -5,7 +5,7 @@ setuptools.setup( name="causal-curve", - version="0.2.4", + version="0.3.0", author="Roni Kobrosly", author_email="roni.kobrosly@gmail.com", description="A python library with tools to perform causal inference using \