{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "(section4.4)=\n",
    "# 4.4 Evaluating models\n",
    "\n",
    "\n",
    "In the last section we created a very simple model linking the binarised self reported health with the deprivation index, controlled by age, for the UK. We emphasised understanding the model and developed intuition of what the model learns, but a modelling task is not complete without evaluation. Evaluation examines how well the model has learned the data and is able generalise it to unseen data.\n",
    "\n",
    "One of the evaluation tools available to us are **goodness-of-fit** metrics. These metrics summarise the discrepancy between observed values from the data used for fitting and the values expected under the estimated parameters of the model. \n",
    "\n",
    "````{margin}\n",
    "```{admonition} Many metrics for different purposes\n",
    "Goodness of fit metrics depend of the kind of model you are fitting, e.g. in regression you tend to look at the *Mean Square Error*, *Root Mean Squared Error*, *Coefficient of Determination*, residual plots, etc. All these metrics have to be interpreted with the full knowledge of the context of the data and the model. You can find more about these metrics in [here](https://medium.com/microsoftazure/how-to-better-evaluate-the-goodness-of-fit-of-regressions-990dbf1c0091)). \n",
    "```\n",
    "````\n",
    "\n",
    "The **goodness-of-fit** metrics alone are not enough for a full evaluation of the model. A fit can learn the data perfectly but can be **overfitted**, meaning that they have learned the peculiarities (noise) of the dataset and will make poor predictions on future unseen samples (we touched on overfitting in [_Section 4.2_](section4.2)). Hence, part of model evaluation is to estimate the generalization accuracy of a model on unseen/out-of-sample data by using a **test set** (i.e data not seen by the model).\n",
    "\n",
    "In this section we will build on the modelling steps done in [_Section 4.3_](section4.3) and perform model evaluation.  In this example we are focusing on logistic regression, however we will try to make the concepts and ideas generalisable to other models. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import statsmodels.api as sm\n",
    "from sklearn.metrics import roc_auc_score\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import roc_curve, precision_recall_curve\n",
    "from sklearn import metrics\n",
    "from matplotlib import pyplot\n",
    "from scipy import stats\n",
    "\n",
    "plt.style.use('seaborn')\n",
    "sns.set_theme(style=\"whitegrid\")\n",
    "sns.set_style(\"white\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data processing\n",
    "\n",
    "**Note**: *We aim that each section can function as a stand-alone material, therefore we repeat the data processing steps in Sections 3.5, 4.3 and now here. Feel free to skip to the next section.*\n",
    "\n",
    "We can access the data by downloading the [csv](https://beta.ukdataservice.ac.uk/datacatalogue/studies/study?id=7724#!/details) option from here.\n",
    "\n",
    "Unzip the data to `$PROJECT_ROOT/data` (where `$PROJECT_ROOT` is the root of the cloned github repository for this course).\n",
    "This should give you `$PROJECT_ROOT/data/UKDA-7724-csv` directory.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "datafolder = '../../../data/UKDA-7724-csv/' # should match the path you unzipped the data to\n",
    "df = pd.read_csv(datafolder + 'csv/eqls_2011.csv')\n",
    "df_map = pd.read_csv(datafolder + 'mrdoc/excel/eqls_api_map.csv', encoding='latin1')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# we are only interested in the UK for this example.\n",
    "df = df.query('Y11_Country == 27')\n",
    "\n",
    "var_map = {\"Y11_Q42\": \"SRH\",\n",
    "           'Y11_Deprindex': 'DeprIndex',\n",
    "           \"Y11_Accommproblems\": 'AccomProblems',\n",
    "           \"Y11_HHsize\": \"HouseholdSize\",\n",
    "           \"Y11_Q32\": \"Children\",\n",
    "           \"Y11_ISCEDsimple\":\"ISCED\",\n",
    "           \"Y11_SocExIndex\":\"SocialExclusionIndex\",\n",
    "           \"Y11_MWIndex\": \"MentalWellbeingIndex\",\n",
    "           \"Y11_Agecategory\":\"AgeCategory\",\n",
    "           \"Y11_HH2a\":\"Gender\",\n",
    "           \"Y11_Q31\":\"MaritalStatus\",\n",
    "           \"Y11_Country\":\"Country\"\n",
    "}\n",
    "\n",
    "df.rename(columns=var_map, inplace=True)\n",
    "df_set = df[var_map.values()]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We drop rows with missing data (**warning**: this shouldn't be done lightly without having explored the missingness of the data, here we are doing for simplicity and to focus on the modelling)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_model = df_set.dropna()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, we dichotomise the `SRH` variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/fc/ys01gk017lg3ylcvv2knwnkc0000gq/T/ipykernel_86753/2217895522.py:2: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  df_model['SRH_binary'] = df_model.SRH.apply(lambda x: 1 if float(x) <= 3 else 0)\n"
     ]
    }
   ],
   "source": [
    "# dichotomise SRH\n",
    "df_model['SRH_binary'] = df_model.SRH.apply(lambda x: 1 if float(x) <= 3 else 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Model 1: Age and Deprivation index.\n",
    "\n",
    "Let's start evaluating the performance of a simple model described in [_Section 4.3_](section4.3) where we model `SRH` as a function of `Age` and `DeprIndex`. \n",
    "\n",
    "In that section we used our complete UK dataset to fit the model as an illustrative example. However, an alternative approach this is to partition your dataset into a **training** sample used to fit you model, and a **holdout** sample for evaluation. The purpose of this is to obtain an unbiased estimate of learning performance. \n",
    "\n",
    "Depending on your model you might need a **training**, **validation** and **testing** set (e.g a validation set can be useful when you have to tune model hyper-parameters). However, for this example we will use a simple **train**/**test** split following a 70/30 rule (for more in depth discussion of what is a \"good test size\" check-out this [blog post](https://www.r-bloggers.com/2021/01/what-is-a-good-test-set-size-2/))."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# test train split using scikit learn, defining random state for reproducibility\n",
    "trainX_model1, testX_model1, trainy_model1, testy_model1 = train_test_split(df_model[['AgeCategory','DeprIndex']], df_model.SRH_binary.values, test_size=0.3, random_state=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "````{margin}\n",
    "```{admonition} Cross-Validation\n",
    ":class: note, dropdown\n",
    "In this example we will use a fixed train/test split, but this has its dangers — what if the split we make isn’t random? (e.g data could be ordered in a non random manner, or we could be unlucky in our split to have a non-representative sample). A solution for this is to use **cross-validation**. This method is very similar to train/test split, but it’s applied to more subsets. Meaning, the dataset is split into $k$ subsets (or folds), and the model is trained on $k-1$ one of those subsets. The remaining subset is used to test the model. This is done iteratively $k$ times and then the score metrics obtained on each of the folds are averaged into a a summarized performance of the model. More information on **cross-validation** can be found [here](https://scikit-learn.org/stable/modules/cross_validation.html).\n",
    "```\n",
    "````\n",
    "\n",
    "Now, let's fit our model on our training set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Optimization terminated successfully.\n",
      "         Current function value: 0.308598\n",
      "         Iterations 7\n"
     ]
    }
   ],
   "source": [
    "trainX_const_model1 = sm.add_constant(trainX_model1) #add constant for intercept\n",
    "logit_model_model1 = sm.Logit(trainy_model1, trainX_const_model1) #Create model instance\n",
    "result_model1 = logit_model_model1.fit() #Fit model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the output, ‘Iterations‘ refer to the number of times the model iterates over the data to optimize the model."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Validating the fit\n",
    "Let's explore the output of the fit. The summary table below gives us a descriptive summary about the results.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                           Logit Regression Results                           \n",
      "==============================================================================\n",
      "Dep. Variable:                      y   No. Observations:                 1402\n",
      "Model:                          Logit   Df Residuals:                     1399\n",
      "Method:                           MLE   Df Model:                            2\n",
      "Date:                Tue, 23 Nov 2021   Pseudo R-squ.:                  0.1086\n",
      "Time:                        15:32:01   Log-Likelihood:                -432.65\n",
      "converged:                       True   LL-Null:                       -485.35\n",
      "Covariance Type:            nonrobust   LLR p-value:                 1.296e-23\n",
      "===============================================================================\n",
      "                  coef    std err          z      P>|z|      [0.025      0.975]\n",
      "-------------------------------------------------------------------------------\n",
      "const           4.5066      0.373     12.067      0.000       3.775       5.239\n",
      "AgeCategory    -0.4717      0.086     -5.505      0.000      -0.640      -0.304\n",
      "DeprIndex      -0.4312      0.045     -9.485      0.000      -0.520      -0.342\n",
      "===============================================================================\n"
     ]
    }
   ],
   "source": [
    "print (result_model1.summary())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In [_Section 4.3_](section4.3) we discussed the interpretation of the coefficients, standard errors and significance parameters. In this section we'll explore the output related to the **goodness-of-fit**.\n",
    "\n",
    "- **Method**:  Maximum Likelihood Estimation (MLE) is a probabilistic framework for estimating the parameters of an assumed probability distribution, given some observed data. MLE involves maximizing a likelihood function in order to find the probability distribution and parameters that best explain the observed data.\n",
    "- **No. Observations**: Number of observations on our training set.\n",
    "- **Df. Residuals**:  This is the Residuals degrees of freedom in the model. This is calculated in the form of `number of observations` - `number of predictors` - 1.\n",
    "- **Df. Model**: Degrees of Freedom of our model, which is basically the number of predictors used in the model (or number of coefficients to be fitted).\n",
    "- **Log-Likelihood**: the natural logarithm of the Maximum Likelihood Estimation (MLE) function given the estimated parameters. The log likelihood function in maximum likelihood estimations is usually computationally simpler, and the log-likelihood maximum is the same as the maximum likelihood.\n",
    "- **LL-Null**: the value of log-likelihood of the model when no independent variable is included (only an intercept is included).\n",
    "- **Pseudo R-squ.**: It is the ratio of the log-likelihood of the null model to that of the full model (this can function as a substitute for the R-squared value in Least Squares linear regression).\n",
    "- **LLR p-value**: A small p-value you can reject the null hypothesis that the model based on the intercept (all coefficients = 0) is better than the full model, again this uses the ratio of the log-likelihood of the null model to that of the full model.\n",
    "\n",
    "For the remainder of this section we will be using the **log-likelihood** values as a way to compare how a model improves when adding a new predictor. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Evaluation through predicting new data\n",
    "  \n",
    "Now we evaluate our model using our test dataset. \n",
    "\n",
    "As we learned in [_Section 4.2_](section4.2), logistic regression works by first obtaining the prediction of the model as a probability, then binarising the predicted probability using a threshold value. Scores above the threshold value will be classified as positive, those below as negative. For now the threshold value of the probability is $P(x)>0.5$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Actual values [1, 1, 1, 1, 0, 1, 1, 0, 1, 1]\n",
      "Predictions : [1, 1, 1, 1, 1, 0, 1, 1, 1, 1]\n"
     ]
    }
   ],
   "source": [
    "# performing predictions on the test dataset\n",
    "yhat = result_model1.predict(sm.add_constant(testX_model1))\n",
    "pred_y_model1 = list(map(round, yhat))\n",
    " \n",
    "# comparing first 10 original and predicted values of y\n",
    "print('Actual values', list(testy_model1)[:10])\n",
    "print('Predictions :', pred_y_model1[:10])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the cell above we are just printing the first 10 observations of our dataset. In order to summarise the the accuracy of the predictions from our model we can use a confusion matrix. This maps the predicted and actual values into a matrix and can give us an idea of what the classification model is getting right and what types of errors it is making.\n",
    "\n",
    "From a confusion matrix we can obtain the True Positives (TP), False Positives (FP), True Negatives (TN) and False Negatives (FN) and calculate the following metrics:\n",
    "\n",
    "\n",
    "- $\\text{Accuracy} = \\frac{TP  + TN}{TP + FP + TN + FN}$\n",
    "\n",
    "\n",
    "- $\\text{Precision} = \n",
    "     \\frac{TP}{TP + FP}$\n",
    "     \n",
    "     \n",
    "- $\\text{Recall (Sensitivity)} =\n",
    "      \\frac{TP}{TP + FN}$\n",
    "\n",
    "- ${\\text{Specificity (Recall of Negative label)}} =\n",
    "      \\frac{TN}{TN + FP}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.8803986710963455\n",
      "Precision: 0.8902027027027027\n",
      "Recall: 0.9868913857677902\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x360 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# confusion matrix using sklearn\n",
    "cnf_matrix = metrics.confusion_matrix(testy_model1,pred_y_model1)\n",
    "\n",
    "def plt_cnf_mat(cnf_matrix, ax, class_names=[0,1]):\n",
    "    tick_marks = np.arange(len(class_names))\n",
    "    ax.set_xticks(tick_marks)\n",
    "    ax.set_xticklabels(class_names)\n",
    "    ax.set_yticks(tick_marks)\n",
    "    ax.set_yticklabels(class_names)\n",
    "    # create heatmap\n",
    "    sns.heatmap(pd.DataFrame(cnf_matrix), annot=True, cmap=\"YlGnBu\" ,fmt='g')\n",
    "    ax.set_title('Confusion matrix', y=1.1)\n",
    "    ax.set_ylabel('Actual label')\n",
    "    ax.set_xlabel('Predicted label')\n",
    "    \n",
    "    \n",
    "fig, ax = plt.subplots(1,1, figsize = (5,5))\n",
    "plt_cnf_mat(cnf_matrix, ax)\n",
    "\n",
    "\n",
    "print(\"Accuracy:\",metrics.accuracy_score(testy_model1, pred_y_model1))\n",
    "print(\"Precision:\",metrics.precision_score(testy_model1, pred_y_model1))\n",
    "print(\"Recall:\",metrics.recall_score(testy_model1, pred_y_model1)) # what is recall? "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can see here that very few true negative values get predicted and the overwhelming majority of responses are true positives. Furthermore, the accuracy, precision, and recall score > 89%, this is happening due to our dataset being highly imbalanced and that the minority class are labeled as negative (0).\n",
    "\n",
    "A more complete evaluation would be to also estimate these metrics for the minority class (specificity):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Specificity: 0.04411764705882353\n"
     ]
    }
   ],
   "source": [
    "testy_model1_minority = abs(testy_model1 - 1)\n",
    "pred_y_model1_minority = abs(np.array(pred_y_model1) -1)\n",
    "\n",
    "print(\"Specificity:\",metrics.recall_score(testy_model1_minority, pred_y_model1_minority))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The result above is not a surprise. In [_Section 4.3_](section4.3) we saw that the model considers deprivation as a continuous variable and observed that the cutoff point of the model (this is the value where the model starts predicting negative labels) for the deprivation predictor was around 7, which is larger than the existing range for this variable. Nonetheless, in our examination of the model in [_Section 4.3_](section4.3) we observed that the model was indeed learning from the data and reproducing it, and after examining the **log-likelihoods** of the fit summary above we can conclude that the model is indeed better than a null model where the predictors do not add any information.\n",
    "\n",
    "This means that the classification matrix  might not be the best tool to evaluate the model in this scenario. Particularly because it shows a snapshot of the results being mapped from a predicted probability using a threshold of $p(x)> 0.5$.\n",
    "\n",
    "\n",
    "### Investigating threshold values\n",
    "\n",
    "Let's go back to our probability and investigate the predicted values given by the model for our two labels:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x141f9e850>"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# link the prediction to the label values\n",
    "df_labels = pd.DataFrame({'prediction': yhat,\n",
    "     'label': testy_model1})\n",
    "\n",
    "fig, ax = plt.subplots(1,1, figsize = (5,5))\n",
    "df_labels[df_labels['label']==1]['prediction'].plot.kde(label='SRH == 1')\n",
    "df_labels[df_labels['label']==0]['prediction'].plot.kde(label='SRH == 0')\n",
    "pyplot.xlabel('p(x)')\n",
    "pyplot.legend()\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ideally, in this density plot we would observe separate probability scores between two classes, with the score of the cases where `SRH==0` on the low probability values and the score of cases with `SRH==1` on the the high values. However, in the current case both distributions are skewed to the high probability values. The reason for this is because our dataset is highly imbalanced and only consists of 10 percent of cases where `SRH ==0`. Thus the predicted probabilities get pulled towards higher values because of the majority of the data being positive cases."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean value for SRH ==1, 0.895\n",
      "Mean value for SRH ==0, 0.823\n",
      "Percentage of cases with SRH ==0, 0.113\n"
     ]
    }
   ],
   "source": [
    "print ('Mean value for SRH ==1,', round(df_labels[df_labels['label']==1]['prediction'].mean(),3))\n",
    "print ('Mean value for SRH ==0,', round(df_labels[df_labels['label']==0]['prediction'].mean(),3))\n",
    "print ('Percentage of cases with SRH ==0,', round(df_labels[df_labels['label']==0]['prediction'].count()/df_labels.shape[0],3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Despite all this, in the density figures above we can observe a separation in the predicted scores, and the performance of the model could be improved by selecting a better threshold value for $p(x)$ to classify each case. This should be done by balancing the rate of False Positives and False Negatives. To assess this trade-off we can use other tools available, such as **ROC curves**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### What Are ROC Curves?\n",
    "\n",
    "A receiver operating characteristic curve, or ROC curve, is a figure that illustrates the performance of a binary classifier as its discrimination threshold is varied.\n",
    "\n",
    "Let's examine how the ROC curve looks for our model, and how it compares to a dummy classifier with no skill in classifying our data. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# function from https://stackoverflow.com/questions/22518230/creating-a-threshold-coded-roc-plot-in-python\n",
    "def plot_roc(labels, predictions, positive_label, thresholds_every=10, title='', c='darkorange'):\n",
    "    # fp: false positive rates. tp: true positive rates\n",
    "    fp, tp, thresholds = roc_curve(labels, predictions, pos_label=positive_label)\n",
    "    roc_auc = roc_auc_score(labels, predictions)\n",
    "\n",
    "    plt.plot(fp, tp, label=title+' ROC curve (area = %0.2f)' % roc_auc, linewidth=2, color=c)\n",
    "    plt.plot([0, 1], [0, 1], color='black', linestyle='--', linewidth=2)\n",
    "    plt.xlabel('False positives rate')\n",
    "    plt.ylabel('True positives rate')\n",
    "    plt.xlim([-0.03, 1.0])\n",
    "    plt.ylim([0.0, 1.03])\n",
    "    plt.title('ROC curve (numbers are threshold values)')\n",
    "    plt.legend(loc=\"lower right\")\n",
    "    plt.grid(True)\n",
    "\n",
    "    # plot some thresholds\n",
    "    thresholdsLength = len(thresholds)\n",
    "    for i in range(0, thresholdsLength, thresholds_every):\n",
    "        threshold_value_with_max_three_decimals = str(thresholds[i])[:4]\n",
    "        plt.text(fp[i] - 0.05, tp[i] + 0.015, threshold_value_with_max_three_decimals, fontdict={'size': 10},color=c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAf8AAAFsCAYAAADCA7BTAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAB1wklEQVR4nO3ddVxV9xvA8Q8tWKAi+23GdDoMFLtbZ4LdXahzzulssVvsmIGdU2e3OBNbmUNQbMUGFIuSuOf3xxlXEBFULpd43q8XL+6959xznnsu+pxvGyiKoiCEEEKIdMNQ3wEIIYQQInlJ8hdCCCHSGUn+QgghRDojyV8IIYRIZyT5CyGEEOmMJH8hhBAinZHkL/TG1tYWR0dHmjRpQtOmTalXrx4tWrTAy8tLu09ISAjTp0+nXr16ODo64ujoyJw5cwgLC4t1rB07dtCmTRuaNGlCw4YNGT16NG/evEnuj/RZZs6cibu7u87PU6tWrVjXNDV5+/YtnTt31j63tbUlMDBQJ+caPnw4K1as+Kz3bN++nd69e390m4ODA+fPn//quB49ekTJkiW/+jgfM3jwYO7cuaOTY4uUTZK/0Ks1a9awa9cudu7cyaFDh2jYsCGTJk0CIDIykm7duqHRaNi5cyd79uxhy5YtBAcH06NHDyIjIwFYsmQJf/31F3/88Qe7du1i165dGBsb06dPH31+tE/6999/uX37NlWrVtV3KCna69evU+2NS2rw22+/MWLECGS6l/THWN8BCBEtMjKSp0+fkjVrVgAOHjyIRqNhxIgR2n3Mzc1xdnamadOmHD58mOrVq7N06VJ27NhBjhw5ADAxMWHo0KEcPnyY8PBwTE1NY53n2LFjzJ07F41Gg4WFBePHjydTpkw4Ojpy+fJlQC1tRT/fvn07W7duJTQ0lEyZMhEREUHXrl2pX78+oJbgFUVhyJAh/PXXX/z5559oNBosLS0ZPXo0P/zwQ5zPumDBAjp27AjA+fPnmTNnDrlz5+bWrVuEh4czZswYKlSowPDhwylYsCA9evQAiPW8Vq1aODg4cPz4cV69esWvv/7KP//8w9WrVzE2Nmbx4sXY2NgAsHHjRq5fv054eDjdunWjZcuWABw9epTFixcTERFBhgwZGDZsGCVLlmTBggX8+++/+Pv7Y2try88//4yzszPh4eEoikLLli3p0KFDnM+1ZMkS/v77b969e0doaCjDhg3jp59+inO8mTNnsnjxYtzc3NBoNHz33XeMHTtWG2+0ESNGEBYWRpMmTdi+fbv22nl6evLq1St69OhBhw4d4nxH69ati/e7uHTpEtOmTUOj0QDQu3dv6tWrB8Dly5dp27Ytz58/p2DBgsyaNQsLCwsuXbqEi4sLoaGhmJiYMGDAAKpVqxYr1tu3bzNy5EhCQ0PJnz8/ISEhca7PvXv3aNu2Le7u7piamhIVFUXNmjVZuXIlQUFBzJgxg/DwcAICAqhUqRJTpkyJ83fz8uVLxowZE+f527dvmTx5Mjdv3iQiIoKKFSsydOhQjI2NmT9/PocPH8bExAQrKyumTp1Kzpw5yZ07N5kzZ+bIkSPUqVMnTrwiDVOE0JMff/xRcXBwUBwdHZXKlSsrtWrVUiZOnKg8f/5cURRFmTBhgjJt2rSPvnfq1KnKxIkTFS8vL6VChQqJPmdAQIBSunRp5dq1a4qiKMqhQ4eUHj16KA8fPlRKlCih3S/m823btilly5ZV3r59qyiKomzdulXp1auXoiiKEhkZqVStWlW5d++ecv78eaV9+/ZKSEiIoiiK4u7urjRo0CBODK9fv1bs7e2Vd+/eKYqiKOfOnVMKFy6sjWnFihVKhw4dFEVRlGHDhinLly/Xvjfm85o1aypTpkxRFEVR9u3bpxQqVEjx8fFRFEVR+vbtqyxevFi739ixYxVFUZRnz54pFSpUUG7evKncu3dPcXBwUAIDAxVFUZSbN28qlStXVoKDg5X58+cr9erVUyIiIhRFUZQRI0YoS5cuVRRFUfz9/ZUBAwYoUVFRsT7Xo0ePlE6dOimhoaGKoijK3r17FQcHB0VRlDjH27FjhzJgwADt802bNik9e/aMc60+/F5+/PFHZcWKFYqiKMrVq1cVOzs7JTw8PM539KnvonPnzsrevXsVRVEUHx8fZdy4cdpr27JlSyUkJESJjIxUmjVrpuzYsUMJDAxUKlasqPz777/a61SuXDnlwYMHyrZt27R/C02aNFG2bNmiKIqiXLp0SbG1tVXOnTsX5zN16NBBOXDggKIoinL8+HGlbdu2iqIoysCBA7X7BwUFKeXLl1e8vLxiXYP58+cr48eP1x4r5vPhw4cra9euVRRF/bscPHiw4urqqjx58kQpVaqU9u9txYoVyuHDh7XHWL9+vTJ06NA4cYq0TUr+Qq/WrFlDtmzZuHbtGk5OTpQsWZLs2bNrt0dX7X8oPDwcIyMjDA0NtSW4xPjnn38oWLAghQsXBqBu3brUrVuXR48effJ9tra2ZMqUCYAGDRrg4uJCQEAA165dI2/evHz//fds2bIFX19f2rZtq33f69evefXqFZaWltrXfH19sba2jlUj8e2332pjKlKkCDt27EjU56lbty4AuXPnJkeOHBQqVAiAPHny8Pr1a+1+0THZ2NhQpUoVzp49i5GREf7+/nTt2lW7n4GBAQ8ePACgRIkSGBur/0X89NNPDBs2jCtXrlCxYkVGjRqFoWHsVsPvvvuO6dOns2fPHnx9ffH09CQ4OFi7Pebxjh07hpeXFy1atABAo9EQGhqaqM/s4OAAQOHChQkPDycoKAiI/R0dP3483u+iQYMGTJgwgaNHj1KpUiV+//137T516tTB3NwcgIIFCxIYGMiVK1fIkycP9vb22tdLlSrFhQsXMDAwAODly5fcuHGDpk2bAlC6dGkKFiz40fhbtWrFjh07qF+/Ptu3b6dVq1YATJs2jZMnT7JkyRLu3r1LWFgYISEhsf52PuX48eN4eXmxdetWAG2/GBsbGwoVKkSzZs2oVq0a1apVo2LFitr35c6dm127diXqHCLtkOQvUoQiRYowYsQIRo0ahb29Pbly5aJUqVIsX74cjUYTK9FoNBouXrzIzz//TIECBYiMjMTX15e8efNq93n37h39+vVj0qRJsaqSjYyMtP9hAyiKwo0bN8icOXOsds+IiIhY8VlYWMR6XK9ePfbu3cvly5e1/3lrNBqaNGnCkCFDtM/9/f21zRjRDA0NiYqKivVahgwZtI8NDAy0scR8/LG4Yt5AmJiYEJ+Y109RFIyNjYmKiqJixYrMnTtXu+3p06fkzJmTw4cPx/rMNWvW5NChQ5w5c4azZ8/yxx9/sGnTJvLkyaPd5+rVq/Tt25euXbtSuXJlypYty/jx42Ndt2gajYaePXvSvn17QL2Zi3mz8inRNxDR32P09fnw+PF9F23btqVmzZqcPn0ad3d3Fi5cyO7du2MdO/r4iqJ89OZSURQiIyO11/zDWD48Vkz169dn6tSp3Llzh4sXLzJt2jQAOnToQKFChahatSoNGjTA09MzTlv8p/4eNBoN8+bN0zYzvXnzBgMDAwwNDVm/fj1eXl6cPXuWKVOmUL58eUaNGqV934c3ciLtk29cpBgODg6UKFFC285Zr149zM3NmTJlirYUExYWxsSJE8mYMSM//fQTpqamODk5MXLkSJ4/fw6oiWTKlCmEhobGaUO2t7fnzp073Lp1C4AjR44wZMgQsmTJQkREBLdv3wbg8OHDn4y1devWbN++ncuXL2vbiytXrsy+ffvw9/cH4M8//6RLly5x3ps7d24CAwN59+5dgtfEysoKb29vAAIDA7l06VKC7/mY6JqEJ0+ecObMGSpWrEiFChU4ffq0trf3iRMnaNy48UfjGjRoEPv376dRo0aMHTuWTJky8fTp01j7XLx4ETs7O7p160a5cuU4cuRInJucaFWqVGHr1q3aUvu8efMYOnRonP2ib1I+TIIJ+dR30bZtW3x8fGjevDkTJ07kzZs3n7zxsLe35969e1y5cgWAW7ducfHiRcqVK6fdx9LSkqJFi/LXX38B6o3QzZs3P3o8MzMzGjVqxPDhw6lbty7m5ua8fv0ab29vBg8eTN26dfHz8+PBgwdxbjysrKy4evUqiqIQEhLCqVOntNuqVKnC6tWrURSF8PBwfv75Z9avX8/169dxcHDghx9+oHfv3nTt2pUbN25o3/fw4UPy58//OZdXpAFS8hcpyujRo2ncuDHu7u5UrVqVlStXsmjRIpo3b64tMdeqVYuVK1dqS119+vTB3Nxc2ynu3bt3lCtXjkWLFsU5fo4cOZg5cybDhg0jKiqKTJkyMWfOHDJnzsyQIUNwcnIiW7Zs2s588bGzs8PY2Jh69ephZmYGQNWqVXFycqJ79+4YGBiQKVMmFi5cGKumASBLliyULl2ac+fOUb169U+ep1OnTgwePJh69eqRK1euWAnnc7x7945mzZoRERHBqFGjyJcvHwATJkzg999/19YGLF68OFYJOlrfvn1xdnZm8+bNGBkZUadOnTixODg44ObmRsOGDTExMaFixYq8fv1am+BjatWqFX5+frRu3RoDAwP+97//aUvAMVlbW1OkSBEaNGjAn3/+mejP+6nvYvDgwUyZMoW5c+diaGhIv379yJUrV7zHypYtG/PmzWPixImEhYVhYGDA1KlTyZcvn7aDKMDs2bMZMWKEtkbkUwm1VatWrF+/nnHjxgGQNWtWevXqRbNmzbC0tMTKyopSpUrh6+tL7ty5te+L/rdRt25dbGxsKFmypPbGyNnZmcmTJ+Po6EhERASVKlWiZ8+emJiY0KBBA1q0aIGFhQUZMmTQlvoB3N3dtZ1PRfphoHzuLbUQ4qv9888/LFmyBFdXV32HItKxBw8eMHjwYDZv3hznJlWkbVLtL4QelCpVinz58nHy5El9hyLSsblz5zJp0iRJ/OmQlPyFEEKIdEZK/kIIIUQ6I8lfCCGESGfSRG//sLAwvL29sba2xsjISN/hCCGEEDoVFRVFQEAAdnZ2seYJSaw0kfy9vb0/Os+4EEIIkRIoigH+/uN4984WA4NwbGxGYWr6IM4+jx+7kinTESwtNxEVlZWnT2eg0WTCyOgVNjajMDaOvarlhg0bKFOmzGfHkyaSv7W1NaBehG+++SbR7/P29sbOzk5XYaVbcl11R66t7si11Q25rqoDBzLg5mbOnDkv+ecfUxYu3M3KlS9i7TNtWhbOnDGjVatidOrkxMSJWbG01PDrr29xd8/D7t1/M2PGSwCePXtGhw4dtPnvc6WJ5B9d1f/NN998crKOD/n5+X3W/iJx5Lrqjlxb3ZFrqxtyXVU+PtCiBeTKlZFcueDnn4l1XbZuBUtLaNwYrKzMyJXLiocPoU8fyJUrK02bwvjx6vtj+tKmbunwJ4QQQujYmzcQc5kPIyOIXrfM2xs2boQJE2K/p0QJ+G/ZCXbvho+sEv3F0kTJXwghhEjJsmSBt2/fP9doIHrtp7Vr4fFjqFUL7t8HU1P4/nsYMQL694dq1aBRI4gx0/NX03nJPygoCAcHh48umerj40OLFi2oV68ezs7O8S7fKoQQQqRmlSvD/v3q43PnoFix99tcXOD8eTh+HLp2hd9/h/r14eRJcHJSfxcooB4jqeg0+Xt6etKuXTvu37//0e1Dhgxh9OjRHDp0CEVR2LJliy7DEUIIIfSiWTPIkAEqVYKBA2HOHJg9+321/sfY2sLgwep7Nm2CGOsxfTWdVvtv2bKFsWPHfnSpzsePHxMWFkaJEiUAaN68OfPnz9eu7y2EEEKkFYaGsGRJ7NcKFYq7338LPQJqaf/MmY8fz83t4VfFo9PkP3ny5Hi3+fv7xxqiYG1tjZ+f31edz9vb+7OP4eHh8VXnFB8n11V35Nrqjlxb3Ujq66rRwLRpebh1yxwTE4XRo33Jnfuddvvp01lYtux/KIoBhQsHM2zYQ6LXLjp2zJK//7Zi8uR7SRpTcgkODmbGjBkcPHiE/Pm/vBOA3jr8fWw9oa9dWcrOzu6zhpR4eHhQunTprzqniEuuq+7ItdUduba6oYvrun07ZM4MV66o7edTp9qxa5e67e1b6NJFbT/PkQNcXDKSN29OrK3ht9/g0CG1F33p0tmSNKbk8u7dO+7fv//V+VJvyd/Gxobnz59rnwcEBJAzZ059hSOEECKVOHVK7RAHUKECXLr0ftuZM2pnukGD4O5d6NkToiuZK1WCpk1h6dJkD/mT3r2D16/Vnzdv4v7283vN69cK4eGWvH5thqXlRkxMAoFeX3xOvSX/7777DjMzM+1d4c6dO6lWrZq+whFCCJFKxDdm3tgYnj+HY8fg338hUyaoWhUqVoQff4Q2bdQageT2+LEa07Fj6g3Jhwk+PPxT7z4E9ARqAOv+e60YxsZxR9B9jmRP/k5OTvTv359ixYoxc+ZMRo0aRXBwMEWKFKFz587JHY4QQohU5lNj5rNnh7JlIXqm92rV1BuBH39Mvvj8/dWbjKNH1YR/8+an9zcxUW9msmR5/9vC4jU3bw7izp0VAOTOfZPffw8mZ86MZMkCEREwfPiXx5gsyf/o0aPax8uWLdM+LlSoEFu3bk2OEIQQQiQDjQb69gVPTzAzgwEDzIhu8v/3Xxgw4P2+587Bzp3vq/DnzoVnz2DatE+fo3Jl2LMHWreOO2a+VCl1xrznz9Xpcs+dU8fK69LLl3DixPtk7+0de3umTOpNSK1aYG+vxhUz2ZuZQcwm/MOHD9OjRw8ePnyIqakpEyZMYNCgQRgbv0/ZH5k657PIDH9CCCGSzM6dEBYGZ8+qiXfYsFw0bapuK1HifbX7X3/Bd9+piT80VG2bv3BBnf8+Ic2aweHDahu+osCqVeqY+QIF1Lnxp06FevXUfVu3hqReVyg8XE32hw6pyf7yZTWOaObm6g1KrVpQsyaULq2W7hOi0Wjo27cvS//rlFCmTBlWr15N0aJFk/YDIMlfCCFEEvqwM56Pj0WcfYKDYexYdeY6UG8WunSBn36C69cTPkdCY+bbtlV/PqZGDfXnc/n7qzP07d0Lbm6xmx1MTNR+BdHJvnx5tTT/uQwNDTEwMMDExIRx48YxdOjQWKX9pCTJXwghRJL5sDOeoeH7znjRVqyAVq3UoXgAVlZQty6sXp2soX6SooCXl5rs9+xRp9+NWbq3s1Pn269TR62BsIh7j5MoQUFBPHz4kMKFCwPg4uLCL7/8ovNlkCX5CyGESDIfdsZTlNiJH2DDBnUJ25QmLEytxt+7V/158OD9NlNTtVTv4KD+fP/915/v2LFjdO/eHUNDQ65cuULGjBnJnDmzzhM/SPIXQgiRhD7sjFegQChgqt3++rU6rv1rV6hTFLVzYEiIerywMPX3lzx+9+59D/2Yy+bmzPk+2depo04slBSCgoIYPnw4f/zxBwAlSpQgICCAjBkzJs0JEkGSvxBCiCTzYWe8wYMfMnt2Vm1nvJs3v6zUrChw545aMo/uVf+VM8J/VIkSarJ3dIQyZdRmi6R04sQJunXrxr179zA2Nmb06NGMGDECk8T0CExCkvyFEEIkmQ8743l4vIvVg79sWXVEwMd07Rr3tRMn1N78R4/Cww/WsrGyUofNmZmpK+aZmSX+8YfPM2ZUb1i+tkbiU8aNG8f48eMBKF68OGvWrNEubpfcJPkLIYRIsVq1goAA9XG2bGq7e82aas/6QoVij49P6ezs7DA2NmbkyJE4Oztjamqa8Jt0RJK/EEKIFCsoSP197pxaa5DU1fC6FBISwqlTp6hbty4ALVu2pFSpUuTPn1/PkUEquoxCCCHSE19fdZggqLP4pabEf/r0aUqUKEGjRo3w9PTUvp4SEj9I8hdCCJHCPH6sThFcsKA6h322bOpQu9QgNDSUQYMGUbVqVW7duoWtra2+Q/ooSf5CCCFShGfP1Ln/f/gBFi9WS/3t26sT7OhoorskdfbsWUqUKMHs2bMxMDBg5MiReHh4YG9vr+/Q4kgFl1MIIURaFBUF9+6pC+GcOAFLl6rz/AO0bAnjxoEOprXXiZUrV+Lk5IRGo6FIkSKsXr2asmXL6juseEnyF0KINOTDVfWWL1cXvIH4V9WztVXn1lcUyJsXXF2/fLraj1EUdZiet7f6c/Wq+vvaNXWynZgaN4bx49Xx9qlJ7dq1yZIlC71792bcuHFkyJBB3yF9kiR/IYRIQz5cVW/QINi1S90W36p6LVtCnz5qFfvy5eoKeaNGff65o2fdi07uV6/C+fO23L8fe8rfmHLlUkv3dnbQpo3aoz81CAsLY/Xq1fTq1QtDQ0Py5s3L3bt3sbKy0ndoiSLJXwgh0pAPV9W7dCnuPh+uqnftGixbpj6uXBkGDkz4PIqiLsHr4fE+2Xt7Q2Dgh3tmAtSpcqOTvJ2d+rhoUXWSntTm4sWLdO3alWvXrhEZGUm/fv0AUk3iB0n+QgiRpny4qp6RUcKr6pUoAbt3q1X/u3erNwcJGTECpk+P+7qlZewkb2Jyg2bNbMmZ82s+Vcrw7t07JkyYwPTp04mKiuLHH3+kdOnS+g7ri0jyF0KINOTDVfU0moRX1Zs1C/r1U6fRbdjw/U1BfFatUhO/sTF07KiOwY9O+N9+G3vWPQ+PoDSR+D08POjatSve3t4YGBgwaNAgJk6ciLm5ub5D+yKS/IUQIg35cFW9YsVib//YqnqHD8OUKWrHv1mz4Kef4j/+yZPQu7f6eNEicHJK+s+Q0pw8eZJatWoRFRVFwYIFWbVqFZUrV9Z3WF9Fkr8QQqQhH66qt2qV2oHvU6vq2dpChw7q6ICiReG/lWbjuHsXmjdXJ94ZMCB9JH6ASpUqUbp0aSpXrsykSZOwSMqhEHoiyV8IIeLxqWFzoJaSN25Up50dOVJNvKGhalW4v7+6/vuaNWBtnXwxf7iqHqgL4ET72Kp65ct/vGNgTK9fq0vdvngBDRrAzJlJEm6KFB4ezowZM+jRowfffPMNxsbGuLu763UhnqQmM/wJIUQ8Yg6bmzZNHTYX7dUrmDdP3ebm9n78/OLFalW7uzt07gyTJukh8CQWGakOw/PxgSJFYNMmtSNhWuTp6Um5cuUYNWoUffv21b6elhI/SPIXQoh4fWrYXMaM6oQ4wcHqT/SiMzHf06AB/P138sasC4MHw6FDakfAvXvVToVpTUREBBMmTKBMmTJ4enqSP39+fvvtN32HpTNS7S+EEPFIaNhc7txqSTgqSh369uF7MmdWq8tTm7AwuHFDHbfv7q5Ou2tiAjt2QL58+o4u6Xl5edGlSxcuX74MwC+//MK0adPIlCmTniPTHUn+QggRj08NmztwAJ4+VeemB6hXT+1pH/M9b9+m7ElsIiLg9u3YU+56e8OtW+pnjcnVFapU0U+cuvTs2TPKlStHWFgY33//PStXrqRmzZr6DkvnJPkLIUQ8PjVszsoKzM3VjoAGBmqSf/VKfc/+/VCunHqDULWqvqJ/T6NRb1JiJnhvb7V0Hx4ed39DQ/jxx/cT9dSsCTVqJHvYyeKbb76hX79+BAcH4+LikqZL+zFJ8hdCiHgkNGzu77/VvgCGhmqp+Kef1N9duqi/TU3V0QC6pihq84K/v/oTEAB37rwv0V+7BiEhH3/v99/HnnLXzk4dHZDC16X5YpGRkbi4uFCmTBnq1q0LgIuLCwYxZyZKByT5CyFEPBIaNjd+vPoTk4WFumjO1woJeZ/MYyb1+F6LiPj08b79Nm6SL1IE0klBF4Br167RpUsXLl26RO7cubl58yYZMmRId4kfJPkLIYTeKIra5n7smLra3p0775N6fCX1+GTOrC6eE/2TK1fsZJ+K1pxJcpGRkcyaNYsxY8YQHh5O7ty5WbFiRYpfdleXJPkLIUQyevgQjhxRE/7Ro/Do0cf3MzOLncyjf6ytP/5aOs5jn+Tj40PXrl25cOECAD179mTWrFlkSYvjFT+DJH8hhNAxjUbtXDd1KqxbF3tbjhxqh7qaNcHeHmxs1ISeKVPsBXLE54uKisLR0ZE7d+6QK1culi9fTr169fQdVoogyV8IkaS+ZEpcRVGrqQsWVPepWFFNlKmRoqhz4F+6pP5cvAj//BN7yCDA3Llqwrezez9BkEhaRkZGzJ8/n23btjF79myyxpy0IZ2T5C+ESFIxp8Q9d06dEnfXLnVb9JS4t2+rs+KVKKEm/zt3oFQpdVhdaqIoarV9dJKPTvgvX8bdN1cuKFNGnUe/T5+UPf4/tYqKimLevHm8fv2a8f/1xGzYsCENGzbUc2QpjyR/IUSS+pIpcT084PFjtSRsbg5z5qgrzaU0fn5xE72fX9z9cuZUF9ApU+b9zzffJH+86cmtW7fo1q0bp0+fxtDQkM6dO/PDDz/oO6wUS5K/ECJJfcmUuP/7n/q4VSv15qFjRzXB6lNgoHpTEjPRP3wYdz8rq9hJvmxZtZQv7fXJQ6PRMH/+fEaOHEloaCj/+9//WLZsmST+BEjyF0IkqS+ZErdMmff7VKkCT56oVerJlUDfvgUPj0wcO/Y+0d+5E3e/TJmgdOn3Sb5MGcifXxK9vty+fZvu3bvj7u4OQKdOnZg3bx5W6XlcYyJJ8hdCJKkvmRJ3/HjInh2GDlU7CubOrbuEGhoK//77vkR/8aLaE19RYrczZMgAJUvGTvQ//ph2l7JNjZydnXF3d+ebb75h6dKlNG7cWN8hpRqS/IUQSepLpsQtW1at6t+3T60BWL066eJ59AjOnIHTp9Xf//6rNkPEZGICBQoEU61aRm2iL1JEfV2kLIqiaGfkmzt3LpaWlkyZMoXs2bPrObLURZK/ECJJfcmUuFZWauL/WhERcOVK7GT/YTu9oaFaGxGzRF+8OHh7X6d06dJfH4TQCY1Gw+LFi9m+fTuHDh3C2NiY//3vfyxdulTfoaVKkvyFEKlWYKDatBCd7C9ciDstbtas6rwBlSqpP+XKqVPhitTj3r17dO/enePHjwOwd+9emjZtqteYUjtJ/kKIVEFR4ObN2KV6H5+4+xUooPY7iE72RYrIJDqplUajYenSpQwZMoTg4GCsra1ZsmSJJP4kIMlfCJFiBQerkwZt2aIm/BcvYm83M1Or7aOTfcWK6hh7kfr5+vrSo0cPjhw5AkDr1q1ZuHAh1tbWeo4sbZDkL4RIUTQaOHkS1q5Vl8YNCnq/zcZGTfTRyb5kSfUGQKQ9u3bt4siRI+TIkYNFixbRqlUrfYeUpkjyF0KkCLduqYverFsH9++/f71CBejcWZ018PvvZUx9WhYeHo6pqSkA/fr1IzAwkL59+5JTqnOSnLSECSHQaNT55itWhBo11Ln3Y5o1S53cpmxZ2LFDfS0wEBo2VIfrNWmirkH/uV69gqVL1ZL8jz/CxIlq4s+TB5yd1fH3Z8/Czz9DvnyS+NMqRVG0s/I9/G94hqGhIePGjZPEryOS/IUQsRbjmTZNXYwnWvRiPGfPgpsbDBigvj5lipr4T52CX39VV+hLjMhIdVhf69bqfPd9+qid9zJmhC5d1DXu792DSZPUGwKRtj18+JAGDRrQq1cvHj16xLoP1zwWOiHV/kKIL1qM59o1mDxZfVy5MvTr9+lzeHrCmjWwYcP7WgIDA6hTR63Wb95cPZdIHxRFYdWqVQwcOJA3b96QLVs2Fi5cSNu2bfUdWrogyV8I8UWL8ZQoAbt3q53udu+OO74e1BXvNmxQO+95er5/3dZWLeV37KgeW6Qvjx8/xsnJiQMHDgDQpEkTlixZwjey9GGykeQvhPiixXhGjID+/aFaNWjUKHYSv3tX3XbwoHrDAJAtG7Rrp5byy5aV9vv0zM/PDzc3N6ysrFiwYAHt27fXTtkrkodO2/z37NlDw4YN+emnn9iwYUOc7VevXqVFixY0btyY3r178+bNG12GI4SIR+XKsH+/+vhTi/FkyPB+MZ6TJ8HJSf0dPbFONFdXtV3fwEDtDLhtm7pS38KF6gx78v98+vPy5Uvt41KlSrF+/XquXr1Khw4dJPHrgc6Sv5+fH3PmzGHjxo3s2rWLzZs3c/uDLsSTJ0+mf//+7N69m3z58rFixQpdhSOE+IRmzdTEXqkSDBwIc+aoi/Hs3g1Vq6ol9QoV1NEAP/6oLsZjawuDB6vv2bQJRo16f7yICPX35MlqZ8LmzWU8fnqlKArr1q0jf/78bN++Xft627Zt+d///qfHyNI3nVX7nzlzhgoVKmBpaQlAvXr1OHjwIP1i9ArSaDQEBwcDEBoaStaYjY5CiGTzJYvxFCig9tL/FFn+Nn17+vQpgwYN4uTJkwDs3r2b5s2b6zkqATos+fv7+8eahjFnzpz4+fnF2mf48OE4OztTpUoVzpw5I708hRAiDVAUhQ0bNlC0aFFOnjxJlixZWLVqFatWrdJ3aOI/Oiv5K4oS57WY7TphYWE4OzuzZs0aihcvzqpVqxg2bBiurq5ffE5vb+84NxgJ8fDw+OLzifjJddWd1HBt/fxyATY8evQQD48vmP1HT1LDtU3pXr16xaRJk7Qr8FWqVAlnZ2dsbGz4559/9BtcGhIQEPBV79dZ8rexseFSjMHC/v7+sWZqunnzJmZmZhQvXhyANm3aMG/evK86p52dHbly5Ur0/h4eHrJ+tw7IddWd1HBtHz58v9pe7ty5KV06dYzlSw3XNjUICgrC19eXLFmyMGfOHIoXL06ZMmX0HVaa8+jRo696v86q/StVqsTZs2cJDAwkNDQUNzc3qlWrpt2eN29enj17xt27dwE4cuQIxWJ2MRZCpCqKAhs3qiMF/vkHrK3VYYEi7fP39yfovxWYMmXKxF9//YWXlxfdu3eXnvwplM6Sv42NDQMHDqRz5840bdoUBwcHihcvjpOTE15eXmTNmpWpU6cyYMAAHB0d2bZtG1OmTNFVOEIIHQoMhLZtoUMHeP0aGjcGb28oWlTfkQld27JlC0WLFmX48OHa10qXLk2ePHn0GJVIiE4n+XF0dMTR0THWa8uWLdM+rl69OtWrV9dlCEIIHTt0CLp3V8fxZ8yorgPQvbuM5U/rAgIC6Nu3L1u3bgXUptyIiAhMTEz0HJlIDFnYRwjxRUJC1AV96tdXE3+lSuoUvj16SOJP67Zu3UrRokXZunUrmTJlYsmSJRw6dEgSfyoi0/sKIT7bxYvQqZO65K6xMUyYAEOHyrj+tC48PJzOnTuzefNmAGrVqsWKFSv4/vvv9RuY+GxS8hdCJFpkpJroK1ZUE3+RInDhgjrPvyT+tM/U1BQDAwMyZszIH3/8weHDhyXxp1KS/IUQiXLzJlSpAmPHqov1DBwIHh7qqn4i7Xrx4gW3bt3SPl+4cCFeXl707dsXQ0NJIamVfHNCiE9SFFi8WE3y589Drlxw5Ig693+GDPqOTujSrl27KFq0KC1btiQ8PByA7Nmzky9fPj1HJr6WJH8hRLyePlWX6+3bV+3g17EjeHlBrVr6jkzoUmBgIJ06daJp06b4+flhaWnJq1ev9B2WSEKS/IUQH7Vtmzphz4ED6rK+mzfDunXqkr4i7dqzZw92dnasX78ec3Nz5s2bx7Fjx2LN0CpSP+ntL4SI5fVrdQjfunXq87p1YdUq+PZb/cYldO/XX39l4cKFAFSpUoVVq1ZRoEABPUcldEFK/kIIrePHoXhxNfGbm8PChXDwoCT+9MLe3h5zc3PmzJnD8ePHJfGnYVLyF0IQFgajRqmd+BQFypZVbwBsbfUdmdClV69ecenSJerUqQNAjx49qFu3rkzNmw5IyV+IdO7ff9VkP2sWGBqqQ/lOn5bEn9YdPHgQOzs7GjduzO3btwF12XVJ/OmDJH8h0qmoKJg+HcqVUxfhKVgQzpyBceNAZmlNu16/fk3Pnj1p0KABjx8/1i6rLtIXSf5CpEP37kGNGjB8OEREqEP5Ll9WbwRE2uXm5oadnR0rVqzAzMyM6dOnc/r0aWnbT4ekzV+IdERRYPVq6N8fgoLgm29g5Upo0EDfkQldmzlzJkOGDAGgXLlyrF69msKFC+s5KqEvUvIXIp3w94dmzdTldoOCoGVLtbpfEn/60LBhQ7JkycLUqVM5ffq0JP50Tkr+QqQDe/ZAz57qDUCWLPDHH9Chgyy9m5a9ffuW9evX06dPHwwMDChSpAgPHjwga9as+g5NpACS/IVIw4KC4PffYdky9XmNGrBmDUiH7rTt6NGjdO/eHV9fXzJnzkzHjh0BJPELLan2FyKNOnMG7O3VxG9qqg7lO3JEEn9aFhQUxC+//ELt2rXx9fWlVKlS2Nvb6zsskQJJ8hcijQkPB2dnqFoV7t5VbwA8PNQaAFmBNe06fvw4xYsXZ9GiRZiYmDBx4kTOnTtHsWLF9B2aSIGk2l+INOTaNXXlvcuX1fb84cPVcftmZvqOTOjSrl27aNq0KQAlSpRgzZo1Mn5ffJIkfyHSAI0G5s9Xk/27d/D99+r0vFWq6DsykRzq1q1LsWLFaNGiBSNHjsREZmkSCZDkL0Qq9/AhdO0KR4+qz3v0gDlzIHNmvYYldCgkJISpU6cyaNAgLC0tMTc3x8PDQ5K+SDRJ/kKkUooCf/6pzs73+jVYW6ud+5o00XdkQpdOnTpFt27duH37Nk+ePGHFihUAkvjFZ5HuP0KkQoGB0LatOlb/9WtwdAQvL0n8aVlISAi///471apV4/bt2xQrVoxffvlF32GJVEpK/kKkMm5u0K0bPHkCGTPC3LlqVb9M2JN2nTlzhq5du3Lr1i2MjIwYPnw4o0ePxkx6coovJMlfiFQiJARcXHKzZYv6vFIlWLsWfvhBv3EJ3bp16xZVq1ZFo9FQpEgR1qxZQ5kyZfQdlkjlJPkLkQpcvAidOsGNGzkxNoYJE2DoUDAy0ndkQtcKFiyIk5MT2bJlY+zYsVLaF0lCkr8QKVhkJEyZoib7qCjInz+UrVvNKVlS35EJXQkLC2Ps2LE0adKESpUqAbB48WIMpF1HJCFJ/kKkUDdvQufOcP68+nzgQGjZ0oeSJUvpNzChMxcuXKBr1674+PiwZ88evLy8MDIyksQvkpz09hcihVEUWLwYSpZUE3+uXPD33zB7NpiZKfoOT+jAu3fvGDFiBBUrVsTHx4dChQqxatUqjKRdR+hIgsk/ODiY8ePH06VLF169esWYMWMIDg5OjtiESHeePoVGjdSx+yEh6lA+Ly+oXVvfkQlduXjxIqVKlWLatGkoisLgwYP5559/KF++vL5DE2lYgsl/0qRJZMmShRcvXmBmZkZQUBBjxoxJjtiESFe2bYNixeDAAbCygs2bYf16sLTUd2RCV0JDQ3FwcODatWsULFiQU6dOMWPGDMzNzfUdmkjjEkz+Pj4+DBw4EGNjY8zNzZk5cyY+Pj7JEZsQ6cLr19ClC7RsCS9eQN26amm/dWt9RyZ0zdzcnHnz5jFw4ED+/fdfbQc/IXQtwQ5/hh+sARoVFRXnNSHElzl+XE38Dx6AuTnMmKFW+Uv/rrQpPDyciRMnkiVLFoYMGQJA27Ztadu2rZ4jE+lNgsm/bNmyzJgxg7CwMNzd3dmwYQPlypVLjtiESLPCwmDUKLUTn6JA2bLqKny2tvqOTOjK5cuX6dq1K1euXCFDhgx06dKFnDlz6jsskU4lWIQfPHgwFhYWZM6cmTlz5mBra8vw4cOTIzYh0iRPTzXZz5oFhoYwdiycPi2JP60KDw9n3LhxlCtXjitXrpA/f34OHTokiV/oVYIl/xMnTvDLL7/EWkBi586dNG3aVJdxCZHmREXBzJkwejREREDBgmppXzp1p12enp506dIFT09PAH799VemTp1KxowZ9RyZSO/iTf5Hjx4lMjISFxcXFEVBUdTxxZGRkcyZM0eSvxCf4d49dcKeU6fU5z//rLbvSw5I2wYPHoynpyf58uVj5cqV1KhRQ98hCQF8Ivn7+Phw7tw5Xrx4wdq1a9+/wdiYHj16JEtwQqR2igKrV0P//hAUBN98AytXQoMG+o5M6IqiKNoZ+ZYuXcq8efOYPHkymTJl0nNkQrwXb/KPrurfsGEDHTp0SM6YhEgT/P2hVy/YtUt93qIFLFkCOXLoNy6hG5GRkUyfPp0zZ86wd+9eDAwMyJ8/P/PmzdN3aELEkWCbf6tWrTh8+LB2Vr+oqCgePHjAwIEDdR6cEKnVnj3Qs6d6A5AlCyxcCB07yhC+tMrb25uuXbvi4eEBgLu7O9WqVdNzVELEL8HkP3DgQB4+fEhAQABFihTB09NThvoJEY+gIPj9d1i2TH1eowasWQN58ug1LKEjkZGRzJgxg3HjxhEeHk6ePHlYsWKFJH6R4iVqhr/t27dTu3ZtRo4cyaZNm3j79m1yxCZEqnLmDNjbq4nf1FQdynfkiCT+tOratWtUqlSJkSNHEh4ejpOTE15eXtSpU0ffoQmRoASTf86cOTE2Nub777/n5s2bFChQgNDQ0OSITYhUITwcnJ2halW4e1e9AfDwUGsAZDLMtGvr1q1cvHiRXLlycfDgQVxdXcmSJYu+wxIiURKs9rewsGDPnj0UKlSILVu2kD9/fl69epUMoQmR8l27prblX76stucPHw7jxoGZmb4jE7rw7t07zP77ckeMGIGiKAwYMICsWbPqOTIhPk+C5ZIxY8bg4+ND5cqVMTQ0pFOnTjLUT6R7Gg3MnQulSqmJ//vv4cQJmDpVEn9aFBUVxYwZMyhYsCABAQEAmJiYMHbsWEn8IlVKsOS/bds2hg4dCsDcuXN1HY8QKd7Dh9C1Kxw9qj7v3h3mzFF79Yu058aNG3Tr1o2zZ88CsH37dnr37q3nqIT4OgmW/I8fP54MYQiR8ikKbNwIxYqpid/aGnbuhBUrJPGnRVFRUcyePZsSJUpw9uxZvv32W/bt2yeJX6QJCZb8c+XKRffu3SlVqlSs+ai7deum08CESEkCA9UpebdsUZ87Oqq9+m1s9BuX0I1bt27RrVs3Tp8+DUDnzp2ZO3cuVlZWeo5MiKSRYPK3tLQE4PHjx5998D179rB48WIiIiLo2rVrnJkC7969y9ixY3n9+jXW1tbMnj1b2s9EiuPmBt26wZMn6lz8c+dCjx4yYU9a9uTJE06fPs3//vc/li5diqOjo75DEiJJJZj8p06d+kUH9vPzY86cOWzfvh1TU1Patm1L+fLlKVCgAKDOf/3zzz/j7OxMtWrVmDlzJq6urgwZMuSLzidEUgsJgWHD1Nn5ACpVgrVr4Ycf9BuX0I2Yo5iqV6/O+vXradCgAdmyZdNfUELoiM5GIZ85c4YKFSpgaWmJhYUF9erV4+DBg9rtV69excLCQjsTVp8+fWQNAZFiXLqk9uRfuBCMjWHKFDh5UhJ/WqTRaFiwYAGOjo4cje7FCXTo0EESv0izdJb8/f39sba21j7PmTMnfn5+2ucPHjwgR44cDBs2DEdHR8aOHYuFhYWuwhEiUSIjYcIEqFgRbtyAIkXgwgUYMQKMjPQdnUhqd+/epVatWvTv35/Q0FAOHDig75CESBYJVvt/KUVR4rxmEKORNDIykgsXLrB+/XqKFSvG3LlzmTZtGtOmTfvic3p7e8e6wUiM6IU4RNJKjdfV19eMsWO/x9tbXXq1XTs/fvnlMRqNQkr6OKnx2qY0Go2GrVu3Mn/+fMLCwsiWLRsjRoygZs2acn11QK5p0oueb+JLJZj8nz9/jqenJ7Vr12by5MncuHGDkSNHUqhQoU++z8bGhkuXLmmf+/v7kzNnTu1za2tr8ubNS7FixQBwcHCgf//+X/o5ALCzsyNXrlyJ3t/Dw4PSpUt/1TlFXKntuioKLF0Kgwap7fy5csHq1VC7tg2Qsrrzp7ZrmxI9fvyYjh07aocxt23blgULFuDr6yvXVgfkb1Y3Hj169FXvT7Daf/jw4Tx8+JCzZ89y/vx5mjZtyqRJkxI8cKVKlTh79iyBgYGEhobi5uYWa6WrkiVLEhgYyPXr1wE4evQoRYsW/YqPIsTne/oUGjVSh/GFhECHDuDlBbVr6zsyoSsZMmTAx8cHa2trtm7dyp9//kmOHDn0HZYQySrB5P/q1Su6du3KyZMncXBwoHnz5ola2MfGxoaBAwfSuXNnmjZtioODA8WLF9eufJUhQwb++OMPRo0aRaNGjTh//jzDhw9Pkg8lRGJs26ZO2HPgAFhZwebNsH49/De6VaQhDx484N27dwBkz56dnTt3cvXqVVq0aKHnyITQjwSr/SMiIoiIiMDd3Z1p06YRGhpKSEhIog7u6OgYZ3zssuiFzgF7e3u2bt36mSEL8XWePVOH8K1dqz6vWxdWroTvvtNvXCLpKYrCsmXLGDRoEL/99pu21rJChQp6jkwI/Uow+deuXZuKFStSuHBh7OzscHBwwMHBITliE+KrhYSoC++cP6/+XLgA9++r28zNYcYM6NtXJuxJix48eEDPnj05fPgwoM7apyhKrI7HQqRXCSb//v3707p1a7755hsAZs6cmWBnPyH0QaMBHx81wUcn+itXICoq9n4ZM0K1ajB7NsifctqjKAorV65k4MCBvH37lmzZsvHHH3/Qpk0bSfxC/CfB5K/RaNi3bx+3bt1i1KhRnDhxgoIFC2Ikg56Fnj15EjvRX7wIb9/G3sfQEIoXh/Ll1Z9y5dSx+/LnmzYFBQXRqlUr7YRiTZs2ZfHixdrCixBClWDyd3FxITAwEC8vLwDc3d0JCAhg1KhROg9OJC+NRq0C9/RU16Rfvhz+m40ZgOnT4c8/1RXshg4FBwd4/hzat4fQUPj2W1i1SjexBQWBh8f7RH/+PHxspEvu3LETfenSaklfpA/Ri49ZWVmxcOFC2rVrJ6V9IT4iweR/9uxZduzYQfPmzcmUKRMrV66kSZMmyRGbSGY7d0JYGJw9C+fOqePed+1St3l5qcvZnj+vPq9UCWrVUmfDa99eXd9+2jR1vHyMEZ1fJDISrl2LneivXlVvTmLKkgXKln2f6MuVg//97+vOLVKfx48fEx4eTr58+TAwMGDlypUA/E/+GISIV4LJ39jYGEPD9yMCTU1NMTbW2cSAQo9OnYL69dXHFSqo89tH8/GBGjUgQwb1ecGCanv6qVMwcqT6WoMG6uMvTf4eHur7T5+G4ODY24yNoUSJ94m+fHmwtVWr9UX6pCgKa9eu5bfffsPOzo4TJ05gZGQkSV+IREgwi//4449s2LCBqKgo7t69y+rVq6XDXxr15g3EXFHZyEgthRsbq+Php05V29TDw+HMGejVK/Z7MmeG168//7whITB2rNoBL7p0ny9f7ERfsqTaO18IUJfc7d27N3v37gXUpceDgoJkSXAhEinB5O/s7MyUKVN48eIF7du3p0qVKjg7OydHbCKZZckSu8OcRqMmfoDChaFfP7VmIE8eNSHnyPH+Pebm6u/PnSDn8GHo3Rvu3VNL8b//ro7BjzETtBBaiqKwYcMG+vfvz8uXL8maNSvz5s2jc+fO0rYvxGdIMPn7+fkxZcqU5IhF6FnlyrBnD7Rurbb5/7fsAgABAWpyP31aLd3XrQt2dup79u9X2/wPHICqVRN3rhcv1D4Fa9aoz+3tYdkytQ1fiI9RFIV27dqxefNmABo0aMCyZcv4TmZnEuKzJdhi2r17dzp06MDOnTsJDw9PjpiEnjRrprbpV6oEAwfCnDlqVfzu3Wop38dHTc4NG6qT4xgZwahRsGmTehNw9qxaO/ApiqKOGChcWE38ZmZqc8LFi5L4xacZGBhQpkwZsmTJwsqVK9m3b58kfiG+UIIl/2PHjuHu7s6OHTuYOXMmdevWpXXr1tLunwYZGsKSJbFfi/k1L10a9z02NvDfkOoEPXigLqCzf7/6vEYNcHVVOw8K8TF+fn5cvXqVWrVqATBw4EDat2/Pt99+q+fIhEjdEiz5GxoaUr16debOncuaNWvw9vamWbNmyRGbSCOiomDBAnVynf371X4By5fD0aOS+MXHKYrC5s2bKVq0KM2bN+fx48cAGBkZSeIXIgkkWPKPjIzk6NGjbN++nStXrtCwYUMmTpyYHLGJNMDbG3r2fD8/QKtWMH8+yIRrIj7+/v707duXbdu2AVCnTh0URdFzVEKkLQkm/ypVqlCwYEFatWrF/PnzMTU1TY64RBowfTqMHg0REersf4sWgcwPJT7lr7/+om/fvjx//pxMmTIxa9YsnJycpCe/EEksweS/adMmvv/++2QIRaQlEREwYoTawe/nn9VOfTIEW3zKyJEjmTp1KqCuJrp8+XL5v0cIHYk3+U+ePBlnZ2emTZv20e1LPuwZJkQMiqL+mJioJX4hEtKsWTMWLVrEtGnT6N27t5T2hdCheJN/xYoVAahXr16yBSOESD+eP3/Otm3b6N27NwBly5blwYMHZMmSRc+RCZH2xZv8o4fW+Pr6MmDAgFjbJk2aJD3+hRBfbMeOHfTp0wd/f3++/fZbHB0dASTxC5FM4k3+8+fP582bN+zfv5+goCDt6xERERw9elSW9BWf9OEKfEIAvHjxgv79+7Nx40YAqlWrRpEiRfQclRDpT7zJ397eHi8vLwwNDbGMMWG7kZERCxYsSI7YRCqlKDBkiPpYhmSLaLt376Z37948e/YMc3Nzpk+fzi+//BJr1VAhRPKIN/lXr16d6tWrU61aNYoXL56cMYlUbu1aGxYuBFNTWL1a39GIlGDVqlV0794dUIcPr1q1igIFCug5KiHSrwR7+y+Kp6u29PYXH7N+PSxYkAuAdevUKXyFaNGiBS4uLvTu3Zv+/ftLaV8IPZPe/iLJHD4M3bqpj+fMUVcHFOnTq1evmDZtGmPGjMHCwoIsWbLg5eWFsXGCU4sIIZJBgr39mzVrRlBQEJkyZeLff//l/v37NGrUKNkCFKnD5cvQvDlERkKHDn4MGGCj75CEnuzfvx8nJyeePHlCZGQkM2fOBJDEL0QKkmDd2/z58xk7dixPnjyhb9++bN++nXHjxiVDaCK1uH9fXeY3KAjatIHffnuk75CEHrx+/Zru3bvTqFEjnjx5QsWKFXFyctJ3WEKIj0gw+R8/fpxJkybh5uZGo0aNWLt2LT4+PskRm0gFXryA+vXh2TO1fX/NGnVpYJG+HDp0CDs7O1atWoWZmRkzZszA3d0dW1tbfYcmhPiIRNXDmZubc+bMGdq0aQOoY/2FCA0FR0e4cQOKFYMdO8DMTN9RieR24cIF6tevD0D58uVZvXo1hQoV0nNUQohPSTD5W1lZMW7cOLy9vZk3bx4zZ84kZ86cyRGbSMGioqBdOzh7FnLnhgMHIMZ0ECIdKVu2LB06dKB48eL8/vvv0rYvRCqQYAXt9OnTyZkzJ66urpibm2NgYMD06dOTIzaRQikK/Por7NqlJvwDB+C77/QdlUgub9++pW/fvly5cgUAAwMD1q1bx9ChQyXxC5FKJPgvNUeOHDRp0oQLFy7g4+NDy5YtyZEjR3LEJlKoqVNh8WK1in/3bihaVN8RieRy5MgRevToga+vL5cvX+bMmTMYGBjICnxCpDIJlvzd3d1p0aIFf//9N0eOHKFly5b8/fffyRGbSIFWrwZnZzAwUCf0qVpV3xGJ5BAUFETfvn2pU6cOvr6+lC5dmmXLlknSFyKVSrDkP2/ePNavX6+divPWrVsMGTKEOnXq6Dw4kbIcPAg9e6qP582Dli31G49IHseOHaN79+7cv38fExMTxowZw7BhwzAxMdF3aEKIL5Rg8o+IiIg1B3fBggWJiorSaVAi5fHwUJN9VBQMHaq2+Yu07+XLlzRp0oS3b99SsmRJVq9eLWt9CJEGJJj8M2TIgJeXF8WKFQPAy8sLc3NznQcmUo67d9VJfIKDoUMHtc1fpA9WVlbMmjWLp0+fMmLECCntC5FGJJj8hwwZQp8+fcibNy+KonD//n3mzZuXHLGJFCAgQJ3Ex98fateGlStlEp+0LDg4mJEjR1KkSBF69+4NILP0CZEGJZj8y5Qpw759+/D09ERRFOzt7bGyskqO2ISeBQeDgwPcugX29rB9u7pMr0ib3N3d6datG3fu3MHS0pL27duTOXNmfYclhNCBBJN/VFQU+/bt49SpUxgZGREYGEjz5s2TIzahR5GR0LYtXLgAefPC/v2QJYu+oxK6EBISgrOzM/PmzUNRFIoVK8aaNWsk8QuRhiWY/CdNmsTt27dp0qQJiqKwdetWfH19GThwYHLEJ/RAUaBvX9i7F7JlU3v5f/utvqMSunD69Gm6devGrVu3MDIyYuTIkYwaNQpTqeIRIk1LMPmfPn2affv2aTv6NG7cmMaNG0vyT8MmToRlyyBDBnUSH5mmPW1SFIUBAwZw69Yt7OzsWL16NaVLl9Z3WEKIZJBg1y0rK6tYQ/sMDAzIIvW/adaKFTB2rNqp788/oXJlfUckkppGowHUf8srV67E2dmZS5cuSeIXIh1JsOSfP39+2rdvT/PmzTEyMmL//v1YWVmxatUqALp166bzIEXy2LcP/uvgzcKF0LSpXsMRSSw0NJQxY8bw4MEDNm3ahIGBAcWKFdMO4xVCpB+JWoXD1taWq1evApArVy4Abt68qbuoRLK7cAFat1Yn8Rk5En7+Wd8RiaR0/vx5unbtyvXr1zE0NMTb21uSvhDpWILJf6rM6JLm3b4NjRpBSAh07gyTJuk7IpFUwsLCGDt2LDNnzkSj0VCoUCHWrFkjiV+IdE6ma0nn/P3VSXyeP4d69WD5cnXRHpH6Xbx4kVKlSuHi4gLA0KFDuXz5MuXKldNzZEIIfZPFt9OxoCC1xH/nDpQqBX/9BTJ7a9qxceNGfHx8sLW1ZfXq1VSoUEHfIQkhUghJ/ulURITaxn/pEuTLp3b2kzldUr+wsDAyZMgAwOTJk7G2tmbgwIGyHocQIpYEq/01Gg3Lly9n2LBhBAUFsXTpUlnVL5VTFOjTBw4cgOzZ1Ul8vvlG31GJrxEeHs7o0aMpWrQob968AcDCwoKRI0dK4hdCxJFg8ndxceHmzZtcuXIFUOf/lk6Aqdu4ceoCPebm6ix+P/6o74jE1/jnn38oU6YMkyZN4t69exw6dEjfIQkhUrgEk//Zs2eZNm0aZmZmZMqUiZUrV3L69OnkiE3ogKsrTJigTuKzeTNIM3DqFR4eztixYylfvjxeXl4UKFCAkydP0qpVK32HJoRI4RJM/sbGxhjGWMPV1NQUY+PEdRXYs2cPDRs25KeffmLDhg3x7nf8+HFq1aqVqGOKL7dnz/vx+4sXg6OjfuMRX87T05Ny5coxYcIEIiMj+e233/D09KRKlSr6Dk0IkQokmMV//PFHNmzYQFRUFHfv3mX16tUUSsRk735+fsyZM4ft27djampK27ZtKV++PAUKFIi13/Pnz5k+ffqXfwKRKOfOQZs2oNHAmDHQq5e+IxJf48GDB3h6epI/f35WrVpFtWrV9B2SECIVSbDk7+zszNWrV3nx4gXt2rUjODiYkSNHJnjgM2fOUKFCBSwtLbGwsKBevXocPHgwzn6jRo2iX79+XxZ9KqTRqJ3tKlaEGjXUCXZimj4dSpSAatXU9niAp0+hdm2oWhWaNIG3bz/vnDdvgoMDhIZC9+5qm79IfQICArSPHR0dWbduHVeuXJHEL4T4bAkm/0yZMjFlyhTOnDnD+fPnmTVrFlZWVgke2N/fH2tra+3znDlz4ufnF2uftWvXUqRIEezt7b8g9NRp504IC4OzZ2HaNBg06P02Ly/YuFEtpbu5qSX0kBD1hqBLF3B3h5Il1Yl4EuvZM3USnxcvoEEDWLJEJvFJbSIiIpg4cSJ58+bVTrMN0LFjRzJmzKjHyIQQqVWC1f6T4pnrddSoUZ98n6IocV4ziJF1bt68iZubG6tXr+bZs2cJhZEo3t7ecW4wEuLh4ZEk506sbdtyUbRoMB4eLzExgbNni+Hh4QXA4cNWFCmSkatXHwGQI0c+tmzxp2PHYBQFLl6Ey5fzUqJEEB4eLxI8V3CwIb17/8i9exkpUiSYESNucuWKRqefL1pyX9e06vbt24wbN47r168D6qx9RYsW1XNUaZf83eqGXNekF7Mm8EskmPwtLS21jyMiIjh16hQlS5ZM8MA2NjZcunRJ+9zf35+cOXNqnx88eJCAgABatGhBREQE/v7+tG/fno0bN37mR3jPzs5Ou/BQYnh4eCT7Mqbm5mrpPfq0GTKAvX1pjI3BwkLtgf/jjzaEh4OPD+TOnY0yZdRJeezt1VqD+fNzkDfv9588T0SEWtV//Tr88AMcO5aRnDkT/t6Sgj6ua1oTGRmJi4sL48aNIyIigrx587Jy5UqyZs0q11ZH5O9WN+S66sajR4++6v0JJv8P2+N79+5N7+h1Xz+hUqVKLFiwgMDAQMzNzXFzc2PixIna7f3796d///6A+iE6d+78VYk/tciSJXabvUYD0YMnCheGfv3Uavo8eaB8eciRQ91mYgLXrsHff6uL75w4Ef85FAV69lSbDqyt1Ul8Ytx3iRTu9u3btGvXTnvz3KdPH1xcXMicObOUoIQQSeKzF/axsLDA398/wf1sbGwYOHAgnTt3pmnTpjg4OFC8eHGcnJzw8vL6omDTgsqVYf9+9fG5cxBzcbWAAPXG4PRptW3+4UOws4O+feHYMXWfzJnVMfqfMmoUrF2r1iTs3QsfDLAQKZy5uTm3bt0iT548HD58mMWLF5NZ5l4WQiShBEv+EydO1LbVK4rC1atXyZ8/f6IO7ujoiOMHg8mXLVsWZ79cuXJx9OjRRB0ztWvWDA4fhkqV1BL6qlUwe7aaoB0d1ar+smXB1BRmzAAjI+jfXx0hED05z6JF8R9/0SKYMkV935YtIAu4pQ63b98mX758GBkZ8d1337F//37s7OzIkiWLvkMTQqRBCSb/D3v2N27cmMaNG+ssoLTO0FAt1ccUc9qEpUvjvqdQITh+POFj79ihNhtEH6dRoy8OUySTqKgoZs+ezejRo5k0aRKDBw8G1GYzIYTQlQST/4MHD7TrgYuU6/RpaN9erU0YPx569NB3RCIhN27coGvXrpw7dw6A+/fv6zcgIUS6kWCb/40bNz46bE+kHD4+apNBWBg4OcHo0fqOSHxKVFQUs2bNokSJEpw7d05bzb9w4UJ9hyaESCcSLPnnyJGDRo0aYW9vH2tCkYTG+YvkERSkTt7z8qU6tG/RIpnEJyV7/vw5TZo04cyZMwB069aN2bNnxxpSK4QQuhZv8g8PD8fU1JSSJUsmaly/0I+LF8HXV+0wuGnT+2GDImWysrLCwMCAb7/9lmXLltGwYUN9hySESIfiTRVt2rRhx44d6Wre/dRI89+EfXnygMz0mjLdvn0bc3NzvvvuO4yMjNi4cSOZM2dO1DTZQgihC/G2+Us7/3tfshhPYKA6QU+NGurPvHnJG7PQP41Gw/z58ylevDg9e/bU/pvKkyePJH4hhF7FW/J/9+4d165di/cmID3NLx5zMZ5z59TFeHbtUrdFL8Zz/rz6vFIlqFUL/vkH2rWDBQv0FrbQozt37tC9e3dOnjwJQPbs2Xn37h0ZMmTQc2RCCPGJ5P/w4UN+/fXXeBfoOXLkiE4DS0lOnVKn3AWoUAFiLFmAj49aso/+P71gQbhyBTw81J/q1dWpdefPh//9L9lDF8lMo9GwaNEihg0bRkhICDY2NixdupQmTZroOzQhhNCKN/kXKFCAnTt3JmMoKdebN5A16/vnRkYQGal2ritWDKZOVaflDQ+HM2egVy91Yp7SpaFOHdiwAX79FbZu1d9nELoXFRVF/fr1+fvvvwFo164dCxYsIHv27HqOTAghYpO+4YnwJYvxlCunzq0P6pS+Y8Ykf9wieRkZGVG+fHk8PT1ZsmQJzZs313dIQgjxUfF2+CtTpkxyxpGifcliPD17wrZt6j5HjrxfwjepREaCp6e6cp/Qn/v37+Pu7q59Pnr0aK5evSqJXwiRosVb8pdJfN77ksV4pk2D7t3VSXcyZoTly7/8/Iqi3lScPw8XLqi/PTwgJOT9Ptmyff3nFImnKAqurq4MHjyYTJky4e3tTfbs2TEzM8Pa2lrf4QkhxCdJtX8ifMliPPnyvV+G93O9fq1O3hOd6M+fBz+/uPvlz682L5QvDx06fNm5xOfz9fWlZ8+e2rb9Bg0a6DkiIYT4PJL8U4DAQDhxQr1ZOHoUrl6Nu4+V1ftEX768WtMgBczkpSgKy5cvZ9CgQbx9+5bs2bOzaNEiWrdure/QhBDis0jy1wNFUZsR3NzUZP/vv+pr0UxN1UmDypd/n/ALFJA5+/WtV69eLP+v/aZZs2YsXrwYGxsbPUclhBCfT5K/HmzcCB07vn9uaqrOH1CrFtSsqSZ7MzP9xSc+rm3btuzYsYMFCxbQtm1bDORuTAiRSkny14PoPgKdO0OnTmpHwuhhgSLlePToEQcPHqRnz54A1K5dm/v375MpUyY9RyaEEF9Hkn8yu3UL3N3VZL9wIWTOrO+IxIcURWHNmjUMGDCA169fU7BgQapXrw4giV8IkSZI8k9mq1erv1u3lsSfEj158oRevXqxb98+ABwdHfnxxx/1HJUQQiSteCf5EUkvKup98u/eXa+hiA8oisLatWspWrQo+/btw9LSkjVr1rBr1y7+J4syCCHSGCn5JyM3N3jyRO25X6WKvqMRMc2aNYshQ4YA0LBhQ1xdXfnuu+/0HJUQQuiGlPyT0cqV6u/u3WXYXkrTpUsXChYsyKpVq9i7d68kfiFEmibJP5k8fw67dqmzBXburO9oxLNnzxg8eDAREREAWFtbc+3aNbp27SpD+IQQaZ5U+yeTDRsgIgIaNAApVOqPoihs2rSJfv36ERgYiKWlpXYdC2Nj+ecghEgf5H+7ZKAosav8hX74+fnx888/s2PHDgDq1q1Lly5d9ByVEEIkP6n2TwaXL8OVK5A9u7oKoEheiqKwefNmihYtyo4dO8icOTOurq4cPHiQ3Llz6zs8IYRIdlLyTwbRpf6OHWXaXn1wc3Ojbdu2ANSpU4fly5eTN29ePUclhBD6I8lfx8LC1PZ+gG7d9BtLelW3bl2aNWtGvXr16NWrl3ToE0Kke1Ltr2M7d8KrV1C6NNjb6zua9CEgIIAuXbpw9+5dAAwMDNi2bRu9e/eWxC+EEEjJX+eko1/y2rZtGz///DMBAQE8f/5cO02vJH0hhHhPSv465OsLf/+ttvO3a6fvaNK2Fy9e0K5dO1q2bElAQAA1atRg4cKF+g5LCCFSJEn+OrRmjTrMr1kzsLLSdzRp186dOylatCibNm3CwsKCBQsWcOTIEfLly6fv0IQQIkWSan8d0Whg1Sr1sVT5686jR49o06YN4eHhVKtWjZUrV/LDDz/oOywhhEjRJPnryIkTcP8+5MkDtWrpO5q0K1euXEydOhVjY2P69euHoaFUZgkhREIk+etIdEe/rl3ByEivoaQpL1++ZMCAAdSvX592/3Wk+P333/UclRBCpC5STNKB169h61b1cdeueg0lTdm3bx92dnasXbuWIUOGEB4eru+QhBAiVZLkrwObNqmT+9SqBdLn7Ou9evWKrl274uDgwJMnT6hYsSJHjhzB1NRU36EJIUSqJMlfB2Rsf9I5cOAAdnZ2rFmzBjMzM2bOnIm7uzu2trb6Dk0IIVItafNPYt7ecOECZM0KzZvrO5rULSIigoEDB/L48WPKly/P6tWrKVSokL7DEkKIVE+SfxKLHt7Xrh2Ym+s3ltRKo9FgaGiIiYkJq1atwt3dnUGDBmEkPSeFECJJSPJPQuHhsG6d+lgW8fl8b968YdCgQQAsW7YMgIoVK1KxYkV9hiWEEGmOtPknoX37ICAAihaFsmX1HU3qcvjwYezs7Fi+fDnr1q3D19dX3yEJIUSaJck/CcWc0U/WkUmct2/f0rt3b+rWrcvDhw8pU6YMHh4e5M2bV9+hCSFEmiXJP4k8fQr794OxMXTsqO9oUocjR45QrFgxXF1dMTExYfLkyZw9e5aiRYvqOzQhhEjTpM0/iaxbB1FR6iI+OXPqO5rUYf369fj6+lKqVClWr15NsWLF9B2SEEKkC5L8k4CiyNj+xAoJCcHCwgKAOXPmYGdnR//+/TExMdFzZEIIkX5ItX8SOHsWbtyAb76B+vX1HU3KFBwczK+//kqZMmUICwsDwNLSkkGDBkniF0KIZCbJPwlEl/q7dFHb/EVsJ0+epHjx4ixcuJBbt25x6tQpfYckhBDpmk6T/549e2jYsCE//fQTGzZsiLP977//pkmTJjRu3Ji+ffvy+vVrXYajE0FBsHmz+ljG9scWEhLCgAEDqFGjBnfv3qV48eJcvHiROnXq6Ds0IYRI13SW/P38/JgzZw4bN25k165dbN68mdu3b2u3BwUFMW7cOFxdXdm9eze2trYsWLBAV+HozNat6g1ApUog082/d/r0aezt7Zk3bx5GRkaMGTOGixcvUqJECX2HJoQQ6Z7Okv+ZM2eoUKEClpaWWFhYUK9ePQ4ePKjdHhERwbhx47CxsQHA1taWp0+f6iocnYk5tl+8d/fuXW7fvk2xYsU4f/4848ePl1X4hBAihdBZC7W/vz/W1tba5zlz5uTKlSva51ZWVtrq37CwMFxdXenUqZOuwtGJW7fg5EmwsIDWrfUdjf75+flpb+Y6/jfZQZs2bSTpCyFECqOz5K8oSpzXDD4y7d3bt2/p27cvhQoVolmzZl91Tm9vb/z8/D7rPR4eHl98vj/++Bb4H7VrP+fmzfQ7HW1YWBhLlizhr7/+Yt26deTPn59//vmHIkWK4OXlpe/w0pyv+ZsVnybXVjfkuia9gICAr3q/zpK/jY0Nly5d0j739/cn5wez3/j7+9OjRw8qVKjAyJEjv/qcdnZ25MqVK9H7e3h4ULp06S86V1QUHDqkPh4yJAelS+f4ouOkdufOnaNHjx7cuHEDQ0NDXr58CfDF11V82tf8zYpPk2urG3JddePRo0df9X6dtflXqlSJs2fPEhgYSGhoKG5ublSrVk27PSoqij59+tCgQQOcnZ0/WiuQkrm5wZMnUKAAVKmi72iSX1hYGMOGDaNy5crcuHGDwoULc/bsWXr16qXv0IQQQiRApyX/gQMH0rlzZyIiImjZsiXFixfHycmJ/v378+zZM65du0ZUVBSH/itC29nZMXnyZF2FlKRizuiXyu5bvpqnpyft2rXDx8cHQ0NDhg0bxrhx48iQIYO+QxNCCJEIOp2SxtHREUdHx1ivRa/TXqxYMa5fv67L0+vM8+ewaxcYGkLnzvqOJvllzJiR+/fvU6hQIVavXk358uX1HZIQQojPIPPRfYENGyAiAho2hO++03c0ycPHx4dChQphYGBAgQIFOHToEGXKlMHc3FzfoQkhhPhMMr3vZ4q5iE96mNHv3bt3ODs7U6xYMVasWKF9vWrVqpL4hRAilZKS/2e6fBmuXIHs2eGDFo00x8PDg65du+Lt7Y2BgQEPHz7Ud0hCCCGSQJot+Ws00KcPVKwINWpAjJmFAZg+Hdq3L0y1arB3r/ragAHqvjVqQKFCUKFC3ONGl/o7dgQzM93Fr0/h4eGMHj2a8uXL4+3tTYECBXB3d2f8+PH6Dk0IIUQSSLMl/507ISxMXW733DkYNEjtpAfg5QUbN8KqVdcpVaoUlSpBrVowd666PSJCHb73X99ErbAwtb0f0m6V/8OHD3FwcODKlSsYGBgwYMAAJk+ejIWFhb5DE0IIkUTSbMn/1CmoX199XKECxJhvCB8ftXRvZqaQIQMULKhW5UdbsADq1oVixWIfc+dOePUKSpcGe3sdfwA9iZ6e94cffuDEiRPMmTNHEr8QQqQxaTb5v3kDWbO+f25kBJGR6uNixdQ5+YODDXnxAs6cgeBgdVt4OCxdCoMHxz1mzLH9aYmnpyfPnz8HwNTUlJ07d+Lp6UnVqlX1HJkQQghdSLPJP0sWePv2/XONBoz/a+QoXBj69YNffy1Iv35Qvjzk+G923r//hmrVYt84APj6qtvMzKBdu+T5DLoWERHBxIkTKVOmDL/++qv29Xz58pExY0Y9RiaEEEKX0mzyr1wZ9u9XH587F7sKPyBAvTFYufIGS5bAw4dgZ6du+/tvaNAg7vG2bVOH+TVrBlZWuo9f17y8vKhQoQJjxowhMjKS7NmzExldNSKEECJNS7Md/po1g8OHoVIlNWmvWgWzZ6tz8Ts6qu3+y5YVwtISZsxQmwUAbtz4+Kx9r1+rvwsVSraPoBORkZFMnz6d8ePHExERwffff8/KlSupWbOmvkMTQgiRTNJs8jc0hCVLYr8WM3EvXQoeHtfjrDa1b18yBKcn7969o2rVqly8eBGAPn364OLiQubMmfUcmRBCiOSUZpO/iMvMzIxy5crh5+fHihUrqFOnjr5DEkIIoQdpts1fqK5du8aFCxe0z6dPn46Xl5ckfiGESMck+SdSaKj62zCVXLHotv2SJUvStm1bgoKCAHVFvixZsug5OiGEEPok1f6JdO6c+rtECb2GkSjXr1+na9eunD9/HoDatWujKIqeoxJCCJFSpJJyrH6FhMD582BgACl53puoqChmzpxJiRIlOH/+PLly5eLAgQMsW7ZMOvUJIYTQkpJ/Ipw7p878V7IkWFrqO5r4tWzZkp07dwLQvXt3Zs+eTdYPZysSQgiR7knJPxGOH1d/16ihzygS1rlzZ7799lv27dvHihUrJPELIYT4KEn+iXDihPo7pSX/W7dusWbNGu3zZs2acfPmTRo2bKjHqIQQQqR0kvwTEBqqVvunpPZ+jUbD3Llzsbe3p2fPnly+fFm7TebkF0IIkRBp809AzPb+lDCn/+3bt+nevTvu7u4AdOrUie+//16/QQkhhEhVpOSfgJTS3q/RaFiwYAHFixfH3d2db775hl27drF27VqsUsJdiRBCiFRDkn8CopN/9ep6DYORI0fSv39/QkND6dChA1evXqVx48b6DUoIIUSqJMn/E1JSe3/fvn0pWLAgO3bsYP369WTLlk2/AQkhhEi1JPl/QnR7v709JHeuvX//PoMHD0aj0QCQJ08efHx8aNq0afIGIoQQIs2R5P8J+hjipygKS5YsoVixYsyaNYvFixdrtxkZGSVfIEIIIdIs6e3/Ccnd2c/X15cePXpw5MgRAFq3bk3r1q2T5+RCCCHSDSn5xyMsLPna+xVFwdXVFTs7O44cOUKOHDnYsmULmzdvxtraWrcnF0IIke5IyT8e587Bu3fqKn66bu/ftGkTvXv3BqBFixYsWrSInDlz6vakQggh0i0p+ccjOav8W7VqRaNGjdi0aRN//fWXJH4hhBA6Jck/Hroc3//o0SPatm3L06dPATA2Nmbv3r20adMGAwODpD+hEEIIEYNU+39EzPb+atWS7riKorB69WoGDBjAmzdvMDExYd26dUl3AiGEECIRJPl/xPnzant/Uo7vf/z4Mb169WL//v0ANGnShBkzZiTNwYUQQojPINX+H5GU7f2KorBmzRqKFi3K/v37sbKyYt26dezYsYNvvvnm608ghEgSAQEB2NraMmbMmFiv+/j4YGtry/bt2xN9rPPnz9OpU6dP7jN8+PB4jxkREUGXLl04f/78R7fXqlWLhg0b0qRJE5o0aUKtWrXo378/ISEh2n1Wr15NgwYNcHBwoEmTJmzYsCHWMe7evUufPn1wdHTE0dGRQYMGERgYmOjPmByePXvGiBEj9B1GHCtXrqR+/frUq1cPNze3ONtPnDih/W6aNGlChQoVtJ26ow0bNizW9z906FD8/Px0Hns0Sf4fkZTJ38fHh+7du/P69WscHR25evUqHTt2lLZ9IVIgS0tL3N3diYqK0r62f//+ZJ1O++7du3Tq1CnWUt0f4+rqyq5du9i1axcHDx7kyZMn7Ny5E4AFCxZw9OhR1q1bx969e1m1ahV79uzhjz/+AMDPz4/OnTvTunVr9uzZw+7duylYsCD9+vXT9cf7LFOmTKFnz576DiOWK1eusHv3bnbt2sXGjRtxcXHh1atXsfapXr269rtZvnw5mTJl0t7E+Pn50adPHw4ePBjrPU5OTkyZMiW5PoZU+38oLAzOnk269v4iRYowfvx48uTJQ6dOnSTpC5GCZcyYkUKFCnHx4kUqVKgAwOnTp6lUqZJ2n2PHjjF37lw0Gg25c+dmwoQJ5MiRg1OnTjF16lTMzMzIly+fdn9fX1/GjRvHq1evyJAhA6NHj6ZIkSLxxrB161Z69uzJmjVrEh3327dvefv2LZaWloSGhrJixQr27t1Ljhw5AMiWLRuTJk2iVatWdO/enT///JMqVapQq1YtAAwMDHByciJXrlxERkZibPw+Nbx69QpnZ2fu3r2Lqakpw4cPp2LFitja2nLjxg0Atm/fzoULF5g2bRq1atWiePHi+Pj4UKpUKTJkyEDp0qUB6N+/Pw4ODpQqVYoxY8bw7NkzDAwMGDRoUKxrHH3d/P39+eGHHwA4cOAAq1atIiwsjHfv3jFp0iTKli1Lp06dyJo1K7du3WLu3LkEBAQwf/58IiMjyZUrFxMnTsTKyire98fUo0cPnj9/Huu1ESNGaP8WAE6ePMlPP/2EmZkZZmZmlCtXjuPHj8c79bqLiwtt27bVLr2+Z88eateujaWlZaz9ChYsyOPHj3nw4AF58uRJ6Cv/apL8P/C17f1Pnz7l559/plevXjRs2BCAUaNGJXGUQqQ9jRrBf11iklzDhrBvX+L2bdCgAYcOHaJChQpcuXIFW1tbFEUB4MWLF4wZM4Y///yTXLlysXz5ciZMmMDMmTMZPnw4a9as4YcffsDZ2Vl7vGHDhjFmzBiKFCnC7du3+eWXXzh06FC85x86dChAgsm/V69eGBkZ8eLFC7755hs6duxIgwYN8PLywtzcnFy5csXav0CBApiamnL37l18fHyo/sFQJiMjIxwcHOKcZ968eeTJk4c//viDGzduMGbMGCpWrPjJ2KpVq8bcuXO5du0av//+OwBBQUH8888/zJw5k2HDhtGiRQtq166Nv78/7du3Z+fOnWTKlEl7jGPHjlGqVClAXdJ806ZNLFmyhGzZsrF161ZWrFihTd62trYsXLiQwMBAhg8fztq1a8maNSubNm1i5syZTJw48ZPvj7ZixYpPfi4Af39/ihUrpn1ubW3Ns2fPPrrv/fv3uXDhApMnT9a+Fl2T4eHhEWf/0qVLc+zYMbp06ZJgHF9Lkv8HvnSIn6IobNy4kV9//ZWXL19y69Yt6tevj6GhtKwIkZrUrFlTW7I/cOAADRo00HbUvXLlCsWLF9cm1jZt2uDq6sqNGzfImTOntpTarFkz5s2bR3BwMN7e3rHarUNCQnj58uVXx+nq6kquXLk4dOgQU6dOpVatWhgYGGBgYBCr2SKmyMhIQC3pR9/QJOTixYvMnDkTUJPs5s2bE3yPvb09oNZ8RkRE4Ovry+XLl6lZsyampqacOXOGu3fvMn/+fG1cDx8+pHDhwtpj+Pr6amtQDA0N+eOPPzh69Cj37t3jwoULsf5vLV68OACenp48ffqUzp07A+pNQ9asWRN8f7TElPw/dt3i+39+8+bNtG/fHlNT0wSvGcC3336Lr69vovb9WpL8P/Al7f3RbTjR7W3169dn2bJlkviF+AyJLZnrWqZMmShUqBAeHh6cO3eOQYMGaZN/9Cqb0RRFITIyEgMDg1jbohfh0mg0mJqasmvXLu22Z8+exany/Rr16tXj9OnTjBkzhhUrVlCgQAEiIiK4e/cu+fPn1+5369YtNBoN+fPnx87ODm9v71jH0Wg09O/fn3HjxmmbC4BYTQAAd+7c0SZlRVEwMDDQ3lREMzMz0z6uUqUK+/fv5/Llyzg5OWnPtWbNGu118PPzi3VOUBNq9HUMDg6mRYsWNGnShLJly2JraxurA2OGDBkAiIqKolSpUixZsgSAd+/eERwcnOD7oyWm5G9jY0NAQID2eUBAQKxmnpiOHDmSqGNGMzY2Tra8IdnpA3fvqr//u3H9JEVR+PPPPylSpAg7d+4kS5YsrFixgv3798epchNCpB4NGjRg1qxZ2NnZxUp+9vb2eHp68ujRI0At2ZUvXx5bW1tevHjB9evXAdj3351M5syZ+f7777XJ//Tp03To0CHJ4/3tt9+4fPkyx44dw9zcnJ9//hlnZ2devHgBqM0Vo0ePpmfPnpibm9OmTRtOnDjBif+WLlUUhUWLFvHixYs4SbhMmTLam587d+7g5OSEgYEBVlZW3Lp1C0VROHr0aLyxVa5cmf379+Pr60uZMmUAqFChAhs3bgTg9u3bNG7cmNDQ0Fjvy507N0+ePAHU6nNDQ0P69OlDhQoVOHny5EdrN+zt7fn333+5d+8eAIsWLcLFxSXR70+MatWq4ebmRmhoKIGBgZw7d+6jzSCBgYGEhYWRO3fuRB/70aNHydLeD1Lyj1diVs8NCQlh6NChBAYGUrduXZYvX/5ZX7QQImWqWbMmzs7O/Pbbb7Fez5EjBxMmTKBfv35ERETw7bffMnnyZExMTJg9ezZDhgzB2Ng4Voe+GTNmMG7cOJYvX46JiQlz5sxJ8o6/2bNnx8nJCRcXF6pWrUqvXr3InDkzXbt21ZbO27Ztq73xsLa2ZtmyZbi4uDBz5kyioqIoUqSIdjRATP3792fUqFE0btwYY2NjXFxctJ30+vTpQ44cOShdunS8TRnZs2fHysqKEiVKaD/3qFGjGDNmDI6OjoDaKS5mez+o38HgwYMBKFSoEIULF6ZBgwZkyJCBsmXLam8MYrK2tmbKlCkMGDAAjUaDjY0NM2bMIEuWLIl6f2IUL16cxo0b07JlSyIjI+nfvz82NjaAOn+Lq6srNjY2PHr06LOHc1+8eJE5c+Z8UVyfTUkDHj58qPz444/Kw4cPP+t9ly5divX81i1FMTZWFAMDRXnxIv73RUZGah+7ubkprq6uikaj+axzp2UfXleRdOTa6o5cW934muv6yy+/KDdu3EjCaFIuHx8f5ddff030/l+a96Klqmr/8+c/3ha/bZsF9+/vpnlza6KbV16/hgYN1OV469SBeDpjxjJsGERGQteuH+/pHxAQQOvWrRk2bJj2tZ9++klbDSaEECLpjBgx4rPazFOzZcuWMXz48GQ7X6pJ/i4u0LOnOg4/pufPYebMLOTO3YmtWwPYsAHu34fVq6FYMXB3hzZtIKGZdN3dYft2sLCAiRPjbt+2bRtFixblr7/+YtmyZdq2NCGEELrx3XffMX36dH2HkSxmzZrFt99+m2znSzXJ/4cf1OT8obt3oXDhCIyMXmNoCGXLqovyFCsGb9+q+7x5AyYm8R9bo4FBg9THgwfDd9+93/b8+XPatm1Ly5YtCQgIoFatWnh6epI9e/ak+3BCCCFEMko1Hf5atFBL9B8qWBBu3jTByCg7oaEGHDkCP/4I2bODmxsUKQKBgWrJPj6bNsHFi/DNNzBkyPvXd+zYQZ8+ffD39ydjxoy4uLjQp08fGcInhBAiVUv1WczKCsaOfcWTJwv45ZdslCoFOXLA+PEwdChcu6beBLRo8fH3h4ZC9PwbkyZBzA6na9euxd/fn+rVq3PlyhX69u0riV8IIUSql+ozWWQkeHubkDt3exYvfsH161C5snpTkDWruk/OnGrV/8fMmwcPHkDx4mpHv+DgYO22JUuWsGjRIo4ePRprsgwhhBAiNUu1yX/jRnB1hej5Nx482EHr1tb076+W/CdOhLVr1cV5mjWDZcviHiMw0JjoRZTGjAmka9dO1KhRQztblY2NDT///LOU9oUQQqQpOm3z37NnD4sXLyYiIoKuXbvGmdnKx8eHUaNGERQURJkyZRg/fnycqSRj+v57tTMfQPv2718fOPAte/c2Y9euI9qZ9b79NuFFQlxd/8fbt1Cq1B5+/bU3T58+xdzcnMuXL8dZ8EEIIYRIK3RWpPXz82POnDls3LiRXbt2sXnzZm7fvh1rnyFDhjB69GgOHTqEoihs2bJFV+HE4eMD27cbA13455/GPH36lMqVK+Pp6SmJXwghRJqms+R/5swZKlSogKWlJRYWFtSrV4+DBw9qtz9+/JiwsDBKlCgBQPPmzWNt17UuXQ6i0RQD1pIhQwZmz57NiRMnKFiwYLLFIIQQQuiDzqr9/f39sba21j7PmTMnV65ciXe7tbU1fn5+X3Su6AUa4ltT+UO+vnD58j8YG/tTvHg55syZQf78+Xn69OkXnV/EFhAQoF34RCQtuba6I9dWN+S66kZ0vvvSBYp0lvyVj6x5HHMK3IS2f47o5RU/Z7UstfN+foKCXmmXmRRCCCFSk4CAAPLmzfvZ79NZ8rexseHSpUva5/7+/uTMmTPW9ufPn2ufBwQExNr+Oezs7NiwYQPW1tba9Z+FEEKItCoqKoqAgADs7Oy+6P06S/6VKlViwYIFBAYGYm5ujpubGxNjTJr/3XffYWZmhoeHB6VLl2bnzp1Uq1bti86VIUMG7TrRQgghRHrwJSX+aAbKx+rfk8iePXtYunQpERERtGzZEicnJ5ycnOjfvz/FihXj+vXrjBo1iuDgYIoUKcLUqVMxNTXVVThCCCGEQMfJXwghhBApj0xdJ4QQQqQzkvyFEEKIdEaSvxBCCJHOSPIXQggh0hlJ/kIIIUQ6I8lfCCGESGck+QshhBDpjCR/IYQQIp1JF8l/z549NGzYkJ9++okNGzbE2e7j40OLFi2oV68ezs7OREZG6iHK1Ceh6/r333/TpEkTGjduTN++fXn9+rUeokydErq20Y4fP06tWrWSMbLUL6Fre/fuXTp16kTjxo3p0aOH/N0mUkLX9erVq7Ro0YLGjRvTu3dv3rx5o4coU6+goCAcHBw+ukLiF+UwJY179uyZUrNmTeXly5dKcHCw4ujoqNy6dSvWPo0aNVIuX76sKIqijBgxQtmwYYMeIk1dErqub9++VSpXrqw8e/ZMURRFmTt3rjJx4kR9hZuqJOZvVlEUJSAgQKlfv75Ss2ZNPUSZOiV0bTUajVK3bl3lxIkTiqIoyowZMxQXFxd9hZtqJOZvtl27dsrx48cVRVGUqVOnKrNnz9ZHqKnSv//+qzg4OChFixZVHj58GGf7l+SwNF/yP3PmDBUqVMDS0hILCwvq1avHwYMHtdsfP35MWFgYJUqUAKB58+axtouPS+i6RkREMG7cOGxsbACwtbXl6dOn+go3VUno2kYbNWoU/fr100OEqVdC1/bq1atYWFhoFxnr06fPZy0Vnl4l5m9Wo9EQHBwMQGhoKBkyZNBHqKnSli1bGDt27EdXvv3SHJbmk7+/vz/W1tba5zlz5sTPzy/e7dbW1rG2i49L6LpaWVlRp04dAMLCwnB1ddU+F5+W0LUFWLt2LUWKFMHe3j65w0vVErq2Dx48IEeOHAwbNgxHR0fGjh2LhYWFPkJNVRLzNzt8+HCcnZ2pUqUKZ86coW3btskdZqo1efLkeFeu/dIcluaTv/KRdYsMDAwSvV18XGKv29u3b3FycqJQoUI0a9YsOUJL9RK6tjdv3sTNzY2+ffsmZ1hpQkLXNjIykgsXLtCxY0f27NlD7ty5mTZtWnKGmColdF3DwsJwdnZmzZo1nDp1ivbt2zNs2LDkDDHN+tIcluaTv42NDc+fP9c+9/f3j1V18uH2gICAj1atiNgSuq7Rr7Vv355ChQoxefLk5A4x1Uro2h48eJCAgABatGhBr169tNdZJCyha2ttbU3evHkpVqwYAA4ODly5ciXZ40xtErquN2/exMzMjOLFiwPQpk0bLly4kOxxpkVfmsPSfPKvVKkSZ8+eJTAwkNDQUNzc3LTteQDfffcdZmZmeHh4ALBz585Y28XHJXRdo6Ki6NOnDw0aNMDZ2VlqUz5DQte2f//+HDp0iF27duHq6krOnDnZuHGjHiNOPRK6tiVLliQwMJDr168DcPToUYoWLaqvcFONhK5r3rx5efbsGXfv3gXgyJEj2hss8XW+OIclWXfEFGz37t1Ko0aNlLp16yqurq6KoihKz549lStXriiKoig+Pj5KixYtlPr16yu///678u7dO32Gm2p86rq6ubkptra2SuPGjbU/I0eO1HPEqUdCf7PRHj58KL39P1NC1/bff/9VWrRooTRs2FDp3r278vz5c32Gm2okdF2PHz+uODo6Kg4ODkqXLl2UBw8e6DPcVKlmzZra3v5fm8MMFOUjDQZCCCGESLPSfLW/EEIIIWKT5C+EEEKkM5L8hRBCiHRGkr8QQgiRzkjyF0IIIdIZSf5C6IGtrS2Ojo40adJE++Ps7PzJ92zfvp3evXsnU4SJd+TIESZNmgSoqwzOmzcvzuspwcKFC/n777/1HYYQKYKxvgMQIr1as2YN2bJl03cYX6127drUrl0bAC8vL+0SuDFfTwnOnz9PgQIF9B2GECmCJH8hUpitW7eyefNmIiIieP36NU5OTnGm73Vzc2Px4sUYGBhgZGTE0KFDKVu2LG/fvmXy5MncvHmTiIgIKlasyNChQzE2jv1Pffjw4RgYGHDnzh0CAwOpXLkyo0aNwsTEhEuXLuHi4kJoaCgmJiYMGDCAatWqERAQwLBhw3j58iUA1atXZ8CAAWzfvp1Dhw7Rt29fNm3aRFRUFJkzZyZv3rwcOnSI4cOH07ZtW9zd3TE1NSUqKoqaNWuycuVKbGxs4o13/vz5HD58GBMTE6ysrJg6dWqcaUuHDx/Oq1evePjwITVq1KBly5ZMmDCBkJAQ/P39KVSoEHPnzmXr1q14e3vj4uKCkZER1atXZ+bMmVy8eJGoqCiKFCnCqFGjyJQpk26/XCFSCKn2F0JPunTpEqva/8WLFwQHB/PXX3/h6urKzp07mTNnDjNmzIjzXhcXF8aOHcv27dv57bffOH/+PABTpkyhaNGibN++nZ07d/Ly5UtWrVr10fNfv36dVatWsX//fu7cucPmzZt5+fIl/fv3x9nZmT179jB9+nSGDBnCw4cP2bJlC7ly5WLHjh1s2LABX19f3r59qz2evb09bdu2pWHDhgwcOFD7er58+ShYsCBHjx4F4NSpU3z33XcUKFAg3nifPn3KmjVr2LZtG9u3b6dy5crxzrEfFhbGvn37GDJkCFu2bKFp06Zs3rwZNzc3Hj16xPHjx+nQoQN2dnYMHTqUn376CVdXV4yMjNi+fTu7d+8mZ86czJw584u/SyFSGyn5C6En8VX7L1myhBMnTnD//n2uX79OSEhInH0aNWpEv379qF69OpUrV8bJyQlQ29y9vLzYunUroCbG+DRr1oyMGTMC0KRJE44cOULu3LnJkyePdqngggULUqpUKS5cuEDVqlXp1asXT58+pVKlSgwaNIjMmTMn6rO2atWKHTt2UL9+fbZv306rVq0+Ga+NjY12Jchq1apRrVo1Klas+NFjly5dWvt4yJAhnD59mmXLlnH//n38/f0/ev2OHz/O27dvOXPmDAARERFkz549UZ9FiLRAkr8QKcizZ89o06YNrVu3pnTp0tSvX59jx47F2W/gwIG0bNmSU6dOsX37dlxdXdm+fTsajYZ58+bxww8/APDmzZt4F1UyMjLSPlYUBUNDQzQaTZz9FEUhMjKS4sWLc+TIEc6ePcu5c+do1aoVf/zxR6I+V/369Zk6dSp37tzh4sWL2mVy44vX0NCQ9evX4+XlxdmzZ5kyZQrly5dn1KhRcY5tYWGhffz7778TFRVFgwYNqFGjBk+fPv3okqcajYaRI0dSvXp1AIKDg3n37l2iPosQaYFU+wuRgnh7e5MtWzb69u1L1apVtYk/KipKu09kZCS1atUiJCSEdu3aMXbsWO7cuUNkZCRVqlRh9erVKIpCeHg4P//8M+vXr//ouQ4cOEB4eDjv3r1jx44d1KxZE3t7e+7du6etYr916xYXL16kXLlyzJw5k0WLFlGnTh2cnZ0pUKAA9+/fj3VMIyMjIiMj45zLzMyMRo0aMXz4cOrWrYu5uTlAvPFev34dBwcHfvjhB3r37k3Xrl25ceNGgtfv1KlT/PLLLzRs2BADAwM8PT211y5mbFWqVGHDhg2Eh4ej0WgYPXo0s2fPTvD4QqQVUvIXIgWpXLkyW7dupX79+pibm1O8eHGyZcuGr6+vdh9jY2NGjhzJ4MGDMTY2xsDAgClTpmBqaoqzszOTJ0/G0dGRiIgIKlWqRM+ePT96rgwZMtC+fXvevHlDvXr1aNGiBYaGhsybN4+JEycSFhaGgYEBU6dOJV++fHTp0oXhw4fj4OCAqakptra2ODg4sHfvXu0xK1asyK+//oqJiUmcpXBbtWrF+vXrGTdunPa1+OI1MTGhQYMGtGjRAgsLCzJkyPDRUv+HBg4cyC+//ELWrFkxNzenbNmyPHjwAICaNWsyffp0IiIi6Nu3L9OnT6dZs2ZERUVRuHBhhg8f/jlflRCpmqzqJ0Q6NHz4cAoWLEiPHj30HYoQQg+k2l8IIYRIZ6TkL4QQQqQzUvIXQggh0hlJ/kIIIUQ6I8lfCCGESGck+QshhBDpjCR/IYQQIp2R5C+EEEKkM/8HqAGg0g9W1KUAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 576x396 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "lr_probs_model1 = result_model1.predict(sm.add_constant(testX_model1))\n",
    "\n",
    "plot_roc(testy_model1, lr_probs_model1, positive_label=1, thresholds_every=3, title=\"Model 1\",c='blue')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The AUC values printed above reflects the area under the ROC curve and provides a measure of how discriminant the model is between the two classes.  [In general, an AUC of 0.5 means no discrimination, 0.7 to 0.8 is considered acceptable, 0.8 to 0.9 is considered excellent, and more than 0.9 is considered outstanding](https://www.sciencedirect.com/science/article/pii/S1556086415306043#:~:text=AREA%20UNDER%20THE%20ROC%20CURVE,-AUC%20is%20an&text=In%20general%2C%20an%20AUC%20of,than%200.9%20is%20considered%20outstanding.).\n",
    "\n",
    "A value of 0.5 for AUC indicates that the ROC curve will fall on the diagonal (i.e., 45-degree line) and hence suggests that the diagnostic test has no discriminatory ability. \n",
    "\n",
    "Here we confirm again that our model has learned something and performs better than an \"unskilled\" dummy classifier. Now, we can use the ROC values to obtain an optimal threshold value. One of the commonly used method for this is the [Youden index method](https://en.wikipedia.org/wiki/Youden%27s_J_statistic). In this method the optimal threshold values is the one that maximises the Youden function which is the difference between true positive rate and false positive rate over all possible threshold values.\n",
    "\n",
    "We wrote a small implementation of this method for this example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.9064\n"
     ]
    }
   ],
   "source": [
    "# function inspired by https://stackoverflow.com/questions/28719067/roc-curve-and-cut-off-point-python\n",
    "def find_optimal_threshold(target, predicted):\n",
    "    \"\"\" Find the optimal probability threshold for a classification model.\n",
    "    Parameters\n",
    "    ----------\n",
    "    target : Matrix with label data, where rows are observations\n",
    "\n",
    "    predicted : Matrix with predicted data, where rows are observations\n",
    "\n",
    "    Returns\n",
    "    -------     \n",
    "    a float, with optimal cutoff value\n",
    "        \n",
    "    \"\"\"\n",
    "    fpr, tpr, thresholds = roc_curve(target, predicted)\n",
    "    j_scores = tpr-fpr\n",
    "    j_ordered = sorted(zip(j_scores,thresholds))\n",
    "    return j_ordered[-1][1]\n",
    "\n",
    "threshold = find_optimal_threshold(df_labels['label'], df_labels['prediction'])\n",
    "print (round(threshold,4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is quite far from the 0.5 value we originally had! Let's see how our classification matrix does now using this new threshold."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```{note}\n",
    "In this case we have decided that the optimal threshold value is the one that, which which maximises the True Positive rate and minimizes the False Positive rate. However, the definition of **optimal** really depends of the research question or the task we are to solve. An alternative would be to give more importance in accurately classifying our `SRH=0` class and try to maximise the True Negative Rate. \n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.553156146179402\n",
      "\n",
      "Precision: 0.9522184300341296\n",
      "Recall: 0.5224719101123596\n",
      "\n",
      "Specificity: 0.7941176470588235\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x360 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "\n",
    "# performing predictions on the test dataset\n",
    "yhat = result_model1.predict(sm.add_constant(testX_model1))\n",
    "pred_y_model1 =  [1 if x > threshold else 0 for x in yhat]\n",
    "\n",
    "\n",
    "# confusion matrix using sklearn\n",
    "cnf_matrix = metrics.confusion_matrix(testy_model1,pred_y_model1)\n",
    "    \n",
    "fig, ax = plt.subplots(1,1, figsize = (5,5))\n",
    "plt_cnf_mat(cnf_matrix, ax)\n",
    "\n",
    "\n",
    "print(\"Accuracy:\",metrics.accuracy_score(testy_model1, pred_y_model1))\n",
    "\n",
    "print ()\n",
    "print(\"Precision:\",metrics.precision_score(testy_model1, pred_y_model1))\n",
    "print(\"Recall:\",metrics.recall_score(testy_model1, pred_y_model1)) # what is recall? \n",
    "\n",
    "print ()\n",
    "testy_model1_minority = abs(testy_model1 - 1)\n",
    "pred_y_model1_minority = abs(np.array(pred_y_model1) -1)\n",
    "\n",
    "print(\"Specificity:\",metrics.recall_score(testy_model1_minority, pred_y_model1_minority))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The specificity for our minority label (`SRH==0`) has improved using the new threshold value, at a large expense of the classification performance of the majority label (`SRH==1`). However, a model that puts all instances in one class is not of good use for us, so this is an improvement. Furthermore, depending on our research question and the ultimate goal of the model we might want to maximise the specificity, even if this means increasing the amount of false negatives we observe. For example, it might be more important to identify people that are likely to report poor health than the ones with good health.\n",
    "\n",
    "In any case, we must remember that up to know we are using a very simple model, only using deprivation as a predictor and controlling for age. Adding more predictors to the model can improve its performance. We'll explore that next."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Model 2: Model 1 + Education, Children, and Accommodation Problems\n",
    "\n",
    "Let's increase the complexity to our model by adding more predictors representing socio-economic factors. In this case we'll add information about education (`ISCED`; levels of education completed), the number of children one has (`Children`), and the number of problems with accommodation reported by the respondents (`AccomProblems`). All these variables are ordered categorical variables that we assume to function as continuous variables for this exercise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Optimization terminated successfully.\n",
      "         Current function value: 0.302262\n",
      "         Iterations 7\n"
     ]
    }
   ],
   "source": [
    "trainX_model2, testX_model2, trainy_model2, testy_model2 = train_test_split(df_model[['AgeCategory','DeprIndex','ISCED',\"Children\",\"AccomProblems\"]], df_model.SRH_binary.values, test_size=0.3, random_state=2)\n",
    "\n",
    "trainX_const_model2 = sm.add_constant(trainX_model2) #add constant for intercept\n",
    "logit_model2 = sm.Logit(trainy_model2, trainX_const_model2) #Create model instance\n",
    "result_model2 = logit_model2.fit() #Fit model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                           Logit Regression Results                           \n",
      "==============================================================================\n",
      "Dep. Variable:                      y   No. Observations:                 1402\n",
      "Model:                          Logit   Df Residuals:                     1396\n",
      "Method:                           MLE   Df Model:                            5\n",
      "Date:                Tue, 23 Nov 2021   Pseudo R-squ.:                  0.1269\n",
      "Time:                        15:32:02   Log-Likelihood:                -423.77\n",
      "converged:                       True   LL-Null:                       -485.35\n",
      "Covariance Type:            nonrobust   LLR p-value:                 6.698e-25\n",
      "=================================================================================\n",
      "                    coef    std err          z      P>|z|      [0.025      0.975]\n",
      "---------------------------------------------------------------------------------\n",
      "const             3.7660      0.526      7.164      0.000       2.736       4.796\n",
      "AgeCategory      -0.4134      0.093     -4.465      0.000      -0.595      -0.232\n",
      "DeprIndex        -0.3698      0.049     -7.621      0.000      -0.465      -0.275\n",
      "ISCED             0.2119      0.072      2.942      0.003       0.071       0.353\n",
      "Children         -0.1362      0.069     -1.981      0.048      -0.271      -0.001\n",
      "AccomProblems    -0.1758      0.097     -1.819      0.069      -0.365       0.014\n",
      "=================================================================================\n"
     ]
    }
   ],
   "source": [
    "print (result_model2.summary())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we compare these fit results to the ones from **Model 1** we observe the following:\n",
    "\n",
    "- The coefficient for `DeprIndex` has become less negative. This could mean that the new variables that we have added to the model have taken some of the weight previously given to `DeprIndex` and `Age`. This is not surprising given that some of these variables are expected to be linked to deprivation (e.g in [_Section 3.5_](section3.5) we observed a correlation between `DeprIndex` and `AccomProblems`).\n",
    "\n",
    "- The coefficient for `AgeCategory` also became less negative, but within the margin of its standard error.\n",
    "\n",
    "- Now, if we look at the parameters of *goodness-of-fit* we can observe that the fit has improved slightly, with a less negative log-likelihood and slightly larger pseudo R-squ. However, if we compare the increase of log-likelihood of adding these new variables with respect to the values of a null model, the improvement is modest (~10 units of log likelihood of **Model 2** vs **Model 1** against ~50 units for **Model 1** vs **Null model**). We might suspect that our new variables barely increase the discrimination power of our model. Lets take a look at evaluating it on the test set."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Comparing predicted values \n",
    "\n",
    "Same as we did in the previous section, let's compare the predicted probability values of an event being classified as `SRH=1` or `SRH=0`. Let's do this but running the model on the test set and comparing the distributions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x141c64a90>"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# link the prediction to the label values\n",
    "yhat_model2 = result_model2.predict(sm.add_constant(testX_model2))\n",
    "df_labels = pd.DataFrame({'prediction': yhat_model2,\n",
    "     'label': testy_model2})\n",
    "\n",
    "fig, ax = plt.subplots(1,1, figsize = (5,5))\n",
    "df_labels[df_labels['label']==1]['prediction'].plot.kde(label='SRH == 1')\n",
    "df_labels[df_labels['label']==0]['prediction'].plot.kde(label='SRH == 0')\n",
    "pyplot.xlabel('Probability')\n",
    "pyplot.legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The shape of the probability distributions look similar to what we observed in **Model 1** (maybe the tails for class `SHR=0` are longer). Again, we can observe that using the default threshold value around 0.5 will not be optimal in this case and a higher value should be chosen.\n",
    "\n",
    "```{note}\n",
    "Probability values of larger than one in this case are a product of using kernel density estimation for our visualisation. We choose this method because we want to compare shapes of distributions, however we must have in mind that it can create the impression that there is data in ranges where there is not.\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Probability threshold cut 0.9176\n",
      "\n"
     ]
    }
   ],
   "source": [
    "threshold_model2 = find_optimal_threshold(testy_model2, yhat_model2)\n",
    "print ('Probability threshold cut',round(threshold_model2,4))\n",
    "print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ROC curves\n",
    "The probability threshold value is slightly lower than for model **Model 1**, but not significantly, given that the predicted distributions are quite similar.\n",
    "\n",
    "Now, let's take a look at our ROC curves and AUC values and compare them to **Model 1**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x396 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_roc(testy_model1, lr_probs_model1, positive_label=1, thresholds_every=5, title=\"Model 1\",c='blue')\n",
    "plot_roc(testy_model2 , yhat_model2, positive_label=1, thresholds_every=15, title=\"Model 2\",c='red')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When comparing the above curves between the two models we can observe the following:\n",
    "\n",
    "- The ROC curve for **Model 2** has a higher granularity of steps in which the True and False Positive rates are evaluated. This is because the sklearn function drops *suboptimal thresholds* which corresponds points on the ROC curve that will have the same TPR and FPR values that adjacent points. In the simpler model there might be more configuration of predictor values needed to produce a high granularity curve.\n",
    "\n",
    "- Despite the point above, AUC values and overall ROC shapes are pretty much the same.\n",
    "\n",
    "This again confirms our theory that this new model doesn't contain much more discriminative power than **Model 1**, with the deprivation index carrying a good bulk of the information that these new variables such as education level and accommodation problems can add to the model."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Classification matrix\n",
    "\n",
    "Finally, let's take a look at our classification performance, using the optimal threshold value of classification for this model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.584717607973422\n",
      "\n",
      "Precision: 0.9522292993630573\n",
      "Recall: 0.5599250936329588\n",
      "\n",
      "Specificity: 0.7794117647058824\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAU0AAAFsCAYAAABIAOtXAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAAo40lEQVR4nO3de1hU1f4/8PfACImJpDF4pxQvx3vhPRX99gMEGQExQwsoSzEFzcoLCGqURuo5mJFl5TmpqccrlOQh9ZiWeelEpmLq0XRARUFQHBGHy7C+f/g0v68hDHvrZmDzfj3PPA+zmLX3Z3d5s9bal9EIIQSIiKhG7GxdABFRfcLQJCKSgKFJRCQBQ5OISAKGJhGRBAxNIiIJGJr1nNlsxj/+8Q+MGTMGgYGB8Pf3x9KlS1FaWvpA23zttdfg6+uLL7/8UnL/EydOYPr06bL3/7DdunUL4eHhVf4+MDAQRqOxFiui+kzD6zTrt/j4eNy8eROLFi1C06ZNUVxcjLfeegtNmjTB0qVLZW0zJycHvr6++PXXX2Fvb/+QK659ly5dgl6vx9GjR21dCqkAR5r12MWLF7Fjxw4sXrwYTZs2BQA4OTnh7bffhre3N4C7o6y33noLAQEB0Ov1WLJkCcrLywEAPXv2xIcffojQ0FD8z//8D7744gsUFRXh1VdfRXl5OcaMGYPs7Gx06dIF169ft+z3j/e3b9/G9OnTERgYiODgYMTFxaGiogJHjhxBQECArP3fT8+ePfHXv/4Ver0eI0aMwM6dOzF9+nSMHDkS4eHhKC4uBgBs3boVzz33HIKCgjBixAhs2LABABATEwOTyYTAwECYzWb06NEDM2bMgK+vL06cOGE5nuTkZDz//PMwm824du0ahgwZgsOHDz/8f3FUvwmqt9LT00VISEi1n5k9e7Z45513REVFhSgpKRETJ04Uq1atEkII0blzZ7Fu3TohhBAnTpwQPXr0ECaTSVy8eFH06dPHso3OnTuLgoKCSu9TUlLExIkThRBClJeXi3nz5gmDwSAOHz4sRo0aJXv/f9a5c2exZs0aIYQQq1atEk899ZS4evWqMJvNIjg4WHz99deiqKhIjBs3Tly/fl0IIcTRo0ctx3C/40lJSal0POXl5eKFF14Qq1atEhEREeLjjz+29q+AGiCONOsxOzs7VFRUVPuZ77//Hi+++CI0Gg0cHBwQGhqK77//3vL7Z599FgDQvXt3lJaWWkZtNeHp6Ylz584hLCwMn376KSIiIuDu7q7I/n19fQEA7du3R+fOneHm5gY7Ozu0bdsWN2/eRJMmTfDJJ59g//79WL58OT755JNqj6Vv376V2uzt7bF06VJ89tln0Gg0iIyMrPE/C2o4GJr1WK9evXD+/HkUFRXd056bm4vJkyfDZDJVCtWKigrL9BgAHB0dAQAajQYAIKwscf/fE0zt2rXD7t27MXnyZBQVFeHll19Genp6pf09jP03atTovj//4erVqwgKCsLly5fh6emJ119/vdrjcHJyum97Tk4OHB0dkZWVxZNDdF8MzXrMzc0Ner0esbGxluAsKirCwoUL4eLigkceeQRDhgzB+vXrIYRAaWkpNm/ejMGDB0vaT/PmzXHixAkAwO7duy3tGzZsQExMDIYMGYJZs2ZhyJAhOHv27D19H8b+ayIzMxPNmzfH1KlTMXToUHz33XcA7l4JoNVqYTabrf5BMBqNmDVrFt5//30EBARg3rx5D71Oqv8YmvXcggUL4OHhgdDQUAQGBuK5556Dh4cH3n33XQBAXFwcrl+/Dr1eD71ejyeffBJTpkyRtI+4uDgkJCQgODgYv/32G1xdXQEAQUFBMJvN8Pf3x5gxY1BUVFTp0p6Hsf+aeOaZZ+Dm5oaRI0ciKCgIV65cQfPmzZGVlQVXV1d069YNfn5+uHHjRrXHOXz4cDzzzDOIiopCdnY21q9f/9BrpfqNlxwREUnAkSYRkQQMTSIiCRiaREQSMDSJiCRgaBIRScDQJCKSgKFJRCQBQ5OISAKGJhGRBAxNIiIJGJpERBIwNImIJGBoEhFJwNAkIpKAoUlEJAFDk4hIAoYmEZEEDE0iIgkYmkREEjA0iYgkYGgSEUnA0CQikoChSUQkAUOTiEgChiYRkQQMTSIiCRiaREQSMDSJiCRgaBIRScDQJCKSgKFJRCQBQ5OISAKtrQuQ6prpa1uXQA/A9ZGuti6BZOssq1fj9uNl9buTvVFWP6XVu9AkovpFo1HXhJahSUSK0qhsFZChSUSK4kiTiEgChiYRkQQajcbWJTxUDE0iUhhHmkRENcbpORGRBGoLTXUdDRGRwjjSJCJF8TpNIiIJ1DY9Z2gSkaIYmkREEjA0iYgk0IAXtxMR1RhHmkREEjA0iYgkYGgSEUnC0CQiqjGONImIJGBoEhFJwNsoiYgk4EiTiEgCPrmdiEgCjjSJiCRQ25qmuo6GiEhhHGkSkaI4PScikoChSUQkgdrWNBmaRKQsjjSJiGqO03MiIgl4cTsRkQRc0yQikoDTcyIiKTg9JyKSQF0DTYYmESmMI00iIgkYmkREEnB6TkRUc4IjTSIiCdSVmQxNIlKYnbpSk6FJRKqSnJyMf/3rXwAALy8vzJ49GzExMcjIyEDjxo0BAFFRUfD29sbBgwfx3nvvoaSkBH5+fpg5c6bV7TM0iUhZtbimefDgQRw4cAApKSnQaDR49dVXsXv3bmRmZuLLL7+ETqezfNZkMiE2Nhbr1q1Dq1atEBkZif3798PLy6vafajsvBYR1TkamS8ZXF1dMXfuXDg4OKBRo0bo2LEjcnJykJOTg/j4eOj1eqxYsQIVFRU4fvw43N3d0a5dO2i1Wuj1eqSnp1vdB0eaRKQsmWuaRqMRRqOxUruzszOcnZ3v26dTp06Wnw0GA3bu3IkNGzbgp59+QkJCApycnBAZGYmtW7fCyckJrq6uls/rdDrk5uZarYuhSUTKkjk9X7NmDZKTkyu1R0VFITo6utq+Z8+eRWRkJObMmYMOHTrgo48+svwuLCwMqampGDly5H1KtV4rQ5OIlCVzqh0REYHg4OBK7VWNMv+QkZGB6dOnIzY2FqNGjcKZM2dgMBjg6+sLABBCQKvVws3NDfn5+ZZ+eXl596x5VoWhSUTKkjk9r24aXpUrV65g2rRpSEpKwqBBgwDcDcnFixdj4MCBcHJywqZNmxAcHIzevXvjwoULyMrKQtu2bZGWloaQkBCr+2BoEpGyavEyzdWrV6OkpASJiYmWttDQUEyePBnjx49HeXk5fHx8EBAQAABITExEdHQ0SkpK4OXldd8p+59phBBCsSNQwDXT17YugR6A6yNdbV0CydZZVi8P/3/I6ndu58uy+imNI00iUhbvCCIikkBdmcnQJCKF8SlHREQScHpORCSBujKToUlECuP0nIhIAoYmEZEEKnuWmsoOh4hIWRxpEpGyOD0nIpJAXZnJ0LSlD5ftwHe7j8O52d3vLWnvrkP84lAkvZeK40cvAAAGPNMVU2eOgr09V1LqGiEEYmKWo1Mnd7zyyhgAwMCBL8DNrYXlM6+8MgajRw+3UYV1g+B1mvSwZB4z4O33X0DPPk9Y2v65dj8Kb9zG2m1voqJCYNrLK7F31zF4+z1lu0Kpkt9/v4i33/4Ex46dRqdO7gCA8+cvoVmzR/HVVytsXF0dw+k5PQylpeU4ezoHG9fsx7JF29G2XQtEzxqN0HAvjB0/BHZ2dii8cQtFt0xwdnaydbn0J+vXf4MxY55F69aPW9qOHj0NOzs7hIXForDwFnx9B+O118bB3t7ehpXWAerKTOVC8/fff8e3336Lq1evws7ODjqdDkOHDkXPnj2V2mW9kp9nxNP9PTBlhh/aubti45r9iJnxBf6+6XVoG9nj4+U7sf2fP6JL97bo/fSTti6X/mT+/CkAgMOHj1nazGYznnmmD2bPngiTqQSTJyfg0Ued8NJLgbYqs25Q2fRckYWy9evX44033gAA9OzZE927dwcAxMfH4+9//7sSu6x3WrdtjmUfvYL2T+ig0WgwPsILly8V4MrlGwCA1173x79+SECr1o9h2aLtNq6WamLcOF/ExUXCwaERnJ0fxcsvB2LPnkO2Lsv2NBp5rzpKkZHm2rVrkZqaavli9j+8/PLLCA4OxsSJE5XYbb1y7r85OHfmCkbqPS1tQgC5V2+gvNyM9k+4QtvIHn6j+2F5YqrtCqUaS03di65dn0TXrndnBkIAWi1XwNQ2PVdkpKnValFeXl6p3WQyoVGjRkrsst6x09hh+ftfIefSdQBAyuZD8OjcEscyzuPDZV+jvNyMiooK7N75C57u72Hjaqkmzp7NxooV62E2m2EylWD9+jT4+w+1dVm2Z6eR96qjFPkzOGXKFAQFBWHQoEGW7xW+du0aDh8+jJkzZyqxy3qnQ6eWmDk3EHOm/x0VFQKubs2wIPEFtHi8KT5Y8jVeei4JdnYa9HrqCUyZ7mfrcqkGoqJCkZCwCnp9NMrLyzFy5BA895yPrcuyvTocgHIo9h1Bubm5OHToEPLy8iCEgJubGwYNGgQ3N7cH2i6/I6h+43cE1WfyviOow6tbZPU7//lzsvopTbEFFzc3NwQFBSm1eSKqL1Q20uQqNREpqw6fCZeDoUlEyuJIk4hIApU9NoGhSUTKUtn0XGV/A4iIlMWRJhEpi2uaREQ1J1Q2PWdoEpGyVLYIyNAkImVxek5EJAGn50REEnCkSUQkgboyk6FJRMrit1ESEUnB0CQikoAngoiIJOB1mkREEnCkSUQkgcrWNFU2cCaiOqeWv40yOTkZo0aNwqhRo7BkyRIAwMGDB6HX6+Hj44OkpCTLZ0+dOoWQkBD4+vpi3rx59/0W3UqHI7syIqIaEBqNrJccBw8exIEDB5CSkoLU1FScPHkSaWlpiI2NxcqVK7Fz505kZmZi//79AIBZs2YhPj4e3377LYQQ2Lx5s9V9MDSJSFl2Ml8yuLq6Yu7cuXBwcECjRo3QsWNHGAwGuLu7o127dtBqtdDr9UhPT8fly5dhMpnQp08fAMCYMWOQnp5udR9c0yQiZckcNRqNRhiNxkrtzs7OcHZ2vm+fTp06WX42GAzYuXMnwsLC4OrqamnX6XTIzc1FXl7ePe2urq7Izc21WhdDk4jqpDVr1iA5OblSe1RUFKKjo6vte/bsWURGRmLOnDnQarW4cOHCPb/XaDQQQlTqp6lBwDM0iUhZMk/qREREIDg4uFJ7VaPMP2RkZGD69OmIjY3FqFGj8NNPPyE/P9/y+7y8POh0Ori5ud3Tfu3aNeh0Oqt1MTSJSFkyQ7O6aXhVrly5gmnTpiEpKQmDBg0CAPTu3RsXLlxAVlYW2rZti7S0NISEhKBNmzZwdHRERkYGPD09kZqaimHDhlndB0OTiJRVi5dprl69GiUlJUhMTLS0hYaGIjExEdHR0SgpKYGXlxdGjhwJAFi2bBni4uJw+/ZtdOvWDeHh4Vb3oRH3m9jXYddMX9u6BHoAro90tXUJJFtnWb3a/+07Wf2y3xghq5/SONIkImXxNkoiIglUdhslQ5OIlKWuzGRoEpGy7FR23yFDk4gUpbIlTYYmESmrwYTmyZMnq+3YvXv3h14MEalPTW5NrE+qDM3q7u3UaDT497//rUhBRKQuKsvMqkNz7969tVkHEamU2kLT6nmt27dvIyEhARERESgsLMT8+fNx+/bt2qiNiFRAYyfvVVdZLe3dd99F06ZNUVBQAEdHRxQVFWH+/Pm1URsRqYBGI+9VV1kNzVOnTmHmzJnQarVo3Lgxli1bhlOnTtVGbUSkArX8FUGKsxqadn+6MtVsNldqIyJqKKxep9mvXz8sXboUJpMJP/zwA9avX48BAwbURm1EpAJ1eaoth9Uh41tvvQUnJyc0bdoUSUlJ6NKlC2bPnl0btRGRCqhtTdPqSLNRo0aYNm0aIiIi0KhRIzg6OtZGXUSkEmq7uN3qSNNgMGDcuHEYMGAAPD09ER4ejitXrtRGbUSkAg3ukqP58+dj7Nix+PXXX/HLL7/A29sbcXFxtVEbEamA2qbnVkPTaDRi3LhxaNSoERwcHBAWFnbPN7gREVWnwYVm+/btcezYMcv706dPo3379ooWRUTqobbQrPJEkF6vB3D3NsoJEyagS5cusLOzw+nTp9GxY8daK5CI6re6fKG6HFWGZnx8fG3WQUQqVZdHjXJUGZr9+/e3/FxYWIg7d+5ACAGz2Yzs7OxaKY6I6r8GE5p/+OCDD/Dpp58CAOzt7VFWVgYPDw/s2LFD8eKIqP7TqGx+bvVE0FdffYXvvvsOvr6+2LVrFxITE+Hh4VEbtRGRCqjtRJDV0GzevDl0Oh06dOiA06dPIzAwEFlZWbVRGxGpQIMLTa1Wi+zsbHTo0AE///wzysvLYTQaa6M2IlKBBheakZGRiI+Px/Dhw7Fr1y4MHz6cTzkiohpT2/M0rZ4IGjFiBEaMGAHg7vpmVlYWunbtqnhhRKQOdXnUKEeVofnuu+9W25H3nxNRQ1RlaLq4uNRiGUSkVnX5iUVyVBmaUVFRtVkHEalUg5meExE9DGp7CDFDk4gUpbLMZGgSkbIaTGjy7DkRPQwNJjTr6tnzQeG3bF0CPYDLhxfYugSS6U72Rln96vKF6nLIOnteXFysSDFEpD4NJjT/sGfPHqxYsQLFxcUQQqCiogKFhYU4evRobdRHRPWcnUbYuoSHyuplp0uWLMGUKVPQqlUrLFiwAEOHDkVoaGht1EZEKmCLe8+LiooQEBCAS5cuAQBiYmLg4+ODwMBABAYGYvfu3QCAgwcPQq/Xw8fHB0lJSTXattWRZuPGjeHv749Tp07B0dERCxcuREhIyAMcDhE1JLV9Q9CxY8cQFxcHg8FgacvMzMSXX34JnU5naTOZTIiNjcW6devQqlUrREZGYv/+/fDy8qp2+1aPx8HBAaWlpWjfvj1OnToFOzs7lJaWyj8iImpQ7DRC1kuuzZs3Y8GCBZaALC4uRk5ODuLj46HX67FixQpUVFTg+PHjcHd3R7t27aDVaqHX65Genm51+1ZHms8++ywmT56MxMREhIaGIiMjo86eWSeiukfuVNtoNN732b3Ozs5wdnaust+iRYvueV9QUICBAwciISEBTk5OiIyMxNatW+Hk5ARXV1fL53Q6HXJzc63WZTU0p0yZgtGjR6Nly5ZYuXIl/vOf/yAgIMDqhomIAPnT8zVr1iA5OblSe1RUFKKjo2u8nXbt2uGjjz6yvA8LC0NqaipGjhxZ6bM1ueXTamiePHkSAHDjxg0AQN++fXH16lW0aNGixkUTUcMld6QZERGB4ODgSu3VjTLv58yZMzAYDPD19QUACCGg1Wrh5uaG/Px8y+fy8vLuWfOsitXQ/L+JXlZWhvz8fHTv3h1bt26VVDgRNUwameuT1qbhNSWEwOLFizFw4EA4OTlh06ZNCA4ORu/evXHhwgVkZWWhbdu2SEtLq9FJbquhuXfv3nve//rrrwxMIqo3unbtismTJ2P8+PEoLy+Hj4+PZYkxMTER0dHRKCkpgZeX132n7H+mEUJI/jMQHByMlJQU6dU/BB7j1ttkv/RwXD6cZusSSCa5t1GO++57Wf02jxgmq5/SarymCdwd5mZmZsJkMilaFBGph8oe3C5tTVOj0aBFixZYuHChkjURkYqo7TZKq6G5YcMGtGzZ8p62c+fOKVYQEamL2h7YUeXIubCwEIWFhZg8eTJu3ryJwsJC3Lx5E/n5+Zg6dWpt1khE9ZidzFddVeVI880338SPP/4IABgwYICl3d7eHt7e3spXRkSqoLaRZpWhuXr1agB3nw7y3nvv1VpBRKQualvTtDoKnjFjhuXEz/nz5zF16tR7rqInIqqOLR4NpySroTl37lx06NABANCmTRv0798fMTExihdGROqgtjVNq7XduHED4eHhAABHR0e89NJLuHbtmuKFEZE61Paj4ZRmNTTNZvM9j0vKz8+HjJuIiKiBUtv03Op1mi+99BKCgoIwdOhQAMChQ4cwe/ZsxQsjInWoywEoh9XQHDt2LHr06IHDhw/D3t4e7du3x9q1a6HX62ujPiKq5+ry+qQcVkMTAFq1aoWSkhJs2LABxcXFCAsLU7ouIlKJurw+KUe1oXn+/Hl88cUX2LFjB9q0aQOTyYS9e/eiadOmtVUfEdVzapueVzlynjRpEl588UU4ODhg7dq1SEtLQ5MmTRiYRCRJg7nk6NSpU+jWrRs6deqEJ554AkDNvj+DiEjNqgzNffv2ISQkBGlpaRgyZAimT5+OkpKS2qyNiFRAbZccVRmaWq0Wfn5+WLduHbZt2wadTgeTyQQfHx9s3CjvCc5E1PBoNELWq66q0dKBh4cH4uLi8MMPP+CVV17B5s2bla6LiFRCbSPNGl1y9IfGjRvj+eefx/PPP69UPUSkMnX5pI4ckkKTiEiqBnWdJhHRg6rLU205GJpEpCiGJhGRBPa2LuAhY2gSkaK4pklEJAGn50REEjA0iYgksGdoEhHVHEeaREQS8EQQEZEEHGkSEUnA6zSJiCRQ20hTbQ8gISJSFEeaRKQonggiIpKA12kSEUmgtjVNhiYRKYqhSUQkgdpCk2fPiUhR9hoh6/UgioqKEBAQgEuXLgEADh48CL1eDx8fHyQlJVk+d+rUKYSEhMDX1xfz5s1DeXm51W0zNIlIUXYyX3IdO3YM48ePh8FgAACYTCbExsZi5cqV2LlzJzIzM7F//34AwKxZsxAfH49vv/0WQogafdMuQ5OIFCX3K3yNRiMuXbpU6WU0Gqvd3+bNm7FgwQLodDoAwPHjx+Hu7o527dpBq9VCr9cjPT0dly9fhslkQp8+fQAAY8aMQXp6utXj4ZomESlK7prmmjVrkJycXKk9KioK0dHRVfZbtGjRPe/z8vLg6upqea/T6ZCbm1up3dXVFbm5uVbrYmgSkaLkrk9GREQgODi4Uruzs7Ok7QhRef8ajabKdmsYmkSkKLkjTWdnZ8kBeT9ubm7Iz8+3vM/Ly4NOp6vUfu3aNcuUvjpc0yQiRcld03xYevfujQsXLiArKwtmsxlpaWkYNmwY2rRpA0dHR2RkZAAAUlNTMWzYMKvb40iTiBRl6+s0HR0dkZiYiOjoaJSUlMDLywsjR44EACxbtgxxcXG4ffs2unXrhvDwcKvb04j7TezrMI9x621dAj2Ay4fTbF0CyXQne6OsfumX/iWr38i2frL6KY0jTSJSFJ9yREQkgdpOnKjteIiIFMWRZi0KHPoEXtV3g4CAqcSMhH/8jDNZhZg/sS/6/eXupQ77j+bg/S+PokIIdG7ngi2LfJB19ZZlGzOSDuDClVtV7YIUFBo8BDMjAyCEwJ07pXhz4Rpkns7GX9+OwPDB3VF0uwQ792Tg3aRtEEKg51/a44NFE+Hc1Am3bt3BwmWbsf/gSVsfRq2z9Ymgh42hWUuebNUUc158GoFzduJaoQleT7XGyreG4YtvTqO5syP83kyDnUaDfyZ4w39we6T9mIWnuzyOHQcMiPv0J1uX3+B16tAKi+dNwGD/WFzNK4TviD7456qZWLtlP9q3cUVfnzkoLS1HcuKriAz3xidrdmHL529h0fJtWLdlP9xcm2HX5vnwGZeA3Gs3bX04tUptDyHm9LyWlJZXIPaTw7hWaAIAnPi9AI+7PIJ16f/FjOUHIATg0tQRTZ0ccLOoFADwdBdXdGzTDNsW+2LbYl/49G9ny0No0EpKyzB19me4mlcIAPjl+Hm4ubrAs1cHbPn6IEpKyiCEwI5vf0aw/wC0eKwp2rZugfXbvgcA5F67iczT2fD26m3Do7ANO42Q9aqrGJq15PK129h3NMfyfl6EJ/b+fBll5gqUmwVmTeiDvR+ORsFNE/5zKg8AcMdUjh0HDAiJ/RazPzqEhFf7ofuTzW11CA1a9qV8pO89ann/fnwYvtmTgSO/nMVY/SA0cXJEo0b2eD5wMFrqXFBw4xYMF/Pw4lgvAMAT7XUY3K8rWro9ZqtDsBlbX9z+sDE0a1ljR3t8OHMI3N2aIuaTw5b2pRt+hefLW3DpWhESJvUHACxY/R9s2H0WAPD7ZSN2HsrG/+vbxiZ1011OjR2x/uMZ6PiEG16b/Sn++vHXOPXfS9iXmoCdG+bhcMZ/UVp295mMY19ZhmD//vjPrvcx/43nkL73KMpKrT+vUW3UFpqKrGnm5ORU+/vWrVsrsds6r1ULJ3w6Zzh+v3wTL7y9ByVlZjzdxRXXjSYYrtxCuVlg+77zmD+xH+w0GkQGdcPaf53BbdPd/9E0GqDMXHenLWrXrnULbP37LJw5dxm+z78DU0kZ3Fyb4YPPvkHMors3XYzVD8R5w90n5dhpNBj7yjKYzRUAgNQ1c/DN7gyb1W8rahuZKRKakZGRMBgM0Ol0lZ4kotFo8O9//1uJ3dZpzZo4YMPb3ti+7zw+3HrC0j6ohxv6dHocU5bsR4UQGD30SRzKvIoKIfBs37YoLTNjddpptH68CXwHtEdYwh4bHkXD9VizJti1eT7Wbf0ei5dvs7SP8vaE37NP47lXlqGJkyOmvzoKSat2AAA+SpyEFZ9/g5SdP2GgZyd079IOew9k2uoQbKYGDw6qVxQJzY0bN2LChAlYsGABPD09ldhFvTPBpxNaP+4E7/5t4d2/raX95UXfQefSGGlL/VEhgJ9P52HZhl8BAG+u+BEJk/pjzPCOsLfT4N0vMvD75eofwErKmBTmjXZtHsdo374Y7dvX0j46LBH9+nggY89S2Ntp8I+N3yFl592rHabN/QwfL5mM2NdDcPu2CeMm/RXFd0psdQg2o7LMVO7e8+PHj2PLli145513Hup2ee95/cZ7z+svufee/5z/jax+fR8fJauf0hS7TrNXr17o1auXUpsnonqCa5pERBJo6vA1l3IwNIlIUWpb02RoEpGiePaciEgClWUmQ5OIlFWX7+6Rg6FJRIpSWWaq7moAIiJFcaRJRIriiSAiIglUlpkMTSJSFkOTiEgCnj0nIpJAZZnJ0CQiZfHecyIiCTjSJCKSgJccERFJoLY7aBiaRKQojjSJiCRQWWYyNIlIWRxpEhFJoLLMZGgSkbJ4RxARkQQqy0yGJhEpS213BKntEioiIkVxpElEiuL0nIhIAl5yREQkQW1nZnh4OAoKCqDV3o23hIQEZGdn4+OPP0ZZWRleeuklvPDCC7K3z9AkIkXV5okTIQTOnz+Pffv2WUIzNzcXM2fOxPbt2+Hg4IDQ0FAMGDAAHh4esvbB0CQiRcmdnhuNRhiNxkrtzs7OcHZ2vm+f8+fPQ6PRYNKkSSgoKMC4cePQpEkTDBw4EC4uLgAAX19fpKenIyoqSlZdDE0iUpi81FyzZg2Sk5MrtUdFRSE6Ovq+fYxGIwYNGoSFCxfCZDIhPDwcfn5+cHV1tXxGp9Ph+PHjsmoCGJpEpDCNzNCMiIhAcHBwpfaqRpkA8NRTT+Gpp54CADg5OWHs2LF47733MGXKlHtreoCzUwxNIlKURiNvVbO6aXhVfv75Z5SVlWHQoEEA7q5xtmnTBvn5+ZbP5OXlQafTyaoJ4MXtRKQ4jcyXdLdu3cKSJUtQUlKCoqIipKSkYOnSpTh06BCuX7+OO3fuYNeuXRg2bJjso+FIk4gUJXd6LseIESNw7NgxBAUFoaKiAhMmTICnpydmzpyJ8PBwlJWVYezYsejVq5fsfWiEEPXqxlCPcettXQI9gMuH02xdAsl0J3ujrH43S7+V1a+Zg6+sfkrjSJOIFCV3TbOuYmgSkcLUdR8lQ5OIFFWba5q1gaFJRIpiaBIRSaKuNU11HQ0RkcI40iQiRT3ILYt1EUOTiBTG0CQiqjGeCCIikkRdp04YmkSkKI40iYgk4IkgIiJJGJpERDWm4ZomEZEUHGkSEdUY1zSJiCRhaBIR1RjXNImIJOFIk4ioxnhxOxGRBDwRREQkCdc0iYhqTG3Tc3X9CSAiUhhHmkSkMHWNNBmaRKQonggiIpJEXauADE0iUpTaTgRphBDC1kUQEdUX6ho3ExEpjKFJRCQBQ5OISAKGJhGRBAxNIiIJGJpERBIwNImIJGBoEhFJwNAkIpKAoUlEJAFDk4hIAoYmEZEEDM06YseOHfD394e3tzfWr19v63JIhqKiIgQEBODSpUu2LoUUxNCsA3Jzc5GUlIQNGzbgq6++wqZNm3Du3Dlbl0USHDt2DOPHj4fBYLB1KaQwhmYdcPDgQQwcOBAuLi5wcnKCr68v0tPTbV0WSbB582YsWLAAOp3O1qWQwvgQ4jogLy8Prq6ulvc6nQ7Hjx+3YUUk1aJFi2xdAtUSjjTrgPs9B1pt36tCpBYMzTrAzc0N+fn5lvd5eXmc5hHVUQzNOmDw4ME4dOgQrl+/jjt37mDXrl0YNmyYrcsiovvgmmYd4ObmhpkzZyI8PBxlZWUYO3YsevXqZeuyiOg++MVqREQScHpORCQBQ5OISAKGJhGRBAxNIiIJGJpERBIwNFXm0qVL+Mtf/oLAwEDLa/To0di6desDbzsyMhLbt28HAAQGBsJoNFb52Vu3biE8PFzyPtLT0xEWFlap/ciRIwgICLDav0uXLrh+/bqkfc6dOxerV6+W1IcaLl6nqUKPPPIIvvrqK8v73NxcBAQEoEePHujatetD2cf/3f793Lx5EydOnHgo+yKqSxiaDYCbmxvc3d1hMBjw22+/YevWrbhz5w4effRRrFu3Dlu2bMHGjRtRUVEBFxcXxMfHo2PHjsjNzcXcuXORl5eH1q1bo6CgwLLNLl264NChQ2jevDlWrVqFlJQUaLVauLu7IzExETExMTCZTAgMDMT27dthMBiwaNEiFBYWwmw2IywsDGPHjgUAfPDBB9ixYwdcXFzg7u5u9XguXLiAhIQEFBcXIy8vD127dsXy5cvh6OgIAFi+fDlOnDiBiooKvP766xgxYgQAVHmcRJIIUpWLFy+KPn363NP2yy+/iH79+omcnByxbds20a9fP3Hr1i0hhBBHjhwREyZMEMXFxUIIIX744Qfh5+cnhBBi6tSpIikpSQghhMFgEH369BHbtm0TQgjRuXNnUVBQIPbs2SN8fHxEYWGhEEKIxYsXi5UrV95TR1lZmfD39xeZmZlCCCGMRqPw8/MTR48eFbt37xb+/v7i1q1boqysTEyePFm8+OKLlY7r8OHDYtSoUUIIIRITE0VqaqoQQojS0lIREBAg0tPTLXWtWrVKCCHEmTNnRP/+/UVBQUG1xzlnzhzx+eefP9A/d2o4ONJUoT9GeABgNpvx2GOPYenSpWjVqhWAu6PERx99FACwb98+ZGVlITQ01NL/5s2bKCwsxMGDBzFnzhwAgLu7OwYMGFBpX4cOHcLIkSPRrFkzAEBMTAwA3PP0coPBgOzsbMTGxt5T42+//Ybff/8d3t7elnpCQkKwbt26ao9v1qxZ+PHHH/HZZ5/BYDAgLy8PxcXFlt+PHz8eANC5c2d07NgRR48eRUZGRpXHSSQFQ1OF/rym+WdOTk6WnysqKhAYGIhZs2ZZ3ufl5aFZs2bQaDT3PLZOq638n4u9vf09j7EzGo2VThCZzWY4OzvfU1N+fj6aNm2KpUuX3rMPe3t7q8f3xhtvwGw2w8/PD8OHD8eVK1fu2Yad3f8/vymEgFarrfY4iaTg2fMG7plnnsE333yDvLw8AMDGjRsREREBABg6dCg2bdoEAMjJycGRI0cq9R88eDB2796NoqIiAMCHH36IL774AlqtFmazGUIIPPnkk3B0dLSE5pUrVxAQEIDMzEwMHToU6enpMBqNqKiosHqCCQAOHDiAadOmwd/fHxqNBseOHYPZbLb8PiUlBQBw8uRJZGVloXfv3tUeJ5EUHGk2cEOHDsWkSZMwceJEaDQaPProo0hOToZGo8GCBQsQExMDPz8/tGzZ8r5n3r28vHDu3DnLlNjDwwPvvPMOGjdujG7dusHPzw8bN27EypUrsWjRInz++ecoLy/HjBkz4OnpCQA4c+YMQkJC4OzsjK5du+LGjRvV1jxz5kxMmzYNzZo1Q+PGjdGvXz9kZ2dbfn/x4kUEBQVBo9Hgb3/7G1xcXKo9TiIp+JQjIiIJOD0nIpKAoUlEJAFDk4hIAoYmEZEEDE0iIgkYmkREEjA0iYgkYGgSEUnwv2P4u0UF9lb4AAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 360x360 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "pred_y_model2 =  [1 if x > threshold_model2 else 0 for x in yhat_model2]\n",
    "\n",
    "cnf_matrix_model2  = metrics.confusion_matrix(testy_model2,pred_y_model2)\n",
    "\n",
    "fig, ax = plt.subplots(1,1, figsize = (5,5))\n",
    "plt_cnf_mat(cnf_matrix_model2 , ax)\n",
    "\n",
    "\n",
    "print(\"Accuracy:\",metrics.accuracy_score(testy_model2 , pred_y_model2 ))\n",
    "\n",
    "print()\n",
    "print(\"Precision:\",metrics.precision_score(testy_model2 , pred_y_model2 ))\n",
    "print(\"Recall:\",metrics.recall_score(testy_model2 , pred_y_model2 )) \n",
    "\n",
    "\n",
    "print ()\n",
    "testy_model2_minority = abs(testy_model2 - 1)\n",
    "pred_y_model2_minority = abs(np.array(pred_y_model2) -1)\n",
    "\n",
    "print(\"Specificity:\",metrics.recall_score(testy_model2_minority, pred_y_model2_minority))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Comparing to **Model 1**:\n",
    "    \n",
    "- Our general accuracy improved slightly (from 0.55 to 0.58!).\n",
    "- The Recall decreased (from 0.52 to 0.55).\n",
    "- Specificity decreased slightly.\n",
    "\n",
    "It can be difficult to track the changes of all of these metrics but with such an imbalanced dataset **Accuracy** is not a good indicator. Particularly, in this case we might want to minimize False Negatives. For these cases, we can use the **F1-score**, which is is the harmonic mean of Precision and Recall and gives a better measure of the incorrectly classified cases than the **Accuracy** metric.\n",
    "\n",
    "$F1  = 2*\\frac{Precision*Recall}{Precision+ Recall}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model 1: 0.6747279322853689\n",
      "Model 2: 0.7051886792452831\n"
     ]
    }
   ],
   "source": [
    "print ('Model 1:', metrics.f1_score(testy_model1 , pred_y_model1))\n",
    "print ('Model 2:', metrics.f1_score(testy_model2 , pred_y_model2))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Model 3: Model 2 + Mental Wellbeing \n",
    "\n",
    "Now let's complicate the model even further, adding a variable related to mental wellbeing.\n",
    "\n",
    "The mental wellbeing index is based on a set of five questions where the respondents state degree of agreement in how they felt over the previous two weeks, measured on a six-point scale. The mental well-being scale converts these to a value between 0 - 100.\n",
    "The questionnaire use only positively phrased questions and in the scale higher values mean better self reported mental health.\n",
    "\n",
    "We decided to add this variable because they should be mostly orthogonal to the existing ones of **Model 2**, and a new dimension to the model that should improve its performance."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Optimization terminated successfully.\n",
      "         Current function value: 0.259393\n",
      "         Iterations 7\n",
      "                           Logit Regression Results                           \n",
      "==============================================================================\n",
      "Dep. Variable:                      y   No. Observations:                 1402\n",
      "Model:                          Logit   Df Residuals:                     1395\n",
      "Method:                           MLE   Df Model:                            6\n",
      "Date:                Tue, 23 Nov 2021   Pseudo R-squ.:                  0.2507\n",
      "Time:                        15:32:02   Log-Likelihood:                -363.67\n",
      "converged:                       True   LL-Null:                       -485.35\n",
      "Covariance Type:            nonrobust   LLR p-value:                 1.069e-49\n",
      "========================================================================================\n",
      "                           coef    std err          z      P>|z|      [0.025      0.975]\n",
      "----------------------------------------------------------------------------------------\n",
      "const                    1.8202      0.589      3.089      0.002       0.665       2.975\n",
      "AgeCategory             -0.4998      0.103     -4.864      0.000      -0.701      -0.298\n",
      "DeprIndex               -0.1861      0.056     -3.341      0.001      -0.295      -0.077\n",
      "ISCED                    0.1335      0.076      1.754      0.080      -0.016       0.283\n",
      "MentalWellbeingIndex     0.0476      0.005     10.077      0.000       0.038       0.057\n",
      "Children                -0.1425      0.075     -1.911      0.056      -0.289       0.004\n",
      "AccomProblems           -0.1901      0.108     -1.764      0.078      -0.401       0.021\n",
      "========================================================================================\n"
     ]
    }
   ],
   "source": [
    "X = df_model[['AgeCategory','DeprIndex','ISCED',\"MentalWellbeingIndex\",\"Children\",\"AccomProblems\"]]\n",
    "\n",
    "y = df_model.SRH_binary.values\n",
    "\n",
    "trainX_model3, testX_model3, trainy_model3, testy_model3 = train_test_split(X, y, test_size=0.3, random_state=2)\n",
    "trainX_const_model3 = sm.add_constant(trainX_model3) #add constant for intercept\n",
    "logit_model3 = sm.Logit(trainy_model3, trainX_const_model3) #Create model instance\n",
    "result_model3 = logit_model3.fit() #Fit model\n",
    "\n",
    "print (result_model3.summary())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's repeat the exercise we did in the previous section and compare the fit results between **Model 2** and **Model 3**. We observe the following:\n",
    "\n",
    "- The coefficient for `DeprIndex` again has become significantly less negative. This could mean that the mental wellbeing variables is sharing the weight that the deprivation index carried (it is not a surprise to think that people living in deprivation are also likely to have poor mental health).\n",
    "- The coefficient for `MentalWellbeingIndex` is one order of magnitude smaller than the other coefficients. This is expected\n",
    "given that the variable is one order of magnitude larger.\n",
    "\n",
    "\n",
    "\n",
    "- Now, if we look at the parameters of *goodness-of-fit* we can observe that the fit has improved significantly, with a less negative log-likelihood (~60 units of log likelihood of **Model 3** vs **Model 2**) and larger pseudo R-squ (~0.25 vs ~0.13). In this case the improvement is comparable to the increase of log-likelihood of adding new variables in **Model 2** with respect to the values of a null model (~60 units of log likelihood of **Model 3** vs **Model 2** against 63 units for **Model 2** vs **Null model**).\n",
    "\n",
    "Take this into consideration, we could suspect that including `MentalWellbeingIndex` will increase the discrimination power of our model. Let's see if this is the case by evaluating it on the test set."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Comparing predicted values\n",
    "Same as we did in the previous section, let's compare the predicted probability values of an event being classified as `SRH=1` or `SRH=0`. Let's do this but running the model on the test set and comparing the distributions.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x141f4a760>"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# link the prediction to the label values\n",
    "yhat_model3 = result_model3.predict(sm.add_constant(testX_model3))\n",
    "df_labels = pd.DataFrame({'prediction': yhat_model3,\n",
    "     'label': testy_model3})\n",
    "\n",
    "fig, ax = plt.subplots(1,1, figsize = (5,5))\n",
    "df_labels[df_labels['label']==1]['prediction'].plot.kde(label='SRH == 1')\n",
    "df_labels[df_labels['label']==0]['prediction'].plot.kde(label='SRH == 0')\n",
    "pyplot.xlabel('Probability')\n",
    "pyplot.legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The shape of for our class `SHR=0` has indeed changed, with now even larger tails to low probability values whilst the shape of our positive class has stayed more or less the same. This points in the same direction of our assumption that **Model 3** has now more discrimination power.\n",
    "\n",
    "Let's confirm this using the **ROC** curves."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x396 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "lr_probs_model3 = result_model3.predict(sm.add_constant(testX_model3))\n",
    "\n",
    "plot_roc(testy_model1, lr_probs_model1, positive_label=1, thresholds_every=5, title=\"Model 1\",c='blue')\n",
    "plot_roc(testy_model2 , yhat_model2, positive_label=1, thresholds_every=20, title=\"Model 2\",c='red')\n",
    "plot_roc(testy_model3 , lr_probs_model3, positive_label=1, thresholds_every=20, title=\"Model 3\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Indeed, **Model 3** appears to be the one with better discrimination power between all models from this section. Now, finally let's look at our classification performance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "p(x) threshold value 0.9044\n",
      "Accuracy: 0.7524916943521595\n",
      "\n",
      "Precision: 0.9529411764705882\n",
      "Recall: 0.7584269662921348\n",
      "\n",
      "Specificity: 0.7058823529411765\n",
      "F-score Model 3: 0.8446298227320125\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x360 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# performing predictions on the test dataset\n",
    "threshold_model3 = find_optimal_threshold(testy_model3, yhat_model3)\n",
    "print ('p(x) threshold value', round(threshold_model3,4))\n",
    "\n",
    "pred_y_model3 =  [1 if x > threshold_model3 else 0 for x in yhat_model3]\n",
    "\n",
    "\n",
    "cnf_matrix_model3  = metrics.confusion_matrix(testy_model2,pred_y_model3)\n",
    "\n",
    "fig, ax = plt.subplots(1,1, figsize = (5,5))\n",
    "plt_cnf_mat(cnf_matrix_model3 , ax)\n",
    "\n",
    "\n",
    "print(\"Accuracy:\",metrics.accuracy_score(testy_model3 , pred_y_model3 ))\n",
    "\n",
    "print()\n",
    "print(\"Precision:\",metrics.precision_score(testy_model3 , pred_y_model3 ))\n",
    "print(\"Recall:\",metrics.recall_score(testy_model3 , pred_y_model3 )) \n",
    "\n",
    "\n",
    "print ()\n",
    "testy_model3_minority = abs(testy_model3 - 1)\n",
    "pred_y_model3_minority = abs(np.array(pred_y_model3) -1)\n",
    "\n",
    "print(\"Specificity:\",metrics.recall_score(testy_model3_minority, pred_y_model3_minority))\n",
    "\n",
    "print ('F-score Model 3:', metrics.f1_score(testy_model3 , pred_y_model3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Most of our metrics have improved with respect to **Model 2**!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Going back to our research question\n",
    "\n",
    "Up to now we have been exploring different models and attempting to contrast and compare them using different metrics following a typical machine learning approach. However, we need to sit back and think about our research question what exactly we are trying to measure:\n",
    "\n",
    "> We want to investigate the contribution of material, occupational, and psychosocial factors on the self reported health (SRH) across different European countries. We will use SRH information collected by the Wave 2 and 3 of the EQLTS survey, aware that they offer only a partial representation of European populations and that SRH is per-se a highly subjective indicator, difficult to compare across countries. \n",
    "\n",
    "Our goal here is not necessarily to accurately classify between the two classes but to measure the level of contribution that these predictors have in our model (hence improving the discrimination power of the model and therefore contributing to accurately classifying between the classes). Some of the metrics we have been using in this section (log-likelihood and AUC) can definitely help us measure these contributions.\n",
    "\n",
    "For example, in **Model 3** just adding the mental wellbeing predictor into the model significantly improved the discrimination power of the model for all of our different metrics, therefore we could hint that the self reported mental wellbeing has a sizable contribution to the self reported health for the UK.\n",
    "\n",
    "```{admonition} Likelihood ratio\n",
    "Up to now we have been comparing the log-likehoods between our different models. The reason we can do this is because these are **nested models** meaning that one model is a special case of the other (e.g Model 1 contains a subset of the predictors of Model 2, and equivalent for Model 2 and 3). We haven't been explicit about this but what we are going is equivalent to a likelihood ratio test, which is a statistical test to determine if one (more complex) model fits the data significantly better than the other. The Likelihood (L) ratio is based on the statistic:\n",
    "\n",
    "$\\lambda = -2 ln \\left(\\frac{{L}(ModelA)}{{L}(ModelB)}\\right)= 2 \\left(log{L}(ModelA) - log{L}(ModelB)\\right)$\n",
    "\n",
    "In the null model scenario (in this case that Model B is not better at fitting the data than Model A), the test statistic follows a ${\\chi}^2$ distribution with degrees of freedom, k, equal to the difference in the number of parameters between the two models being fitted.  This is known as [Wilk’s theorem](https://projecteuclid.org/journals/annals-of-mathematical-statistics/volume-9/issue-1/The-Large-Sample-Distribution-of-the-Likelihood-Ratio-for-Testing/10.1214/aoms/1177732360.full).\n",
    "\n",
    "Knowing this, we can calculate a p-value using the chi-square test using the cumulative density function of the ${\\chi}^2$ distribution :\n",
    "\n",
    "$p=1-cdf\\chi^{2}(\\lambda,k)$  \n",
    "\n",
    "```\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So, lets calculate the likelihood ratio of Model 3 against Model 2. Given that we have both log-likelihoods, calculating the test statistic is simple:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "120.20568306789198\n"
     ]
    }
   ],
   "source": [
    "LR = 2 *(result_model3.llf - result_model2.llf)\n",
    "\n",
    "print (LR)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So our likelihood ratio test statistic is around 120, with one degree of freedom, given that we only added one extra variable to Model 3. We can now calculate the p-value:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.0\n"
     ]
    }
   ],
   "source": [
    "degrees_of_freedom = 1\n",
    "p = 1 - stats.chi2.cdf(LR,1)\n",
    "\n",
    "print (p)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Such a small p-value confirms what we already know that Model 3 fits significantly better the data than the Model 2."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model 4: A simpler model with equivalent discrimination power\n",
    "\n",
    "During this section we have slowly built the complexity of the model in order to improve the discrimination power of it. However, we don't necessarily always want a very complex model, given that this can lead to problems with model explanability and **overfitting**. Furthermore, in this case we can to assess the contribution of individual SE factors into the self reported health, and ideally we would only use variables that are completely orthogonal to each other (i.e. measure different things). However, we don't want to lose model performance by reducing the amount of information we feed into it.\n",
    "\n",
    "Everything we have learn about our data by slowly increasing the complexity of the models hint us that is possible to build a simpler model that is equivalent in discrimination power. Let's see what happens if we remove the variables  `Children` and `AccomProblems` that we know are related to `DeprIndex` and `Age`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Optimization terminated successfully.\n",
      "         Current function value: 0.261841\n",
      "         Iterations 7\n",
      "                           Logit Regression Results                           \n",
      "==============================================================================\n",
      "Dep. Variable:                      y   No. Observations:                 1402\n",
      "Model:                          Logit   Df Residuals:                     1397\n",
      "Method:                           MLE   Df Model:                            4\n",
      "Date:                Tue, 23 Nov 2021   Pseudo R-squ.:                  0.2436\n",
      "Time:                        15:32:03   Log-Likelihood:                -367.10\n",
      "converged:                       True   LL-Null:                       -485.35\n",
      "Covariance Type:            nonrobust   LLR p-value:                 5.247e-50\n",
      "========================================================================================\n",
      "                           coef    std err          z      P>|z|      [0.025      0.975]\n",
      "----------------------------------------------------------------------------------------\n",
      "const                    1.4628      0.565      2.591      0.010       0.356       2.569\n",
      "AgeCategory             -0.5012      0.096     -5.230      0.000      -0.689      -0.313\n",
      "DeprIndex               -0.2209      0.053     -4.156      0.000      -0.325      -0.117\n",
      "ISCED                    0.1419      0.076      1.862      0.063      -0.007       0.291\n",
      "MentalWellbeingIndex     0.0475      0.005     10.117      0.000       0.038       0.057\n",
      "========================================================================================\n"
     ]
    }
   ],
   "source": [
    "X = df_model[['AgeCategory','DeprIndex','ISCED',\"MentalWellbeingIndex\"]]\n",
    "\n",
    "y = df_model.SRH_binary.values\n",
    "\n",
    "trainX_model4, testX_model4, trainy_model4, testy_model4 = train_test_split(X, y, test_size=0.3, random_state=2)\n",
    "trainX_const_model4 = sm.add_constant(trainX_model4) #add constant for intercept\n",
    "logit_model4 = sm.Logit(trainy_model4, trainX_const_model4) #Create model instance\n",
    "result_model4 = logit_model4.fit() #Fit model\n",
    "\n",
    "print (result_model4.summary())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Only 4 units of **log-likelihood** are lost by dropping these variables. And the **Pseudo R-squ.** is equivalent."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x396 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "lr_probs_model4 = result_model4.predict(sm.add_constant(testX_model4))\n",
    "\n",
    "plot_roc(testy_model3 , lr_probs_model3, positive_label=1, thresholds_every=20, title=\"Model 3\",c='red')\n",
    "plot_roc(testy_model4 , lr_probs_model4, positive_label=1, thresholds_every=20, title=\"Model 4\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Our **ROC** curves are equivalent!\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### References and Further Reading\n",
    "\n",
    "[Blog post: Testing if one model fits the data significantly better than another model](http://sherrytowers.com/2019/03/18/determining-which-model-fits-the-data-significantly-better/)\n",
    "\n",
    "[Blog post: How are the likelihood ratio, wald and lagrange multiplier test different and/or similar](https://stats.idre.ucla.edu/other/mult-pkg/faq/general/faqhow-are-the-likelihood-ratio-wald-and-lagrange-multiplier-score-tests-different-andor-similar/)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}