predict_us-ltcf-covid-19.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# The Predictability of COVID-19 Cases in US Nursing Homes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The focus of this project is to identify factors that cause COVID-19 outbreaks in nursing homes and to provide an exemplary concept for the application of the findings using machine learning algorithms to allow future research to derive appropriate countermeasures for practice."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1 Import Python Libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ignoring all warnings\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "from numpy import mean, std\n",
    "import pandas as pd\n",
    "\n",
    "import datetime\n",
    "import ipywidgets as widgets\n",
    "import missingno as msno\n",
    "\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from sklearn.preprocessing import LabelEncoder, StandardScaler\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.svm import SVC\n",
    "from sklearn.naive_bayes import GaussianNB\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn.ensemble import RandomForestClassifier, StackingClassifier\n",
    "\n",
    "import tensorflow as tf\n",
    "from tensorflow import keras\n",
    "from keras.models import Sequential\n",
    "from keras.layers import Dense, Dropout\n",
    "\n",
    "from sklearn import metrics\n",
    "from sklearn.model_selection import GridSearchCV, cross_val_score, KFold\n",
    "from sklearn.metrics import confusion_matrix, precision_score, recall_score, precision_recall_curve\n",
    "from sklearn.metrics import roc_curve, roc_auc_score, f1_score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Adjusting the visualisation settings of Pandas\n",
    "pd.options.display.float_format = \"{:.4f}\".format\n",
    "pd.set_option('display.max_columns', 50)\n",
    "\n",
    "# Calling one of IPython's predefined ‘magic functions’ to include matplotlib graphs in notebook\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2 Load Data Sets with Pre-selected Features into Pandas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.1 Provider Info"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "General information on currently active nursing homes, including number of certified beds, quality measure scores, staffing and other information used in the Five-Star Rating System. Data are presented as one row per nursing home.\n",
    "\n",
    "Data Retreived: August 20, 2020\n",
    "\n",
    "Source: https://data.medicare.gov/Nursing-Home-Compare/Provider-Info/4pq5-n9py"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_nh = pd.read_csv(\"01_Original Data/Provider_Info.csv\",usecols=['Federal Provider Number',\n",
    "                                                                  'Provider Zip Code',\n",
    "                                                                  'Ownership Type',\n",
    "                                                                  'Date First Approved to Provide Medicare and Medicaid services',\n",
    "                                                                  'Overall Rating', \n",
    "                                                                  'Reported RN Staffing Hours per Resident per Day',\n",
    "                                                                  'Reported Total Nurse Staffing Hours per Resident per Day',\n",
    "                                                                  'Total Amount of Fines in Dollars'])\n",
    "\n",
    "df_nh.rename(columns={'Federal Provider Number':'provider_number',\n",
    "                      'Provider Zip Code':'zip_code',\n",
    "                      'Ownership Type':'ownership',\n",
    "                      'Overall Rating':'rating',\n",
    "                      'Total Amount of Fines in Dollars':'total_fine',\n",
    "                      'Reported RN Staffing Hours per Resident per Day':'rn_staff',\n",
    "                      'Reported Total Nurse Staffing Hours per Resident per Day':'total_staff',\n",
    "                      'Date First Approved to Provide Medicare and Medicaid services':'approved_date'},inplace=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2 COVID-19 Nursing Home Data Set"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The Nursing Home COVID-19 Public File includes data reported by nursing homes to the CDC’s National Healthcare Safety Network (NHSN) system COVID-19 Long Term Care Facility Module, including Resident Impact, Facility Capacity, Staff & Personnel, and Supplies & Personal Protective Equipment, and Ventilator Capacity and Supplies Data Elements.\n",
    "\n",
    "Data Retreived: August 20, 2020\n",
    "\n",
    "Source: https://data.cms.gov/Special-Programs-Initiatives-COVID-19-Nursing-Home/COVID-19-Nursing-Home-Dataset/s2uc-8wxp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_nh_covid = pd.read_csv(\"01_Original Data/COVID-19_Nursing_Home_Dataset.csv\",usecols=['Week Ending',\n",
    "                                                                                        'Passed Quality Assurance Check',\n",
    "                                                                                        'Federal Provider Number',\n",
    "                                                                                        'Residents Total Confirmed COVID-19',\n",
    "                                                                                        'Residents Total COVID-19 Deaths',\n",
    "                                                                                        'Number of All Beds',\n",
    "                                                                                        'Total Number of Occupied Beds',\n",
    "                                                                                        'Staff Total Confirmed COVID-19',\n",
    "                                                                                        'Staff Total COVID-19 Deaths'])\n",
    "\n",
    "df_nh_covid.rename(columns={'Federal Provider Number':'provider_number',\n",
    "                            'Residents Total Confirmed COVID-19':'total_inf_res',\n",
    "                            'Residents Total COVID-19 Deaths':'total_inf_staff',\n",
    "                            'Staff Total Confirmed COVID-19':'total_deaths_res',\n",
    "                            'Staff Total COVID-19 Deaths':'total_deaths_staff',\n",
    "                            'Number of All Beds':'total_beds',\n",
    "                            'Total Number of Occupied Beds':'occupied_beds'},inplace=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.3 Deficiencies Displayed on Nursing Home Compare"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A list of all health deficiencies currently listed on Nursing Home Compare including the most recent comprehensive inspection and the most recent 36 months of complaint inspections.\n",
    "\n",
    "Data Retreived: August 20, 2020\n",
    "\n",
    "Source: https://data.medicare.gov/Nursing-Home-Compare/Deficiencies-Displayed-on-Nursing-Home-Compare-Cyc/np3k-uatv\n",
    "\n",
    "Source: https://data.medicare.gov/Nursing-Home-Compare/Deficiencies-Displayed-on-Nursing-Home-Compare-Cyc/3j8m-gmpk\n",
    "\n",
    "Source: https://data.medicare.gov/Nursing-Home-Compare/Deficiencies-Displayed-on-Nursing-Home-Compare-Cyc/7gue-kitf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_def1 = pd.read_csv(\"01_Original Data/Deficiencies_Cycle_1.csv\",usecols=['Federal Provider Number', \n",
    "                                                                           'Scope Severity Code',\n",
    "                                                                           'Deficiency Description'])\n",
    "\n",
    "df_def2 = pd.read_csv(\"01_Original Data/Deficiencies_Cycle_2.csv\",usecols=['Federal Provider Number', \n",
    "                                                                           'Scope Severity Code',\n",
    "                                                                           'Deficiency Description'])\n",
    "\n",
    "df_def3 = pd.read_csv(\"01_Original Data/Deficiencies_Cycle_3.csv\",usecols=['Federal Provider Number', \n",
    "                                                                           'Scope Severity Code',\n",
    "                                                                           'Deficiency Description'])\n",
    "\n",
    "df_def1.rename(columns={'Federal Provider Number':'provider_number'},inplace=True)\n",
    "df_def2.rename(columns={'Federal Provider Number':'provider_number'},inplace=True)\n",
    "df_def3.rename(columns={'Federal Provider Number':'provider_number'},inplace=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.4 LTCFocus.org Data Set"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "LTCFocus.org is a product of the Shaping Long-Term Care in America Project being conducted at the Brown University Center for Gerontology and Healthcare Research and supported, in part, by the National Institute on Aging. The website hosts data regarding the health and functional status of nursing home residents, characteristics of care facilities, state policies relevant to long term care services and financing, and data characterizing the markets in which facilities exist and, in the future, we plan to expand to include information about other sectors of the long-term care system.\n",
    "\n",
    "Data Retreived: August 20, 2020\n",
    "\n",
    "Source: http://ltcfocus.org/download/13f2aa4c-7145-7b6c-f2ad-dc8e59bf86d9"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_res = pd.read_csv(\"01_Original Data/facility_2017.csv\",delimiter=';',usecols=['PROV1680',\n",
    "                                                                                 'state',\n",
    "                                                                                 'county',\n",
    "                                                                                 'paymcaid',\n",
    "                                                                                 'multifac',\n",
    "                                                                                 'pctwhite_2011p'])\n",
    "\n",
    "df_res.rename(columns={'PROV1680':'provider_number'},inplace=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.5 USAFacts.org County-level Tracker"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The county-level tracker makes it easy to follow COVID-19 cases on a granular level, as does the ability to break down infections per 100,000 people.\n",
    "\n",
    "Data Last Updated: August 20, 2020\n",
    "\n",
    "Source: https://usafacts.org/visualizations/coronavirus-covid-19-spread-map/Source: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_county_cases = pd.read_csv(\"01_Original Data/covid_confirmed_usafacts.csv\")\n",
    "\n",
    "df_county_deaths = pd.read_csv(\"01_Original Data/covid_deaths_usafacts.csv\")\n",
    "\n",
    "df_county_population = pd.read_csv(\"01_Original Data/covid_county_population_usafacts.csv\",usecols=['countyFIPS',\n",
    "                                                                                                    'population'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.6 Two-Digit State Code Listing (manually created) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Geographic Reference Files are documents that list codes for geographic entities.\n",
    "\n",
    "Data Retreived: August 20, 2020\n",
    "\n",
    "Based on: https://www.census.gov/data/datasets/1997/econ/gus/gidstate.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_county_key1 = pd.read_excel(\"01_Original Data/state_code.xlsx\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.7 US Zipcodes to County State (manually created)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Databases of U.S. zip codes and their associated county code.\n",
    "\n",
    "Data Retreived: August 20, 2020\n",
    "\n",
    "Based on: https://www2.census.gov/geo/docs/reference/codes/files/national_county.txt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "zip_to_county = pd.read_excel(\"01_Original Data/zip_to_county.xlsx\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.8 SSA and FIPS County Codes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "CMS periodically produces SSA to FIPS state and county crosswalk files. Some CMS data files have SSA state and county codes or county name rather than FIPS state and county codes. The data files below are processed to be easier for SAS and Stata use.\n",
    "\n",
    "Data Retreived: August 20, 2020\n",
    "\n",
    "Source: http://data.nber.org/data/ssa-fips-state-county-crosswalk.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_county_key2 = pd.read_excel(\"01_Original Data/FY 2017 FR Cty CBSA Xwalk and CBSA Con Cty.xlsx\",\n",
    "                               usecols=['FIPS State county code',\n",
    "                                        'CBSA (Blanks are Rural)'])\n",
    "\n",
    "df_county_key2.rename(columns={'FIPS State county code':'fips',\n",
    "                               'CBSA (Blanks are Rural)':'cbsa_code'},inplace=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3 Data Pre-Processing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.1 COVID-19 Nursing Home Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "fb374fc1b7024be8be6a93a5bb2a7552",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Dropdown(options=(datetime.date(2020, 8, 2), datetime.date(2020, 7, 26), datetime.date(2020, 7, 19), datetime.…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Converting the column Week Ending in a date format\n",
    "df_nh_covid['Week Ending'] = pd.to_datetime(df_nh_covid['Week Ending']).dt.date\n",
    "\n",
    "# Selecting the most recent date\n",
    "max_date_filter = df_nh_covid['Week Ending'].max()\n",
    "\n",
    "# Filtering LTC facilities out that did not pass the quality assuance check\n",
    "df_nh_covid = df_nh_covid[df_nh_covid['Passed Quality Assurance Check']=='Y']\n",
    "\n",
    "# Assigning the most recent date as a default for the dropdown function\n",
    "new_date = max_date_filter\n",
    "\n",
    "# Creating a dropdown function which allows to select a range of available dates\n",
    "dropdown_date = widgets.Dropdown(options=sorted(df_nh_covid['Week Ending'].unique(),reverse=True))\n",
    "\n",
    "input_date_filter = widgets.Output()\n",
    "\n",
    "def dropdown_date_eventhandler(change):\n",
    "    input_date_filter.clear_output()\n",
    "    with input_date_filter:\n",
    "        if (change.new==new_date):\n",
    "            display(max_date_filter)\n",
    "        else:\n",
    "            display(change.new)\n",
    "\n",
    "dropdown_date.observe(dropdown_date_eventhandler,names='value')\n",
    "\n",
    "display(dropdown_date)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Keeping only the data entries with the selected date (by default the most recent date)\n",
    "date_selected = dropdown_date.value\n",
    "df_nh_covid = df_nh_covid[df_nh_covid['Week Ending']==date_selected]\n",
    "\n",
    "# Dropping the columns 'Week Ending' and 'Passed Quality Assurance Check'\n",
    "df_nh_covid= df_nh_covid.drop(['Week Ending','Passed Quality Assurance Check'],axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2 Deficiencies Displayed on Nursing Home Compare"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Merging the three deficiencies tables into one new data frame\n",
    "df_def = df_def1.append(df_def2)\n",
    "df_def = df_def.append(df_def3)\n",
    "\n",
    "# Deleting the old data frames\n",
    "del df_def1,df_def2,df_def3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Categorising the severity codes into federal and serious federal deficiencies\n",
    "df_def.loc[df_def['Scope Severity Code'].isin(['B','C','D','E','F']),'fed_def'] = 1\n",
    "df_def.loc[df_def['Scope Severity Code'].isin(['G','H','I','J','K']),'serious_fed_def'] = 1\n",
    "\n",
    "# Creating a new deficiency type for implementing appropriate infection prevention measures based the deficiency description\n",
    "df_def.loc[df_def['Deficiency Description'].isin([\n",
    "    'Provide and implement an infection prevention and control program.']),'infection_def'] = 1\n",
    "\n",
    "df_def = df_def[df_def['Scope Severity Code'].isin(['B','C','D','E','F','G','H','I','J','K'])]\n",
    "\n",
    "# Grouping the number of deficiencies bye nursing homes \n",
    "df_def = df_def.groupby(['provider_number'])[['fed_def','serious_fed_def','infection_def']].sum().reset_index()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.3 LTCFocus.org Data Set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Attaching the state_code to the LTCFocus.org Data Set\n",
    "df_res = pd.merge(df_res,df_county_key1,how='inner',on='state')\n",
    "\n",
    "# Converting the county and state_code columns into three and two character long strings\n",
    "df_res['county'] = df_res['county'].apply(lambda x: '{0:0>3}'.format(x))\n",
    "df_res['state_code'] = df_res['state_code'].apply(lambda x: '{0:0>2}'.format(x))\n",
    "df_res['state_code'] = df_res['state_code'].astype(str)\n",
    "df_res['county'] = df_res['county'].astype(str)\n",
    "\n",
    "# Combining the two columns into a new column county_code\n",
    "df_res['county_code'] = df_res['state_code'] + df_res['county']\n",
    "\n",
    "# Dropping the old columns\n",
    "df_res = df_res.drop(['state','county','state_code'],axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.4 USAFacts.org County-level Tracker"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Converting date format from dropdown function into the same format as the columns in the county cases and deaths data sets\n",
    "timestampStr = date_selected.strftime('X%m/X%d/%y').replace('X0','X').replace('X','')\n",
    "\n",
    "# Keeping only the county cases and deaths from the date selected in the dropdown\n",
    "df_county_cases.drop(df_county_cases.columns.difference(['countyFIPS',\n",
    "                                                         timestampStr]),1,inplace=True)\n",
    "df_county_deaths.drop(df_county_deaths.columns.difference(['countyFIPS',\n",
    "                                                           timestampStr]),1,inplace=True)\n",
    "\n",
    "# Dropping unallocated cases and deaths as they can not be assigned to a specific county\n",
    "df_county_cases = df_county_cases[df_county_cases['countyFIPS']!=0]\n",
    "df_county_population = df_county_population[df_county_population['countyFIPS']!=0]\n",
    "df_county_deaths = df_county_deaths[df_county_deaths['countyFIPS']!=0]\n",
    "\n",
    "# Merging the three County-level Tracker tables into one new data frame\n",
    "df_county_combined = pd.merge(df_county_population,df_county_cases,how='left',on=['countyFIPS'])\n",
    "df_county_combined = pd.merge(df_county_combined,df_county_deaths,how='left',on=['countyFIPS'])\n",
    "\n",
    "# Renaming the columns in the newly created data frame\n",
    "df_county_combined.columns = ['countyFIPS',\n",
    "                              'population',\n",
    "                              'confirmed',\n",
    "                              'deaths']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4 Data Mapping"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Taking the Provider Info data frame as basis for further processing \n",
    "df_merged = df_nh.copy()\n",
    "\n",
    "# Mapping the COVID-19 Nursing Home data set to the newly created data frame\n",
    "df_merged = pd.merge(df_merged,df_nh_covid[['provider_number',\n",
    "                                            'total_inf_res',\n",
    "                                            'total_inf_staff',\n",
    "                                            'total_beds',\n",
    "                                            'occupied_beds',\n",
    "                                            'total_deaths_res',\n",
    "                                            'total_deaths_staff']]\n",
    "                   ,how='left',on=['provider_number'])\n",
    "\n",
    "# Rounding the reported staffing hours per resident per days \n",
    "df_merged['rn_staff'] = (df_merged['rn_staff']).round(2)\n",
    "df_merged['total_staff'] = (df_merged['total_staff']).round(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Mapping the Deficiencies Displayed on Nursing Home Compare data set to the newly created data frame\n",
    "df_merged = pd.merge(df_merged,df_def,how='left',on=['provider_number'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Mapping the LTCFocus.org data set to the newly created data frame\n",
    "df_merged = pd.merge(df_merged,df_res[['provider_number',\n",
    "                                       'paymcaid',\n",
    "                                       'multifac',\n",
    "                                       'pctwhite_2011p',\n",
    "                                       'county_code']]\n",
    "                   ,how='left',on=['provider_number'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Converting the county_code column to numeric values\n",
    "df_merged['county_code'] = pd.to_numeric(df_merged['county_code'],errors='coerce')\n",
    "\n",
    "# Mapping the SSA and FIPS County Codes data set to the newly created data frame\n",
    "df_merged = pd.merge(df_merged,df_county_key2,how='left',left_on=['county_code'],right_on=['fips'])\n",
    "\n",
    "# Dropping the fips column\n",
    "df_merged = df_merged.drop(['fips'],axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Mapping the USAFacts.org County-level Tracker data set to the newly created data frame\n",
    "df_merged = pd.merge(df_merged,df_county_combined[['countyFIPS',\n",
    "                                                   'population',\n",
    "                                                   'confirmed',\n",
    "                                                   'deaths']]\n",
    "                   ,how='left',left_on=['county_code'],right_on=['countyFIPS'])\n",
    "\n",
    "# Dropping the countyFIPS column\n",
    "df_merged = df_merged.drop(['countyFIPS'],axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5 Data Preparation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.1 Missing Value Treatment"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 5.1.1 Identify Missing Values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x2285ab16748>"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1728x720 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Illustrating the missing values in each column\n",
    "msno.bar(df_merged)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "provider_number          0\n",
       "zip_code                 0\n",
       "ownership                0\n",
       "approved_date            0\n",
       "rating                 199\n",
       "rn_staff               492\n",
       "total_staff            492\n",
       "total_fine               0\n",
       "total_inf_res         1151\n",
       "total_inf_staff       1151\n",
       "total_beds            1250\n",
       "occupied_beds         1161\n",
       "total_deaths_res      1151\n",
       "total_deaths_staff    1151\n",
       "fed_def                161\n",
       "serious_fed_def        161\n",
       "infection_def          161\n",
       "paymcaid               959\n",
       "multifac               959\n",
       "pctwhite_2011p         959\n",
       "county_code            959\n",
       "cbsa_code             6997\n",
       "population            2087\n",
       "confirmed             2087\n",
       "deaths                2087\n",
       "dtype: int64"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Printing the number of missing entries for each column\n",
    "df_merged.isnull().sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "provider_number        object\n",
       "zip_code                int64\n",
       "ownership              object\n",
       "approved_date          object\n",
       "rating                float64\n",
       "rn_staff              float64\n",
       "total_staff           float64\n",
       "total_fine              int64\n",
       "total_inf_res         float64\n",
       "total_inf_staff       float64\n",
       "total_beds            float64\n",
       "occupied_beds          object\n",
       "total_deaths_res      float64\n",
       "total_deaths_staff    float64\n",
       "fed_def               float64\n",
       "serious_fed_def       float64\n",
       "infection_def         float64\n",
       "paymcaid              float64\n",
       "multifac               object\n",
       "pctwhite_2011p         object\n",
       "county_code           float64\n",
       "cbsa_code             float64\n",
       "population            float64\n",
       "confirmed             float64\n",
       "deaths                float64\n",
       "dtype: object"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Printing the data types of each column\n",
    "df_merged.dtypes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 5.1.2 Overall Rating (Provider Info)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "199\n"
     ]
    }
   ],
   "source": [
    "# Creating a new data frame with only missing values in the respective column \n",
    "no_rating = df_merged.copy()\n",
    "no_rating = no_rating[(no_rating['rating'].isnull())]\n",
    "\n",
    "# Removing the above used entries from the main data frame\n",
    "df_merged = df_merged[~df_merged['provider_number'].isin(no_rating['provider_number'])]\n",
    "\n",
    "# Filling the missing values in the no_rating data frame with the median of the respective value from the main data frame\n",
    "rating_median = df_merged['rating'].median()\n",
    "no_rating['rating'] = no_rating['rating'].fillna(rating_median)\n",
    "\n",
    "# Adding the filled data frame to the main data frame\n",
    "df_merged = df_merged.append(no_rating)\n",
    "\n",
    "# Rounding the column rating to convert it from a float to an integer\n",
    "df_merged['rating'] = df_merged['rating'].round()\n",
    "\n",
    "# Printing the number of entries the applied method filled\n",
    "print(no_rating.rating.notnull().sum())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 5.1.3 Reported RN Staffing Hours per Resident per Day (Provider Info)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "492\n"
     ]
    }
   ],
   "source": [
    "# Creating a new data frame with only missing values in the respective column \n",
    "no_rn_staff = df_merged.copy()\n",
    "no_rn_staff = no_rn_staff[(no_rn_staff['rn_staff'].isnull())]\n",
    "\n",
    "# Removing the above used entries from the main data frame\n",
    "df_merged = df_merged[~df_merged['provider_number'].isin(no_rn_staff['provider_number'])]\n",
    "\n",
    "# Filling the missing values in the rn_staff data frame with the median of the respective value from the main data frame\n",
    "rn_staff_median = df_merged['rn_staff'].median()\n",
    "no_rn_staff['rn_staff'] = no_rn_staff['rn_staff'].fillna(rn_staff_median)\n",
    "\n",
    "# Adding the filled data frame to the main data frame\n",
    "df_merged = df_merged.append(no_rn_staff)\n",
    "\n",
    "# Printing the number of entries the applied method filled\n",
    "print(no_rn_staff.rn_staff.notnull().sum())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 5.1.4 Reported Total Nurse Staffing Hours per Resident per Day (Provider Info)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "492\n"
     ]
    }
   ],
   "source": [
    "# Creating a new data frame with only missing values in the respective column \n",
    "no_total_staff = df_merged.copy()\n",
    "no_total_staff = no_total_staff[(no_total_staff['total_staff'].isnull())]\n",
    "\n",
    "# Removing the above used entries from the main data frame\n",
    "df_merged = df_merged[~df_merged['provider_number'].isin(no_total_staff['provider_number'])]\n",
    "\n",
    "# Filling the missing values in the total_staff data frame with the median of the respective value from the main data frame\n",
    "total_staff_median = df_merged['total_staff'].median()\n",
    "no_total_staff['total_staff'] = no_total_staff['total_staff'].fillna(total_staff_median)\n",
    "\n",
    "# Adding the filled data frame to the main data frame\n",
    "df_merged = df_merged.append(no_total_staff)\n",
    "\n",
    "# Printing the number of entries the applied method filled\n",
    "print(no_total_staff.total_staff.notnull().sum())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 5.1.5 Number of All Beds (COVID-19 Nursing Home Dataset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1250\n"
     ]
    }
   ],
   "source": [
    "# Creating a new data frame with only missing values in the respective column \n",
    "no_total_beds = df_merged.copy()\n",
    "no_total_beds = no_total_beds[(no_total_beds['total_beds'].isnull())]\n",
    "\n",
    "# Removing the above used entries from the main data frame\n",
    "df_merged = df_merged[~df_merged['provider_number'].isin(no_total_beds['provider_number'])]\n",
    "\n",
    "# Filling the missing values in the total_beds data frame with the median of the respective value from the main data frame\n",
    "total_beds_median = df_merged['total_beds'].median()\n",
    "no_total_beds['total_beds'] = no_total_beds['total_beds'].fillna(total_beds_median)\n",
    "\n",
    "# Adding the filled data frame to the main data frame\n",
    "df_merged = df_merged.append(no_total_beds)\n",
    "\n",
    "# Printing the number of entries the applied method filled\n",
    "print(no_total_beds.total_beds.notnull().sum())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 5.1.6 Total Number of Occupied Beds (COVID-19 Nursing Home Dataset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1162\n"
     ]
    }
   ],
   "source": [
    "# Converting the column occupied_beds from an object to numeric values\n",
    "df_merged['occupied_beds'] = pd.to_numeric(df_merged['occupied_beds'],errors='coerce')\n",
    "\n",
    "# Creating a new data frame with only missing values in the respective column \n",
    "no_occupied_beds = df_merged.copy()\n",
    "no_occupied_beds = no_occupied_beds[(no_occupied_beds['occupied_beds'].isnull())]\n",
    "\n",
    "# Removing the above used entries from the main data frame\n",
    "df_merged = df_merged[~df_merged['provider_number'].isin(no_occupied_beds['provider_number'])]\n",
    "\n",
    "# Filling the missing values in the occupied_beds data frame with the median of the respective value from the main data frame\n",
    "occupied_beds_median = df_merged['occupied_beds'].median()\n",
    "no_occupied_beds['occupied_beds'] = no_occupied_beds['occupied_beds'].fillna(occupied_beds_median)\n",
    "\n",
    "# Adding the filled data frame to the main data frame\n",
    "df_merged = df_merged.append(no_occupied_beds)\n",
    "\n",
    "# Printing the number of entries the applied method filled\n",
    "print(no_occupied_beds.occupied_beds.notnull().sum())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 5.1.7 Deficiencies Displayed on Nursing Home Compare"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Replacing missing values in the deficiency columns with 0s \n",
    "df_merged[['fed_def','serious_fed_def','infection_def']] = df_merged[['fed_def','serious_fed_def','infection_def']].fillna(value=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 5.1.8 paymcaid (LTCFocus.org Data Set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "959\n"
     ]
    }
   ],
   "source": [
    "# Creating a new data frame with only missing values in the respective column \n",
    "no_paymcaid = df_merged.copy()\n",
    "no_paymcaid = no_paymcaid[(no_paymcaid['paymcaid'].isnull())]\n",
    "\n",
    "# Removing the above used entries from the main data frame\n",
    "df_merged = df_merged[~df_merged['provider_number'].isin(no_paymcaid['provider_number'])]\n",
    "\n",
    "# Filling the missing values in the paymcaid data frame with the median of the respective value from the main data frame\n",
    "paymcaid_median = df_merged['paymcaid'].median()\n",
    "no_paymcaid['paymcaid'] = no_paymcaid['paymcaid'].fillna(paymcaid_median)\n",
    "\n",
    "# Adding the filled data frame to the main data frame\n",
    "df_merged = df_merged.append(no_paymcaid)\n",
    "\n",
    "# Printing the number of entries the applied method filled\n",
    "print(no_paymcaid.paymcaid.notnull().sum())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 5.1.9 multifac (LTCFocus.org Data Set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "959\n"
     ]
    }
   ],
   "source": [
    "# Creating a new data frame with only missing values in the respective column \n",
    "no_multifac = df_merged.copy()\n",
    "no_multifac = no_multifac[(no_multifac['multifac'].isnull())]\n",
    "\n",
    "# Removing the above used entries from the main data frame\n",
    "df_merged = df_merged[~df_merged['provider_number'].isin(no_multifac['provider_number'])]\n",
    "\n",
    "# Converting the multifac column into binary values\n",
    "df_merged['multifac'] = np.where(df_merged['multifac']=='Yes',1,0)\n",
    "\n",
    "# Filling the missing values in the multifac data frame with the median of the respective value from the main data frame\n",
    "multifac_median = df_merged['multifac'].median()\n",
    "no_multifac['multifac'] = no_multifac['multifac'].fillna(multifac_median)\n",
    "\n",
    "# Adding the filled data frame to the main data frame\n",
    "df_merged = df_merged.append(no_multifac)\n",
    "\n",
    "# Printing the number of entries the applied method filled\n",
    "print(no_multifac.multifac.notnull().sum())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 5.1.10 pctwhite_2011p (LTCFocus.org Data Set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1458\n"
     ]
    }
   ],
   "source": [
    "# Converting the column pctwhite_2011p from an object to numeric values\n",
    "df_merged['pctwhite_2011p'] = pd.to_numeric(df_merged['pctwhite_2011p'],errors='coerce')\n",
    "\n",
    "# Creating a new data frame with only missing values in the respective column \n",
    "no_pctwhite_2011p = df_merged.copy()\n",
    "no_pctwhite_2011p = no_pctwhite_2011p[(no_pctwhite_2011p['pctwhite_2011p'].isnull())]\n",
    "\n",
    "# Removing the above used entries from the main data frame\n",
    "df_merged = df_merged[~df_merged['provider_number'].isin(no_pctwhite_2011p['provider_number'])]\n",
    "\n",
    "# Filling the missing values in the pctwhite_2011p data frame with the median of the respective value from the main data frame\n",
    "pctwhite_2011p_median = df_merged['pctwhite_2011p'].median()\n",
    "no_pctwhite_2011p['pctwhite_2011p'] = no_pctwhite_2011p['pctwhite_2011p'].fillna(pctwhite_2011p_median)\n",
    "\n",
    "# Adding the filled data frame to the main data frame\n",
    "df_merged = df_merged.append(no_pctwhite_2011p)\n",
    "\n",
    "# Printing the number of entries the applied method filled\n",
    "print(no_pctwhite_2011p.pctwhite_2011p.notnull().sum())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 5.1.11 USAFacts.org County-level Tracker"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creating a new data frame with only missing values in the respective column but not missing values in the column county_code\n",
    "no_county = df_merged.copy()\n",
    "no_county = no_county[(~no_county['county_code'].isnull())&(no_county['population'].isnull())]\n",
    "\n",
    "# Dropping the columns with missing values\n",
    "no_county = no_county.drop(['county_code','population','confirmed','deaths'],axis=1)\n",
    "\n",
    "# Removing the above used entries from the main data frame\n",
    "df_merged = df_merged[~df_merged['provider_number'].isin(no_county['provider_number'])]\n",
    "\n",
    "# Dropping zip code that occur more than once and are therefore not assignable to a single county\n",
    "zip_to_county.drop_duplicates(subset='zip_code',inplace=True,keep=False)\n",
    "\n",
    "#zip_to_county.rename(columns={'zip_county_code':'county_code'},inplace=True)\n",
    "\n",
    "# Mapping the US Zipcodes to County State data set to the no_county data frame\n",
    "no_county = pd.merge(no_county,zip_to_county,how='left',on=['zip_code'])\n",
    "no_county = no_county.drop(['zip_code'],axis=1)\n",
    "\n",
    "# Rounding the column county_code to convert it from a float to an integer\n",
    "no_county['county_code'] = no_county['county_code'].round()\n",
    "\n",
    "# Mapping the USAFacts.org County-level Tracker data set to the no_county data frame\n",
    "no_county = pd.merge(no_county,df_county_combined[['countyFIPS',\n",
    "                                                   'population',\n",
    "                                                   'confirmed',\n",
    "                                                   'deaths']]\n",
    "                   ,how='left',left_on=['county_code'],right_on=['countyFIPS'])\n",
    "\n",
    "# Dropping the countyFIPS column\n",
    "no_county = no_county.drop(['countyFIPS'],axis=1)\n",
    "\n",
    "# Adding the filled data frame to the main data frame\n",
    "df_merged = df_merged.append(no_county)\n",
    "\n",
    "# Dropping the zip_code column\n",
    "df_merged = df_merged.drop(['zip_code'],axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 5.1.12 CBSA (Blanks are Rural) (SSA and FIPS County Codes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Converting the urban column into binary values\n",
    "df_merged['urban'] = np.where(~np.isnan(df_merged['cbsa_code']),1,0)\n",
    "\n",
    "# Dropping the cbsa_code column\n",
    "df_merged = df_merged.drop(['cbsa_code'],axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 5.1.12 Drop remaining LTC Facilities with Missing Values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "#df_merged = df_merged.drop_duplicates()\n",
    "df_merged = df_merged.dropna()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(13078, 24)"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Printing the number of rows and columns in the data frame\n",
    "df_merged.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.2 Feature Engineering"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 5.2.1 Ownership Type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Converting the for_profit column into binary values\n",
    "df_merged['for_profit'] = np.where(df_merged['ownership'].str[:10]=='For profit',1,0)\n",
    "\n",
    "# Dropping the cbsa_code column\n",
    "df_merged= df_merged.drop(['ownership'],axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 5.2.2 Facility Age"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calculating the years each nursing home is operating for\n",
    "df_merged['approved_date'] = pd.to_datetime(df_merged['approved_date']).dt.date\n",
    "df_merged['years'] = ((date_selected - df_merged['approved_date'])/np.timedelta64(1,'Y')).round(2)\n",
    "\n",
    "# Dropping the approved_date column\n",
    "df_merged = df_merged.drop(['approved_date'],axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 5.2.3 Bed Occupancy Rates"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calculating the occupancy of beds in each nursing home\n",
    "df_merged['occupancy'] = (df_merged['occupied_beds']/df_merged['total_beds']*100).round(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 5.2.4 Excess Beds per County"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creating a new data frame with the columns county_code, total_beds_ and occupied_beds in order to group by the county_code\n",
    "county_excess = df_merged[['county_code','total_beds','occupied_beds']]\n",
    "county_excess = county_excess.groupby(['county_code']).sum().reset_index()\n",
    "\n",
    "# Calculating a new column by subtracting the total number of beds by the total occupied beds in a county \n",
    "county_excess['county_excess'] = county_excess['total_beds'] - county_excess['occupied_beds']\n",
    "\n",
    "# Removing nursing homes that are in a county with a negative excess of beds in a county\n",
    "# (possibly caused by an error in the reporting of numbers)\n",
    "county_excess = county_excess[county_excess['county_excess'] >= 0]\n",
    "\n",
    "# Mapping the county_excess to the main data frame\n",
    "df_merged = pd.merge(df_merged,county_excess[['county_code','county_excess']],how='left',on=['county_code'])\n",
    "\n",
    "# Dropping the occupied_beds column\n",
    "df_merged = df_merged.drop(['occupied_beds'],axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 5.2.5 Competition Metrics (Herfindahl Index)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creating a new data frame by grouping the column total_beds based on the county_code\n",
    "market_share = df_merged.groupby(['county_code'])[['total_beds']].sum().reset_index()\n",
    "\n",
    "# Renaming the sum of total_beds to sum_total_beds to avoid name collisions\n",
    "market_share.rename(columns={'total_beds':'sum_total_beds'},inplace=True)\n",
    "\n",
    "# Mapping the sum_total_beds to the main data frame\n",
    "df_merged = pd.merge(df_merged,market_share[['county_code','sum_total_beds']],how='left',on=['county_code'])\n",
    "\n",
    "# Calculating the share of the beds for each county\n",
    "df_merged['beds_market'] = ((df_merged['total_beds']/df_merged['sum_total_beds'])**2)\n",
    "market_share = df_merged.groupby(['county_code'])[['beds_market']].sum().reset_index()\n",
    "\n",
    "# Renaming the sum of beds_market to sum_beds_market to avoid name collisions\n",
    "market_share.rename(columns={'beds_market':'sum_beds_market'},inplace=True)\n",
    "\n",
    "# Mapping the sum_beds_market to the main data frame\n",
    "df_merged = pd.merge(df_merged,market_share[['county_code','sum_beds_market']],how='left',on=['county_code'])\n",
    "\n",
    "# Dropping the county_code column\n",
    "df_merged = df_merged.drop(['county_code'],axis=1)\n",
    "\n",
    "# Calculating the herfindahl index\n",
    "df_merged['herfindahl'] = np.where(np.isnan(df_merged['beds_market']), np.nan,df_merged['sum_beds_market'])\n",
    "df_merged['herfindahl'] = (df_merged['herfindahl']*100).round(2)\n",
    "\n",
    "# Dropping the columns sum_beds_market, sum_total_beds and beds_market\n",
    "df_merged = df_merged.drop(['sum_beds_market','sum_total_beds','beds_market'],axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 5.2.6 Percentage of Racial and Ethnic Minority Residents  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Converting the pctwhite_2011p column to numeric values\n",
    "df_merged['pctwhite_2011p'] = pd.to_numeric(df_merged['pctwhite_2011p'],errors='coerce')\n",
    "\n",
    "# Calculating share of racial and ethnic minority residents\n",
    "df_merged['minority'] = 100-df_merged['pctwhite_2011p'].round(2)\n",
    "\n",
    "# Dropping the pctwhite_2011p column\n",
    "df_merged = df_merged.drop(['pctwhite_2011p'],axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 5.2.7 County Cases and Deaths per 100K Population"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calculating the county cases and deaths on a 100K population basis for a more appropriate comparison between counties\n",
    "df_merged['county_cases_100'] = (df_merged['confirmed']/df_merged['population']*100000).round(0)\n",
    "df_merged['county_deaths_100'] = (df_merged['deaths']/df_merged['population']*100000).round(0)\n",
    "\n",
    "# Dropping the columns confirmed, deaths and population\n",
    "df_merged = df_merged.drop(['confirmed','deaths','population'],axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <font color='grey'>5.2.8 Mortality Ratios (Not used)</font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mortality ratios in nursing homes were dropped as features for this project due to the difficulty of their interpretation. A large share of nursing homes have mortality rates of over 100% due to the lack of adequate testing capabilities. On the one hand, the removal of nursing homes with mortality ratios above 100% is out of proportion to the added value of the features, and on the other hand does not solve the problem of difficult interpretability even with mortality rates below 100%."
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "# Calculating the mortality ratios for residents, staff and on a county level\n",
    "df_merged['res_rate'] = np.where(df_merged['total_inf_res']>0,(df_merged['total_deaths_res']/df_merged['total_inf_res']*100).round(2),0)\n",
    "df_merged['staff_rate'] = np.where(df_merged['total_inf_staff']>0,(df_merged['total_deaths_staff']/df_merged['total_inf_staff']*100).round(2),0)\n",
    "df_merged['county_rate_100'] = (df_merged['county_deaths_100']/df_merged['county_cases_100']*100).round(2)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "# Capping ratios larger than 100% as they mean that more people are dying through the effects of COVID-19 than being infected\n",
    "# (driven by the limited testing capabilities in LTC facilities)\n",
    "a = np.array(df_merged['res_rate'].values.tolist())\n",
    "b = np.array(df_merged['staff_rate'].values.tolist())\n",
    "df_merged['res_rate'] = np.where(a > 100, 101, a).tolist()\n",
    "df_merged['staff_rate'] = np.where(b > 100, 101, a).tolist()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 5.2.9 Drop remaining LTC Facilities with Missing Values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "#df_merged = df_merged.drop_duplicates()\n",
    "df_merged = df_merged.dropna()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(13070, 24)"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Printing the number of rows and columns in the data frame\n",
    "df_merged.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.3 Create Target Features (Dependant Variables)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Setting the 95% percentile as threshold in order to classify the 5% highest cases and deaths as outbreak \n",
    "# Threshold for deaths among staff is not calculated as it would be 0; differentiation only between deaths or no deaths\n",
    "inf_res_95_up = df_merged.loc[:,'total_inf_res'].quantile(0.95)\n",
    "inf_staff_95_up = df_merged.loc[:,'total_inf_staff'].quantile(0.95)\n",
    "deaths_res_95_up = df_merged.loc[:,'total_deaths_res'].quantile(0.95)\n",
    "\n",
    "# Calculating the max values in the aforementioned features as a boundary for the Pandas cut function\n",
    "inf_res_max = df_merged.loc[:,'total_inf_res'].max()\n",
    "inf_staff_max = df_merged.loc[:,'total_inf_staff'].max()\n",
    "deaths_res_max = df_merged.loc[:,'total_deaths_res'].max()\n",
    "\n",
    "# Setting the 75% percentile as threshold in order to classify the 25% highest mortality rates as outbreak\n",
    "# It is not the 95% percentile as the mortality rates above the 80% percentile already cross 100%\n",
    "#res_rate_75_up = df_merged.loc[:,'res_rate'].quantile(0.75)\n",
    "#staff_rate_75_up = df_merged.loc[:,'staff_rate'].quantile(0.75)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "# Creating four different categorical target features infected and deaths among residents and staff (No Case, Confirmed Cases, Outbreak)\n",
    "df_merged['inf_res'] = pd.cut(df_merged['total_inf_res'],[-1,0,inf_res_95_up,inf_res_max],labels=[0,1,2])\n",
    "df_merged['inf_staff'] = pd.cut(df_merged['total_inf_staff'],[-1,0,inf_staff_95_up,inf_staff_max],labels=[0,1,2])\n",
    "df_merged['deaths_res'] = pd.cut(df_merged['total_deaths_res'],[-1,0,deaths_res_95_up,deaths_res_max],labels=[0,1,2])\n",
    "df_merged['deaths_staff'] = np.where(df_merged['total_deaths_staff']==0,0,1)\n",
    "\n",
    "# Calculating target features for two mortality rates\n",
    "#df_merged['res_rate_75_up'] = np.where(df_merged['res_rate']>=res_rate_75_up,1,0)\n",
    "#df_merged['staff_rate_75_up'] = np.where(df_merged['staff_rate']>=staff_rate_75_up,1,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creating four different target features infections and fatalities among residents and staff (No Case, Confirmed Cases)\n",
    "df_merged['inf_res'] = np.where(df_merged['total_inf_res']==0,0,1)\n",
    "df_merged['inf_staff'] = np.where(df_merged['total_inf_staff']==0,0,1)\n",
    "df_merged['deaths_res'] = np.where(df_merged['total_deaths_res']==0,0,1)\n",
    "df_merged['deaths_staff'] = np.where(df_merged['total_deaths_staff']==0,0,1)\n",
    "\n",
    "# Calculating target features for two mortality rates\n",
    "#df_merged['res_rate_75_up'] = np.where(df_merged['res_rate']>=res_rate_75_up,1,0)\n",
    "#df_merged['staff_rate_75_up'] = np.where(df_merged['staff_rate']>=staff_rate_75_up,1,0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.4 Convert Independant Variables in Binary Values (Used for the Univariate Analyses)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "# Setting the median as threshold in order to allow the calculation of odds ratios between low and high feature values\n",
    "beds_median = df_merged.loc[:,'total_beds'].median()\n",
    "fed_def_median = df_merged.loc[:,'fed_def'].median()\n",
    "rating_median = df_merged.loc[:,'rating'].median()\n",
    "fines_excl_0_median = df_merged.loc[df_merged['total_fine']!=0,'total_fine'].median()\n",
    "paymcaid_median = df_merged.loc[:,'paymcaid'].median()\n",
    "county_excess_median = df_merged.loc[:,'county_excess'].median()\n",
    "herfindahl_median = df_merged.loc[:,'herfindahl'].median()\n",
    "years_median = df_merged.loc[:,'years'].median()\n",
    "occupancy_median = df_merged.loc[:,'occupancy'].median()\n",
    "minority_median = df_merged.loc[:,'minority'].median()\n",
    "county_cases_100_median = df_merged.loc[:,'county_cases_100'].median()\n",
    "county_deaths_100_median = df_merged.loc[:,'county_deaths_100'].median()\n",
    "#county_rate_100_median = df_merged.loc[:,'county_rate_100'].median()"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "# Creating a new data frame for the odds ratio calculation\n",
    "df_binary = df_merged[['provider_number',\n",
    "                       'inf_res',\n",
    "                       'inf_staff',\n",
    "                       'deaths_res',\n",
    "                       'deaths_staff',\n",
    "                       #'res_rate_75_up',\n",
    "                       #'staff_rate_75_up'\n",
    "                      ]]"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "# Converting the remaining features into binary values\n",
    "df_binary['beds_high'] = np.where((df_merged['total_beds']>0) &(df_merged['total_beds']>=beds_median),1,0)\n",
    "df_binary['years_high'] = np.where(df_merged['years']>=years_median,1,0)\n",
    "df_binary['for_profit'] = df_merged['for_profit']\n",
    "df_binary['multifac'] = df_merged['multifac']\n",
    "df_binary['urban'] = df_merged['urban']\n",
    "df_binary['occupancy_low'] = np.where(df_merged['occupancy']<occupancy_median,1,0)\n",
    "df_binary['rating_low'] = np.where(df_merged['rating']<rating_median,1,0)\n",
    "df_binary['fed_def_high'] = np.where(df_merged['fed_def']>=fed_def_median,1,0)\n",
    "df_binary['serious_fed_def'] = np.where(df_merged['serious_fed_def']>0,1,0)\n",
    "df_binary['infection_def'] = np.where(df_merged['infection_def']>0,1,0)\n",
    "df_binary['fine'] = np.where(df_merged['total_fine']==0,0,1)\n",
    "df_binary['fine_high'] = np.where((df_merged['total_fine']>0) & (df_merged['total_fine']>=fines_excl_0_median),1,0)\n",
    "df_binary['rn_staff_low'] = np.where(df_merged['rn_staff']<0.75,1,0)\n",
    "df_binary['total_staff_low'] = np.where(df_merged['total_staff']<4.1,1,0)\n",
    "df_binary['paymcaid_high'] = np.where(df_merged['paymcaid']>=paymcaid_median,1,0)\n",
    "df_binary['minority_high'] = np.where(df_merged['minority']>=minority_median,1,0)\n",
    "df_binary['county_excess_high'] = np.where(df_merged['county_excess']>=county_excess_median,1,0)\n",
    "df_binary['herfindahl_low'] = np.where(np.isnan(df_merged['herfindahl']),np.nan,np.where(df_merged['herfindahl']<herfindahl_median,1,0))\n",
    "df_binary['county_cases_100_high'] = np.where(df_merged['county_cases_100']>=county_cases_100_median,1,0)\n",
    "df_binary['county_deaths_100_high'] = np.where(df_merged['county_deaths_100']>=county_deaths_100_median,1,0)\n",
    "df_binary['county_rate_100_high'] = np.where(df_merged['county_rate_100']>=county_rate_100_median,1,0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.5 Reorder and Export Data Frames"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 5.5.1 Main Data Frame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Converting columns from a float to an integer\n",
    "cols = ['rating',\n",
    "        'total_fine',\n",
    "        'total_inf_res',\n",
    "        'total_inf_staff',\n",
    "        'total_beds',\n",
    "        'total_deaths_res',\n",
    "        'total_deaths_staff',\n",
    "        'multifac',\n",
    "        'fed_def',\n",
    "        'serious_fed_def',\n",
    "        'infection_def',\n",
    "        'county_excess',\n",
    "        'county_cases_100',\n",
    "        'county_deaths_100']\n",
    "\n",
    "for cols in cols:\n",
    "    df_merged[cols] = df_merged[cols].apply(lambda x: int(x) if x == x else \"\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Reordering the structure in the data frame\n",
    "df_merged = df_merged[['inf_res',\n",
    "                       'inf_staff',\n",
    "                       'deaths_res',\n",
    "                       'deaths_staff',\n",
    "                       'total_inf_res',\n",
    "                       'total_inf_staff',\n",
    "                       'total_deaths_res',\n",
    "                       'total_deaths_staff',\n",
    "                       #'res_rate',\n",
    "                       #'staff_rate',\n",
    "                       'total_beds',\n",
    "                       'years',\n",
    "                       'for_profit',\n",
    "                       'multifac',\n",
    "                       'urban',\n",
    "                       'occupancy',\n",
    "                       'rating',\n",
    "                       'fed_def',\n",
    "                       'serious_fed_def',\n",
    "                       'infection_def',\n",
    "                       'total_fine',\n",
    "                       'rn_staff',\n",
    "                       'total_staff',\n",
    "                       'paymcaid',\n",
    "                       'minority',\n",
    "                       'county_excess',\n",
    "                       'herfindahl',\n",
    "                       'county_cases_100',\n",
    "                       'county_deaths_100',\n",
    "                       #'county_rate_100'\n",
    "                      ]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 5.5.2 Univariate Analyses Data Frame"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "# Converting columns from a float to an integer\n",
    "cols = ['multifac',\n",
    "        'herfindahl_low']\n",
    "\n",
    "for cols in cols:\n",
    "    df_binary[cols] = df_binary[cols].apply(lambda x: int(x) if x == x else \"\")"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "with pd.ExcelWriter('02_Data Processing\\odds_data_frame.xlsx') as writer:  \n",
    "    df_binary.to_excel(writer, sheet_name='odds_data_frame',index=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6 Describe the Data Frame"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6.1 Generate Descriptive Statistics"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {
    "scrolled": true
   },
   "source": [
    "# Creating a summary table\n",
    "df_desc = df_merged.describe()\n",
    "\n",
    "# Adding the standard deviation metric to the summary table\n",
    "df_desc.loc['-2_std'] = df_desc.loc['mean'] - (df_desc.loc['std'] * 2)\n",
    "df_desc.loc['+2_std'] = df_desc.loc['mean'] + (df_desc.loc['std'] * 2)\n",
    "\n",
    "# Printing the summary table\n",
    "df_desc"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6.2 Create Correlation Matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x2285bd2a808>"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 792x648 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Creating a correlation matrix\n",
    "corr = df_merged.corr()\n",
    "mask = np.triu(np.ones_like(corr, dtype=np.bool))\n",
    "\n",
    "# Setting up the matplotlib figure\n",
    "f, ax = plt.subplots(figsize=(11, 9))\n",
    "\n",
    "# Generating a custom diverging colormap\n",
    "cmap = sns.diverging_palette(220, 10, as_cmap=True)\n",
    "\n",
    "# Drawing the heatmap with the mask and correct aspect ratio\n",
    "sns.heatmap(corr, mask=mask, cmap=cmap, vmax=.3, center=0,\n",
    "            square=True, linewidths=.5, cbar_kws={\"shrink\": .5})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 7 Predictive Modeling"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7.1 Data wrangling"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 7.1.1 Select Target Variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Dropping other target variables since inf_res is the target variable for this model\n",
    "df_merged = df_merged.drop(['inf_staff',\n",
    "                            'deaths_res',\n",
    "                            'deaths_staff',\n",
    "                            'total_inf_res',\n",
    "                            'total_inf_staff',\n",
    "                            'total_deaths_res',\n",
    "                            'total_deaths_staff'\n",
    "                           ],axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Dropping the multifac variable due to the lack of statistical significance demonstrated \n",
    "# in the univarate and bivariate analyses\n",
    "df_merged = df_merged.drop(['multifac'\n",
    "                           ],axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "####  <font color='grey'>7.1.3 Encode Target Variablen (Not applied)</font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Not required as the target variables are already encoded in the previous transformation process."
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "encoder = LabelEncoder()\n",
    "\n",
    "# label encoding the target variable column\n",
    "df_merged['inf_res'] = encoder.fit_transform(df_merged['inf_res'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 7.1.4 Split Data Frame into Independent and Dependent Variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Splitting the data into independent 'X' and dependent 'Y' variables\n",
    "X = df_merged.drop(columns=['inf_res']).values\n",
    "Y = df_merged.filter(['inf_res']).values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 7.1.5 Split Data Frame in Training and Testing Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Splitting the data set into 80% training data and 20% testing data\n",
    "X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size = 0.2, random_state = 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 7.1.6 Scale Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Scaling the data to bring all features to the same level of magnitude\n",
    "sc = StandardScaler()\n",
    "X_train = sc.fit_transform(X_train)\n",
    "X_test = sc.transform(X_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7.2 Select Model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 7.2.1 Machine Learning Models"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following section evaluates a total of six machine learning models (Logistic Regression, Nearest Neighbor, Support Vector Machine, Naïve Bayes, Decision Tree, Random Forest). The stacking model in which different machine learning models are combined is not used due to its poor performance and time consuming calculations."
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "# Creating a stacking ensemble of models function\n",
    "def get_stacking():\n",
    "    \n",
    "    # Defining the base models\n",
    "    level0 = list()\n",
    "    level0.append(('log', LogisticRegression(random_state=0)))\n",
    "    level0.append(('knn', KNeighborsClassifier(n_neighbors=5,metric='minkowski',p=2)))\n",
    "    level0.append(('svc_lin', SVC(kernel='linear',random_state=0)))\n",
    "    level0.append(('gauss', GaussianNB()))\n",
    "    level0.append(('tree', DecisionTreeClassifier(criterion='entropy',random_state=0)))\n",
    "    level0.append(('forest', RandomForestClassifier(n_estimators=100,max_features='auto',oob_score=True,random_state=1,n_jobs=-1)))\n",
    "                   \n",
    "    # Defining meta learner model\n",
    "    level1 = LogisticRegression()\n",
    "                   \n",
    "    # define the stacking ensemble\n",
    "    model = StackingClassifier(estimators=level0,final_estimator=level1,cv=5)\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ">log 0.7376 (0.0134)\n",
      ">knn 0.7033 (0.0141)\n",
      ">svc_lin 0.7372 (0.0146)\n",
      ">gauss 0.6918 (0.0143)\n",
      ">tree 0.6686 (0.0168)\n",
      ">forest 0.7457 (0.0109)\n"
     ]
    }
   ],
   "source": [
    "# Creating a list of models to evaluate\n",
    "def get_models():\n",
    "    models = dict()\n",
    "    models['log'] = LogisticRegression(random_state=0)\n",
    "    models['knn'] = KNeighborsClassifier(n_neighbors=5,metric='minkowski',p=2)\n",
    "    models['svc_lin'] = SVC(kernel='linear',random_state=0)\n",
    "    models['gauss'] = GaussianNB()\n",
    "    models['tree'] = DecisionTreeClassifier(criterion='entropy',random_state=0)\n",
    "    models['forest'] = RandomForestClassifier(n_estimators=100,max_features='auto',oob_score=True,random_state=1,n_jobs=-1)\n",
    "    #models['stacking'] = get_stacking()\n",
    "    return models\n",
    "\n",
    "# Creating a function to evaluate a given model using cross-validation\n",
    "def evaluate_model(model, X, Y):\n",
    "    scores = cross_val_score(model,X,Y,scoring='accuracy',cv=10)\n",
    "    return scores\n",
    "\n",
    "# Assigning the models to evaluate\n",
    "models = get_models()\n",
    "\n",
    "# Evaluating the models\n",
    "model_results, names = list(), list()\n",
    "for name, model in models.items():\n",
    "    scores = evaluate_model(model,X_train,Y_train)\n",
    "    model_results.append(scores)\n",
    "    names.append(name)\n",
    "    print('>%s %.4f (%.4f)' % (name, mean(scores), std(scores)))\n",
    "\n",
    "# Saving the results of all models including the stacking ensemble in order to save time to reproduce the results \n",
    "np.save('model_results.npy', model_results)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Loading the results and assigning the model names to the variable names\n",
    "model_results = np.load('model_results.npy').tolist()\n",
    "names = ['log','knn','svc_lin','gauss','tree','forest']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 7.2.2 Keras Neural Network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From C:\\Users\\44792\\anaconda3\\lib\\site-packages\\tensorflow\\python\\ops\\nn_impl.py:180: add_dispatch_support.<locals>.wrapper (from tensorflow.python.ops.array_ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use tf.where in 2.0, which has the same broadcast rule as np.where\n",
      "WARNING:tensorflow:From C:\\Users\\44792\\anaconda3\\lib\\site-packages\\keras\\backend\\tensorflow_backend.py:422: The name tf.global_variables is deprecated. Please use tf.compat.v1.global_variables instead.\n",
      "\n",
      "1046/1046 [==============================] - 0s 16us/step\n",
      ">keras 0.7505 (0.0000)\n",
      "1046/1046 [==============================] - 0s 15us/step\n",
      ">keras 0.7328 (0.0177)\n",
      "1046/1046 [==============================] - 0s 17us/step\n",
      ">keras 0.7333 (0.0145)\n",
      "1046/1046 [==============================] - 0s 16us/step\n",
      ">keras 0.7349 (0.0129)\n",
      "1046/1046 [==============================] - 0s 16us/step\n",
      ">keras 0.7390 (0.0141)\n",
      "1046/1046 [==============================] - 0s 15us/step\n",
      ">keras 0.7408 (0.0134)\n",
      "1045/1045 [==============================] - 0s 16us/step\n",
      ">keras 0.7457 (0.0173)\n",
      "1045/1045 [==============================] - 0s 17us/step\n",
      ">keras 0.7440 (0.0168)\n",
      "1045/1045 [==============================] - 0s 18us/step\n",
      ">keras 0.7413 (0.0176)\n",
      "1045/1045 [==============================] - 0s 17us/step\n",
      ">keras 0.7423 (0.0169)\n",
      ">keras 0.7423 (0.0169)\n"
     ]
    }
   ],
   "source": [
    "fold_no = 1\n",
    "keras_results = list()\n",
    "scores = []\n",
    "\n",
    "for idx in KFold(n_splits=10).split(X_train):\n",
    "\n",
    "    # Defining the keras model\n",
    "    model = Sequential()\n",
    "    model.add(Dense(16, input_dim=18, activation='relu'))\n",
    "    model.add(Dropout(0.4))\n",
    "    model.add(Dense(8, activation='relu'))\n",
    "    model.add(Dense(1, activation='sigmoid'))\n",
    "    \n",
    "    # Compiling the keras model\n",
    "    model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])\n",
    "    \n",
    "    # Fitting the keras model on the dataset\n",
    "    history = model.fit(X_train[idx[0]],Y_train[idx[0]],validation_data=(X_test,Y_test),epochs=100,batch_size=150,verbose=0)\n",
    "\n",
    "    # Applying a k-fold validation of the data set\n",
    "    score = model.evaluate(X_train[idx[1]],Y_train[idx[1]],verbose=1)\n",
    "    scores.append(score[1])\n",
    "\n",
    "    # Increasing fold number by 1\n",
    "    fold_no = fold_no + 1\n",
    "    \n",
    "    name = 'keras'\n",
    "    print('>%s %.4f (%.4f)' % (name, mean(scores), std(scores)))\n",
    "\n",
    "scores = np.array(scores)\n",
    "keras_results.append(np.array(scores))\n",
    "\n",
    "name = 'keras'\n",
    "print('>%s %.4f (%.4f)' % (name, mean(scores), std(scores)))\n",
    "\n",
    "# Saving the results of all models including the stacking ensemble in order to save time to reproduce the results \n",
    "np.save('keras_results.npy', keras_results)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Visualising the model accuracy\n",
    "plt.plot(history.history['accuracy']) \n",
    "plt.plot(history.history['val_accuracy']) \n",
    "plt.title('model accuracy')\n",
    "plt.ylabel('accuracy')\n",
    "plt.xlabel('epoch') \n",
    "plt.legend(['train', 'test'], loc='upper left') \n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Loading the results\n",
    "keras_results = np.load('keras_results.npy').tolist()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 7.2.9 Model Comparison"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Combining the results of the models\n",
    "model_results.append(keras_results[0])\n",
    "names.append('keras')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plotting performance of models for comparison\n",
    "plt.boxplot(model_results, labels=names, showmeans=True)\n",
    "plt.title('model accuracy')\n",
    "plt.ylabel('k-fold accuracy')\n",
    "plt.xlabel('machine learning models') \n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7.3 Tree Based Feature Selection"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 7.3.1 Random Forest Classification Algorithm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "RandomForestClassifier(bootstrap=True, ccp_alpha=0.0, class_weight=None,\n",
       "                       criterion='gini', max_depth=None, max_features='auto',\n",
       "                       max_leaf_nodes=None, max_samples=None,\n",
       "                       min_impurity_decrease=0.0, min_impurity_split=None,\n",
       "                       min_samples_leaf=1, min_samples_split=2,\n",
       "                       min_weight_fraction_leaf=0.0, n_estimators=100,\n",
       "                       n_jobs=-1, oob_score=True, random_state=1, verbose=0,\n",
       "                       warm_start=False)"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Running the random forest classification algorithm again as only the results were saved in the previous steps\n",
    "forest = RandomForestClassifier(n_estimators=100,max_features='auto',oob_score=True,random_state=1,n_jobs=-1)\n",
    "forest.fit(X_train,Y_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 7.3.2 Determine Feature Importance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'feature importance')"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYgAAAFtCAYAAAAdyv0XAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nOydd7wcZfX/358kQAKEHpWe0IIgRUwCAlJUigXwq4AUaYKIfBGwY/kiYgVBQORHUWoAaX71GxUEpEknoQQINWCAiIUaQidwfn+cZ5O5m7n3zszO3r2597xfr33tTjtzZnd2zvOc5zznyMwIgiAIgmaGdFqBIAiCoH8SBiIIgiDIJQxEEARBkEsYiCAIgiCXMBBBEARBLmEggiAIglzCQLQJSWMl3S1ptqRDO61PGSStIullSUM7rctgQdK+km7qZtuekq5q47l/KunwdsnPOd8MSR/tg/OMkPRHSbMkXdru8/Wiyy8kHdRJHaoQBqJ9fBO43sxGmtkvWxEk6XpJB9SkV6+Y2ZNmtriZvd1X5+wOSaMlmaRhndalU5jZBWa2bTtkSxoF7A2c3g75HWZn4N3Asma2S1+dtBtj/3Pgu5IW7is96iAMRPtYFZjWaSUAFtSH64Kk94KkaxP7Apeb2Wt5Gxfg6wL/Dz5iZnPKHlj3dZvZP4GHgB3rlNt2zCxeNb+Aa4G3gdeBl4G1gEWA44AngX8DpwEj0v5LA38CngFeSJ9XStt+3CTrV8BowIBhmXNeDxyQPu8L3AycADwP/Cit/zzwYDrHlcCq3ejfRX6S/SPglqTDH4FlgQuAl4DJwOjM8QYcCjwOPIu3noakbUOA7wFPAP8BzgOWbDrv/ul7+lt6t3Tel4EPAqun7/i5JP8CYKnM+WcAXwfuBWYBFwPDM9t3Au5Juj8GbJ/WLwmcCfwT+Ee65qHdfEdHAZcB5yc5BwATgFuBF5OMXwELN30vBwGPpt/gFECZ3+ymzL4/B25KOjVv60nOUOD49L38HTiEpnsl5179XGZ5K2Am8C3gX8BEerg/M/fHD/F7bjZwFbBcZvte6fd+Dvhu+n0+mrYtApwIPJ1eJwKLNOnyTfxe+SfwKeDjwCP4vf2dbq7rB8CbwFv4fbM/Je+9tH4T/L5/EZgKbJU5x774PT47fdd7Au/F/6tvp/O+mNn/u8DZnX4+lXqWdVqBgfoi88BOyycCk4BlgJH4Q/anaduywGeARdO2S4E/9CCrcTP3ZCDmAF8GhgEj0h9rerqBh6U/yi3d6N5FfpI9HX8wLwk8kP6gH02yzsve+OnY69K1rpL2bej2+SRrNWBx4H+BiU3nPQ9YLOmdd61rANvgD5dRuCE5MbN9BnAHsELS4UHgoLRtAm40tsEfGCsCa6dtf8BdLYsB70oyvtjNd3QU/vD5VJIzAvgA/kAZlvR+EDi86Xv5E7BU+l6eYZ5x2hc3CEOAX+MGfNHstoJyDkq/z0r4g/2vzd9f03U8A4zPLG+F3zvHpO93BMXuz8fwhtCItPyztG0d/EG5RZL3iyS/YSCOBm5L3/co/GH8wyZdjgQWAr6Q9L0w6bEu/jBerYff6PzMctl7b0XcqH08/S7bpOVRaZ+XgLHp+OWBdfN+r8z5Pw3c1elnU6nnWKcVGKgvuj6wBbwCrJ7Z/kHg790cuyHwQp6stNy4mXsyEE82ybwC2D+zPAR4lZxeRLP8JPu7me3HA1dklncA7sksG+mBlZYPBq5Jn68BDs5sG4s/aIdlzrtaT9eao++ngLszyzPo2io+FjgtfT4dOCFHxruBN0i9urRud+C6bs55FKmV2YNehwO/b/peNs8sXwIckfnNbsd7O7+ja8+jywOnFznXkjFquBHvyUC8RTKQaXkrvOU9vIfryrs/v9f0e/8lfT4SuCizbbEkv2EgHgM+ntm+HTAjo8trpF4cbhQM2Diz/53Ap3r4jbIGouy99y2SAcmsuxLYJ13Hi7jhHNG0T5ffK7N+G+Dxnu6Z/vZakP2LCxKj8NbXnZIa64S7A5C0KO4O2h5v9QGMlDTUqg8UP9W0vCpwkqTjM+uEt5KeKCDv35nPr+UsL97D+Z/AW/Ok9yeatg3DH9Dd6d4FSe8Cfgl8CH9oDMFdH1n+lfn8aub8KwOX54hdFW+l/jPzGw3pRZcu2ySthbeQx+G/9zD8AdaTXtnvbQ1gA2CCmb3Zw3l7krNCk149fpf49zayad0zZvZ6Y6Hg/VlIHzN7RdJzmX3z7ocVMsvPZc7RGCfp7d7rjrL33qrALpJ2yKxbCG80vCLps7gr80xJNwNfM7OHejj/SNyoLDDEIHXf8Cx+I69rZkul15Jm1rixv4a3ZjY2syXw7jj4Axy8ZZPllfS+aGbde5r2aT7mKbxluVTmNcLMbql6Ub2wcubzKrh/mfS+atO2OXT901s3nxv8NK1fP31fn2Ped9UbT+Gusrz1b+C+88b3s4SZrduDrGbdTsUHItdMen2nhF7gLqn9gCskjS1xXJZ/4u6lBit3t2PiXtw1lKX5unq7P3vTZ64Oydgsm9medz88TXsoe+89hfcgsv+ZxczsZwBmdqWZbYO7lx7CXYPNMrK8Fx/HWGAIA9EHmNk7+M1zQmr9ImlFSdulXUbiBuRFScsA328S8W/cb9qQ9ww+iPo5SUMlfZ78h16W04BvS1o3nX9JSe0M/fuGpKUlrQwchrtOAH4LfEXSGEmLAz8BLrbuI02eAd4hc/349/Uy/n2tCHyjhF5nAvtJ+oikIel3WNs8yuQq4HhJS6Rtq0vasoTskbhf+mVJawNfKnEsAGb2W9yw/FVSb79pHpcAh6XrWgp3k/TE5UBv19jb/dkTlwGflLR5CvE8mq7Pnd8C35M0StJyuEvq/BLyy1D23jsf2EHSdul/NlzSVpJWkvRuSTtKWgxvWLyMD0yD/19Xyglp3RJ39S4whIHoO76FD5DdJuklfPCw0Uo8ER8UexYfsPtL07EnATtLekFSY07FF/AH43P4YF2PPQEz+z0+8HhROv/9wMdavage+D/cvXIP8Gf8wQxwFh4Z8zc88uN1fDA9FzN7FY/kulnSi5I2wSNUNsIHm/+MDzYWwszuwFvpJ6Tjb2Beq3JvYGF8kPcF/OG2fFHZuLthDzyq5dfMM4qlMLNz8QfptZJGlzz817ihuxe4GzcAc5j38GrmPODjkkb0ILO3+7NbzGwa8N/4wPI/8e91ZmaXHwFTkr73AXelde2g7L33FB7x9h28ofIU/p8bkl5fw3slz+MP/4PTodfiIe7/kvQsgKTl8QH7P9R9Ue2kERoXBLUhyXA3y/RO6zLYkfQxfIB+1R72+QnwHzM7se80G1yksb/HzOz/dVqXMoSBCGonDETnSD2BrfFexLvxiKjbzKzPUmkEA4dwMQXBwEK4C+4F3MX0IO7XD4LSRA8iCIIgyCV6EEEQBEEuA2ai3HLLLWejR4/utBpBEAQLFHfeeeezZjYqb9uAMRCjR49mypQpnVYjCIJggUJSt5kUwsUUBEEQ5BIGIgiCIMglDEQQBEGQy4AZgwiCYMHirbfeYubMmbz++uu97xy0zPDhw1lppZVYaKGFCh/TVgMhaXs8j9BQ4DeNLIiZ7VvgeV7WB3Yzs8vS+g3xzJhL4DlkfmxmlfLaBEHQP5k5cyYjR45k9OjRZFKsB23AzHjuueeYOXMmY8aMKXxc21xMkobipRA/hiep2l3SOk27PYkX17iwaf2rwN4p1fL2wIkpM2UQBAOE119/nWWXXTaMQx8giWWXXbZ0b62dPYgJwHQzexxA0kV4ZsQHGjuY2Yy07Z3sgWb2SObz05L+gxfdWaCKbQRB0DNhHPqOKt91OwepV6RrdaaZaV0pJE3AUzA/lrPtQElTJE155plnKisaBEEQzE87exB55qpU4qeUQ30isE8qutNVmNkZwBkA48aNi6RSQbAAM/qIP9cqb8bPPtHrPptuuim33NKuoorzM2PGDG655Rb22GOPPjtnK7TTQMyka7nDlShRSlDSEngxmO+Z2W1VFChywxW5iYIgGJj0pXGYM2cOM2bM4MILL1xgDEQ7XUyTgTVTeb+Fgd2ASUUOTPv/HjjPzC5to45BEAxiFl/cy8Jff/31bLnlluy6666stdZaHHHEEVxwwQVMmDCB9dZbj8cecw/3vvvuy0EHHcSHPvQh1lprLf70pz8BPuC+3377sd566/H+97+f6667DoBzzjmHXXbZhR122IFtt92WI444ghtvvJENN9yQE044gRkzZvChD32IjTbaiI022miuwbr++uvZaqut2HnnnVl77bXZc889aWTenjx5MptuuikbbLABEyZMYPbs2bz99tt84xvfYPz48ay//vqcfvrptXw/betBmNkcSYcAV+JhrmeZ2TRJRwNTzGySpPG4IVgar/36gxS5tCteGH1ZSfsmkfua2T3t0jcIgsHN1KlTefDBB1lmmWVYbbXVOOCAA7jjjjs46aSTOPnkkznxRC+4N2PGDG644QYee+wxtt56a6ZPn84pp5wCwH333cdDDz3EtttuyyOPeKzNrbfeyr333ssyyyzD9ddfz3HHHTfXsLz66qtcffXVDB8+nEcffZTdd999bk65u+++m2nTprHCCiuw2WabcfPNNzNhwgQ++9nPcvHFFzN+/HheeuklRowYwZlnnsmSSy7J5MmTeeONN9hss83YdtttS4W05tHWeRBmdjleEze77sjM58m466n5uPNpX+HyIAiC+Rg/fjzLL+8lyFdffXW23XZbANZbb725PQKAXXfdlSFDhrDmmmuy2mqr8dBDD3HTTTfx5S97eeu1116bVVddda6B2GabbVhmmWVyz/nWW29xyCGHcM899zB06NC5xwBMmDCBlVbyx+OGG27IjBkzWHLJJVl++eUZP348AEsssQQAV111Fffeey+XXXYZALNmzeLRRx/t3wYiCIJgQWGRRRaZ+3nIkCFzl4cMGcKcOXPmbmsOF5VET4XXFltssW63nXDCCbz73e9m6tSpvPPOOwwfPjxXn6FDhzJnzhzMLDdc1cw4+eST2W677Xq4wvJELqYgCIISXHrppbzzzjs89thjPP7444wdO5YtttiCCy64AIBHHnmEJ598krFjx8537MiRI5k9e/bc5VmzZrH88sszZMgQJk6cyNtvv93juddee22efvppJk+eDMDs2bOZM2cO2223HaeeeipvvfXWXB1eeeWVlq81ehBBEPQLFpSIwrFjx7Llllvy73//m9NOO43hw4dz8MEHc9BBB7HeeusxbNgwzjnnnC49gAbrr78+w4YNY4MNNmDffffl4IMP5jOf+QyXXnopW2+9dY+9DYCFF16Yiy++mC9/+cu89tprjBgxgr/+9a8ccMABzJgxg4022ggzY9SoUfzhD39o+VoHTE3qcePGWXPBoAhzDYL+y4MPPsh73/veTqtRin333ZdPfvKT7Lzzzp1WpRJ537mkO81sXN7+4WIKgiAIcgkXUxAEQUHOOeecTqvQp4SBKEi4q4KgfrqLygnqp8pwQriYgiDoCMOHD+e5556r9OAKytGoB5ENoy1C9CCCIOgIK620EjNnziQyMfcNjYpyZQgDEQRBR1hooYVanukbtJdwMQVBEAS5hIEIgiAIcgkDEQRBEOQSYxB9TNGqWREyGwRBp4keRBAEQZBLGIggCIIglzAQQRAEQS5hIIIgCIJcwkAEQRAEuYSBCIIgCHIJAxEEQRDkEgYiCIIgyCUMRBAEQZBLGIggCIIglzAQQRAEQS5hIIIgCIJc2mogJG0v6WFJ0yUdkbN9C0l3SZojaeembftIejS99mmnnkEQBMH8tM1ASBoKnAJ8DFgH2F3SOk27PQnsC1zYdOwywPeBjYEJwPclLd0uXYMgCIL5aWcPYgIw3cweN7M3gYuAnbI7mNkMM7sXeKfp2O2Aq83seTN7Abga2L6NugZBEARNtNNArAg8lVmemdbVdqykAyVNkTQlCp8HQRDUSzsNhHLWWZ3HmtkZZjbOzMaNGjWqlHJBEARBz7TTQMwEVs4srwQ83QfHBkEQBDXQTgMxGVhT0hhJCwO7AZMKHnslsK2kpdPg9LZpXRAEQdBHtM1AmNkc4BD8wf4gcImZTZN0tKQdASSNlzQT2AU4XdK0dOzzwA9xIzMZODqtC4IgCPqIYe0UbmaXA5c3rTsy83ky7j7KO/Ys4Kx26hcEQRB0T8ykDoIgCHIJAxEEQRDkEgYiCIIgyCUMRBAEQZBLGIggCIIglzAQQRAEQS5hIIIgCIJcwkAEQRAEuYSBCIIgCHIJAxEEQRDkEgYiCIIgyCUMRBAEQZBLGIggCIIgl14NhKR3SzpT0hVpeR1J+7dftSAIgqCTFOlBnIPXdFghLT8CHN4uhYIgCIL+QREDsZyZXQK8A3MLAb3dVq2CIAiCjlPEQLwiaVnAACRtAsxqq1ZBEARBxylSUe6reC3p1SXdDIwCdm6rVkEQBEHH6dVAmNldkrYExgICHjazt9quWRAEQdBRikQx/TewuJlNM7P7gcUlHdx+1YIgCIJOUmQM4gtm9mJjwcxeAL7QPpWCIAiC/kARAzFEkhoLkoYCC7dPpSAIgqA/UGSQ+krgEkmn4ZFMBwF/aatWQRAEQccpYiC+BXwR+BI+SH0V8Jt2KhUEQRB0niJRTO8Ap6ZXEARBMEgoEsW0maSrJT0i6XFJf5f0eBHhkraX9LCk6ZKOyNm+iKSL0/bbJY1O6xeSdK6k+yQ9KOnbZS8sCIIgaI0iLqYzga8Ad1IixUYazD4F2AaYCUyWNMnMHsjstj/wgpmtIWk34Bjgs8AuwCJmtp6kRYEHJP3WzGYUPX8QBEHQGkWimGaZ2RVm9h8ze67xKnDcBGC6mT1uZm8CFwE7Ne2zE3Bu+nwZ8JEUMWXAYpKGASOAN4GXilxQEARBUA9FehDXSfo58L/AG42VZnZXL8etCDyVWZ4JbNzdPmY2R9IsYFncWOwE/BNYFPiKmT1fQNcgCIKgJooYiMZDfVxmnQEf7uU45ayzgvtMwN1ZKwBLAzdK+quZdRn7kHQgcCDAKqus0os6A4/RR/y5131m/OwTfaBJEAQDkSJRTFtXlD0TWDmzvBLwdDf7zEzupCWB54E9gL+knE//SUkCxwFdDISZnQGcATBu3Lhm4xMEQRC0QJEeBJI+AawLDG+sM7OjezlsMrCmpDHAP4Dd8Ad/lknAPsCteIbYa83MJD0JfFjS+biLaRPgxCK6BkEQBPVQJMz1NDyy6Mu4S2gXYNXejkuFhQ7BZ2I/CFxiZtMkHS1px7TbmcCykqbjacUbobCnAIsD9+OG5mwzu7fMhQVBEAStUaQHsamZrS/pXjP7gaTj8QHrXjGzy4HLm9Ydmfn8Om5wmo97OW99EARB0HcUCXN9Lb2/KmkF4C1gTPtUCoIgCPoDRXoQf5K0FPBz4C48yihyMQVBEAxwihiIY83sDeB3kv6ED1S/3l61gr4mQmaDIGimiIvp1sYHM3vDzGZl1wVBEAQDk257EJLeg890HiHp/cyb1LYEHnoaBEEQDGB6cjFtB+yLT3A7nnkG4iXgO+1VKwiCIOg03RoIMztX0kRgdzO7oA91CoIgCPoBPY5BpGJBX+wjXYIgCIJ+RJFB6qslfV3SypKWabzarlkQBEHQUYqEuX4+vf93Zp0Bq9WvThAEQdBfKJLNNWZNB0EQDEJ6NRCSFgK+BGyRVl0PnJ5ScQdBEAQDlCIuplOBhYD/l5b3SusOaJdSQRAEQecpYiDGm9kGmeVrJU1tl0JBEARB/6CIgXhb0upm9hiApNXwcqBBMB+R0ykIBg5FDMQ3gOskPY7Ppl4V2K+tWgVBEAQdp0gU0zWS1gTG4gbioZTdNQiCIBjAFIliGg4cDGyOz3+4UdJpqRpcEARBMEAp4mI6D5gNnJyWdwcmEiVBgyAIBjRFDMTYpiim6yKKKegLYsA7CDpLkVxMd0vapLEgaWPg5vapFARBEPQHivQgNgb2lvRkWl4FeFDSfYCZ2fpt0y4IgiDoGEUMxPZt1yIIgiDodxQJc31C0tLAytn9zeyudioWBEEQdJYiYa4/xEuPPoaHuZLeP9w+tYIgCIJOU8TFtCuwupm92W5lgiAIgv5DkSim+4GlqgiXtL2khyVNl3REzvZFJF2ctt8uaXRm2/qSbpU0TdJ9acJeEARB0EcU6UH8FA91vR+Ym2LDzHbs6SBJQ4FTgG2AmcBkSZPM7IHMbvsDL5jZGpJ2A44BPitpGHA+sJeZTZW0LBD1J4IgCPqQIgbiXPzBfR/wTgnZE4DpZvY4gKSLgJ2ArIHYCTgqfb4M+JUkAdsC95rZVAAze67EeYMgCIIaKGIgnjWzX1aQvSLwVGZ5Jj6nIncfM5sjaRawLLAWYJKuBEYBF5nZsc0nkHQgcCDAKqusUkHFIAiCoDuKGIg7Jf0UmERXF1NvYa7KWWcF9xmGJwccD7wKXCPpTjO7psuOZmcAZwCMGzeuWXYQBEHQAkUMxPvT+yaZdUXCXGficycarAQ83c0+M9O4w5LA82n9DWb2LICky4GNgGsIgpIUyekEkdcpCJopMlFu64qyJwNrShoD/APYDdijaZ9JwD7ArcDOwLVm1nAtfVPSosCbwJbACRX1CIIgCCrQrYGQ9DkzO1/SV/O2m9kvehKcxhQOAa4EhgJnmdk0SUcDU8xsEnAmMFHSdLznsFs69gVJv8CNjAGXm1mxZmAQtJHIMBsMJnrqQSyW3kdWFW5mlwOXN607MvP5dbqpK2Fm5+OhrkEQBEEH6NZAmNnp6f0HfadOEARB0F8oMkgdBEHNxMB5sCBQJNVGEARBMAgJAxEEQRDk0quBkPRuSWdKuiItryNp//arFgRBEHSSImMQ5wBnA99Ny48AF+MhqkEQdJgIvQ3aRREX03JmdgkpUZ+ZzQHebqtWQRAEQccpYiBeSem2DUDSJsCstmoVBEEQdJwiLqav4ikxVpd0M55ddee2ahUEQRB0nB4NhKQhwHA8F9JYPPvqw2YWxXuCIAgGOD0aCDN7R9LxZvZBYFof6RQEQRD0A4qMQVwl6TOp0lsQBEEwSCg6BrEYMEfS67ibycxsibZqFgRBEHSUIvUgKmdzDYIgCBZcejUQkrbIW29mf6tfnSAIOklMuguyFHExfSPzeTgwAbiT3kuOBkEQBAswRVxMO2SXJa0MHNs2jYIgCIJ+QZVsrjOB99WtSBAEQdC/KDIGcTIpzQZuUDYEprZTqSAIgqDzFBmDmJL5PAf4rZnd3CZ9giAIgn5CEQOxlJmdlF0h6bDmdUEQBMHAosgYxD456/atWY8gCIKgn9FtD0LS7sAewBhJkzKbRgLPtVuxIAiCoLP05GK6BfgnsBxwfGb9bODedioVBEEQdJ5uDYSZPQE8AXyw79QJgiAI+gu9jkFI2kTSZEkvS3pT0tuSXuoL5YIgCILOUWSQ+lfA7sCjwAjgAODkIsIlbS/pYUnTJR2Rs30RSRen7bdLGt20fZVkmL5e5HxBEARBfRSaSW1m04GhZva2mZ0NbN3bMZKGAqcAHwPWAXaXtE7TbvsDL5jZGsAJwDFN208AriiiYxAEQVAvReZBvCppYeAeScfiA9eLFThuAjDdzB4HkHQRsBPwQGafnYCj0ufLgF9JkpmZpE8BjwOvFLqSIAiCoFaK9CD2Svsdgj+sVwY+U+C4FYGnMssz07rcfcxsDjALWFbSYsC3gB/0dAJJB0qaImnKM888U0ClIAiCoChFsrk+IWkEsLyZ9fjAbiKvRKkV3OcHwAlm9nJPlU7N7AzgDIBx48Y1yw6CIAhaoEgU0w7APcBf0vKGTRPnumMm3ttosBLwdHf7SBoGLAk8D2wMHCtpBnA48B1JhxQ4ZxAEQVATRcYgjsLHE64HMLN7mqONumEysKakMcA/gN3wmdlZJuGpPG4FdgauNTMDPtTYQdJRwMtm9qsC5wyCIAhqooiBmGNms3py9eRhZnNSq/9KYChwlplNk3Q0MMXMJgFnAhMlTcd7DruVUz8IgiBoF0UMxP2S9gCGSloTOBRPw9ErZnY5cHnTuiMzn18HdulFxlFFzhUEQRDUS5Eopi8D6wJvABfikUaHt1OpIAiCoPP0lM11opntBXzBzL4LfLfv1AqCIAg6TU89iA9IWhX4vKSlJS2TffWVgkEQBEFn6GkM4jQ8tHU14E66zlmwtD4IgiAYoHTbgzCzX5rZe/Hoo9XMbEzmFcYhCIJggNPrILWZfakvFAmCIAj6F4WyuQZBEASDjzAQQRAEQS5hIIIgCIJcwkAEQRAEuYSBCIIgCHIJAxEEQRDkEgYiCIIgyCUMRBAEQZBLGIggCIIglzAQQRAEQS5hIIIgCIJcwkAEQRAEuYSBCIIgCHIJAxEEQRDkEgYiCIIgyCUMRBAEQZBLGIggCIIglzAQQRAEQS5hIIIgCIJcwkAEQRAEubTVQEjaXtLDkqZLOiJn+yKSLk7bb5c0Oq3fRtKdku5L7x9up55BEATB/Axrl2BJQ4FTgG2AmcBkSZPM7IHMbvsDL5jZGpJ2A44BPgs8C+xgZk9Leh9wJbBiu3QNgqBeRh/x50L7zfjZJ9qsSdAK7exBTACmm9njZvYmcBGwU9M+OwHnps+XAR+RJDO728yeTuunAcMlLdJGXYMgCIIm2mkgVgSeyizPZP5ewNx9zGwOMAtYtmmfzwB3m9kbzSeQdKCkKZKmPPPMM7UpHgRBELTXQChnnZXZR9K6uNvpi3knMLMzzGycmY0bNWpUZUWDIAiC+WnbGATeY1g5s7wS8HQ3+8yUNAxYEngeQNJKwO+Bvc3ssTbqGQRBP6bIeEaMZbSHdhqIycCaksYA/wB2A/Zo2mcSsA9wK7AzcK2ZmaSlgD8D3zazm9uoYxAEg4gwNuVom4spjSkcgkcgPQhcYmbTJB0tace025nAspKmA18FGqGwhwBrAP8j6Z70ele7dA2CIAjmp509CMzscuDypnVHZj6/DuySc9yPgB+1U7cgCIKqDJaeSMykDoIgCHIJAxEEQRDkEgYiCIIgyCUMRBAEQZBLGIggCIIglzAQQRAEQS5hIIIgCIJcwkAEQRAEuYSBCIIgCHIJAxEEQRDkEt3VlLQAACAASURBVAYiCIIgyCUMRBAEQZBLGIggCIIgl7Zmcw2CIAh6pj9nho0eRBAEQZBL9CCCIAgGAEV6IlCuNxI9iCAIgiCXMBBBEARBLmEggiAIglzCQARBEAS5hIEIgiAIcgkDEQRBEOQSBiIIgiDIJQxEEARBkEsYiCAIgiCXMBBBEARBLm01EJK2l/SwpOmSjsjZvoiki9P22yWNzmz7dlr/sKTt2qlnEARBMD9tMxCShgKnAB8D1gF2l7RO0277Ay+Y2RrACcAx6dh1gN2AdYHtgf+X5AVBEAR9RDt7EBOA6Wb2uJm9CVwE7NS0z07AuenzZcBHJCmtv8jM3jCzvwPTk7wgCIKgj5CZtUewtDOwvZkdkJb3AjY2s0My+9yf9pmZlh8DNgaOAm4zs/PT+jOBK8zssqZzHAgcmBbHAg8XUG054NkWLq1uOf1VVujU97JCp76XFTrBqmY2Km9DO9N9K2ddszXqbp8ix2JmZwBnlFJKmmJm48oc0045/VVW6NT3skKnvpcVOvVMO11MM4GVM8srAU93t4+kYcCSwPMFjw2CIAjaSDsNxGRgTUljJC2MDzpPatpnErBP+rwzcK25z2sSsFuKchoDrAnc0UZdgyAIgiba5mIyszmSDgGuBIYCZ5nZNElHA1PMbBJwJjBR0nS857BbOnaapEuAB4A5wH+b2ds1qVbKJdUHcvqrrNCp72WFTn0vK3TqgbYNUgdBEAQLNjGTOgiCIMglDEQQBEGQSxiIIAiCIJcwEBWRtLSk9TutR51Iel9NcpapQ05/Q9Iu6X1Mp3XJUpc+7bo+SSMkja1TZkU9ars+Sdek92NalVU3kjYrsq6QrIE+SC1pSTyf04r4ZLungSvN7MUKsq4HdsSjv+4BngFuMLOvlpQjPHVIVqc7rOSPkX70e8zsFUmfAzYCTjKzJ8rIyci7CVgYOAe4sMp3lOQ8in8/Z+Mz4EvfZJI+3dN2M/vfkvKOBX4EvAb8BdgAOLwxW7+gjLvMbKPGe5nz58i6j5zJnw3MrHDjQ9KdZvYBSdeY2Uda0Km268vI3AE4DljYzMZI2hA42sx2LCkn7/uaBUwBfmRmzxWQUefv9wDwJeA0YA+aJvea2V0VZG4KjCYTXWpm51WQM9/1Vb3mAW0gJO0NfB+4CvhHWr0SsA3wg7JfvqS7zez9kg4AVjaz70u6t+SfeVvg/wGPNum0BnCwmV1VQta9+INufWAiHjb8aTPbsqiMHJlrAp8HdsHnnpxtZleXlCHgo0nOBOBi4Bwze6SEjLN72Gxm9vmSOt1jZhtK+i/gU8BXgOvMbIMSMv6Kh2xvCNyYo1Thh56kVdPH/07vE9P7nsCrZnZ0CVl3A38ADsCTXjbr9YuCcq7GH04tX19G5p3Ah4Hrzez9aV2p/0w65ljgbeDCtGq39P4SsLmZ7VBARm3Xl1IJ7Q9sjhupJlH24aKykryJwOp4w6oR0m9mdmgJGR8ENgUOp+t9sATwX2Xu9QbtTLXRH/gu8IHmlrCkpYHbgbLWeZik5YFdk+wqnAR81MxmNOk0BrgceG8JWXPMzCTthPcczpS0T69H9YCZPSrpe/hN/0vg/emB/52irfbUY7gauFrS1sD5wMGSpgJHmNmtBWTsV/ki8lkovX8c+K2ZPe+XVYqP4720icDxrSjT6OVJ2szMst3/IyTdDBQ2EPjD8lP4/3lkC2p9gpquL8McM5tV4btupvl7uk/SzWa2Weo9F6G260t54S6T9D9m9sNWZCXGAetU6W1nWBhYnPnvg5fwicilGegGQuR3498hP99TbxyNT/y7ycwmS1oN7wmUYRieSqSZfzDvIVaU2ZK+DXwO2CKlRC8rYy5pTGU//I90NbCDmd0laQXgVqCQgZC0bNJpL+DfwJfx2fEbApcChX3AkhYBPsP8Xe8yD1CASZIewl1MB0saBbxeUsaZZraXpF+b2Q0lj+2OxSRtbmY3wVw3w2IlZWxvZsdIWqTC9zKXlHX5NkmbmtkzkhYzs1eqykvcL2kPYGjqnR4K3FJBzuKSNjaz2wEkTcAfhuCTaXulTdf342SgVjOzoyWtArzHzMpmfrgfeA/wz6qKpHvyBknnVHUzNzPQXUz7AEfiLqan0upVcBfTD83snA7o9G28B3JRRqeV8VbgJWb20xKy3oP7Pyeb2Y3p5tyqit8yyfsb8GvgMjN7rWnbXmY2Mf/I+eQ8grfSzraUqTez7VtmVnhgT9JfcF/znczremNmhVuAkoYAmwAPAi+Z2duSFgNGmtm/Ssh5AK9vMgnYivn9zs8XlZWR+QHgLDwPGcCLwOfL+LAz7rNaxg6Sq+JMYHEzW0XSBsAXzezgCrIWxXvb2+Lf15X4f6+UcZY0Hv+eFk9yXsJdatOAT5jZJSVk1Xl9p+INzg+b2XuTd+IqMxtfUs51eAPqDuCNxvqSbq8TzexwSX8kP7lpeRfhQDYQMNedtB0+ICy89X6lmb1QQsbJ9DygWNhPmOStgw92Z3WaZGYPlJSzGPB6euCtBayNDwq/VUZORt7hZnZi07rDzOykknLUYlc5K+t+M2s5ukrSrWb2wRZlHIoPTK6G9/iyBsLMbLUWZC+B/x9nVTj2t8AHgVHAY9lNSa+y/v7bcZfEpMy4QS2/Q6vIg07U7DYuKaO268sMfN+dkTW1rL9fUu64YZmeqqSNUo+/ZVkNBrqLCTN7IVnnuRFDZYxDojEItRleHe/itLwL3rItq9MDwAPycFCroE+DvwEfSkbwmqTnZ/GBzirsDZzYtG5ffNykDFdJ2qXxJ076XWRmVUrH3iJpPTO7r8KxzTp9BvjfqsbLzH4J/FLSqWb2pVaUkfQ5Mztf0leb1jfOVWhgOe27e+pNXok3PFrGzJ5qGjeolAstNVy+zvwuwrKDuF1cjZnvqZJLra7rA95Krl1Leo7CexRl9anDZflz4CPAx83sWzXIG9gGQh5SdxrefZ+Jt6hWkvQiHjFUqBtvZucmefsCWzda6JJOw91XZXRaBTgWj+yYldYtCVyLD+DOKCPOzF6VtD9wspkdK+meMvqk8++Ou6rGSMpm3B0J9Bo+mMOobAsvGel3ldSpEdY4DNhP0uN417tSqxj4Ku7bnyPp9YycJUrKoWEc0jUNz6x/soSYxjhDK4PKWZ3+hUe01cFTaSzE5JmYD8Xdc1W4FP8P/obqD2GA/2Oeq/GNXvbtjTqv75fA74F3Sfox3jP5XlkhkjYBTsaDVBbGo+VeKXl/Lp96DztKuogaQm8xswH7wkPGNs5ZvwkwtYK8h4FlMstLAw+XlHEr3sofmlk3FB+DuK2krLtx18JtwLpp3X0VrmtV3Kd+K7Bl5rURMKyCvDuBVZrk31VBp25fHb6vdsCDE14B/o63GKd1Uqek15p46d4HgMcbrwpylgMuwAMM/oNHoS1bUac7a7q2+2v8nmq7viRvbTxc+RDgvRVlTMFD3e9Oz4P9gJ+UlLEzcAUwG7iu6XVtFb0G9BiEpEfNbM1utk03szVKytsPL4d6XVq1JXCUpR5GDTp1u62b/bcEvgbcbB7Fsho++avUmEjdSNoeTzPc6DZvARxoZle2ILOV1npDxtL4QzQr528V5EzFe4B/NZ8XszWwu5kd2MuhebKG4/H06zbpVWqeR5J1Ez7v5wTciO2H9zK/X1ZWXUg6Cn8I/56ug6+lBvQlnYH3klt1NdaCeskWUOH6ppjZOGXmiEi6xcw2raBbXaG3A95A/BKffHIeXSOG9gb+bpn62CVkvgevmw1wu5WIgknHX4TXvji3Sad9gOXMbNcKOrUUrifpJjPbXNJsug7GV3bDSFoO76kJuNXMKtXYlbQjHrO+Av6gWRV40MzWLSnnAOAwfFLiPUm3W62kLzzJavyZpwLvN7N3JN1hZhMqyLoUeAh38R2Njx89aGaHVZDVmFF9n5mtl9bdaGYfKnh8rcEYSebf80WVG9BPEWRr4D22Sq7GOq8vXVejPPIqwAvp81LAk2ZWKp2HPILwo7gr7l94uOu+VmFyW5K3I94wA5+k+Kcqcgb0GISZHSrpY8BOdI0YOsXMLi8rT5o7Q3huzLOkCVYu5nlvvMX4g4xOTwF/xEPvyugzN1wPqByuZ2abp/da/OGJRXBDOAxYR1Kl1jrwQ/xh3qW1XkHOYcB43I23taS18d+gCi9KWhwPErhA0n8oGIufwxpmtouknczsXEkX4oPNVXhdHtL7qLxY1z+AMmM/tQZjAJR9UPbAx2qQUdv1Na4rjUNOajxP0vPmoxV02wvPjXcIPst/ZXxQvjSSfopnMLggrTpMPiHz26WFVfW7DcYXcCpwCt7CAx+DmNxBfW5PN9LdmXWVfLXp5qzFzwscA8wA/owbvj/if6Iqsqak96nAkPT5jgpyJqf3e4BFGp8r6rRY+r6G4T2/Q8mMTZWUdUd6/xvwPtw/XnrcIMkYjzcWVsLzYP2OnDG4AnKuAxbKLC+EpyUpI+PD6f3Tea8ScpZI78vkvSp+Ty1fX+bY+cZYGvdsBVkL42lz1sNzV5WWkeTc2/ivpOWhwL1VZA3oHkRPSDrDyvuMN7YU8wxzo3MWrlGnI61k2J7VFK5n7iaZKmkVq+Dfb+JTwFgzazXaBOprrc+UtBSes+hqSS/gSRKrcKR5GOE7uKsQeVbPKqGFZ6Sxke/hE/AWxyd3VmG0mU0GXsbHH5BnML29pJwV8Oiqhh998bSuDFvgkXl5OZKMgrPy8dxLn8Rb+A2XTlZOlbkndVxfg2flqWnOT/p8jgqRf5I+gUd7PYZf4xhJXzSzKyrqtRTzrm/JnnbskapWakF40U2rA1gWmFlB3u24Nb4rLY8i03qvQd8nS+5/GZ6c6y689fF1fL5B1fNfi0dAXIM/rCZRoeWPR1IsXtN3slj6zrOt9coRJ0nmlvh8gUqtNHIisqjYQqvz1Y1epaLH0jH7AU/gWX3Pwf3++5SUcVh637zT30s7ri8jaxl8ntDd6X94IhV6Nvg41BqZ5dWBhyrqtHvm+s5N17dbFVkDfZD6bfyLam51CFjRzEq1/iXtiYeofgD/8ncGvmdml5aQ8VJ3m4ARZla4V5cGgk/CfZ7C52QcZgVSH3cjr5YZmJJ+h8fkX0PXyJVOR1dtDqxpZmenCU2Lm1neIGp3x38JOBj/807PbBqJR5IVTRqXlfkT4FjrOqnwa2ZWOJY++b0/jqdwuTizaQk8AVyVwfNugzEkrWtm03o5vu70H/OlMs9bV0JeS9dX4jwnm9mXC+z3NzPbIrMsvJTAFj0clidHuItxDu5yFBWCaebKG+AG4lHgI5bjMpH0lJmtXEHm2vhsRfDY4lITbCQ9CYw3s3/XpVOdSHo3fmOB+8f/U0HGPnnrrVw4cHNEVbOsUpFVkr6PZ8wca2ZryRMQXmpdM4T2JmNJfNzpp8ARmU2zrUIepiRzboqGzLpSD9UUnLAhHgWVdU/Nxn3rVWfqd3e+XvVTTek/Uhjwovi4wVbMa+wtgaeVKZP9uBB1GbUisjSv7sk2eITeJfh9vws+x+prFc55p5l9oIq+zQz0MYgT8T90nk/92IoyF8VdHgaMqHD8efiNMJ+BYF6u+0JIOhfvMWRbn8dbhRj6dPyu+HT96/E/4smSvmGe2rgwZQxBDzJGJp2OxsP+Jiad9qTa7OP/At6PuwEws6cllZJjnidpVvI5/8vM3pC0FbC+pPOsWn6gofIsrG8ASBqBR4CV0WsqMFXShTZvlv/SeM2SWo1DotdMyFZf+o8v4vUNVsDHIRrnfgkPGGkHLecmL0F2jObfuPsTvBjZ0hVl3iZpvPl4VGtU8UsNtBewTcH9jgTuwyfL/QCPrPlem3Rat8A+841/5K0rcc6pwLsyy6OoNuO8lhm9SdbtRdYVkNOIFmqMHy1GxXEDPBJqGB6X/xg+Me3yirK+CdyEhz5/Pn3+ZkVZ1+Mt62XwRtGdwC/quicz5yk9rtGDrN8V3O/LdV9HH11fr7LwBudXajznA3iwymN4RNN9Ve/1gd6DKMoxeP2D3tgdnxj1OoCkn+Et0h+1QaeJeKqLnhgiaWlLrUT57M5WftMh1tWl9BzV6pafzbwZvVuTZvRW1OntNPZzEd5r251qkVqXSDodWErSF/CH8a8r6vSOmc1J7oETzezkRmRbWczzZ92Huy2Fp8KuOg9iSTN7KU0KPNtSxcOKsvqKQlFI6Tt+Hz5/ITvjvFJq+z6kSG/r7TSxbb5qgBWpY84IMPBdTEUp+vCagd+cjVz2i9DVv1onRXQ6Hs92ehn+8NwV+HEL5/yLpCuB36blz+JV7soywsyukSTzwiVHSboRNxpl2QMfiD8Jv8ab07qyvAH8FXdNjMVDVUuVUs3wljzB4d7McxFULtRkZlfIq8gNAzf0Vm1Mo46Kh0V4s0ZZhQZB0xjSVriBuBx/CN5E+aqQRajz+opmQr5F0q/wIIO5WRGsQoI9M3tC0kZ4OVTDAyjKJ+ojDESDHm9SzZui/wYwTV7b1vCBpZs6oRN460le83dr3KB82krWlGiS9w15SuzNkrwzzOz3FUS1OqM3q9MMfCZ8q7wbn019F1545q8tyNoPOAj4sZn9XV4u9vwqgiR9ER9cfo15lQ6rxve3VPEwPVS6pfGQMbNNKujWKjvjkXF3m9l+KZjiN2UEtOP65OnMv4GPK86XztyKFyVr5FxqzO5v3AdVUsEciQ9yN+aanC3pUjMr7ekY0FFMRSkQaZAbldPAahiULatT2uejZvbXpnX7tEOfMsirfz2IT9b5IT5R51gzu62CrFHAF5i/nkCVZHbCK5vth0c0XYKXEa21Fyjpd2ZWKE1CirT7oFXMVVUGSd+2HioWyuumgPeSx+FjUsJn995uKSVLzTrNF8XVzX6TzWx8pkE0G5/5XzgnVzuuT56P6zTmr3hYKnVH6iE1Y1ah3oWkB+nqCh+Bj4WUjviKHoQzo6eNRR+4ZR4MBSjSzT0ytfi/hkf2/Abv5VQyEMmnfgze2hfzQhJLhZRaip5IvYhDzWx2FX0S/wfciLf4W6kngJmZpH/hUVFz8CiRyyRdbWbfbEV2E2Va/48Br9Z47p7YBQ/RzcXMtgYaCSUPtJQ5Nfn+v94mnXqdfZ4M+73ymfC/xh/GL+PlOQvTpuubY2anVjw2y8uZz8Px2eNVa1TMoCZX+KDoQcjTDfzFzGanEMWNgB9V9cv1cJ5CraG072Z4LqBX5EXPNwJOshLFxtMf52t4KCC4X/23PRzSm7zpwA5Wcm5Hjpxx+EB1I4x0Fl5nuXTCN6UJV63ok+Qcis/EfhY3pH8ws7carjAzW73Vc2TOVTiOXtL78e/qdto8qbBEa32+77zs76B5BZ/m20S1MqhzY/sljcZzNFUagK/j+jLHHUUN6cxz5C6CZzEoXYVR0h/wuUzNrvD/JN0K31uDpQfxP2Z2qXwm7XbAcXjivY17Pqw0ZaztqcAGaZLTN/GsrOcxLw66CEvj1/AYPnty1TQwXNXq/7tV45A4C6/YdyPMncF8Nt6VL8ufJH3cKmTfbWI5fIymiwE2z0H1yRZlt8LpeIqT+6hQqrIkRe+LByX9hq75hcreF3V/p3Nj+61c1cU86ri+Bg338zcy66qOIWVZtAUZv0+vBtdXVWKw9CDuNk8V/VO84tqFZVr7Jc5TpuXYKHZ+JPAPMzuzzPFJxiPAz8zsrORnPAYYZxWKjCR5JwHvwRPaZVtDRROrNeTcbE0zlPPWFZQ1G5+z8AbwFhXdXn1JyZ5kpaIwVSjRgxgOfIl59QT+Bpza8Gl3Ank9iLXw1DmvULEnkmT1x+vL9riG4nOQjjazX7XhXMXHyAaJgfgTHknzUTyP0mv4xKm6avg2zlPmwXAD8Bd8wHQLfObkPZYKvRSUMV/mVUlbWLW6C0g6O2e1lR0QlnQC3gL6LX7TfxYvqPK7JLBW115/Q9K2ZlaoVrm8jvETeEr02lwU3ZzrO2b2k4L7jsDLxj7c4jnrqLWMpFXz1pdxyTbJq+v6FqKrsbkeON3SjPYScrLXNwfvzVetMdLbuYo/pwaJgVgU2B7vPTwqjxVfr+ifuMR5yjwY3oPH8082sxslrQJsZSUm/qQxiD3JFDAC3mPlChjVTiZaJA+zAlXcJK1tZg91F5rYCSNTt189ycxLFmhWsuJaklVLxJd80tbP8Wy3YyRtiLdmS6fMkDQFr7d+KR45tDeetbSd8zR606nO6/sNPgemERiyF/C2mR1Qm8I1U8rTMRgMBMz1g1fK5NmOB0MdSDoV91t/2MzeK8+/c5WZje/l0GY53zSf0ZtbkrEdA6YFdDrDzA7sxtgUMjJt0Cm3Fdugamu2LiTdgkd8NYdc/q6knDvx+PvrGy1NZWoll5RVW63luqj5+qY2eyLy1vUnyhiIQTFIrUwmT3ywdCF8gKqoT7z2QUzVE1JaVwGjxgDdFMoNtOeSxlXmw8rFdDdmOe9vZo+3qlMdtMMApBb2WcCFVi3ZX5ZFzQsZtcocM5ulroWoqvJquifvkXQsXmt5sToEt0Cd1/e2pNUtzaWRT05sKRy7Dyh84YPCQNBiJs82tQyPpfWQ0rckNTLLNlwMpSNhzOyP6eMDwHfo6qIwyqczeCXzuWpM97dxt8Rl9J6Tqk+py6+e2A0fh5qSjMXZeC+wiqGuK+Lrfkl74Jlm18SLNN1SUVZereVP93hE+6nz+r4BXCfpcfzBuyqpml8nSM+Dc63n2iTFGxHWRxkSO/mipkyewCZAo6Tjm3hL4aWKOt1cw3XtiVd9m4nnYHoY2KUFeQ/jqZnH4Df6qsCqNei5CHBlyWOuxmsAvEimuh0Vq9zVfD9NwTO53o0bh/3wtButyBySvvt/AE/hKRcKVybDH07vpNdreM6p2WXuT2Biev9Oup8mp2v9MTC84nUdVmRdH/9+i2aubzKebLPS9SV5i+Ah3BuQ6p13+PqupIWa1tnXoBiDkPR1PAX1NvhM0s/jXfqTS8ppecBN8wqEbEk9IaWNAkYCrrFMj0SZTK8FZd1k7UmnsDRupNcscczCeM9hIjDfgJ+VrHJXJ3X71SWtjxuZj+N/7gvwRGt7WbnJaS0VukmhpB/DjfDWzdutQmRVnk7tCDEvqMtEM9tL0mFmVjSJXneyPmxm12b+z10o+z+uE3nW4o3w3zGb+O8XZWUNCheTmR0naRtqyORpZtMlDTWzt/EkWGW7ptkCIa/iuYHmiqd4MfeGPg/h9WzzuIZy7pnvp6iM5lKhZY1Wbkx3GRlm9qakycCNnTQG3VCbXz0NmL6IT5Q8wlLhIOB2+Wz7Mtyq1grFnIaHXq+G9xzmqknJyV/ybLd7AGMkTcpsWgJPI98JPpACDT4v6TyafPElDeCW+ATHHXK2lf4f18zT6TWEasW15jJYehCLAa+b510fixuJK6x8rPLf8LkUv8Hz+fwT2NcqRCxI2szMbu5tXSuUbalJOh9YG5jGvLEMs/JhkrXFdKuFusPtIl3fv/Hxh6/gyQhPsQpJ/yStZjUNwqcewFg8F0/lyWSSTjWzL7Woy6q4q3K+8qy4e7ctMf696HQoPmdhNdyV16VWvVULLR5jTdGQees6QRpnNTN7udedu5MxSAzEncCH8NQUt+Gto1fNbM+Scup8MOR1vWurhVtFnqT7rMREvR7kbAJMs5SkT9LieIW82yvIOh53D15K1+5yJ7vw87koWnFbSPoEsC5dC+FUyeJZ62SyulANdc5r1qdHA1jGNdvN/7i2mtBVkCcfnIhXFgTPP7a3mU0rK2tQuJhwQ/iqpP2Bk81j/qtUAPtUegi8TsrbLukwihcFQdIH8dzvoyR9NbNpCdwd00luk7SOtVBTInEqXV1br+asK8oyuEsiO++h0134fZj/N983Z12vSDoNHzTdGu+Z7kzJLKUNOm0I8pAnyjyOFuuc10mB3lGvrtk09rcusGTTOMQSZAx9hzgD+KqZXQcgr5v+a+bVnCjMoDEQ6cG8J177F6pdex0PhoWBxdP5s/7Bl/CHQ52UDfTeHNhHPrv3DapPBOySMNA8IV6le83MOhYy2Eyb/Oqbmtn6acD7B6nH1EnjVzffA8Y3eg0pFPuvePhyf6XI/2YsHr69FF3HIWbjs9k7yWIN4wBgZtcnN3tpBouBOAyPq/+9mU1Lk1l6SgfRhTofDGnA9QZJ57Ta4pN0HF57uLuuY1nf/fat6JPh8eTvbeTJPxio5GeXV+w6FXi3mb0vRfzsaBWqY9XALfi403J4udcGs/Hi8FV4Lb2/KmkF/H4aU1nD/kdddc77kiLVHP8P+D9JHzSzW/tApzI8Lul/cDcTeLbaSmMig8JAmCev+1tm+XF8ckxR2vFgeFXSz5nf91wmhcRDwBmpdX428Fszm5WRVSossUYXxUHAL/HWo+Fd9gMryvo1PhnpdAAzu1fShXjsep+Svp8ngA82+dUfbGHQ9U/yQjjH4ikyoGQpzX7OFaqnznl/5SBJD1qaBZ9Cuo8vG9hRB40wXjzdymi8JyrgBipO3hsUBiJ1a79JxYdxmx4MF+AFyj+JP1D3wTO6FsbMfgP8JkVm7YdX3boZ+HW2i9nXpBbjbjWJW9TM7lDXtAh9HgGTpWa/+nF4ZM2HgFvxP3cdFcr6C4Yb983x7+oMfMJpf6aMa3Z9y6RIMU930+dzPBKNMN59mFenvtEbqpRXpL939eriAry1PQYfXJ6Bz6AsRXow3IGXbtwVj1WvOm6wrJmdCbxlZjekFkfpP458av3a6fUsXmf3q/Kyih1B0rmpVdxYXlrSWRXFPStpdealE9kZ7811koZffR8z2xuYAPxPRVnn4g2XXzIvfUfZ1Cb9mW3M7H/N7Ktm9hUz+z0+Ga9jSFpdXrENSVtJOjR7v1LONTsk9Roaspehcw3vxjyWtfFIzcZM+DvpOq+lONbhaeF98QLuTO/3ZtbdUEHOVOBdmeVRwNSKOt1m86bFfwLPFfVYSRm/AB7FW2gT+3OK6QAAC+BJREFUmrY93MHv++4i6wrKWg0f1HwVj12/iRrSf7R4ffc1LQ9pXlfmniqybkF74b2i+/DQ5Hszr78D53dYt3vwh/gaeDXGE4DLK8raG88z9kN8MuhD+Az4Tl7fqXXJGhQuJrwSGcA/U8z503iJzrLUOeD2I0lL4jWlT8YHvL9SUsb9wPfMLK/o/YSKetXBkGwseYutqn/g4yvX4SGvL+Fd6NLzBGqkTr/63ZI2MbPbACRtDNQ2WbKDXAhcQc5EOWtDMaSSvGNmcyT9F3CimZ1cMewdMztPnoLnw7gb59PWeph4S1iLkxyzDBYDUcfDGGp8MJjZn9LHWeTkvSnInmbWxXXTmHlsmcHqDnA8nvbh0rS8C54crQr/h6eiuAs37P2BOv3qGwN7S2pUBlwFr5l8Hx2sNdIq6f6bBezeaV1yeCtFJu7DvBDVhVqQtwyezfdsSaP6y0zqOhgUM6nrQtIxwO3MezD8DdjEKuTgbyV8U15Td1G8Vb0V8waglsBTiLy3rD51I2lTPKHhO7iLr1IooKT7zex9tSrXIt3Mnq1acKZfFyEaiEhaBw8MudXMfitpDPBZM/tZBVlza82Y2VopVPlSq1B/vT8yKAyEpHPxFMMthaLV/GC4gRS+afOqWhV6GKbZ24cDK9A1p8xLeART7YXOy5D0O4B5YXafSnqVyp6bZJ2Bz36/r14tyyPpS/icjtVw33WDkXj69p5y8AcDEEn3kGrNWIvV6fojg8XF1FIoWvbBICk772Ek1f3FlcM3zdN9nCTpy1Ueun3A/njP6hWY2/O6FXfvFULzMsIOA/aTF2RpZXZ3HfRnv3pQkJQpIK+0bulkfcCbZmaSGlF2na6WVyuDxUC0OmjajgdDy+GbaXBtU+YvUt/pMEnRtezi25SPw669zGur9HO/elCccZnPw/ExsmW62bc3LpHXX1hK0hfwWjO/blG/fsNgcTHtjafauAx/IO+KVwCb2OOB7dVpNXxwc1PgBTz873NmNqOEjInA6njYXuOBbGZWZpZ47ciTEO4D/D6t+hRwjpmd2DmtgqB7VLJYlqRFLNXukNea2RZvBF1pFWvN9EcGhYGAuQNTjVC0a7KhaCpZea1mvRbDw2dnVzj2QWAd64c/oqSNyAzmm1mlMMIgqJt0bzYYgvcovmQl6ro0xiMz6S0GJIPFxUQyCN3FJ5etvFYZdU3xnV0PlC4LeD9etrTTM4vnw8zuwkNTg6C/kc2nNgfPrLBrSRkLS9oH2FQ5ZUetg/VK6mTQGIheqJSnpCKNFN9j8ZxOjeywO5BJKFiQ5YAHJN1B1xKhO7aqZBAMVMys6ryjLAfh5QOa031D5+uV1MagcTH1RF74ah+c8yrgMzav6tpIPH66cMptSVvmrbf+V8M5CPoNadLs94Et0qobgKOrTC6VtL95TrUBSfQgOscqwJuZ5TfxaKTChCEIgkqchbtnG26lvfB0LvO5inrDzM7sp5GEtRAGwulLF1ODicAdkn6Pd0n/C8/sWRhJs5kXz70wni7gFTNbok5Fg2CAsbqZfSaz/IM04a003UUSMkAy8g4KA6H6K6+1jJn9WNIVeB0AgP2ykT5FIqvMLFuyFEmforNJ+oJgQeA1SZub2U0AkjZjXmW/soyjn0YS1sGgGIOQdABeUCe38lp/pOq4iKTbzKy/F2QJgo4haUO8t74k7j14HtjXzKZWkHUpcKiZ9btIwjoYFD0I66eV13qhV7dXU3hdI5574Fv8IGgBM7sH2EDSEmn5pRbEDehIwkFhIKDHymtfNLO6ymPWSZEHfTa8rhHPvVNbtAmCBRxJnzOz85vnIlWcg9TgqBpU67cMCgMh6Rf4w/Ra4CdmdkfadIykhzunWWuYWaVC5EEwSGkk0hvZ414lGOiRhIPCQNB/K6/1RBEX00p4htTN8B7HTXha85lt1i0IFjjM7PTkSXjJzE5oRVYjd1NTJCHMyzY8ICIJq5bLXNDYs9k4SLoG5mbo7HMkHSdp3R52KRJZdTY+E3sFYEXgj2ldEAQ5mNnbQMvjA43EfmY20syWyLxGDhTjAAO8B5GpvLZcKhKUrby2QscUcx4CzpCUG1lVMI34KDPLGoRzJB1es55BMNC4RdKvgIuBVxorU/6wIMOANhDAF5lXee1OulZeO6VTSkFtkVXPSvoc82pk7w48V7+2QTCg2DS9H51ZZ3i25yDDYJkH0S8rryV/6CdxA7EycAmeIvuVIpFVklYBfgV8EL/Bb8Fjsp9sm9JBEAwaBoWBAOhv+VKaIqvOzERWIelhMxtbQMa5wOFNlfKOK1trOwgGE/r/7d1diFVVGMbx/6NIXhRKJVFkWFFBhglJOlERFH0pCqkJWSBdRkmJBSWCFEQ3koSEEYiUUgiWhTcSYtJNn2ZTGXqTNykqhGTCFDO+Xew1055xO3LGcfZi1vODA2fvOXvvdQ7Mec9e613rla4B3gSui4jHUq2YrvG86N5IjfcuJiDb9VJGI7NqVn05joj4s5Na22aF2kI17rcmbR+mGo9wgBiiiABBnuulLI+IzfUdkvZExIMdZFZdbK1tsxJdHRHbJb0KEBG9kvoudFCJSvkyyaby2ihnVq2nysgYVGt7tNpqNk6dkXQVaf6CpHlA1muztaWUAJHTeimjllkVER9I+p7/a20/Ua+1bWaNVlHNH7o5ZQ5OA5a026Q8FTFInWPltVwzq8zGO0lLgd1UmYOLgbnAWs+DOFcRASJXuWVWmZVAUndEzJJ0L1U203rgtYiY23LTslNEF1OOldcyzawyK0H//9t8YFNEfCZpXYvtyVYRASLTyms5ZlaZleAPSe8BD1Gt6HwZ5axL15EiP5SI2En70+r7M6vMbGw9STUG8WhEnAKuBF5ut0l5KuIOItPKazllVpkVI01O/aS2fYwMUuBzVESAIM/Ka+tavr6Z2bCcxWRmZo2KGIOQdL2kTyWdkHRc0o5Uja3NNp2W9Fd69Ejqk3QxxdPNzEZVEQGCDCuvDalENZlqws7GNttkZlZXRBeTpAMRMftC+9om6euImNd2O8zMoJxB6uwqr2WaWWVmNqCUO4jsKq9Jqndx9WdWvR8RJ9ppkZnZYKUECFdeMzPrUCmD1OdUXgNarbyWY2aVmVldKQFiQirOA2RTeS27zCozs7q2vyTHSo6V16ZFRD0gbJH0YmutMTMboog7iFRjYTFwHDhJVXntw3ZbVWVWSZqYHk/TcmaVmVldEYPUOcoxs8rMrM4BoiXOrDKz3BXRxZSp7DKrzMzqHCDak2NmlZnZAH8htSfHzCozswEeg2iRpNupSp8K2BMRB1tukpnZAAcIMzNr5DEIMzNr5ABhZmaNHCDMGkhaKek3Sds6PG6GpKcuVbvMxpIDhFmz54DHI2J5h8fNADoOEJImdnqM2aXmAGE2hKRNwE3A55LWSNos6TtJP0palF4zQ9JXkvanxz3p8LeA+yQdkPSSpBWSNtbOvUvSA+n535Jel/QN0CXpLkn7JP0gabeka9PrVko6KKlb0sdj+VlY2ZzFZNZA0hGqMrCrgIMRsVXSVOBbqhnvAZyNiB5JtwAfRcSc9OW/OiIWpPOsAOZExPNpexfVkipfSgpgWURslzQJ2AcsioiTkpYBj0TEs5KOAjdGxD+SpkbEqTH8KKxgnihnNryHgYWSVqftycANwFFgo6TZQB9w6wjO3QfsSM9vA+4AvpAEMBE4lv7WDWyTtBPYOZI3YTYSDhBmwxOwOCIODdopraNaPv5Oqq7anvMc38vgrtzJtec9EdFXu86vEdHVcI75wP3AQmCtpJkR0dvpGzHrlMcgzIa3G3hB6We9pP4FFacAxyLiLPAM1S9+gNPAFbXjjwCzJU2QNB24+zzXOQRMk9SVrjNJ0kxJE4DpEbEXeAWYClw+au/ObBi+gzAb3hvABqA7BYkjwALgXWCHpKXAXuBMen030CvpJ2BLOvZ34GfgF2B/00Ui4l9JS4B3JE2h+t/cABwGtqZ9At72GISNFQ9Sm5lZI3cxmZlZIwcIMzNr5ABhZmaNHCDMzKyRA4SZmTVygDAzs0YOEGZm1ug/CMmXRWgXYp0AAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Determining the 20 most important features for the chosen machine learning model\n",
    "importances = pd.DataFrame({'features':df_merged.drop(columns=['inf_res']).columns,\n",
    "                            'importance':np.round(forest.feature_importances_,3)})\n",
    "importances = importances.sort_values('importance',ascending=False).set_index('features')\n",
    "importances.head(20).plot.bar()\n",
    "plt.title('feature importance ranking (random forest)')\n",
    "plt.ylabel('feature importance')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 7.3.3 Drop Least Important Features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Dropping features due to a lack of statistical importance for the model\n",
    "# County Cases and Deaths are dropped as they include also cases from nursing homes and thus artificially \n",
    "# improve the models performance\n",
    "df_merged = df_merged.drop(['for_profit',\n",
    "                            'urban',\n",
    "                            'rating',\n",
    "                            'serious_fed_def',\n",
    "                            'infection_def',\n",
    "                            'total_fine',\n",
    "                            #'county_cases_100',\n",
    "                            #'county_deaths_100',\n",
    "                           ],axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7.4 Data Wrangling of Data Frame with Important Features"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 7.4.1 Split Data Frame into Independent and Dependent Variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Splitting the data into independent 'X' and dependent 'Y' variables\n",
    "X_short = df_merged.drop(columns=['inf_res']).values\n",
    "Y_short = df_merged.filter(['inf_res']).values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 7.4.2 Split Data Frame in Training and Testing Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Splitting the data set into 80% training data and 20% testing data\n",
    "X_train_short, X_test_short, Y_train_short, Y_test_short = train_test_split(X_short, Y_short, test_size = 0.2, random_state = 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 7.4.3 Scale Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Scaling the data to bring all features to the same level of magnitude\n",
    "sc = StandardScaler()\n",
    "X_train_short = sc.fit_transform(X_train_short)\n",
    "X_test_short = sc.transform(X_test_short)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7.5 Hyperparameter Tuning (Random Forest Classification Algorithm)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "# Creating different options for tuning for the parameters criterion, min_samples_leaf, min_samples_split and n_estimators\n",
    "param_grid = {\"criterion\":[\"gini\",\"entropy\"],\"min_samples_leaf\":[1,5,10,25,50,70],\"min_samples_split\":[2,4,10,12,16,18,25,35],\"n_estimators\":[100,400,700,1000,1500]}\n",
    "\n",
    "# Searching for optimal parameters\n",
    "forest = RandomForestClassifier(n_estimators=100,max_features='auto',oob_score=True,random_state=1,n_jobs=-1)\n",
    "clf = GridSearchCV(estimator=forest,param_grid=param_grid,n_jobs=-1)\n",
    "clf.fit(X_train_short, Y_train_short)\n",
    "\n",
    "print('The parameters combination that would give best accuracy is:')\n",
    "print(clf.best_params_)\n",
    "print('-'*100)\n",
    "print('The best accuracy achieved after parameter tuning via grid search is:',round(clf.best_score_,4))"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "# Saving the result of the hyperparameter tuning as it is highly time and resource consuming\n",
    "The parameters combination that would give best accuracy is:\n",
    "{'criterion': 'gini', 'min_samples_leaf': 5, 'min_samples_split': 2, 'n_estimators': 1500}\n",
    "----------------------------------------------------------------------------------------------------\n",
    "The best accuracy achieved after parameter tuning via grid search is: 0.7519"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7.6 Run Random Forest Classification Algorithm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ">forest 0.7497 (0.0119)\n"
     ]
    }
   ],
   "source": [
    "# Creating a list of models to evaluate\n",
    "def get_models():\n",
    "    models = dict()\n",
    "    models['forest'] = RandomForestClassifier(n_estimators=1500,criterion='gini',min_samples_split=2,min_samples_leaf=5)\n",
    "    return models\n",
    "\n",
    "# Creating a function to evaluate a given model using cross-validation\n",
    "def evaluate_model(model, X_train_short, Y_train_short):\n",
    "    scores = cross_val_score(model,X_train_short,Y_train_short,scoring='accuracy',cv=10)\n",
    "    return scores\n",
    "\n",
    "# Assigning the models to evaluate\n",
    "models = get_models()\n",
    "\n",
    "# Evaluating the models\n",
    "for name, model in models.items():\n",
    "    scores = evaluate_model(model,X_train_short,Y_train_short)\n",
    "    model_results.append(scores)\n",
    "    names.append('forest2')\n",
    "    print('>%s %.4f (%.4f)' % (name, mean(scores), std(scores)))\n",
    "\n",
    "# Saving the results of all models including the stacking ensemble in order to save time to reproduce the results \n",
    "np.save('model_results2.npy', model_results)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "RandomForestClassifier(bootstrap=True, ccp_alpha=0.0, class_weight=None,\n",
       "                       criterion='gini', max_depth=None, max_features='auto',\n",
       "                       max_leaf_nodes=None, max_samples=None,\n",
       "                       min_impurity_decrease=0.0, min_impurity_split=None,\n",
       "                       min_samples_leaf=5, min_samples_split=2,\n",
       "                       min_weight_fraction_leaf=0.0, n_estimators=1500,\n",
       "                       n_jobs=None, oob_score=False, random_state=None,\n",
       "                       verbose=0, warm_start=False)"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Using RandomForestClassifier method of ensemble class to use Random Forest Classification algorithm\n",
    "forest = RandomForestClassifier(n_estimators=1500,criterion='gini',min_samples_split=2,min_samples_leaf=5)\n",
    "forest.fit(X_train_short,Y_train_short)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_results2 = np.load('model_results2.npy').tolist()\n",
    "names = ['log','knn','svc_lin','gauss','tree','forest','keras','forest2']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plotting performance of models for comparison\n",
    "plt.boxplot(model_results2, labels=names, showmeans=True)\n",
    "plt.title('model accuracy')\n",
    "plt.ylabel('k-fold accuracy')\n",
    "plt.xlabel('machine learning models') \n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7.7 Evaluate Random Forest Classification Algorithm"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 7.7.1 Confusion Matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAUwAAAEYCAYAAAA3cc++AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nO3deZxVdf3H8dd7BlkUxAVUNndcUVEUzT01xKXU0iS1TCmXNJcyt8w1U9Pcl7Kfa5pLi0lIbpWlpoAgLogibomgiIrihiyf3x/nO3QZZu6cgZl75955P3ucB/d8z/d8z/fcvJ/5LmdRRGBmZk2rKXcFzMwqhQOmmVlODphmZjk5YJqZ5eSAaWaWkwOmmVlODpi2RCR1kfRXSR9K+sNSlHOwpAdbsm7lImkHSS+Vux7WeuTrMKubpIOAHwEbALOBCcD5EfHYUpb7beCHwLYRMW+pK9rGSQqgf0RMKXddrHzcwqxikn4EXA78AlgVWB24FtinBYpfA5jcHoJlHpI6lLsOVgIR4aUKF6A78DFwQJE8ncgC6rS0XA50Stt2BqYCPwZmANOBw9K2c4AvgLnpGMOBs4HbCspeEwigQ1r/LvAqWSv3NeDggvTHCvbbFhgLfJj+3bZg2yPAecDjqZwHgR6NnFtd/U8uqP++wJ7AZOB94PSC/IOBJ4BZKe/VQMe07d/pXD5J53tgQfmnAG8Dv6tLS/usk46xRVrvDcwEdi73fxtelnxxC7N6fQnoDNxTJM9PgW2AgcBmZEHjjILtq5EF3j5kQfEaSStGxFlkrda7IqJrRNxQrCKSlgOuBPaIiG5kQXFCA/lWAu5LeVcGLgXuk7RyQbaDgMOAVYCOwElFDr0a2XfQBzgT+C1wCDAI2AE4U9LaKe984ESgB9l3tyvwA4CI2DHl2Syd710F5a9E1to+ovDAEfEKWTC9XdKywE3AzRHxSJH6WhvngFm9VgZmRvEu88HAuRExIyLeJWs5frtg+9y0fW5EjCJrXa2/hPVZAAyQ1CUipkfExAby7AW8HBG/i4h5EXEH8CLw1YI8N0XE5Ij4DLibLNg3Zi7ZeO1c4E6yYHhFRMxOx58IbAoQEeMi4sl03NeB3wA75TinsyJiTqrPIiLit8DLwGigF9kfKKtgDpjV6z2gRxNja72BNwrW30hpC8uoF3A/Bbo2tyIR8QlZN/YoYLqk+yRtkKM+dXXqU7D+djPq815EzE+f6wLaOwXbP6vbX9J6kkZKelvSR2Qt6B5FygZ4NyI+byLPb4EBwFURMaeJvNbGOWBWryeAz8nG7Rozjaw7WWf1lLYkPgGWLVhfrXBjRDwQEV8ha2m9SBZImqpPXZ3eWsI6Ncd1ZPXqHxHLA6cDamKfopeYSOpKNi58A3B2GnKwCuaAWaUi4kOycbtrJO0raVlJy0jaQ9IvU7Y7gDMk9ZTUI+W/bQkPOQHYUdLqkroDp9VtkLSqpK+lscw5ZF37+Q2UMQpYT9JBkjpIOhDYCBi5hHVqjm7AR8DHqfV7dL3t7wBrL7ZXcVcA4yLie2Rjs79e6lpaWTlgVrGIuJTsGswzgHeBN4Fjgb+kLD8HngKeBZ4Dxqe0JTnWQ8BdqaxxLBrkashm26eRzRzvRJpQqVfGe8DeKe97ZDPce0fEzCWpUzOdRDahNJus9XtXve1nA7dImiXpm00VJmkfYCjZMARk/z9sIengFquxlZwvXDczy8ktTDOznBwwzcxycsA0M8vJAdPMLCc/MCCn2i7do8Pyq5S7Gu3Shn2WL3cV2q1nnh4/MyJ6tlR5tcuvETFvsZuiFhGfvftARAxtqWO2JAfMnDosvwp9Dr6i3NVolx4+d0i5q9Bu9ey2TP07r5ZKzPuMTusXvyrr8wnXNHWHVdk4YJpZ6UhQU1vuWiwxB0wzKy1V7tSJA6aZlZaaukW/7XLANLMScpfczCwf4S65mVk+cpfczCw3d8nNzPKQu+RmZrkId8nNzPIR1FRu2KncmptZZapxC9PMrGnCkz5mZvl40sfMLL8KnvSp3FBvZpWn7mlFxZbcRalW0tOSRqb1tSSNlvSypLskdUzpndL6lLR9zYIyTkvpL0navaljOmCaWWmppviS3/HApIL1i4DLIqI/8AEwPKUPBz6IiHWBy1I+JG0EDAM2Jnsl8rWSikZsB0wzKy2p+JKrCPUF9gL+L60L2AX4Y8pyC7Bv+rxPWidt3zXl3we4MyLmRMRrwBRgcLHjegzTzEoo19OKekh6qmD9+oi4vl6ey4GTgW5pfWVgVkTMS+tTgT7pcx/gTYCImCfpw5S/D/BkQZmF+zTIAdPMSiff04pmRsSWjRYh7Q3MiIhxknYuKLm+aGJbsX0a5IBpZiXUIpcVbQd8TdKeQGdgebIW5wqSOqRWZl9gWso/FegHTJXUAegOvF+QXqdwnwZ5DNPMSmspZ8kj4rSI6BsRa5JN2vwjIg4G/gnsn7IdCtybPo9I66Tt/4iISOnD0iz6WkB/YEyxY7uFaWal1XrXYZ4C3Cnp58DTwA0p/Qbgd5KmkLUshwFExERJdwMvAPOAYyJifrEDOGCaWemoZe/0iYhHgEfS51dpYJY7Ij4HDmhk//OB8/MezwHTzEpKNZU7EuiAaWYlkz0Os3JvjXTANLPSEQ1fzFMhHDDNrIREjbvkZmb5uEtuZpaTA6aZWQ6SkF9RYWaWj1uYZmY5edLHzCwPX1ZkZpafu+RmZjnI12GamTVD5TYwHTDNrITkLrmZWW7ukpuZ5SDkFqaVXscONdx17DZ07FBDbY24/5m3ufyBl/nlsE3Zep2VmP159vK8n9zxDJOmzWafLXpz5C5rA/DJnPn87E/P8+K02QD8+4yd+WTOfOYvCOYvCPa57PGynVclOO7o7/HQ/aPo0XMVHh0zYZFt11xxKWefcQovvjadlXv0ICI4/eQTefjB+1m2Sxeu/PUNbDZwCwBW7d6JDTceAEDfvqtz2933lPxcyqJy46UDZqX6Yt4CDr52NJ9+MZ8ONeLuH36JR158F4AL//oif3v27UXyv/n+pwy75kk++mweO23Qk18csAlfv+I/C7cfdO2TfPDJ3JKeQ6UadvChDD/yBxx7xOGLpL819U0e+efD9O23+sK0hx+8n1dfmcKYCZMYN3Y0J594LA/8M/veO3fpwiP/GVfSupedKrtLXrk1Nz79Inv9SIda0aFWZO91atj412fx0WdZq/PpNz5gtRU6l6SO1Wjb7XdgxRVXWiz9jFNP4qzzLliky3n/fSM48FuHIIktB2/Dh7M+5O23p5eyum2OpKJLW+aAWcFqBCN/vD1jz92NxyfP5Jn/fgjAj/dcj1Enbc8Z+2xIx9rF/y/+5tb9+NekdxeuR8AtRw7m3hO3Y9g2/RbLb027/76/0qt3bwZsstki6dOnTaN3n74L13v36cPb094CYM7nn7Pbjlsz9MvbMeqv99JuqImlDWu1LrmkAC6NiB+n9ZOArhFxdjPK2AM4D1iO7KscGREntUJ1K9KCgL1/9RjdOnfg14cPYr3VunLxfS/x7uw5dKyt4fxvDuDIXdfmqgenLNxnm3VX4ptb9+ObVz2xMO2Aq55gxkdzWLlrR249ajCvzPiYsa9+UI5Tqkiffvopl11yAX/4y98W29ZQq7+uFTVh0qus1qs3r7/2Kl/fewgbbjyAtdZep9XrW05SZV+43po1nwN8XVKPJdlZ0gDgauCQiNgQGAC82oL1qxqzP5/H6CnvseMGPXl39hwAvpi/gD+Omcpm/VZYmG+DXt244JubcOSN45j16f/GK2d8lO3z3sdf8OBz77DZ6itg+b3+2iv89/XX2XnbQWyx8bpMe2squ+4wmHfeeZveffow7a2pC/NOe+stVu3VG4DV0r9rrrU2226/I889O6HB8quNu+QNmwdcD5xYf4OkNST9XdKz6d/VF9+dk4HzI+JFgIiYFxHXpv2/Kmm0pKclPSxp1ZS+k6QJaXlaUreU/hNJY9Pxzklpy0m6T9Izkp6XdGDrfA2tY6XlOtKtc9ZB6LRMDdut14NXZ3xCz26dFuYZssmqTH47mwnvvUJnrj1sC378+2d47d1PFubp0rGW5TrVLvy8/Xo9Fu5j+Wy08SZMem0a4ydOYfzEKfTu05e/PzqGVVddjd33/Cp33XEbEcFTY55k+e7Ls9pqvZj1wQfMmZP+UM2cyZjRT7D+BhuW+UxKY2kDpqTOksak3+7Egt/0zZJeK4gBA1O6JF0paUqKAVsUlHWopJfTcmhTx27tWfJrgGcl/bJe+tXArRFxi6TDgSuBfevlGQD8qpFyHwO2iYiQ9D2y4Ppj4CSyl7E/Lqkr8LmkIUB/svcVCxghaUegJzAtIvYCkNS9/kEkHQEcAVDbrWczT711rbJ8Jy7+1qbU1mT/kY16Zjr/eGEGtx09mJW7ZkFz0rSPOOMPzwPwwyH9WXHZjpz7jewylrrLh3p07civDx8EQG2NGDF+Gv9+cWZ5TqpCHHHYITz+6L94/72ZbLr+mpx8+pkccujhDeb9yu578PCDf2PwZhvQpUsXrrzu/wCY/NIkTjr+B9TU1LBgwQKOO/EnrL/BRqU8jbJpgQcIzwF2iYiPJS0DPCapbjzkJxHxx3r59yCLAf2BrYHrgK0lrQScBWwJBDBO0oiIaHQ8SsVmVpeGpI8joqukc4G5wGekMUxJM4FeETE3nfD0iOhRb//xwGER8UwDZW9CFkx7AR2B1yJiqKRTgf2A24E/R8RUSZcA+wOz0u5dgQuAR4EHgLvJxkYfLXY+nVbtH30OvmIJvw1bGmPOHVLuKrRbPbstMy4itmyp8jqt1j/6Hnxl0TyvXrpn7mNKWpasAXV0WkbWD5iSfgM8EhF3pPWXgJ3rlog4sqF8DSnF6OvlwHCyiZvGNBS1JwKDGsl/FXB1RGwCHAl0BoiIC4HvAV2AJyVtQNaqvCAiBqZl3Yi4ISImp/KfAy6QdOYSnJuZNUP2XvLiC9BD0lMFyxGLlSPVSpoAzAAeiojRadP5qdt9maS68ak+wJsFu09NaY2lN6rVA2ZEvE/WihtekPwfYFj6fDDZX4j6LgZOl7QegKQaST9K27oDb6XPC8cdJK0TEc9FxEXAU8AGZK3Iw1MXHUl9JK0iqTfwaUTcBlwCLBzXMLPWImpqii/AzIjYsmC5vn4pETE/IgYCfYHBaZL4NLLf/FbASsApCw+6uCiS3qhSze//Cijsch8HHCbpWeDbwPH1d4iIZ4ETgDskTQKeJ+uCA5wN/EHSo0DhgNsJaQLnGbIhgL9FxIPA74EnJD0H/BHoBmwCjEl/pX4K/LylTtbMGteSs+QRMQt4BBgaEdMjMwe4iWzeArKWY+EFxn2BaUXSG9Vqkz4R0bXg8zvAsgXrrwO75ChjJDCygfR7gcWu9I2IHzZSzhVA/QHIV8han2ZWIhLU1i7dpI+knsDciJglqQuwG3CRpF4RMV1Z1N2XrJEFMAI4VtKdZJM+H6Z8DwC/kLRiyjeErJXaKN9LbmYl1QKXWvYCbpFUS9ZLvjsiRkr6RwqmAiYAR6X8o4A9gSnAp8BhkA0XSjoPGJvynZuGEBvlgGlmJdXcbnd9abhu8wbSG+y1RnYp0DGNbLsRuDHvsR0wzaxkJOomdiqSA6aZlVDbv/2xGAdMMyupCo6XDphmVkLukpuZ5ZPd6eOAaWaWSwXHSwdMMystd8nNzPKQu+RmZrnUPa2oUjlgmlkJyV1yM7O83CU3M8tD7pKbmeUiqOjX7DpgmllJuYVpZpaTxzDNzHKQqnSWXNLyxXaMiI9avjpmVu0quIFZtIU5kcXfrFa3HsDqrVgvM6tStdXYwoyIfo1tMzNbEqrwWyNzze9LGibp9PS5r6RBrVstM6tWNSq+tGVNBkxJVwNfJnt/OGRvXft1a1bKzKpXTY2KLm1ZnhbmthFxJPA5ZK+mBDq2aq3MrCoJUBP/a7IMqbOkMZKekTRR0jkpfS1JoyW9LOkuSR1Teqe0PiVtX7OgrNNS+kuSdm/q2HkC5lxJNWQTPUhaGViQYz8zs8W0QJd8DrBLRGwGDASGStoGuAi4LCL6Ax8Aw1P+4cAHEbEucFnKh6SNgGHAxsBQ4Nr0rvPG656jctcAfwJ6pkj+WN0BzcyaRcW743m65JH5OK0uk5YAdgH+mNJvAfZNn/dJ66TtuyqbedoHuDMi5kTEa8AUYHCxYzd54XpE3CppHLBbSjogIp5v8qzMzOoRUNMCs+SpJTgOWJesUfcKMCsi5qUsU4E+6XMf4E2AiJgn6UNg5ZT+ZEGxhfs0KO+dPrXAXLIoXrl3zptZ2eWIlz0kPVWwfn1EXF+YISLmAwMlrQDcA2zYQDlRd8hGtjWW3qgmA6aknwIHpUoJ+L2k2yPigqb2NTMrpHyv2Z0ZEVvmKS8iZkl6BNgGWEFSh9TK7AtMS9mmAv2AqZI6AN2B9wvS6xTu06A8rcVDgK0i4oyI+ClZH/87eU7GzKy+Gqno0hRJPVPLEkldyIYLJwH/BPZP2Q4F7k2fR6R10vZ/RESk9GFpFn0toD8wptix83TJ36iXrwPwao79zMwW0wJXWvYCbknjmDXA3RExUtILwJ2Sfg48DdyQ8t8A/E7SFLKW5TCAiJgo6W7gBWAecEzq6jeq2MM3LiPrz38KTJT0QFofQjZTbmbWLGLp7yWPiGeBzRtIf5UGZrkj4nPggEbKOh84P++xi7Uw62bCJwL3FaQ/2UBeM7OmSRV9L3mxh2/c0Ng2M7MlVcHxMtcs+TpkTdaNgM516RGxXivWy8yqUEt0ycspzyz5zcBNZOe6B3A3cGcr1snMqphSt7yxpS3LEzCXjYgHACLilYg4g+zpRWZmzaYmlrYsz2VFc9J9l69IOgp4C1ildatlZtVIquwueZ6AeSLQFTiObCyzO3B4a1bKzKpXW+92F5Pn4Ruj08fZ/O8hwmZmzSZUnS1MSfdQ5Eb0iPh6q9TIzKqXqveyoqtLVosKMKBvdx7/5Z7lrka7tOJWx5a7CtaCqrJLHhF/L2VFzKz6CaitxoBpZtYaKngI0wHTzEqrXQRMSZ0iYk5rVsbMqlulX4eZ573kgyU9B7yc1jeTdFWr18zMqpJUfGnL8twaeSWwN/AeQEQ8g2+NNLMlUPcStKV54no55emS10TEG/UuBSj6VGIzs8bUtu2YWFSegPmmpMFApEfC/xCY3LrVMrNqpApoRRaTJ2AeTdYtXx14B3g4pZmZNVsFx8tc95LPIL00yMxsaQjoUMGz5HmeuP5bGrinPCKOaJUamVlVq+oWJlkXvE5nYD/gzdapjplVNVX2hetNXlYUEXcVLLcAXyd7v4+ZWbPU3UtebGmyDKmfpH9KmiRpoqTjU/rZkt6SNCEtexbsc5qkKZJekrR7QfrQlDZF0qlNHXtJbo1cC1hjCfYzM2uJFuY84McRMV5SN2CcpIfStssi4pLCzJI2IpuH2RjoDTwsqe4ljtcAXwGmAmMljYiIFxo7cJ4xzA/43xhmDfA+0GQkNjNryNI+3i0ipgPT0+fZkiYBfYrssg9wZ7q1+zVJU4DBaduUiHg11evOlLfRgFm0S57e5bMZ0DMtK0bE2hFxd64zMzMrkN1LXnwBekh6qmBpdIJZ0prA5kDdmyGOlfSspBslrZjS+rDovMvUlNZYeqOKBsyICOCeiJiflkafwG5mlkeOWyNnRsSWBcv1DZUjqSvwJ+CEiPgIuA5YBxhI1gL9VV3WBnaPIumN1z3H+Y2RtEWOfGZmRYlcLcymy5GWIQuWt0fEnwEi4p3UsFsA/Jb/dbunAv0Kdu8LTCuS3qhGqyepbnxze7Kg+ZKk8ZKeljQ+32mZmRUSNU0sTZaQDRXeAEyKiEsL0nsVZNsPeD59HgEMk9RJ0lpAf2AMMBboL2ktSR3JJoZGFDt2sUmfMcAWwL5NnoGZWQ6iRS5c347sDbbPSZqQ0k4HviVpIFm3+nXgSICImCjpbrLJnHnAMRExH0DSscADQC1wY0RMLHbgYgFT6WCvLOFJmZktSkt/a2REPEbD44+jiuxzPnB+A+mjiu1XX7GA2VPSj4pU4NLGtpmZNaSFWphlUyxg1gJdaTiSm5ktkWp9vNv0iDi3ZDUxs6qX3RpZ7losuSbHMM3MWoyW/k6fcioWMHctWS3MrN2o3HBZJGBGxPulrIiZVb+6pxVVqiV5WpGZ2RKr4HjpgGlmpaSqHcM0M2tR7pKbmTVD5YZLB0wzK6UqvqzIzKxFuUtuZtYMlRsuHTDNrMQquIHpgGlmpeMuuZlZbkIV3Cl3wDSzknEL08wsL1X2GGbOd7RZW3Pk9w5n9d6rMGjggIVpp53yEzYbsAFbbb4p39x/P2bNmgXAe++9x+67fZkeK3TlhOOOXaScIbvuzKYbr8/Wgway9aCBzJgxo6TnUalqasQTd5zCn644CoDrzjqI0Xedypi7TuP3Fw9nuS4dAdhui3X4z+9PYfbYK9hvt4GLlHHv1T9g+r9/ubCM9kIqvrRlDpgV6tuHfpd7R96/SNquu32FcROeZ+zTz9K//3pcfNEFAHTu3Jkzzz6PCy66pMGybrrldkaPm8DocRNYZZVVWr3u1eDYg77MS6+9s3D95Ev+zNYHXsjgAy/gzbc/4OhhOwHw5vQPOOKs33HX/U8tVsZltz7M8DNuLVmd24K6LnmxpS1zwKxQ2++wIyuttNIiabt9ZQgdOmSjLIO33oa3pk4FYLnllmO77benc+fOJa9nNeqzygoM3X5jbrrnPwvTZn/y+cLPnTstQ0QA8N/p7/P8y9NYsCAWK+eRMZOZ/cmc1q9wG6Mm/teWOWBWqVtvvpHdh+6RK++R3zuMrQcN5ILzz1v4Q7fGXfyTb/DTK/6yWBD8zdmH8PrDv2D9NVfl2jv/VabatX3ukrcSSatJulPSK5JekDRK0nrlrldbd9EF51PboQPDDjq4ybw33Xo7T014jocfeZTHH3uU39/2uxLUsHLtscMAZrw/m6cnvbnYtiPPvo21h/yUF197m/2HDCpD7dq+luiSS+on6Z+SJkmaKOn4lL6SpIckvZz+XTGlS9KVkqZIelbSFgVlHZryvyzp0KaO3WYDprI79O8BHomIdSJiI7KXta9a3pq1bbfdeguj7hvJzbfenushB3369AGgW7duHDjsIMaOHdPaVaxoXxq4NnvvtAkv3ncOt154GDtvtR43/vw7C7cvWBD88cHx7LvrwCKltGdNdchzNTHnAT+OiA2BbYBjJG0EnAr8PSL6A39P6wB7AP3TcgRwHWQBFjgL2BoYDJxVF2Qb02YDJvBlYG5E/LouISImAE9L+ruk8ZKek7QPgKTlJN0n6RlJz0s6MKUPkvQvSeMkPSCpV0o/LrVan5V0ZzlOsKU9+MD9/OqSi/jjPSNYdtllm8w/b948Zs6cCcDcuXMZNWokG288oIm92rczrxrBukN/xgZ7ncV3Tr2JR8ZO5vAzbmXtfj0W5tlrx02Y/Po7RUppx5rojufpkkfE9IgYnz7PBiYBfYB9gFtStluAfdPnfYBbI/MksEKKA7sDD0XE+xHxAfAQMLTYsdvydZgDgHENpH8O7BcRH0nqATwpaQTZiU6LiL0AJHWXtAxwFbBPRLybguj5wOFkf33Wiog5klYoxQm1pO8c8i0e/dcjzJw5k3XW7MvPzjyHi395AXPmzGHvoV8Bsomfq67N/t6sv+6azP7oI7744gv+OuIvjBz1IKuvsQZf23N35s6dy/wF8/nyLrtx+Pe+X87TqkiS+L9zv0235bogwXOT3+K4X9wFwKCNVueuS7/PCssvy547bsIZR+3FoP3PB+DhG05gvbVWpWuXTky5/zyOOuf3PPzEpHKeSqvLeeF6D0mFlxVcHxHXN1ietCawOTAaWDUipkMWVCXVXfLRBygcQ5ma0hpLb1RbDpiNEfALSTsCC8hOcFXgOeASSRcBIyPiUUkDyALvQ6l7WgtMT+U8C9wu6S/AXxo8kHQEWROefquv3npntARuve2OxdK+e/jwRvO/NOX1BtP/M6ahv0mWx6PjXubRcS8DsMthlzWYZ9wL/2XdoT9rcNtuwy9vtbq1ZTkakTMjYssmy5G6An8CTkgNqOYcMoqkN6otd8knAg2NnB8M9AQGRcRA4B2gc0RMTvmfAy6QdCbZFzIxIgamZZOIGJLK2Qu4Ju0zTtJifzwi4vqI2DIituzZo2eLn6BZu6QmljxFZL3HPwG3R8SfU/I7BUNuvYC6uzCmAv0Kdu8LTCuS3qi2HDD/AXSStLCPKGkrYA1gRkTMlfTltI6k3sCnEXEbcAmwBfAS0FPSl1KeZSRtLKkG6BcR/wROBlYAupbw3MzarRqp6NKUNCF8AzApIi4t2DQCqJvpPhS4tyD9O2m2fBvgw9R1fwAYImnFNNkzJKU1qs12ySMiJO0HXC7pVLKxy9eBs4Er0xjHBODFtMsmwMWSFgBzgaMj4gtJ+6f83cnO93JgMnBbShNwWUTMKt3ZmbVfLXCp5XbAt4HnJE1IaacDFwJ3SxoO/Bc4IG0bBewJTAE+BQ4DiIj3JZ0HjE35zo2I94sduM0GTICImAZ8s4FNX2og7XUa+OuQZtZ3bCD/9ktVOTNbMksZMSPisSKl7NpA/gCOaaSsG4Eb8x67TQdMM6suErm63W2VA6aZlVTlhksHTDMrtQqOmA6YZlZC+WbC2yoHTDMrmWZcatkmOWCaWUnleShMW+WAaWYlVcHx0gHTzEqrguOlA6aZlZDcJTczy0W4S25mllsFx0sHTDMrLXfJzcxyquB46YBpZqVVwfHSAdPMSieb9KnckOmAaWalk/PNkG2VA6aZlVQFx0sHTDMrJblLbmaWVwXHSwdMMysdP97NzKwZKrlL3pbfS25mVUgqvjS9v26UNEPS8wVpZ0t6S9KEtOxZsO00SVMkvSRp94L0oSltSnqVd5McMM2spNTEksPNwNAG0i+LiIFpGQUgaSNgGLBx2udaSbWSaoFrgD2AjYBvpbxFuUtuZqXTAo93i4h/S1ozZ/Z9gDsjYg7wmqQpwOC0bUpEvAog6c6U94VihbmFaWYlU/d4t6XpkhdxrKRnU5d9xZTWB3izIM/UlNZYelEOmGZWUjUqvgA9JD1VsByRo9jrgCAi7HQAAAssSURBVHWAgcB04FcpvaEQHEXSi3KX3MxKSk2PVM6MiC2bU2ZEvLOwfOm3wMi0OhXoV5C1LzAtfW4svVFuYZpZabXArM9iRUq9Clb3A+pm0EcAwyR1krQW0B8YA4wF+ktaS1JHsomhEU0dxy1MMysZ/a/bvRRl6A5gZ7Ku+1TgLGBnSQPJutWvA0cCRMRESXeTTebMA46JiPmpnGOBB4Ba4MaImNjUsR0wzaykcnTJi4qIbzWQfEOR/OcD5zeQPgoY1ZxjO2CaWWlV7o0+DphmVlpL2yUvJwdMMyshLXWXvJwcMM2sZPxecjOzZnDANDPLyV1yM7M8/BI0M7N8PIZpZtYM7pKbmeXkFqaZWU4OmGZmOVVyl1wRTT4z0wBJ7wJvlLseS6EHMLPclWinKvm7XyMierZUYZLuJ/s+ipkZEQ29s6fsHDDbCUlPNfehrNYy/N1XDz9A2MwsJwdMM7OcHDDbj+vLXYF2zN99lfAYpplZTm5hmpnl5IBpZpaTA6aZWU4OmLYI6X83rknqXs66VKvC77ihdWu7HDBtIUmKNAso6QfAEZKWL3O1qkq97/irknqHZ14rhgOmLVTwQz4SOBS4MyI+kuRnDrSQgu/4R8ApQLe6bZL8e2zj/EOwhdIPtguwF/Az4BNJRwEDJT0dEb8pawWrhKStgP2BnSJirqQtgU8iYlJhC9TaHgfMdq7eDzQi4hNJI4ELganAJOBFYFNJHSPii3LVtVI1EASXJXv4+LAUPDcBtpa0XUQ8XZZKWi6+cN0AkHQQ0B8YA7yTkt+IiPfStu8Be0XEZ+WqYyWqN2a5OfBWRMyQdBqwPnBrRPxD0oXACxFxaznra8W5hWlIOho4GLgSuA44NyJuVGY4cCIwzMGy+QqC5THAMOAxSRsD+9e11tMfpK8Bvy1bRS0XDzK3YykgrgRsCuwJdAamALekS136pKwHRMTzZapmxZO0E/ANYA+y7vgCYK6kWknbAaeRfcevlLGaloO75O1MQ5MKks4EdgM+i4jdU9oPgPHAmIhYUPqaVq7637GkwcCWZOOW+wBfjYg5knaNiL9LWjki3itXfS0/d8nbkXrjaSeStSgvBl4D5gGXp23DgB8A+zpYNk+973hb4L/AdOB04MOI2DhtGw7sKWmMg2XlcAuzHZJ0PNllLd+PiBfTHT3HAesBqwArA991N3zJpessvwF8JyJekbQv8CNgBFmX/CDgsIh4rozVtGZywGxnJHUhm1z4OfAZWVd8I+CvwAvAqsDbEfFu2SpZ4STtCZwF7BARX0haH1gJ+AA4Bnif7KaASWWspi0BB8wq18B4WkfgN8DyZBepP0l2HeBrEXFyeWpZ2Rr4jrcGjgBeIfuetwfmAD+NiCfLU0trCR7DrGL1xtO+Dswiu8byh8A2wEsR8aak/YDhkrqS3XHiv6I51fuOuwHzgaeBZ8la778ku1zrCJp+W6K1cW5hVrG6H3MaszwQuBvYD7g2Iu5KeX5ANsFzYERMLF9tK5ukk8hmwnsBJ0TE0wXf/4Fkkz77R8TLZa2oLRVfh1mFJK0lafn0Y90GGErWLVyFbMLh+5K+m7KvTPZDdrBsBkmDJA2W1Dk9rGQPsov/BfxF0pD0/e8KnAAc4mBZ+Rwwq4ykvYHfAcem8cppZLc1DgO2IwueTwBnS/pGRJwXES+WrcIVSNJewI3AhmQX93cAvksWGN8GLgLukLQ7Wfd8b8+GVwd3yatImp29GBgOTIyI2QXbjgPeiYi70ucewA0R8UZ5aluZ0l07NwAHR8TogvQ1gJuAr0XEx5L+A3xCdpH65+WprbU0T/pUifTMygOAH0XEk5JqU3ptRMwHaoFTJW1Cdn3g7hHx3/LVuGINAq6KiNGSlomIuSn9XbKnO31DUpBN+lzgYFldHDCrh4A1gOUAUpAs/PcySa8AqwPfcLBsnoLZ8LWAD1PyvIIs88iC5PZkVyAc6NZ79fEYZpVILZ2HgO7pwRl1D9eQpF6SzgEejoirI+KFsla2AhVcanUPsI2kQWlSpya14r8AAria7MHA/o6rkANmdXkV+D6wg6SaSIAdyCZ8Ope1dtVhNPAYcGAKmgsiYn66//4g4L2IeL+8VbTW4kmfKiPpBLL7xO8ku1B9WeBYskkKz9S2AEl9yCbWdgXGAp+Tfef7+/776uaAWYEaeUTbwgmIdOfOGsCOZE/Kuc4/5JaV7skfRHY3z3TgnxExuby1stbmgFlh6t2K159sAuKDyF6m1Ski5hTkrQHwI9rMWoYDZoVKtzQeTvaCsn5k79v5WFKHiJhXfG8zWxKe9KkQ6cEOdZ93IHuYw/5kQXMC8LikLg6WZq3HAbMCSFoH+JmyV7JC9lzF/0TE68DciDgeeB7Yt0xVNGsXHDArQ3eyh2bsJ2kg2QNod5e0d8HkzzvAMuWqoFl74DHMNkzSChExK33emOwBGl2AS4B1yS6i/hXZbY/fIHsVrmdqzVqJW5htlKTdgDGSrkhd8feBa4CPgePJXof7FbK7S7qRXWfpYGnWitzCbKNS1/tJ4Auyh88eT/bYsA3IHvSwCnB5RLxZtkqatTN++EYbFRETJG0B/Av4CBgCfJnsYunuwECgRtIpZBM//stn1srcwmzjUnf8YeD4iLg5PbZtM7IAeq/fPGhWOg6YFSAFzQfJ3jp4bbnrY9ZeuUteASJibJoEGivp84i4sdx1MmuP3MKsIJI2Bz6NiJfKXRez9sgB08wsJ1+HaWaWkwOmmVlODphmZjk5YJqZ5eSAaWaWkwOmLUbSfEkTJD0v6Q+Sll2KsnaWNDJ9/pqkU4vkXSE9Sb65xzhb0kl50+vluVnS/s041pqS/H6kdsoB0xryWUQMjIgBZA//OKpwY3rXebP/24mIERFxYZEsKwDNDphmpeKAaU15FFg3tawmSboWGA/0kzRE0hOSxqeWaFcASUMlvSjpMeDrdQVJ+q6kq9PnVSXdI+mZtGwLXAisk1q3F6d8P5E0VtKzks4pKOunkl6S9DCwflMnIen7qZxnJP2pXqt5N0mPSposae+Uv1bSxQXHPnJpv0irfA6Y1ihJHYA9gLr3ma8P3BoRmwOfAGcAu0XEFsBTwI8kdQZ+C3wV2AFYrZHirwT+FRGbAVsAE4FTgVdS6/YnkoYA/YHBZE9nGiRpR0mDyB6mvDlZQN6qwSMs6s8RsVU63iSy94rXWRPYCdgL+HU6h+HAhxGxVSr/+5LWynEcq2K+l9wa0kXShPT5UeAGoDfwRkQ8mdK3ATYie/kaQEfgCbLndb4WES8DSLqN7IVt9e0CfAcgIuYDH0pasV6eIWl5Oq13JQug3YB7IuLTdIwROc5pgKSfk3X7uwIPFGy7O72K+GVJr6ZzGAJsWjC+2T0d2w9pbsccMK0hn0XEwMKEFBQ/KUwCHoqIb9XLN5DsKfAtQcAFEfGbesc4YQmOcTOwb0Q8I+m7wM4F2+qXFenYP4yIwsCKpDWbeVyrIu6S25J6EthO0roAkpaVtB7Ze9LXSm+6BPhWI/v/HTg67VsraXlgNlnrsc4DwOEFY6N9JK0C/JvshXBd0uuHv5qjvt2A6ZKWAQ6ut+0ASTWpzmsDL6VjH53yI2k9ScvlOI5VMbcwbYlExLuppXaHpE4p+YyImCzpCOA+STOBx4ABDRRxPHC9pOHAfODoiHhC0uPpsp2/pXHMDYEnUgv3Y+CQiBgv6S6y97G/QTZs0JSfAaNT/udYNDC/RPZk+1WBoyLic0n/Rza2OV7Zwd/FrzFu9/y0IjOznNwlNzPLyQHTzCwnB0wzs5wcMM3McnLANDPLyQHTzCwnB0wzs5z+H4m/w6qPWLHiAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.model_selection import cross_val_predict\n",
    "# Creating a function to visualise a multi class confusion matrix\n",
    "def plot_confusion_matrix(cm, classes,\n",
    "                          normalize=False,\n",
    "                          title='Confusion matrix',\n",
    "                          cmap=plt.cm.Blues):\n",
    "    import itertools\n",
    "    if normalize:\n",
    "        cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]\n",
    "\n",
    "    plt.imshow(cm, interpolation='nearest', cmap=cmap)\n",
    "    plt.title(title)\n",
    "    plt.colorbar()\n",
    "    tick_marks = np.arange(len(classes))\n",
    "    plt.xticks(tick_marks, classes, rotation=45)\n",
    "    plt.yticks(tick_marks, classes)\n",
    "\n",
    "    fmt = '.2f' if normalize else 'd'\n",
    "    thresh = cm.max() / 2.\n",
    "    for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):\n",
    "        plt.text(j, i, format(cm[i, j], fmt),\n",
    "                 horizontalalignment=\"center\",\n",
    "                 color=\"white\" if cm[i, j] > thresh else \"black\")\n",
    "    plt.ylim(len(classes)-0.5,-0.5)\n",
    "    plt.ylabel('True label')\n",
    "    plt.xlabel('Predicted label')\n",
    "    plt.tight_layout()\n",
    "\n",
    "# Creating the multi class confusion matrix and applying the new function\n",
    "predictions = cross_val_predict(forest, X_train_short, Y_train_short, cv=3)\n",
    "cnf_matrix = confusion_matrix(Y_train, predictions)\n",
    "np.set_printoptions(precision=2)\n",
    "\n",
    "# Plotting non-normalized confusion matrix\n",
    "plt.figure()\n",
    "plot_confusion_matrix(cnf_matrix, classes=['No Cases','Cases'],\n",
    "                      title='Confusion matrix')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Precision: 0.7542\n",
      "Recall: 0.7801\n",
      "F1 Score: 0.7669\n"
     ]
    }
   ],
   "source": [
    "# Printing additional evaluation scores\n",
    "print(\"Precision:\", round(precision_score(Y_train_short, predictions),4))\n",
    "print(\"Recall:\",round(recall_score(Y_train_short, predictions),4))\n",
    "print(\"F1 Score:\",round(f1_score(Y_train_short, predictions),4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 7.7.2 Precision Recall Curve"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAzIAAAG2CAYAAACki7PKAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nOzdd3xUVf7/8ddNCD0JvRhQekdBIgiCdARRwAJYsLuILquiuNZVcBVY9avwUxAVda2Ii4BSbFRFQCCK9CK9Se81JOf3x4eemWQSZibt/Xw85pHknnPvfIJxZj73nPM5nnMOERERERGR7CQiswMQERERERFJLyUyIiIiIiKS7SiRERERERGRbEeJjIiIiIiIZDtKZEREREREJNtRIiMiIiIiItlOmomM53kfeJ633fO8xX7aPc/z/p/neX96nrfQ87zLgx+miIiIiIjIGYGMyPwXaJ9Keweg6slHT+DtCw9LRERERETEvzQTGefcT8DuVLp0Bj52Zg5QxPO8ssEKUERERERE5Hx5gnCNOGDjWT9vOnls6/kdPc/riY3aUKhQoQY1atQIwtNnzMGDsGJFpj19rhIRAVFR9jUy0h5RUVCokH3Nkwfy5bOvIiKSxZw4AUeOgHNw7Jh99bwz7ceOQWKi9Tl+HJKSMi9WEQmuqlUhJiZTQ0hISNjpnCvpqy0YHx09H8ecr47OuXeBdwHi4+Pd/Pnzg/D0GfP66/DEE5CcnGkh5BrJyfY+d76dO8/9uWhRS25iYqBaNWjVCipWhCpV7Gu+fOGJV0QkW3IODh+GjRvta1KSvQBv2waHDlnycewY7NoFu3fbHb1TScqOHbB9O2zYYMeSk+16u1ObkCEiOd6wYdCmTaaG4Hneen9twUhkNgHlz/q5HLAlCNcNqcceg5tuguHDYfJk2LfPXrNPPeDcnwN5bN9u53nemWtI4PbssQfA0qUwbty57XnyQPHiULDgmZGcwoXtRmD79vZ+26CBJT4XXwylS1vfCNXmE5Hs6vjxM0nJ/v324rhliyUny5fDsmVQqpQlLytWWBIioVOgAERHn3vM1xu+vw8BSUn2RnfJJVCmTPDjEwm2TB6NSYvnAvjE7XleBWCCc66Oj7aOQG/gWqAR8P+ccw3TumZmj8iEw/mJzqkbXOd/v3+/3SRLTrbHqZtop77ftctGL5KSzn0cOmQ31E5dz9fjr7/sfS0qKuX5334LBw5AkSJw9Kg9cqK4OHvExEClSvb+Ua6cJTwxMVCihP0b5M+f2ZGKSI6VmAiLF8P69faC/9NPULnymTeDw4dhyRL7cLtlC6xbZ8nJjh26M5YeBQrYv9fRo/bGFxUFLVrYCz34vmNZoIAlg7Vq2ZtBbGzK/kWK2N0xzYEWCTvP8xKcc/G+2tL8P9LzvJFAC6CE53mbgBeAKADn3HBgEpbE/AkcBu4JTtjZn+edO43Yn8KFQx9LoJKT7WbRkSP2PvDnn7BokSU+mzbZ18RES44OHDhzo/BU8jV7tr1HV6gAe/faI7Nt3myPQNWoYe99O3ZAw4ZQrJhNe4uJsa9Fi1p7xYr2vlahQmD/nUUkh0pKOpOczJljIyXlytmL59Gj9vOpIfvcwvNsONzX48ABu6NUpMiZhZORkfZzzZpnRioSE+2OXY0aZ+7YFSxo7QUL2nzjcuUgb96s9UYqImET0IhMKOSGERmx9/ft2y2hOTUle9s2uzH555+WLGzcaNOys/NNx+hoe28uXdrej/fvh5tvtvfYcuXseOXKULu2prqJZDuHDtkL17x5sHKl3b3YsAESEs7Mgc3OL2Dpce219iK2f78tZvQ8SzDi4mzIu1EjWxwcGZnZkYpIDnFBIzIiFyIyEsqWtUdqEhNtndKBAzbl+/ff7SbmihWwdm3KwgBZzYED9nXbtjPH/vtf333LlrWRnvz57X2/SRO46CJLclTQQCSMjh+3ubvr18PWrTZ0e+CA3X3Zswc++iizI8yYAgVsWB3sxSYiwl5kly6FG26wEYxSpewOS968Nl0qMtIWF1asaFOrzh9FiYnR0LOIZDkakZFs4dQU8l27zkxt27PHborOn28zOhITre/+/fbYt893tbSsrnFjm0lRoQJccYUlO5Ura2q2yAXZvRu+/97ujCQkwJgxmR1R4PLnt6lUefJAyZJnFvfVqmV3Rk6csEV/tWrZC0dUVGZHLCISNKmNyCiRkRzt6FEb1dm1y9bPbt5sM0NWrYKff87s6AKXL599Xsmf36aRFyliN07Ll4dOnWw0RyRXS0yEhQthyhT7IH/smI2uTJ4Mc+dmdnSmcGFb37F1q92x2LjR5p7Wq3dmUeWxYzYiUqmSjaZcconVpRcRyaWUyIik4cCBM6M9u3fbSE9y8pk93nbtssfo0fY5JCrKppGtXJnZkZ/RqhXUqWM3ZWvVsu+LFs3sqESCzDlLWObNg4EDYc0a++C/b19mR2b14UuXtuHj6Gir8V+6tCUqNWrYSIoWyYmIpIsSGZEQSU62ROfUfnMrV9qoz6lNQHftss9c06dnzjS3vHntxm/FivYZq149G8HJ4mXhRawyyGefWRniw4etAtjvv2eNUog1akDz5ra4rXFj+x+rpM9Np0WyrWPHjrF7924OHDhAUlJSZocjOUhkZCTR0dEUK1aMfAEsDlYiI5IFJCZaIYOlSy25iYy0KW6jRmVOPM89B1ddZY/z93cTCavDh2HmTEtW5s2z79NTMz0YOna00ZMSJWyEp3hxm9JVu7YlLgUKhDcekUx07NgxNmzYQNGiRYmJiSEqKgpPxR4kCJxzJCYmsn//fvbs2cPFF1+cZjKjREYkiztxwmbI7N9vxQv277cS1evWWeKza1fontvzbL+46tWtglqNGvbZrWDB0D2n5HKJibYx1WefwYwZMG2a1WoPh2bNbK+SW2+F+vVVjUvEh61btxIVFUWJUxuDioTAzp07SUxMpGwapW2VyIhkY85ZIrN/v01j27EDvv4afvzRNgL3vOBvYZE/v60xLlvWvlavDu3bw6WXansISafduy1ZWbnSsvIVK2DBgtDNtWzY0P5wCxa0BfOFCtmC+tq1LXFR0iKSppUrV1KhQgXy5s2b2aFIDnb8+HHWrVtHtWrVUu2nfWREsjHPs9kuZ98Ya9HizPdHj9oUtWXLLLH59lu72b11a8af81S1txUrzhx75hlbc1OjBlx2mRUTqFvXvpYrp8+HctKxYzBpko2yzJhh8yiDLTLS/vCuugoaNLCyfh06QLFiwX8ukVwoKSmJKJXxlhCLioq64PVXSmREsrn8+S2hqFvXfu7f374ePmxT0/78E379FQYMuPDnOn7cPpee/9k0JsZKQV9yCbzyispB5xrOWda8Y4dlvcOH26ZOwVKmjA0H7tkDfftCfLz9keXPr+pfIiGmNTESasH4G9PUMpFcJDERfvkF/vjDkpuffgrdmuq6daFNG3jgAfssKjnA4cM20rJyJQwdavMdd+wI3vU7dbI1LDVqWDWw4sWDd20RCdiyZcuoWbNmZochuUAgf2uaWiYigO1/06LFmalpzllRgWXLbM/ARYts0/NgFBdYtMgeb7xhn0urVLHPpc2anZmSpoICWcyGDfDbb/DXX5b17tkDY8acqSUezKSlWDEbXald2yqGde2qBVgiIpIuSmREcjHPOzMtrVs3O5acbJ9XN2ywaWmrV9vm6PPm2Q35jFi+3B4AH31kX/Pnt8+wTZtCu3a23CE29sJ/J0lDcjL88APMmQNjx56btIRK9erQqJF9rVjRstg6dbSwSkQkA6ZPn07Lli154YUX6NevX7rOXbduHRUrVuSuu+7iv//9b0jiCyclMiJyjogI206jdGm44go79txz9vl361YrPLV4sY22LF5sCU5GHD1qoz8JCTBkiB2rXh1atrT12y1bWtEpfda9QEePWgWICRMsm5w1K3zP/eabcPPNttZFREQkyJTIiEhAIiIgLs4ebdueOZ6UZHvfPPecjeCsW5fx5zi/UlpMjC3DeOYZuO46u6mvNd5+OAcbN1rScqrU8ZYtNqR26FBonzs21krZ1axpu91362bzCUVEJOgaNmzIsmXLMrTPT1xcHMuWLSM2h0yB0GJ/EQmqY8dszc3kyTBypC25CKYiRewmf+3aUKuWfXYuU8bW/+R4ycmWrKxZY/+wBw/a0Njs2Za0hENcnA2V5ckDjz9uC64KFQrPc4tIWGixv4TLhS72171NEQmqfPmgXj2rlpuQYJ+v//c/eO016NkTrrnmwtbC7N0LI0ZAnz52rYsvPrPn4U03wYcf2rKPbG/XLpg61aol3H03XH45lCwJFSpAq1b2D9yvH3z1VfCSmLx5oUkTuPde6N0bHnkEBg+2NTULF9o0tU2brNzd1Km2SF9JjIjkINOnT8fzPPr168fkyZNp0qQJBQsWpHTp0jz44IPs3bv3dN9169bheR533303f/zxBx06dKBIkSIULVr0nGuOHDmSZs2aERMTQ6FChWjUqBFffvmlz+ffs2cPzzzzDDVr1qRAgQIUL16cJk2aMGzYMJ8xnm3u3Ll07tyZuLg48uXLR5kyZWjevDkjR470GfP5pkyZQtu2bSlSpAgFChSgXr16vPnmmyQnJ/v9N5ozZw4tW7akcOHCFCtWjNtvv50dwSwMkwZNLRORkCpb1kZQznb4MHz9Naxfb5t5Tp5sxQUyKjHRykiPGWMPsEGDVq3g6quhSxeIjs749UPu0CFLFhISbNf7P/6whCFU8uSxbLJmTdv7pUwZO1aggCUzIiK53KxZsxg4cCCdO3emefPm/PzzzwwfPpz58+fzyy+/kPes18pVq1bRtGlTGjZsSM+ePdm5c+fptj59+jB48GAqV67M7bffTp48eZg0aRLdu3dn48aNPP7446f7bt26lWbNmrF69WoaN27M9ddfz+HDh1m4cCGvvfYaDz30kN94ExISaNq0KYULF6ZLly6UKVOG7du3k5CQwJgxY7j11ltT/X0/++wz7rzzTqKjo+nWrRuxsbGMHz+ehx9+mPnz5/PRqUo9Z5k7dy7/+c9/aNu2Lb169eKXX37h888/Z82aNcyaNSs8exE55zLl0aBBAyci4pxzycnOLVjg3AsvOHfXXc7FxDhniz6C8yhQwLkePZwbN865LVsy+Zc9cMC56dOde/FF5zp0cK5Ro+D+sr4eRYvaP+y4cc4tW+bc4cOZ/I8gIlnZ0qVLfTeE+rUqmI8MmjZtmgMc4D7++ONz2u69914HuMGDBzvnnFu7du3pvgMGDEhxrUmTJjnAde3a1R07duz08UOHDrkrr7zSRUVFuU2bNp0+3rlzZwe4V199NcW1zu53KsYXXnjh9LE+ffo4wC1YsCDFuTt37jz9/amY77rrrtPH9u7d66Kjo11MTIxbtWrV6eNHjx51TZs2dYCbMGGCz3+j0aNHnz6elJTkWrVq5QA3a9asFHH44vdv7SzAfOcnn9DUMhHJdJ5na8X79YP//hf27bPlH6NGwZNPQv36F3b9I0fg009tZOaii+z5PA/69w/x0pITJ2wty0cf2TQtz7OhoRYt4PnnbWH+r78G9zmrVLGNJf/9b/juOxvy2rnT/mE7d7ZF+AUKBPc5RURymBo1atCjR49zjvXv35/IyEg+/fTTc46XLVuWvn37prjGsGHDiIiI4O233z5nBKdgwYI899xzJCYmMubkNIKtW7fyzTffULduXR577LEU14qLiwso7kI+pvsWT2Nz4XHjxnHgwAF69epFlSpVTh/Ply8fL7/8MoDPEZkWLVpw0003nf45IiKCO++8E4BwrYPX1DIRyZIKFbLiV926waBBts597VorxrV0KSxZYo9162D37ow9R79+9qhTx/ayadbMZlxVrWpr2tM1Kn78uK0jWboUfv/ddhhdssSysmAqWBBKlLAAY2OhWjVLUGrVsprZqlctInLBrrrqqhRTo8qVK8cll1zCwoULzzl+2WWXEeWj4szcuXOJjY3lzTffTNF2ah3JipOlOhMSEnDO0aZNGyIyUJ6za9euDBkyhEaNGnHbbbfRpk0bmjVrRrFixdI8948//gCgefPmKdquuuoq8uTJc7rP2er7uMt4KuE6ey1RKCmREZFsISICKle2x/XXnznunC0xmTLFBj4WL7ZBiPRYvNger79uP59673LO1rw/84yt9Ulh1Sro0MFKHAdbZKRtrFOvng1XXXaZjabExdl6FhERCZmSJUv6PF6qVCnWrFnDsWPHzjnmy+7duzlx4gT9+/f3+zyHTpbH33fyptdFF12UoXgbN27M5MmTefnll3nnnXd46623iIiIoF27dgwePJjq1av7PXf//v0AlC5dOkVbZGQkxYsXP93nbDExMSmO5Tn5/pSUlJSh3yO99G4oItma50HhwjYo0bmzHdu1y/Z9HDMGPv/cBkvSw51Vlf6tt+xRubIjb+Ihrim7iGYFE6i9bSrVlo4laOMfefPa6Mrdd9vUs9q1IX/+YF1dRETSwV/lre3bt5M3b17y5ct3+pi/Re0xMTHExMSwdu3aNJ+vSJEiAGy5gPnOLVu2pGXLlhw8eJCZM2fyv//9jw8//JCOHTuydOnSc6a3nR8nwLZt21K0JSUlsWvXLipVqpThuEJJa2REJMcpXtxGbT780JaHjB4Nd9xxYddcvdpj2YbCDP61MTdN602NpWOIwHELI1mO/ztdqWrVCuLjbTHQqT1hHn8cGjRQEiMiWU/mL+EP/HGBZs2ahTvvOps2bWLDhg1ceumlAV2jYcOGrF+/nq1bt6bZt0GDBniex5QpU1KUO06vwoUL0759e95//326devG6tWrWbZsmd/+l112GQA//fRTirbZs2dz4sQJ6tWrd0ExhYoSGRHJ0aKjbX+Zjz+297bVq2HIENuG5eRr9wUZxS3UZDmNmcVDDOUzbuOct77oaGjZ0jbR+ewzWLHCigA4Z/Ph5s2zhUC5YkdPEZHsYdmyZSkW9b/wwgucOHGC22+/PaBr9O7dG+cc999/PwcOHEjRvnTpUrZv3w5AmTJluOGGG1i4cCGvn5rnfJbNmzen+lwzZ85M8RzOudMjS2ePIJ2vS5cuREdHM3z4cNasWXP6+PHjx3n22WcBTi/iz2o0tUxEcpVKleDhh8/8/Ndf8OMnfzHtlXms21mIabTK0HXn0Jg5NOZtHqIHnzHt2ck0v+NivMqVtKZFRCSbadu2Lffffz/jx4+nSpUq/PTTT/zyyy/Ex8enup/L2Tp27MgTTzzBq6++StWqVWnXrh0XXXQRf/31F4sWLeK3335j9uzZp9fYDBs2jIULF/LEE08wduxYmjZtypEjR1i8eDHr1q07J8k432uvvcaUKVNo1aoVlSpVIjIykhkzZjB//nw6dOhAjRo1/J4bGxvLsGHDuPPOO2nQoAHdu3cnJiaG8ePHs3z5cu644w46duyYvn/AMNG7q4jkTuvXw9y5lPnsM+74+mvOnnm2k+J8wL1sohyzaEIC8em+fMuX21DgdZsp1qcPBFA4RkREsogmTZrwz3/+k3/9619MmDCBQoUK8cADDzBo0CC/a018eeWVV2jWrBlDhw5l4sSJHDx4kNKlS1OjRg2GDRtG3bp1T/ctXbo0c+fOZdCgQYwZM4bBgwcTHR1N9erV+ec//5nq8zz44IPExMQwZ84cpkyZQp48eahYsSKvv/46Dz74YJpx9ujRg7JlyzJw4EBGjhzJsWPHqFatGkOGDKF3794B/77h5p0//y9c4uPjXbhqTIuIAFbDedQoePVVK5EcoK2UYSZNmUFzVlKNH2mX7qeuVAnKlbNlMU88YVWURUSyomXLllGzZs3MDiNTTJ8+nZYtW/LCCy/Qr1+/zA4nxwvkb83zvATnnM87ihqREZGcyTmYPdsSlx07bMOZBQtsd8x0KstfdI3+nq6f9IBObcGzvWuGDLG1N+vWpX2NNWvs8dNPtlfl00/bvpX162vmmYiISEZosb+I5BzO2a6Z//d/tvHMVVfB//t/MHKkJTWBJjGRkdCjh2UpmzbZdffvt/rOJ8tsFisG/fvb0y1eDFdfbZt4BiIpCV56CRo2hFKl4Ior4McfM76xp4iISG6k+4Aikr0lJ9tOmB9/DPPnWxnjjLrsMhvBSWXjMF9q14YZM2zZTa9e8N13gZ+7Z4+F3e7kbLUSJaBmTdtKpm9f8LHfmIiIiKA1MiKSnSQl2fDH8uXw55+QkABjx2b8enFxNsrSuLF9jY4OWqgJCTBihG3KebK6ZobUqQNffGHJkohIOOTmNTISXlojIyI5V1ISDB0K48ZZNrBkSXCu26QJvPgitG4dnOv50KCBPYYNs005J0ywhGTyZBtECtTixZbM3HQTPPAAtG0bspBFRESyFSUyIpL1rF0LN94IGzfCrl0Xdq2CBaFAARgwwBKYSy4J6shLWjwPSpaEe+6xx5o18M03VpI5Pb76yh5gOditt0KVKsGPV0REJLvQYn8RyRoOH4ZPPoF69axW8YIFF5bEdO5swyAHD9qQSM+eNrQRxiTGl0qV4NFHrX7Anj02/axTJ4iNDfwazz8PVavaKM0XX4CPDaNFRERyPI3IiEjm2bTJhie+/96+ZlThwlahrG5dePJJWzGfDRQpAvfdZw+wwmjvvw9TpsDEiWmfP2aMPSIjbX+ae+6BW245XVhNREQkR1MiIyLhc/w4TJ0KP/wA06bZqEt6FS1qVcUOHYK777Yaxg0bQjp2Ws6qYmJsylmfPrBvHwwfDgMH2vepSUqy8s0//giDBsGXX6a78JqIiEi2o0RGRELr8GEYP94+XU+Zkvancn8ef9w+4V90Ua4YcoiNtcGlRx+15T0vvhjYeQsX2gy6O+6AChWgVi1o08ZGf0RERHISJTIiElzOwaJF8PPP0Lt3xq9Trhy0bw8PP2xTxnKpfPls481//MNywQkT4NdfU98888QJ+PDDc4+VLGkV1Lp0gTx65RcRkRxAi/1F5MIdO2aJy/XX2zDAZZdlLImJjoY774SffoING+C993J1EnO2EiXgoYdg0iRbWvTVV/ZPFagdO6BrV7j4Yhvp2bkzdLGKiIiEgzbEFJGMOXHCVqRPnAijR1sJrowoVw6uuw5uvtm2s4+MDGqYOd3x45aYDB0KiYnpO7dKFejQASpWhKZNIT4+V8zaE5E0aENMCZcL3RBTIzIiEjjnbJ1LxYoQFWXzlN57L31JTMGCVmLrxRdtCtqGDfD227Y5pZKYdMubF954A1auhGuuSd+5f/4Jb74Jjz1m9RLatYPVq0MTp4iIBEeLFi3wzrvr1K9fPzzPY/r06ZkTVCbRTGkRSV1iopVH/uor+N//rFpYekVE2Nyozz+3W//58gU/zlyuQgX47jtYvx5+/x1WrbKfp04N/BqTJ9soTdu2Nm3thhugUKGQhSwiInJBlMiIiG87d9qt+hkzbNQkverUgcaNbfTl2muttrCE3CWX2APgiSdsP9CpU22vmkDXxZwq5RwVZaM0t91m+4sqqRERkaxEiYyImL17bb3Lr7/a9LGlS9N3foEClrA0amRfa9cOTZySLoULQ6dOttj/229h1Ciry7BmTdrnJiaeWQZVqJAlNaNGWYIjIiKS2bRGRiS3O3IEXn4ZSpeGHj1s0UR6kphSpeDdd2HrVlv0/8QTSmKyqA4d4L//tbUxK1fCZ5/B009D2bJpn3voEIwda2tyhgyxQnUiIjnN9OnT8TyPfv36MXXqVJo3b050dDT16tUDICkpiWHDhhEfH0+hQoWIjo6mZcuWTJkyxef1Nm/ezD/+8Q8qV65Mvnz5KFWqFK1atWLUqFGn++zbt49BgwbRrFkzSpcuTb58+ahUqRJ9+vRhX0b3XssllMiI5DbHjtlCijFjrERy2bLw3HNW/ipQtWrZObNmwbZt8Le/2Q6Oki14HlStalPGBgyA5cuhb19LUgLx6KM2U/DZZ+GHHyA5ObTxikjW4HnZ53GhZs6cSfv27YmNjeWhhx6idevWOOfo1q0bf//730lMTOS+++7jtttuY9myZbRr144vv/zynGssWbKE+vXr89Zbb1G5cmUee+wxbrzxRvbv38/w4cNP91u2bBn9+vUjJiaG7t2707t3b+Li4hg8eDCtWrXieHren3Mb51ymPBo0aOBEJEwOHHBu0CDnrrnGuago56z+WPoesbHODRvm3Lp1mf3bSIgkJTn31VfO3Xuvc2XLpu/P4z//cW7RIudOnMjs30JELtTSpUt9Hs/IW0dmPTJq2rRpDnCA+/zzz89pe/vttx3gHn30UZeUlHT6+M6dO13FihVd8eLF3eHDh08fr1evngPcl19+meJ5Nm3adPr7vXv3ut27d6foM2DAAAe4jz/++JzjzZs3d5z3S77wwgsOcNOmTUvX75vZ/P2tnQ2Y7/zkExqREcmp1q2D4cPh0ktto8mnnrLqY+nZbKRqVVslPmuWraF58MEzK8klx4mIgBtvhPfft003p02zatmBePJJ27v0kktsdqKISHYWHx/Prbfees6xoUOHUqJECV599VUiIs58hC5evDiPP/44u3btYvLkyQDMmTOHBQsW0LFjR7p27Zri+nFxcae/j42NpWjRoin69OrVC8DvtDXRYn+RnOPwYVuVPWECzJ5t9XfTKyICbrkFrr/eqo2VKhX8OCVbiIiw/UkPHbI1Ma+9ZslNWjZvhocftpmHK1fa0isRkewmPv7c/RcPHz7MkiVLqFChAi+99FKK/qtOvueuWLGC66+/nlObvrdr1y6g5/vuu+8YMmQI8+fPZ/fu3SSfNWd369atGf01cjwlMiLZ2fbt8PXXMH26JTD792fsOpGR0LEjDBxo619EzvLII5acfPihDfLNm5f2Ofv3Q5kyUL68jdB06hSceesiIuFQ6rwbeXv27ME5x9q1a+nfv7/f8w6d3Gvt1CL9iy66KM3n+vzzz7n99tuJjY2lffv2VKhQgfz58wPQv39/jqm6il9KZESymxMnrETykCG2QWVG1a5tC/07dIB774UiRYIXo+Q4nmd/JvfeC7/9ZrMM585N+7yNG6FLFysD3aEDPP+8bTEkItmPc5kdQfh45915iTm5F1qLFi2YNm1amucXOfmeumXLljT7vvTSS8FzyUYAACAASURBVBQsWJDffvuNSpUqnT6+bdu2VJMmUdUykewhMRE++giqVYP8+aFp0/QnMUWKQJs2MGyYJUOLF9uuh489piRG0uXyyy2XTk62ZVcPPJD2OQcP2p9s3bqWFA0aZNPQRESyg+joaGrUqMHChQs5fPhwmv2vuOIKAH744Yc0+65Zs4aaNWuek8QAzJ49O2PB5iJKZESyqr17YcQI6NrV5ufcfbete0lKCux8z4MrroB//Qt++cV2RPzxR7uVHhkZ0tAld/A82yRz+HDLjW+8MfBzn37a/qy7dbPyzyIiWV3v3r3ZvXs3jzzyiM+SyHPnzj2d5DRs2JDLL7+ciRMnMnr06BR9N591J6d8+fKsWrWKHTt2nD62fft2nnnmmRD8FjmLppaJZCWJifDdd7Yvy7Zt6T+/QAFLfLp3h8aNwUcVFJFQiIyEr76CGTPg7bfhrL3e/HLORmnGj4f+/W1/mkD3shERCbeHHnqIn3/+mREjRjBlyhRatmxJyZIl2bRpEwkJCSxfvpytW7dS8GS5x08//ZQWLVrQtWtX2rVrx+WXX86+ffv47bffKFCgwOkpar169aJv3740aNCAG2+8kYMHDzJhwgQaN27MsmXLMvNXzvKUyIhktlPzc776yh5796bv/CJF4LrrbDV1x46B18sVCYHmze3x7rswcqQlKmlVDj161Mo3v/WW/Qm3agXNmlmxABGRrMLzPEaOHEmHDh14//33GT16NMeOHaNs2bJceumlPP3005QoUeJ0/5o1a5KQkMDLL7/MxIkTmTZtGkWLFqVOnTqnSysD9OnTh4iICN555x2GDx9O2bJluf/++3n++efJly9fZvyq2YbnMmnlVnx8vDtVmk4k10lOtpGXkSNh7FircZte9etD795w++2gFzrJwlatsnU0S5emb6CxSRMYOhTq1QtdbCKS0rJly6hZs2ZmhyG5QCB/a57nJTjn4n21aURGJFyOH7fEZcYM+PxzSG85xagoK/90553Qvj3k0f++kj1UrQpTp9pUskWLbNrZBx/AX3+lft6sWZav160L99xjsybLlQtPzCIikvVpsb9IqB09Cn//u42a3H23bcYRaBITHW27Ek6ebIv1v/zSppEpiZFsyPPg0kvh5Zdh9Wq4777Azlu0yIrrlS9v15g5M3eVgRUREd+UyIiEyt69dgu5aFEreZwezZrBp5/ahpfTpkHr1hAbG5o4RTJBwYJWlG/uXLjmmvSd26wZxMRYjj90KBw5EpIQRUQki1MiIxJsGzZAnz6WwIwebSMygWja1ObbbNsGP/1ka19O7uwrklNdcYUtF/vrL5ty1rt3YOcdPGizNHv3tqlr992X/tmaIiKSvSmREQmW/fuhcmW45BIYPDiwczp2tI0uDx2Cn3+2hQClSoU2TpEsqHRp21PmzTdhzZr07UmzebPdA8ifH267zWppiIhIzqdERuRCJCfDt9/Cvffa1K81awI775FHbOrZhAm2eF8lk0VOq1jRKpHv2QPvvWfHChQI7NyRI21pmaabiYjkfEpkRNLr+HHbHKN7d9sF8NprbQF/WqpVs/Uuyck2YqM1LyKpKlIE7r/fFvZv3w6ffAJt2qS9aebhw3Zv4J//TLsymoj4llnbc0juEYy/MSUyIoE4etR29WvVyqqPdetmFcQC0asXrFwJK1bY6mTPC2moIjlR4cLQowf8+KONtsyaZWtjUvPqq1C2LPTvD4mJ4YlTJCfImzcvRzSsKSF25MiRC97wU4mMiC/OwZIl8P77VnmsSBG7FTxtWuDXaNsW1q6Ft99O+xOXiAQsIgIaN7Z7A598knb/fv1sQPTVV220RkRSV6JECTZt2sTu3btJTEzU6IwEjXOOxMREdu/ezaZNmyhevPgFXc/LrD/O+Ph4N3/+/Ex5bhGfjh+3RGXqVJs6tnZtxq81YwZcfXXwYhORVF1/vS05S0tEBDz4IPzrX1ZgQER8O3r0KDt27ODo0aOcOHEis8ORHCRPnjzkz5+fkiVLkj+A6qye5yU45+J9tgWSyHie1x4YAkQCI5xzg85rvxj4CChyss9TzrlJqV1TiYxkGUeOwCuv2C59GZl/Ehlp+7w0b25llwNdlSwiQTVvHtx6q222GYjLLrN7F0WLhjYuERHJuNQSmTSnlnmeFwkMBToAtYBbPc+rdV6354AvnXP1gVuAdO7+JxJmzsGYMTZtrHhxm3uSkSRm0CCrPvb99/DMM0piRDLRFVfAqlUwfrxtwxSRxjvcH39A9erw7LNWTEBERLKXQNbINAT+dM6tcc4dB74AOp/XxwExJ7+PBbYEL0SRINq3zyqGVawIN91kG1YGuqCxeHHb3OKTT2DHDkuGnnzSViGLSJbgeXDddfDppzB7Nlx6aer9d+yAAQNsmlnr1jBiBGgWjYhI9pDm1DLP824G2jvn7j/58x1AI+dc77P6lAV+AIoChYA2zrkEH9fqCfQEuPjiixusX78+WL+HSOq2bbMEZuhQOHAg8PPq14cOHazaWIsWEBUVqghFJASSkqzSWc+esHFj4Of16gVDhqRd6llERELrgqaWAb5qxZ6f/dwK/Nc5Vw64FvjE87wU13bOveuci3fOxZcsWTKApxbJoMREWL7cSiRHRECZMjYNLK0kJiICateGgQNtu/DffrO1M23bKokRyYYiI6F9e9iwwV4S6tUL7Lzhw63SevnyMHFiaGMUEZGMCSSR2QSUP+vncqScOnYf8CWAc242kB8oEYwARQLmHMyZA7fdBiVLQs2atmlloJX5rr8eFi6ExYvhqafgootCG6+IhFX16vD77/a/eFxcYOds2mRT1Tp2hN27QxufiIikTyCJzDygqud5FT3Py4st5v/mvD4bgNYAnufVxBKZHcEMVMSvrVut6ljt2ra5xMiRthYmEPXrW/+9e+Gbb+waIpKj1a5tCcoff8BjjwV2zqRJtkzub3+Dv/4KbXwiIhKYQMsvXwsMxkorf+Cce9nzvBeB+c65b05WMXsPKIxNO/unc+6H1K6p8suSYdu3W1mijz+2W6sZuU16993w979Dgwa2OlhEcq3kZHjjDejbN7D+ERG2P+6rr0LdunoJEREJpQveRyYUlMhIuqxbB08/bbVVE1LUkQhMqVLQsKEt+L/44qCGJyLZn3Pw9dfQvz8sWBDYOTVrWkLTsWNoYxMRya2UyEj2k5Rk23R/8gmsWGEjL+lVuDDUqQNVqtgueddcYyt/RUTSsGcP9O5t9UICKcfcpw+89lrae9eIiEj6KJGR7GPWLPs0MHEiHD+esWs0a2a74d1+u/Z4EZELsmyZTTmbNCntvrfdBh98YNXOREQkOFJLZPKEOxiRFI4ds40e3nwTfkh1aZV/tWrZZpV33WUjMCIiQVCzpt1XWbUKWra0quz+fP45rF4No0bBJZeEL0YRkdxKiYxknpkzbb+WH3+0fV/S67HHoHNnuPJK7VonIiFVtapVOps7F774AsaOtaV75/v1V6hQAW64AcaMCXeUIiK5i6aWSXgtXmyfAsaNgyVL0ndumTLw0EM28qIyySKSiU6cgGeftcrv/lStCosWaaqZiMiF0NQyyVxr1tjE8a++soX76Umer7sOKle2csmBbsktIhJiefLAf/5jm2z27Gn1Sc63ahXkzw+TJ0Pr1uGPUUQkp1MiI6GxcydMnQrvv29Tx9KTvFSqBE8+CXfeaZ8CRESyqHvvtZGXq6/236dNGxtI/vJLFU4UEQkmJTISPBs2wMiR8N13MGNG+pIXgMaN7VPB3Xfb7U4RkWygWTObNVunjv8+Y8bY7NiFC6Fs2fDFJiKSk+nTolyYdevgm2/sXfqnn9KfvFx+OTzyCHTvronkIpJt1a5tL38vvwzPPw/JySn77NwJF11kBQEaNgx/jCIiOY0SGUmf5GRLWL74At55J2PXqFfPqo3ddRdUrBjc+EREMtGzz0KTJtCqlf8+jRrBP/8JAwZoqpmIyIVQ1TJJ2+HDMGWKVRr76ivYty/914iLgx494J57bHWsiEgOduiQFVn8+GP/fYoWteKNmmomIuKfqpZJ+q1ebVPGpk+3xfpHjqT/GiVLwk032YYKrVvr1qOI5BqFCsFHH1m9knff9d1nzx6bavbkk/Dii9oOS0QkvTQiI2c4Z0nLoEEwbVrGrlGlik0Z69gRLr1UyYuI5HrTp8MDD8DKlf77lCoFEydCvM97jiIiuVdqIzIR4Q5GsqDDh2HUKFt9es01GUtiunaF33+3d+rnnoP69ZXEiIgALVrAggWpl2jevh2uuAJGjPBdKEBERFJSIpNbbdliu7l16WJzIG65BQIdIYuKso0Rhg61ksvO2QYJ9eqB54U2bhGRbKhAAbtHdNddqff729/sntInn8Dx4+GJTUQku9LUstxk1y5b9zJiBMyalb5zS5SA666DTp2gbVsoXDg0MYqI5HDz5kHfvlYAMjWlSsErr6Sd/IiI5GSpTS1TIpOTJSfbKMu4cfDtt7BoESQlBX5+1apw553QsiVceaWmiomIBNGvv9ps3rQKQd50E3zwAcTEhCcuEZGsRFXLcpvFi2HSJBt5WbUq/edffDH8619w992QR38iIiKh0KiRjcr87W8wd67/fl99Ze0jRkC7duGLT0Qkq9MamZxi40Z48EEoUwbq1rV6nulNYrp1s6lnf/4J99+vJEZEJMQuvRTmzIGvv4YGDfz327jRRm/+8x9bligiIppalv2tW2ejJ198ASdOpO/catWgYkW46ip4/HEoWDAkIYqISNqcs1nAHTum3XfnTihePPQxiYhkNk0ty2l27rTtoqdNs3e99Kx7ueQSm5tw7bW2eF+jLiIiWYLn2UtzcjL07w///rf/UswlSti2X23ahDdGEZGsRCMy2cXx4/DDD/C//1mp46NHAz+3RQsrs3zzzRAXF7IQRUQkeFauhOrVU+/TsSNMmBCeeEREMoNGZLKrgwftltvYsbapQHpERUGPHtCzp1UcExGRbKVaNdi7F8qXhwMHfPeZONFGcvbsgSJFwhufiEhmUyKTFU2ZYptNTpoEx44Ffl7hwrbWpXt3qFkzdPGJiEhYxMbabOKrr7Zyzf4ULWr3u3r0CF9sIiKZTYlMVvLLL/D00/Dzz+k7r2hR+Mc/4LHH7F1PRERyjLx5rbLZ7NnQpIn/fnfcYdX3//1vG5QXEcnpVH45sx05AqNH2wL8pk0DT2KKFoUnnrDNBbZts5WhSmJERHKsxo1h69bUC0z+5z9w+eWwZk344hIRySwakcksy5fDK6/YTmf79wd2Tv78tnD/xhtt/kCBAiENUUREspYyZWDfPrj3Xv9LJxcvhsqVYd48iPe5PFZEJGdQ1bJw2rYNBg2y+QGpTXY+W/HiVnGsUydo3RoKFQptjCIiki2sWAEPPAAzZvjvU706zJ9vSyhFRLIjVS3LTEuXwsiRdmvs++/Td+6bb0KvXtrrRUREUqheHaZOheefh5df9t1nxQqIibGpZhUqhDU8EZGQ0yfkUFi7Fr74whKYRYvSd26ZMjZn4LnnNHVMRERSFREBL70EzZtD16427ex8zkHFinZfTQUtRSQnUSITLCdOWOIybJiVl0mvG26ABx+EVq0gMjL48YmISI7Vtq2tjSlf3n+fWrXg00/h9tvDF5eISCgpkbkQztktru++g759M3aNPn3s3IsuCm5sIiKSq5QrZ/soV6oE27f77tOjB+zebRX7RUSyOyUy6eUcrF4N774LY8bY9+lRqhTcc48t3m/c2LZkFhERCYJChayuzLvvWiEAXx5+GKpUgQ4dwhubiEiwKZEJ1MqV8MYb8OWXdjsrPRo1gu7drXRy3bpavC8iIiHVs6dV7L/rLt/t119vBQKefDK8cYmIBJM+UadlwQIYOhQ++ggSE9N37oABcMsttspSREQkjO68E2rUsHtp50tKgqeegh9+gLFjrbKZiEh2E5HZAWRZc+fC1VdD/fowYkTgSUzr1vaukJwMTz+tJEZERDJNw4awcaP/ZZhTp0JsrL3liYhkN0pkznbiBEyaZJXDGjWCn38O7LwmTWyM/o8/YPJk28BSa19ERCQLKFfO6tK0bu2/T6NGMHFi+GISEQkGTS1LToaFC2HUKPj4Y9iyJe1z8ueHyy6zhOXmm23VpIiISBYVG2v36a6/3qaT+XLDDfDtt6knPCIiWUnuTWQWLLA9X8aPh7/+CuycqCibLvb445pQLCIi2UrevLZbwG232Z7N50tMhDZtbC/mTZugWLHwxygikh65d2rZxo3w3nuBJTGlS8MTT1jf/v2VxIiISLbkebZ387x59tbmy5EjULw4LFkS3thERNIr9yYyrVvbbafUXHyxLfRfvx5eeUW3p0REJEeIj7dZ1ZUq+e9z5ZUwblz4YhIRSa/cm8gULAht26Y8nicPdO5sr96rVsF990G+fOGPT0REJIRKlbL1MgUL+m4/eNDWzTzzjO0FLSKS1eTeRAagUyf7mjevJTWvvw6bN1sS07mzHRcREcmhKle2WdP16/vvM3AglCxphT1FRLKS3LvYHyxZKVrUkpjo6MyORkREJOyio+G332DGDOjeHbZtS9ln1y5rGzlS9/hEJOvI3SMyJUrAjTcqiRERkVyveXNYvhw6dPDdPmYMtGgB69aFMyoREf9ydyIjIiIipxUpAhMmQOPGvttnz4bq1a2Ap9bNiEhmUyIjIiIip0VEwKxZ8MYbvtuPH4d+/SAuzvqJiGQWJTIiIiKSwqOP+k9mALZuhauuguee0+iMiGQOJTIiIiLi06OPwqhRqe8D/fLLULUqbNkSvrhERECJjIiIiKSiWzdYsADq1fPfZ/Vqm2o2ZAgkJ4cvNhHJ3ZTIiIiISKoqVrQSzUOHpt7v0UchKgp27AhPXCKSuymRERERkTR5Hjz0EKxaBTVr+u+XnAylSsGkSeGLTURyJyUyIiIiErAqVWyq2T33pN6vY8e0R3BERC6EEhkRERFJl7x54YMPYOZMiIz03693b8iTB+bMCV9sIpJ7KJERERGRDLnqKjhxAq65xn+fpCTbYPP558MXl4jkDkpkRERE5IJ89x2MHZt6n3//20ZnvvsuPDGJSM6nREZEREQuWJcusGtX6n2SkqBDB+jUSZtoisiFUyIjIiIiQVGsGBw/nvYi//Hj4YYbbFqaiEhGKZERERGRoImKsjLNmzZBiRL++339NdSuDXv2hC82EclZlMiIiIhI0MXFwebNltT4s3IlVKgA06aFLSwRyUGUyIiIiEhI5M1r08x27YL4eN999u+Htm3h9dfDG5uIZH9KZERERCSkihWDefP8j84kJcHjj8OVV8KBA+GNTUSyLyUyIiIiEhZDh0Lfvv7bf/0VLr8c1qwJX0wikn0pkREREZGwefVV+OMPKFfOd/uff0KDBjBkiEo0i0jqlMiIiIhIWF16KSQkQOXKvtv37oVHH4XISE01ExH/lMiIiIhI2JUqBcuXw7PP+u/jHHTvrv1mRMQ3JTIiIiKSKfLkgZdegkmToGBB332+/RZq1YJt28Ibm4hkfQElMp7ntfc8b4XneX96nveUnz7dPM9b6nneEs/zPg9umCIiIpJTdegA69b5b1+1Cpo2hUOHwhaSiGQDaSYynudFAkOBDkAt4FbP82qd16cq8DRwlXOuNvBoCGIVERGRHKpkSUhOhuee893+559QuzbMnBneuEQk6wpkRKYh8Kdzbo1z7jjwBdD5vD5/A4Y65/YAOOe2BzdMERERyek8D1580X+J5vXroVkzuPNOjc6ISGCJTByw8ayfN508drZqQDXP837xPG+O53ntfV3I87yenufN9zxv/o4dOzIWsYiIiORYnmclmgcP9t/nk0+gYUPYuNF/HxHJ+QJJZDwfx86v7J4HqAq0AG4FRnieVyTFSc6965yLd87FlyxZMr2xioiISC7xyCMwejTky+e7felSqFMHxo8Pb1wiknUEkshsAsqf9XM5YIuPPl875xKdc2uBFVhiIyIiIpIhN90E8+dDlSq+2/fvh06d4P/+L7xxiUjWEEgiMw+o6nleRc/z8gK3AN+c12cc0BLA87wS2FSzNcEMVERERHKfOnVg0SL4978hws+nlr594ZlnrFiAiOQeaSYyzrkTQG/ge2AZ8KVzbonneS96ntfpZLfvgV2e5y0FpgFPOOd2hSpoERERyT3y57dqZlOn2ve+DBwIzZvbJpsikjt4zp2/3CU84uPj3fz58zPluUVERCR7Wr4cWrWCrVt9t8fGwv/+B23bhjcuEQkNz/MSnHPxvtoC2hBTREREJCuoUcMW+pcu7bt93z5o1w7eeAMy6V6tiISJEhkRERHJVooUgcWL4Y47/Pd57DFbX5OYGL64RCS8lMiIiIhItlOiBHz8MUyeDEWL+u6zdCnkzWvVzUQk51EiIyIiItlW69bw229QsaL/PvXqwYkT4YtJRMJDiYyIiIhkaxUqWDLTqJHv9rVroWNH2LYtrGGJSIgpkREREZFsr0gRmD0bLr/cd/sPP0CZMjBsWHjjEpHQUSIjIiIiOYLnQUIC3Huv/z5//zvcd5+mmonkBEpkREREJEd57z0YMMB/+wcfQHQ07NwZvphEJPiUyIiIiEiOEhEBTz8NH37ov8/Ro1YE4JdfwheXiASXEhkRERHJke6+G1asgPLlfbdv3gxNm0KzZmENS0SCRImMiIiI5FjVqsH69dCzp/8+M2dav6NHwxeXiFw4JTIiIiKSo3kevP02vPQSREb67rNqFRQoADNmhDc2Eck4JTIiIiKS40VEwLPPwpw5qfdr0SL1tTUiknUokREREZFcIz4etm+HUqX897n3Xnj//fDFJCIZo0RGREREcpWSJWHbNmjZ0n+fRx9VeWaRrE6JjIiIiORKU6fao1KllG0HD1qis25d2MMSkQApkREREZFcq2VLWLQIqlRJ2bZ4MbRvD0lJ4Y9LRNKmREZERERytYIF4ZtvfLetWAEvvBDeeEQkMEpkREREJNerWRPGjPHd9vLL8Oab4Y1HRNKmREZEREQEuOEG/wnLww/DL7+ENx4RSZ0SGREREZGTeveGrl19t7VtC5MnhzceEfFPiYyIiIjIWUaMgLx5Ux4/csSSmf/7v/DHJCIpKZEREREROUtMDGzeDFFRvtv79oWePcG58MYlIudSIiMiIiJynhIlICHBvvry3nvQvLlKM4tkJiUyIiIiIj7UrWt7yfjz889QtSrs2hW+mETkDCUyIiIiIn6ULg2bNsHFF/tuX7sWqleHzz8Pb1wiokRGREREJFVxcbB0qSUsvuzaBbffDr16wbFj4Y1NJDdTIiMiIiKShkKFYNkyePBB/33eecfWzezbF764RHIzJTIiIiIiAfA8GDYMxo6FIkV89/n1V+jWTRXNRMJBiYyIiIhIOnTpYkUAbrjBd/sPP0D//uGNSSQ3UiIjIiIikk5xcTB6NDz1lO/2/v2hXz+NzIiEkhIZERERkQyIiICBA+GNN3y39+8PN94Ihw6FNy6R3EKJjIiIiMgFeOQR+Mc/fLeNG2elm5cuDW9MIrmBEhkRERGRC+B5MHgw3Hyz7/bdu21zzU8/DW9cIjmdEhkRERGRCxQRYZti9unjuz05Ge64A6ZPD2tYIjmaEhkRERGRIIiKgtdfh0GDLLHxpW1bmDQpvHGJ5FRKZERERESC6Mkn4ccffbedOAEdO8Inn4Q3JpGcSImMiIiISJC1agV79kDBgr7b77sPfv89vDGJ5DRKZERERERCoEgR+PVX322JifDoo7Z2RkQyRomMiIiISIjUqQNffOG77aefoEsXOHIkvDGJ5BRKZERERERCqHt3K8FcuHDKtvHjoVEj2LIl/HGJZHdKZERERERCrGhR+Oor322LFkHDhrBmTXhjEsnulMiIiIiIhEG7djBwoO+2zZuhWjWYOTO8MYlkZ0pkRERERMLkqafg2Wd9tyUlQbNm8P774Y1JJLtSIiMiIiISRi+9BKNGQZ48vtvvvx8++yy8MYlkR0pkRERERMKsWzf/m2YC/O1vsHhx+OIRyY6UyIiIiIhkghYtYN06KwRwviNHoHNn2Lo13FGJZB9KZEREREQyySWXwB9/+G5bswbq1oUdO8Ibk0h2oURGREREJBOVL2/JSqlSKdt27YIOHeDYsfDHJZLVKZERERERyWQlSsDYsb7bEhLgnnsgMTG8MYlkdUpkRERERLKAJk1g4kTImzdl28iRcPfdcPRo2MMSybKUyIiIiIhkEddeC999B1FRKds+/xxq1oSffw5/XCJZkRIZERERkSykZUsYMMB327p10KYNbNkS1pBEsiQlMiIiIiJZzOOPw6uv+m47fhzi4mDZsvDGJJLVKJERERERyWI8D/r2haFD/fdp0CD1TTVFcjolMiIiIiJZ1EMP+a9mduQItGsHN90EBw6ENy6RrECJjIiIiEgW1qWLVS3zZ8wYqFHD/8aaIjmVEhkRERGRLO6WW6yaWfHivtu3bIF69VJPeERyGiUyIiIiItnANdfADz9A2bL++9x2G7zzTvhiEslMSmREREREsonLL4dVq6BXL/99evWCFSvCF5NIZlEiIyIiIpKNFCoEb78Ns2dDdLTvPg0bwpQp4Y1LJNyUyIiIiIhkQ1de6X+B//79NhVt2rTwxiQSTkpkRERERLKpihVh5UooWjRlW1KSJTN794Y/LpFwUCIjIiIiko1VrQqTJ/uuaJaYaPvM7NsX/rhEQk2JjIiIiEg2d/nlMH8+xMambJs6Fdq2hT17wh+XSCgpkRERERHJASpUsJEZX+bNgzZtYPv2sIYkElJKZERERERyiPh4+Phj8LyUbb/9BqVLw6JF4Y9LJBSUyIiIiIjkIHfcAePGQf78vtsvvdTKN4tkdwElMp7ntfc8b4XneX96nvdUKv1u9jzPeZ4XH7wQRURERCQ9OnWCiRP9tz/0EPzjH1bZTCS7SjOR8TwvKsqL2QAAHYVJREFUEhgKdABqAbd6nlfLR79o4GHg12AHKSIiIiLp06oVfPAB5Mnju/2tt6BwYSUzkn0FMiLTEPjTObfGOXcc+ALo7KPfv4FXgKNBjE9EREREMuiee+Dnn/1PMzt61IoAiGRHgSQyccDGs37edPLYaZ7n1QfKO+cmpHYhz/N6ep433/O8+Tt27Eh3sCIiIiKSPldeCRs3Qp06vtunT4cffwxrSCJBEUgi46PuBe50o+dFAG8Aj6d1Iefcu865eOdcfMmSJQOPUkREREQyrEQJWLAArr7ad/vNN8OSJeGNSeRCBZLIbALKn/VzOWDLWT9HA3WA6Z7nrQOuBL7Rgn8RERGRrCMyEmbMgBtvTNm2f7+N2HzySfjjEsmoQBKZeUBVz/Mqep6XF7gF+OZUo3Nun3OuhHOugnOuAjAH6OScmx+SiEVEREQkw774wgoB+HLnnfDKK+GNRySj0kxknHMngN7A98Ay4Evn3BLP8170PK9TqAMUERERkeCJioLRo6FqVd/tTz4J338f3phEMsJzzqXdKwTi4+Pd/PkatBERERHJDEuXQsOGcOhQyraiRWHFCtCSZslsnuclOOd8LlkJaENMEREREclZatWCmTN9t+3ZA/fdB4mJ4Y1JJD2UyIiIiIjkUvXqwZYtvkszjx8PTz0V/phEAqVERkRERCQXK1sWxo3zvWnm4MFaLyNZlxIZERERkVyucmV4772Ux5OToWtX+OWX8MckkhYlMiIiIiJCjx7w/PMpjx84AE2bwsKF4Y9JJDVKZEREREQEgH/9C9q08d122WWwalV44xFJjRIZEREREQEgTx4YNQoqVfLdfsUVsHdveGMS8UeJjIiIiIicVqyY/wX++/bB9deHNx4Rf5TIiIiIiMg5qlSBiRN9t82cCf37hzceEV+UyIiIiIhICtdeC5984rutXz//iY5IuCiRERERERGfevSAgQN9t113HUyeHN54RM6mREZERERE/OrbF2rX9t3Wti0cPRreeEROUSIjIiIiIn7lyQO//QZxcb7bL7sMnAtvTCKgREZERERE0pA3L0ydClFRKdtWroQ33gh/TCJKZEREREQkTdWqwbRpvtsefxwWLQpvPCJKZEREREQkIFddBU8/7butSRP/iY5IKCiREREREZGADRgAnTqlPH7wILRvD2vWhD8myZ2UyIiIiIhIunzwARQvnvL48ePQuTMcOhT+mCT3USIjIiIiIulSvDjMmQOxsSnbFi+GChXgr7/CHpbkMkpkRERERCTdqlSB6dN9t+3cCWXLwoEDYQ1JchklMiIiIiKSIfXq+U9mALp00R4zEjpKZEREREQkw5o3hzFjfLdNnQo9eyqZkdBQIiMiIiIiF+SGG+D55323jRgBw4aFNx7JHZTIiIiIiMgF698fnnvOd1vv3jB+fHjjkZxPiYyIiIiIBMWLL8Ijj/hu69QJ1q8PbzySsymREREREZGg8DwYPNgW+fvSvj3s2xfemCTn+v/t3XmYlOWZ7/HvzZZBjQOIOhNQwXXCpUYjoMYYF8QFDQSNCwkaB0WdYDwezInG5WgU3BOvOC6JEUYkKkQTkaiJcYhiFnFkghrXo1FZxqi44QIu4HP+eIuk7Xqbrobut5b+fq6rrq567qer7n5SFvXLuxlkJEmS1K6mTIGBA8vHn34aevWC998vvic1HoOMJEmS2lWfPnDvvbDBBvn1/v3hz38utic1HoOMJEmS2t1WW2VnLIsor73+OgwbBosXF9+XGodBRpIkSR3iyCPhppvya0uXwllnFduPGotBRpIkSR1mzBi44grokvOtc/p0+P73vWCm1o5BRpIkSR3q1FPhN7/Jr33723DBBcX2o8ZgkJEkSVKHGzYMLr00v3buufDAA8X2o/pnkJEkSVIhJk6Eww7Lrx1+OCxaVGw/qm8GGUmSJBWia1eYOTO7MGZzr74Ko0fD8uXF96X6ZJCRJElSYbp2hTvugM02K6/96U9w5pnF96T6ZJCRJElSoXr0gD/+Efr1K6/98Ifw0EPF96T6Y5CRJElS4fr3h9tvh27dymtHHQUrVhTfk+qLQUaSJElVMWQITJhQPv7iizBunNeX0ZoZZCRJklQ155+fbZ1pbsYMOP54WLWq+J5UHwwykiRJqpoNN4Rf/AK65HwrnToVTjjBLTPKZ5CRJElSVQ0Zkh3kn2fq1OyCmVJzBhlJkiRV3YQJ2daXPBdcANOnF9uPap9BRpIkSVUXAVdfnX/wP8BJJ8GSJcX2pNpmkJEkSVJN6NYNrroKJk4sry1fnoUcj5fRagYZSZIk1ZTLL4cRI8rHZ8+GrbeG994rvifVHoOMJEmSakoEXHMNdO1aXnv+eRg/3i0zMshIkiSpBm2xBZx+en7tllvg7LOL7Ue1xyAjSZKkmnTBBXDssfm1Cy+EJ58stB3VGIOMJEmSalKXLjBlCuyzT379yCNh5cpie1LtMMhIkiSpZnXpAnPmwIknltcefxy+973ie1JtMMhIkiSppkXAxRdDr17ltcmT4Z57iu9J1WeQkSRJUs3r1Qsuuqh8PCUYOxYWLiy+J1WXQUaSJEl14aST4OtfLx9/7TXYay94+eXie1L1GGQkSZJUN6ZNg+HDy8cXLoSddoJFi4rvSdVhkJEkSVLd6NoVpk+H/v3La6+8Avvum/1U4zPISJIkqa5suin8/Of5tb/8BQYPhvffL7YnFc8gI0mSpLozdCjceGN+bckS2HlnWLas2J5ULIOMJEmS6tLRR8Pvfpdfe/pp2H33LNSoMRlkJEmSVLe++EWYMSO/9tRTsNlm2e5majwGGUmSJNW1I4+EKVOyC2fm2XprePPNYntSxzPISJIkqe6NGwczZ0L37vn1/feHFSuK7UkdyyAjSZKkhnD44XDbbfm1+fPha1+DlIrtSR3HICNJkqSGMXJkdp2ZPLNmZVtt1BgMMpIkSWooY8fCnXdmF89sbtw4mDOn+J7U/gwykiRJajgHHwzXXFM+vmIFjBgB99xTfE9qXwYZSZIkNaTx4+Ggg8rHP/wwO9OZp2WubxUFmYg4MCKeiYjnIuKMnPrEiHgyIh6LiDkRsUX7typJkiRVLiI7Xmabbcpry5bB8OHwzjvF96X20WqQiYiuwNXAQcAgYExEDGo2bQEwOKW0I3AbcGl7NypJkiS11UYbwf33w847l9deeAFOOcUzmdWrSrbIDAWeSyk9n1L6EJgBjGo6IaV0X0ppeenhPKB/+7YpSZIkrZ3PfCY7wL9fv/LaDTfAOecU3pLaQSVBph+wuMnjJaWxlhwH/CqvEBEnRMT8iJi/dOnSyruUJEmS1kHv3tk1ZrrkfPudPBnuuqv4nrRuKgkykTOWuwEuIsYCg4HL8uoppetSSoNTSoM33njjyruUJEmS1tFuu8GkSfm1L3852wVN9aOSILME2KzJ4/7AS80nRcR+wFnAyJTSB+3TniRJktR+zjgD9t23fDwl+MpXDDP1pJIg8zCwTUQMjIgewFHA7KYTImJn4MdkIebV9m9TkiRJWncRcOutsP325bVly2DUKHj22eL7Utu1GmRSSiuBk4F7gKeAn6WUnoiI8yNiZGnaZcAGwK0R8UhEzG7h6SRJkqSq6tMHfv972Hzz8trbb8NJJxXfk9ouUpXONzd48OA0f/78qry2JEmStGQJDBkCL79cXnvwweyYGlVXRPx3SmlwXq2iC2JKkiRJjaZ/f5g3L792yinw/vvF9qO2MchIkiSp09piC5g2rXz84YfhgANgxYrie1JlDDKSJEnq1MaMga22Kh9/4AEvllnLDDKSJEnq1Lp3h5tugh49ymvf/z488kjxPal1BhlJkiR1ervuCtdem1879FB4991i+1HrDDKSJEkSMG4cjB5dPv7CC3DiicX3ozUzyEiSJEklU6bAeuuVj998M0yeXHw/aplBRpIkSSrp3TsLLXnOPhvmzi22H7XMICNJkiQ1MWoUXHZZfu3ww+Gtt4rtR/kMMpIkSVIzEydmJwBobunSbKtNSsX3pE8yyEiSJEnNdOkCd98N3brl18ePL7YflTPISJIkSTn69IFHH82vTZnixTKrzSAjSZIktWDQIDjzzPzapElw++3F9qO/M8hIkiRJazB5Muy1V37t0EPhgQeK7UcZg4wkSZLUijlzoG/f/Npee8FLLxXbjwwykiRJUqu6doUXX4TNN8+vDxoEH31UaEudnkFGkiRJqsD668PDD0PPnuW1Zcvg/POL76kzM8hIkiRJFdpkE5g7FyLKa5MmwS9/WXxPnZVBRpIkSWqDIUPgxhvzayNHwh13FNtPZ2WQkSRJktpo7NjsjGV5jjsO3nmn2H46I4OMJEmStBauuQY23bR8/PXX4dpri++nszHISJIkSWth001h3jzYZZfy2uTJsGRJ8T11JgYZSZIkaS0NGAA33QRdmn2rfvtt+PKXYcWKqrTVKRhkJEmSpHWw3XYwblz5+COPwLnnFt9PZ2GQkSRJktbRhRdC797l41dcke1+pvZnkJEkSZLW0cYbw89+Bj16fHJ85UrYfXdYuLA6fTUyg4wkSZLUDvbbD77znfzannvC4sXF9tPoDDKSJElSOznnHBg6tHx88WLYf394663ie2pUBhlJkiSpnfToAT/9KUSU155+Gs47r/CWGpZBRpIkSWpH22wDkybl1/7932Hu3GL7aVQGGUmSJKmdnXkmzJxZPv7xx7D33jBnTuEtNRyDjCRJktQBjjgCLr44v3bwwfDww8X202gMMpIkSVIHmTgR9tijfPyDD+DYY7PTM2vtGGQkSZKkDtK9O0ybll1nprknn4Qbbii8pYZhkJEkSZI60FZbwUMPwZZbltfOPhvefLP4nhqBQUaSJEnqYAMHwvXXl4+/8goccwykVHxP9c4gI0mSJBVgn31g2LDy8TvvzK49o7YxyEiSJEkF+cEPoGfP8vGTT852P1PlDDKSJElSQXbcEX784/Lxt9+G3XaDWbOK76leGWQkSZKkAh19NIwenV877jgP/q+UQUaSJEkq2JQp8JnPlI+/8QZceGHx/dQjg4wkSZJUsN694Q9/yK9dfnn+Gc70SQYZSZIkqQoGDIAFC/Jr48fDfvvB8uWFtlRXDDKSJElSley0E3z3u/m1OXNg/fXhgw+K7aleGGQkSZKkKjrnnOxsZi05+eTieqknBhlJkiSpinr2hHvvhe23z69ff322dUafZJCRJEmSqmyTTeDRR1vezWy//eDll4vtqdYZZCRJkqQa0KVLdurlgw7Krx9wAKxaVWxPtcwgI0mSJNWQn/40f/yxx+CHPyy2l1pmkJEkSZJqSJ8+MGtWfu2001q+/kxnY5CRJEmSasyoUXD33fm1L34R5s0rtp9aZJCRJEmSatBBB8Ehh+TX9tgDFi4stp9aY5CRJEmSatSVV+aPf/wxfP7z8LvfFdtPLTHISJIkSTVq4EC48cb82htvwJe+BOPGwWuvFdtXLTDISJIkSTXs6KNhwYLs9Mx5/uM/YOONYdGiYvuqNoOMJEmSVON22gl+8xvo3r3lOXvsAa+/XlxP1WaQkSRJkurAsGHZqZd32CG/vmQJbL45vPdesX1Vi0FGkiRJqhNDhmS7mQ0fnl9fvhwmTCi2p2oxyEiSJEl1pGvXbDez6dPz69OmwVVXFdtTNRhkJEmSpDo0dmzLgeVb34I77yy2n6IZZCRJkqQ6NWFCy9ea+eY3YdWqYvspkkFGkiRJqmMTJuQfM7N4MZxzTvH9FMUgI0mSJNWxLl1g5kzo2bO8dtFFcPrpxfdUBIOMJEmSVOd694Y77sivXXopHHIILFtWbE8dzSAjSZIkNYDhw+HUU/Nrd90FvXrBGWdkp2huBAYZSZIkqUFccgl87nNrru+yC9x6K6RUXF8dwSAjSZIkNYgePWDWrDXPefppOOII2HJLuPBCePzxYnprbxUFmYg4MCKeiYjnIuKMnPqnImJmqf5QRAxo70YlSZIktW7AAFi5MruWzJq8+CKcdRbssANEQL9+8NnPwlFHwW231f4uaK0GmYjoClwNHAQMAsZExKBm044D3kwpbQ1cAVzS3o1KkiRJqkzXrtn1ZZ55JgsmlXjppWxrzcyZcPjhMGxYx/a4rirZIjMUeC6l9HxK6UNgBjCq2ZxRwLTS/duAYRER7demJEmSpLbadlu45RZYsACGDm3b7x5ySMf01F66VTCnH7C4yeMlwK4tzUkprYyIZcBGwGtNJ0XECcAJpYfvRsQza9N0Bfo2f211GNe6OK51cVzrYrnexXGti+NaF8e17iBnn53dmqjGWm/RUqGSIJO3ZaX5OQ4qmUNK6Trgugpec51ExPyU0uCOfh251kVyrYvjWhfL9S6Oa10c17o4rnVxam2tK9m1bAmwWZPH/YGXWpoTEd2AfwTeaI8GJUmSJKm5SoLMw8A2ETEwInoARwGzm82ZDXyjdP+rwG9TqvczU0uSJEmqVa3uWlY65uVk4B6gKzA1pfRERJwPzE8pzQamANMj4jmyLTEVnhuhw3T47mv6G9e6OK51cVzrYrnexXGti+NaF8e1Lk5NrXW44USSJElSvanogpiSJEmSVEsMMpIkSZLqTl0HmYg4MCKeiYjnIuKMnPrEiHgyIh6LiDkR0eJ5qLVmFaz1SRHx54h4JCJ+HxGDqtFnI2htrZvM+2pEpIiomdMg1psK3tfHRsTS0vv6kYg4vhp9NoJK3tcRcUTpM/uJiLi56B4bRQXv6yuavKf/X0S8VY0+G0EFa715RNwXEQtK30VGVKPPRlDBWm9R+q73WETcHxH9q9FnI4iIqRHxakQ83kI9IuLK0v8Wj0XE54vu8W9SSnV5IzvxwF+ALYEewKPAoGZz9gHWK93/N2Bmtfuux1uFa71hk/sjgV9Xu+96vFWy1qV5nwYeAOYBg6vddz3eKnxfHwtcVe1e6/1W4VpvAywAepceb1LtvuvxVulnSJP53yI7iU/Ve6+3W4Xv6+uAfyvdHwS8WO2+6/FW4VrfCnyjdH9fYHq1+67XG/Al4PPA4y3URwC/IruO5G7AQ9XqtZ63yAwFnkspPZ9S+hCYAYxqOiGldF9KaXnp4Tyya+Co7SpZ67ebPFyfnAuiqiKtrnXJBcClwPtFNtdgKl1rrbtK1no8cHVK6U2AlNKrBffYKNr6vh4D3FJIZ42nkrVOwIal+/9I+XX4VJlK1noQMKd0/76cuiqUUnqANV8PchRwY8rMA3pFxD8X090n1XOQ6QcsbvJ4SWmsJceRpUe1XUVrHRETIuIvZF+wTymot0bT6lpHxM7AZimlO4tsrAFV+hlyWGnT+W0RsVlOXa2rZK23BbaNiD9ExLyIOLCw7hpLxf82lna3Hgj8toC+GlEla30eMDYilgB3k20BU9tVstaPAoeV7o8GPh0RGxXQW2fU1u/gHaaeg0zkjOVuBYiIscBg4LIO7ahxVbTWKaWrU0pbAacDZ3d4V41pjWsdEV2AK4DTCuuocVXyvv4lMCCltCPwn8C0Du+qMVWy1t3Idi/bm2wrwfUR0auD+2pEFf/bSHbNt9tSSqs6sJ9GVslajwFuSCn1J9sdZ3rpc1xtU8lafxvYKyIWAHsB/wOs7OjGOqm2fM50qHr+j2kJ0PT/He1PzibbiNgPOAsYmVL6oKDeGk1Fa93EDOArHdpR42ptrT8NbA/cHxEvku2bOtsD/tdKq+/rlNLrTT43fgLsUlBvjaaSz5AlwB0ppY9SSi8Az5AFG7VNWz6vj8LdytZFJWt9HPAzgJTSg8A/AH0L6a6xVPJ5/VJK6dCU0s5k3/tIKS0rrsVOpa3fCztMPQeZh4FtImJgRPQg+0Ce3XRCaRecH5OFGPe3XnuVrHXTLxwHA88W2F8jWeNap5SWpZT6ppQGpJQGkB37NTKlNL867da1St7XTff5HQk8VWB/jaTVtQZmkZ2ghYjoS7ar2fOFdtkYKllrImI7oDfwYMH9NZJK1noRMAwgIj5LFmSWFtplY6jk87pvk61d3wWmFtxjZzIbOKZ09rLdgGUppb9Wo5Fu1XjR9pBSWhkRJwP3kJ3NYmpK6YmIOB+Yn1KaTbYr2QbArREBsCilNLJqTdepCtf65NLWr4+AN4FvVK/j+lXhWqsdVLjWp0TESLLdE94gO4uZ2qjCtb4H2D8ingRWAf8npfR69bquT234DBkDzEilUxCp7Spc69OAn0TE/ybb9eZY17ztKlzrvYGLIiKRndVzQtUarnMRcQvZevYtHd91LtAdIKX0I7LjvUYAzwHLgX+tTqcQ/vckSZIkqd7U865lkiRJkjopg4wkSZKkumOQkSRJklR3DDKSJEmS6o5BRpIkSVLdMchIUicVEfeXTlVasyJi74hIEXFeBz3/eaXn37sj5kuSOo5BRpIaWEcHAUmSqsUgI0mSJKnuGGQkSZIk1R2DjCQ1qNLuZPeVHp5b2sUsNT8uJiJ6RMSkiFgUER9ExBMRMSbn+W4o/f7WEXFWRDwXER9FxKlN5vSLiGsjYmHpuV6KiOsi4p9ynm//iPjPiHglIt4vzf11RAxv4e/ZLSLui4h3I+KNiLgpIjbOmRcRcVJE/CkilkfEsoj4bUQc0Ia1+3REXBkRL5ee48GIGFbp70uSOl63ajcgSeow9wMDgG8Ac0uP88wAdgbuJPt3YQxwc0S8lVL6Vc78q4GdSvPfApYARMR2pdfpW6o9C2wNHA8Mj4ghKaXXSnNHAncAfwVuB94E/hn4AnAAcG+z1xwKnF4a/xGwB/A1YMuI+EJKqWk4+xFwAvA8cC3QEzgS+FVEHJ9SmtrCOlDqrStwF7An8BBZGNwSuLv090mSaoBBRpIaVErp/oiALMjcn1I6r4Wp/wTskFJ6FyAibiILPacCeUFmW2CnlNJfm41PA3oBe6aUHlw9GBGjgV8A5wPfLA0fC3xYep5Xmz5JRPTJec2DgK+mlH5emtOFLNTsC+wGPFga35csxMwH9kopLS+NXwz8CbgqIn6ZUlrawloAjCMLMTOBMatDUkQcU/obJUk1wF3LJEnfXR1iAFJKc4EXgcEtzL+8eYiJiF2AXYEfNQ0xpee7nSxYHNHseT4iCzM0m/9GzmvevzrElOZ8DNxYeti0z6NLP//v6hBTmr8IuJJs68zhLfxdq30dSMA5zbb0TAeebuV3JUkFcYuMJGlBztj/AJu3MH9+ztjQ0s/NWzjV83rARhHRt7R72UxgNPDniLiZbPetP6SU3mljj5BtBVrtc6WfD+TMn9tsTkt2BF5NKT3bdDCllCLij8C/tPL7kqQCGGQkqZNLKb2dM7ySlrfav5oztnp3sNGlW0vWB15LKc2MiJXAacC3ge8AH0bELODUnN3WWuoRoGuTsQ2Bd1NK7+XMf6XJnDXZEHiqhVre3y5JqgJ3LZMktVXKGVsdNI5NKcUabgv/9iQp/Tyl9AVgY7LwcyfZ7mcz16G3t4ENImK9nNqmzXpd03OUnQ2tZJO1bUyS1L4MMpLU2FaVfnZd46x191+ln7u19RdTSm+klGallA4jO0vYnhHRq7Xfa8GjpZ9fyqntWfr5SCvP8RiwSURs03QwsjMn7L6WfUmS2plBRpIa2+oD5/t15IuklB4iO3bm+LzrtUREz4jYtcnjfSPiU83mfIrseJeV/H23sbaaXvr5vYj4hybP3R/4X8AK4LZWnuMmIIALSuFltaOBz65lX5KkduYxMpLU2J4hu1bLmIj4gNIB8imlSR3wWl8jO2j/1xFxH9nWkS5k17LZC5gHHFia+wOgX0TMBV4AupNdP2Y7sjOfvctaSCn9NiJ+AownO5HAHfz9OjJ9gPGtnHoZYCpwTOl3BpT+li2Br5Cd8jn3gp2SpGIZZCSpgaWUVkbEV4FLyLYorF8qtXuQSSk9GxE7kx24P5Ls4pbvk10wczp/P10ywMXAYcAuwAhgOdkFNI8DbljHVk4kO8vZCcAEstM8/zdwSUrp1xX8HasiYgRwIVmY2ZEslI0g2z3NICNJNSA+eYp8SZIkSap9HiMjSZIkqe4YZCRJkiTVHYOMJEmSpLpjkJEkSZJUdwwykiRJkuqOQUaSJElS3THISJIkSao7BhlJkiRJdccgI0mSJKnu/H+px/smZlC+1gAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 1008x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Getting the probabilities of our predictions\n",
    "y_scores = forest.predict_proba(X_train_short)\n",
    "y_scores = y_scores[:,1]\n",
    "\n",
    "precision, recall, threshold = precision_recall_curve(Y_train_short, y_scores)\n",
    "def plot_precision_and_recall(precision, recall, threshold):\n",
    "    plt.plot(threshold, precision[:-1], \"r-\", label=\"precision\", linewidth=5)\n",
    "    plt.plot(threshold, recall[:-1], \"b\", label=\"recall\", linewidth=5)\n",
    "    plt.xlabel(\"threshold\", fontsize=19)\n",
    "    plt.legend(loc=\"upper right\", fontsize=19)\n",
    "    plt.ylim([0, 1])\n",
    "\n",
    "plt.figure(figsize=(14, 7))\n",
    "plot_precision_and_recall(precision, recall, threshold)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 7.7.3 ROC AUC Curve"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1008x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Computing true positive rate and false positive rate\n",
    "false_positive_rate, true_positive_rate, thresholds = roc_curve(Y_train_short, y_scores)\n",
    "\n",
    "# Creating a function to plot them against each other\n",
    "def plot_roc_curve(false_positive_rate, true_positive_rate, label=None):\n",
    "    plt.plot(false_positive_rate, true_positive_rate, linewidth=2, label=label)\n",
    "    plt.plot([0, 1], [0, 1], 'r', linewidth=4)\n",
    "    plt.axis([0, 1, 0, 1])\n",
    "    plt.xlabel('False Positive Rate (FPR)', fontsize=16)\n",
    "    plt.ylabel('True Positive Rate (TPR)', fontsize=16)\n",
    "\n",
    "# Plotting them against each other\n",
    "plt.figure(figsize=(14, 7))\n",
    "plot_roc_curve(false_positive_rate, true_positive_rate)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 7.7.4 ROC AUC Score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ROC-AUC-Score: 0.976\n"
     ]
    }
   ],
   "source": [
    "# Calculating the ROC AUC Score\n",
    "r_a_score = roc_auc_score(Y_train_short, y_scores)\n",
    "print(\"ROC-AUC-Score:\",round(r_a_score,4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 8 Model deployment (simplified concept with Random Forest Classification Algorithm)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Example Nursing Home:\n",
    "\n",
    "Federal Provider Number: 165427\n",
    "Provider Name: Newton Health Care Center\n",
    "Provider Address: 200 S 8th Ave East\n",
    "Provider City: Newton\n",
    "Provider State: Iowa\n",
    "\n",
    "Copy variables below and replace it with the input fields in the code below for a faster evaluation:\n",
    "\n",
    "total_beds = 70\n",
    "years = 19.92\n",
    "occupancy = 68.57\n",
    "fed_def = 7\n",
    "rn_staff = 0.39\n",
    "total_staff = 2.52\n",
    "paymcaid = 50\n",
    "minority = 12.5\n",
    "county_excess = 27\n",
    "herfindahl = 50.04\n",
    "county_cases_100 = 1218\n",
    "county_deaths_100 = 65"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Please answer the following 12 questions to determine if the selected nursing home is susceptible to infections.\n",
      "Enter the total number of certified beds:70\n",
      "Enter the number of years the nursing home has been in operation:19.92\n",
      "Enter the proportion of occupied beds:68.57\n",
      "Enter the total number of federal deficiencies within the last 36 months:7\n",
      "Enter the average staffing levels of registered nurses per hours per resident day:0.39\n",
      "Enter the average total staffing levels per hours per resident day:2.52\n",
      "Enter the proportion of facility residents whose primary support is Medicaid:50\n",
      "Enter the proportion of facility residents who are not white:12.5\n",
      "Enter the total number of beds available in the respective county:27\n",
      "Enter the herfindahl index of the respective nursing home:50.04\n",
      "Enter the total number of confirmed infection in the county:1218\n",
      "Enter the total number of confirmed fatalities in the county:65\n",
      "The selected nursing home is susceptible to COVID-19 infections.\n"
     ]
    }
   ],
   "source": [
    "# Creating a 12 question based questenair\n",
    "print('Please answer the following 12 questions to determine if the selected nursing home is susceptible to infections.')\n",
    "\n",
    "# Creating input fields\n",
    "total_beds = int(input('Enter the total number of certified beds:'))\n",
    "years = float(input('Enter the number of years the nursing home has been in operation:'))\n",
    "occupancy = float(input('Enter the proportion of occupied beds:'))\n",
    "fed_def = int(input('Enter the total number of federal deficiencies within the last 36 months:'))\n",
    "rn_staff = float(input('Enter the average staffing levels of registered nurses per hours per resident day:'))\n",
    "total_staff = float(input('Enter the average total staffing levels per hours per resident day:'))\n",
    "paymcaid = float(input('Enter the proportion of facility residents whose primary support is Medicaid:'))\n",
    "minority = float(input('Enter the proportion of facility residents who are not white:'))\n",
    "county_excess = int(input('Enter the total number of beds available in the respective county:'))\n",
    "herfindahl = float(input('Enter the herfindahl index of the respective nursing home:'))\n",
    "county_cases_100 = int(input('Enter the total number of confirmed infection in the county:'))\n",
    "county_deaths_100 = int(input('Enter the total number of confirmed fatalities in the county:'))\n",
    "\n",
    "target = [[total_beds,\n",
    "           years,\n",
    "           occupancy,\n",
    "           fed_def,\n",
    "           rn_staff,\n",
    "           total_staff,\n",
    "           paymcaid,\n",
    "           minority,\n",
    "           county_excess,\n",
    "           herfindahl,\n",
    "           county_cases_100,\n",
    "           county_deaths_100]]\n",
    "\n",
    "pred = forest.predict(target)\n",
    "\n",
    "if pred[0] == 0:\n",
    "    print('The selected nursing home is not susceptible to COVID-19 infections.')\n",
    "else:\n",
    "    print('The selected nursing home is susceptible to COVID-19 infections.')"
   ]
  },
  {
   "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}