04.07-Random-Sample-Imputation.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Random sample imputation\n",
    "\n",
    "Imputation is the act of replacing missing data with statistical estimates of the missing values. The goal of any imputation technique is to produce a **complete dataset** that can then be then used for machine learning.\n",
    "\n",
    "Random sampling imputation is in principle similar to mean / median / mode imputation, in the sense that it aims to preserve the statistical parameters of the original variable, for which data is missing.\n",
    "\n",
    "Random sampling consist of taking a random observation from the pool of available observations of the variable, and using that randomly extracted value to fill the NA. In random sample imputation one takes as many random observations as missing values are present in the variable.\n",
    "\n",
    "By random sampling observations of the variable for those instances where data is available, we guarantee that the mean and standard deviation of the variable are preserved.\n",
    "\n",
    "By random sampling observations of the present categories, for categorical variables, we guarantee that the frequency of the different categories / labels within the variable is preserved.\n",
    "\n",
    "\n",
    "### Which variables can I impute by Random Sample Imputation?\n",
    "\n",
    "Random Sample Imputation can be applied to both numerical and categorical variables.\n",
    "\n",
    "\n",
    "### Assumptions\n",
    "\n",
    "Random sample imputation assumes that the data are missing completely at random (MCAR). If this is the case, it makes sense to substitute the missing values by values extracted from the original variable distribution. \n",
    "\n",
    "From a probabilistic point of view, values that are more frequent, like the mean or the median or the most frequent category, for categorical variables, will be selected more often -because there are more of them to select from-, but other less frequent values will be selected as well. Thus, the variance and distribution of the variable are preserved. \n",
    "\n",
    "The idea is to replace the population of missing values with a population of values with the same distribution of the original variable.\n",
    "\n",
    "\n",
    "### Advantages\n",
    "\n",
    "- Easy to implement\n",
    "- Fast way of obtaining complete datasets\n",
    "- Preserves the variance of the variable\n",
    "\n",
    "### Limitations\n",
    "\n",
    "- Randomness\n",
    "- The relationship of imputed variables with other variables may be affected if there are a lot of NA\n",
    "- Memory heavy for deployment, as we need to store the original training set to extract values from and replace the NA in coming observations.\n",
    "\n",
    "\n",
    "### When to use Random Sample Imputation?\n",
    "\n",
    "- Data is missing completely at random\n",
    "- No more than 5% of the variable contains missing data\n",
    "- Well suited for linear models as it does not distort the distribution, regardless of the % of NA\n",
    "\n",
    "If used in combination with a Missing Indicator, as we will see in the next lecture, then this method can be used when data is not missing at random as well, or when there are many missing observations.\n",
    "\n",
    "\n",
    "#### Randomness\n",
    "\n",
    "Randomness may not seem much of a concern when replacing missing values for data competitions, where the whole batch of missing values is replaced once and then the dataset is scored and that is the end of the problem. However, in business scenarios the situation is very different. \n",
    "\n",
    "Imagine for example a car manufacturer is trying to predict how long a certain car will be in the garage before it passes all the security tests. Today, they receive a car with missing data in some of the variables, they run the machine learning model to predict how long this car will stay in the garage, the model replaces missing values by a random sample of the variable and then produces an estimate of time. Tomorrow, when they run the same model on the same car, the model will randomly assign values to the missing data, that may or may not be the same as the ones it selected today, therefore, the final estimation of time in the garage, may or may not be the same as the one obtained the day before.\n",
    "\n",
    "In addition, imagine the car manufacturer evaluates 2 different cars that have exactly the same values for all of the variables, and missing values in exactly the same subset of variables. They run the machine learning model for each car, and because the missing data is randomly filled with values, the 2 cars, that are exactly the same, may end up with different estimates of time in the garage.\n",
    "\n",
    "This may sound completely trivial and unimportant, however, businesses must follow a variety of regulations, and some of them require the same treatment to be provided to the same situation. So if instead of cars, these were people applying for a loan, or people seeking for disease treatment, the machine learning model would end up providing different solutions to candidates that are otherwise in the same conditions. And this is not fair or acceptable. This behaviour needs to be avoided.\n",
    "\n",
    "#### So, should we randomly replace NA or not?\n",
    "\n",
    "It is still possible to replace missing data by random sample, but these randomness needs to be controlled, so that individuals in the same situation end up with the same scores and therefore with the same solutions offered. How can we ensure this? by appropriately setting seeds during the random extraction of values.\n",
    "\n",
    "Finally, another potential limitation of random sampling, similarly to replacing with the mean and median, is that estimates of covariance and correlations with other variables in the dataset may also be washed off by the randomness, particularly if there are a lot of missing observations.\n",
    "\n",
    "\n",
    "### Final note\n",
    "\n",
    "Replacement of missing values by random sample, although similar in concept to replacement by the median or mean, is not as widely used in the data science community as the mean / median imputation, presumably because of the element of randomness, or because the code implementation is not so straightforward.\n",
    "\n",
    "However, it is a valid approach, with clear advantages over mean / median imputation as it preserves the distribution of the variable. And if you are mindful of the element of randomness and account for it somehow, this may as well be your method of choice, particularly for linear models.\n",
    "\n",
    "## In this demo:\n",
    "\n",
    "We will learn how to perform random sample imputation using pandas on the Ames House Price and Titanic Datasets.\n",
    "\n",
    "- To download the datasets please refer to the lecture **Datasets** in **Section 1** of this course."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# to split and standarise the datasets\n",
    "from sklearn.model_selection import train_test_split"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Random Sampling for Numerical Variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>survived</th>\n",
       "      <th>age</th>\n",
       "      <th>fare</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>29.0000</td>\n",
       "      <td>211.3375</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>0.9167</td>\n",
       "      <td>151.5500</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0</td>\n",
       "      <td>2.0000</td>\n",
       "      <td>151.5500</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0</td>\n",
       "      <td>30.0000</td>\n",
       "      <td>151.5500</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0</td>\n",
       "      <td>25.0000</td>\n",
       "      <td>151.5500</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   survived      age      fare\n",
       "0         1  29.0000  211.3375\n",
       "1         1   0.9167  151.5500\n",
       "2         0   2.0000  151.5500\n",
       "3         0  30.0000  151.5500\n",
       "4         0  25.0000  151.5500"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# load the Titanic Dataset with a few variables for demonstration\n",
    "\n",
    "data = pd.read_csv('../titanic.csv', usecols=['age', 'fare', 'survived'])\n",
    "data.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "survived    0.000000\n",
       "age         0.200917\n",
       "fare        0.000764\n",
       "dtype: float64"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# let's look at the percentage of NA\n",
    "\n",
    "data.isnull().mean()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Imputation important\n",
    "\n",
    "Imputation should done over the training set, and then propagated to the test set. This means that the random sample to be used to fill missing values both in train and test set, should be extracted from the train set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((916, 3), (393, 3))"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# let's separate into training and testing set\n",
    "\n",
    "X_train, X_test, y_train, y_test = train_test_split(data,\n",
    "                                                    data.survived,\n",
    "                                                    test_size=0.3,\n",
    "                                                    random_state=0)\n",
    "X_train.shape, X_test.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Sole\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:6: 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: http://pandas.pydata.org/pandas-docs/stable/indexing.html#indexing-view-versus-copy\n",
      "  \n",
      "C:\\Users\\Sole\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:7: 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: http://pandas.pydata.org/pandas-docs/stable/indexing.html#indexing-view-versus-copy\n",
      "  import sys\n",
      "C:\\Users\\Sole\\Anaconda3\\lib\\site-packages\\pandas\\core\\indexing.py:543: 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: http://pandas.pydata.org/pandas-docs/stable/indexing.html#indexing-view-versus-copy\n",
      "  self.obj[item] = s\n"
     ]
    }
   ],
   "source": [
    "# let's impute Age by random sampling both in\n",
    "# train and test sets\n",
    "\n",
    "# create the new variable where NA will be imputed:\n",
    "# make a copy from the original variable, with NA\n",
    "X_train['Age_imputed'] = X_train['age'].copy()\n",
    "X_test['Age_imputed'] = X_test['age'].copy()\n",
    "\n",
    "# extract the random sample to fill the na:\n",
    "# remember we do this always from the train set, and we use\n",
    "# these to fill both train and test\n",
    "\n",
    "random_sample_train = X_train['age'].dropna().sample(\n",
    "    X_train['age'].isnull().sum(), random_state=0)\n",
    "\n",
    "random_sample_test = X_train['age'].dropna().sample(\n",
    "    X_test['age'].isnull().sum(), random_state=0)\n",
    "\n",
    "# what is all of the above code doing?\n",
    "\n",
    "# 1) dropna() removes the NA from the original variable, this\n",
    "# means that I will randomly extract existing values and not NAs\n",
    "\n",
    "# 2) sample() is the method that will do the random sampling\n",
    "\n",
    "# 3) X_train['Age'].isnull().sum() is the number of random values to extract\n",
    "# I want to extract as many values as NAs are present in the original variable\n",
    "\n",
    "# 4) random_state sets the seed for reproducibility, so that I extract \n",
    "# always the same random values, every time I run this notebook\n",
    "\n",
    "# pandas needs to have the same index in order to merge datasets\n",
    "random_sample_train.index = X_train[X_train['age'].isnull()].index\n",
    "random_sample_test.index = X_test[X_test['age'].isnull()].index\n",
    "\n",
    "# replace the NA in the newly created variable\n",
    "X_train.loc[X_train['age'].isnull(), 'Age_imputed'] = random_sample_train\n",
    "X_test.loc[X_test['age'].isnull(), 'Age_imputed'] = random_sample_test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# check that NA were imputed\n",
    "X_train['Age_imputed'].isnull().sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# check that NA were imputed\n",
    "X_test['Age_imputed'].isnull().sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>survived</th>\n",
       "      <th>age</th>\n",
       "      <th>fare</th>\n",
       "      <th>Age_imputed</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>501</th>\n",
       "      <td>1</td>\n",
       "      <td>13.0</td>\n",
       "      <td>19.5000</td>\n",
       "      <td>13.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>588</th>\n",
       "      <td>1</td>\n",
       "      <td>4.0</td>\n",
       "      <td>23.0000</td>\n",
       "      <td>4.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>402</th>\n",
       "      <td>1</td>\n",
       "      <td>30.0</td>\n",
       "      <td>13.8583</td>\n",
       "      <td>30.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1193</th>\n",
       "      <td>0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>7.7250</td>\n",
       "      <td>40.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>686</th>\n",
       "      <td>1</td>\n",
       "      <td>22.0</td>\n",
       "      <td>7.7250</td>\n",
       "      <td>22.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>971</th>\n",
       "      <td>0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>7.8792</td>\n",
       "      <td>39.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>117</th>\n",
       "      <td>1</td>\n",
       "      <td>30.0</td>\n",
       "      <td>56.9292</td>\n",
       "      <td>30.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>540</th>\n",
       "      <td>1</td>\n",
       "      <td>2.0</td>\n",
       "      <td>26.0000</td>\n",
       "      <td>2.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>294</th>\n",
       "      <td>0</td>\n",
       "      <td>49.0</td>\n",
       "      <td>110.8833</td>\n",
       "      <td>49.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>261</th>\n",
       "      <td>1</td>\n",
       "      <td>35.0</td>\n",
       "      <td>26.2875</td>\n",
       "      <td>35.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>587</th>\n",
       "      <td>1</td>\n",
       "      <td>2.0</td>\n",
       "      <td>23.0000</td>\n",
       "      <td>2.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>489</th>\n",
       "      <td>1</td>\n",
       "      <td>42.0</td>\n",
       "      <td>26.0000</td>\n",
       "      <td>42.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>151.5500</td>\n",
       "      <td>2.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>405</th>\n",
       "      <td>0</td>\n",
       "      <td>18.0</td>\n",
       "      <td>13.0000</td>\n",
       "      <td>18.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1284</th>\n",
       "      <td>0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>8.0500</td>\n",
       "      <td>24.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      survived   age      fare  Age_imputed\n",
       "501          1  13.0   19.5000         13.0\n",
       "588          1   4.0   23.0000          4.0\n",
       "402          1  30.0   13.8583         30.0\n",
       "1193         0   NaN    7.7250         40.5\n",
       "686          1  22.0    7.7250         22.0\n",
       "971          0   NaN    7.8792         39.0\n",
       "117          1  30.0   56.9292         30.0\n",
       "540          1   2.0   26.0000          2.0\n",
       "294          0  49.0  110.8833         49.0\n",
       "261          1  35.0   26.2875         35.0\n",
       "587          1   2.0   23.0000          2.0\n",
       "489          1  42.0   26.0000         42.0\n",
       "2            0   2.0  151.5500          2.0\n",
       "405          0  18.0   13.0000         18.0\n",
       "1284         0   NaN    8.0500         24.0"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train.head(15)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can see how NAs are replaced by different values in the different rows! This is what we wanted."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Random sampling preserves the original distribution of the variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f14ecf7f0>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# we can see that the distribution of the variable after\n",
    "# random sample imputation is almost exactly the same as the original\n",
    "\n",
    "fig = plt.figure()\n",
    "ax = fig.add_subplot(111)\n",
    "\n",
    "X_train['age'].plot(kind='kde', ax=ax)\n",
    "X_train['Age_imputed'].plot(kind='kde', ax=ax, color='red')\n",
    "\n",
    "lines, labels = ax.get_legend_handles_labels()\n",
    "ax.legend(lines, labels, loc='best')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can see that replacing missing values with a random sample from the training set preserves the original distribution of the variable. If you remember from previous notebooks, every other imputation technique altered the distribution of Age, because the percentage of NA in Age is high, ~20%. However, random sample imputation preserves the distribution, even in those cases. So this imputation technique is quite handy, if we are building linear models and we don't want to distort normal distributions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original variable variance:  194.16304666581854\n",
      "Variance after random imputation:  198.53703762759602\n"
     ]
    }
   ],
   "source": [
    "# there is some change in the variance of the variable.\n",
    "# however this change is much smaller compared to mean / median\n",
    "# imputation (check the previous notebook for comparison)\n",
    "\n",
    "print('Original variable variance: ', X_train['age'].var())\n",
    "print('Variance after random imputation: ', X_train['Age_imputed'].var())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>fare</th>\n",
       "      <th>age</th>\n",
       "      <th>Age_imputed</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>fare</th>\n",
       "      <td>2248.326729</td>\n",
       "      <td>136.176223</td>\n",
       "      <td>100.938070</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>age</th>\n",
       "      <td>136.176223</td>\n",
       "      <td>194.163047</td>\n",
       "      <td>194.163047</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Age_imputed</th>\n",
       "      <td>100.938070</td>\n",
       "      <td>194.163047</td>\n",
       "      <td>198.537038</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                    fare         age  Age_imputed\n",
       "fare         2248.326729  136.176223   100.938070\n",
       "age           136.176223  194.163047   194.163047\n",
       "Age_imputed   100.938070  194.163047   198.537038"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# the covariance of Age with Fare is also less affected by this\n",
    "# imputation technique compared to mean / median imputation\n",
    "\n",
    "X_train[['fare', 'age', 'Age_imputed']].cov()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7f14e90908>"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Finally, the outliers are also less affected by this imputation\n",
    "# technique\n",
    "\n",
    "# Let's find out using a boxplot\n",
    "X_train[['age', 'Age_imputed']].boxplot()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So random sample imputation offers all the advantages provided by the preservation of the original distribution. And that is a big plus, particularly, if we care about distribution and outliers for our machine learning models. This is particularly relevant for linear models. But not so important for tree based algorithms."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Randomness can lead to different scores being assigned to the same observation\n",
    "\n",
    "Let's examine the effect of randomness on multiple scoring, and how we can mitigate this behaviour, as this is very important when putting our models in production / integrating our models with live systems."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>survived</th>\n",
       "      <th>age</th>\n",
       "      <th>fare</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>15</th>\n",
       "      <td>0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>25.925</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    survived  age    fare\n",
       "15         0  NaN  25.925"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# let's pick one observation with NA in Age\n",
    "# in this case we pick observation indexed 5\n",
    "\n",
    "observation = data[data.age.isnull()].head(1)\n",
    "observation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>survived</th>\n",
       "      <th>age</th>\n",
       "      <th>fare</th>\n",
       "      <th>Age_random</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>15</th>\n",
       "      <td>0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>25.925</td>\n",
       "      <td>3.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    survived  age    fare  Age_random\n",
       "15         0  NaN  25.925         3.0"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# and now let's fill that NA with a random value\n",
    "# extracted from the same variable where observations are available\n",
    "\n",
    "# extract a random value, just 1\n",
    "sampled_value = X_train['age'].dropna().sample(1)\n",
    "\n",
    "# re index to 5\n",
    "sampled_value.index = [15]  # pandas needs the same index to be able to merge\n",
    "\n",
    "# replace the NA with the sampled value\n",
    "observation['Age_random'] = sampled_value\n",
    "\n",
    "observation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>survived</th>\n",
       "      <th>age</th>\n",
       "      <th>fare</th>\n",
       "      <th>Age_random</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>15</th>\n",
       "      <td>0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>25.925</td>\n",
       "      <td>22.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    survived  age    fare  Age_random\n",
       "15         0  NaN  25.925        22.0"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# let's repeat the exercise again: \n",
    "# we fill the NA with another random extracted value\n",
    "\n",
    "# extract a random value, just 1\n",
    "sampled_value = X_train['age'].dropna().sample(1)\n",
    "\n",
    "# re index to 5\n",
    "sampled_value.index = [15]  #pandas needs the same index to be able to merge\n",
    "\n",
    "# replace the NA with the sampled value\n",
    "observation['Age_random'] = sampled_value\n",
    "\n",
    "observation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>survived</th>\n",
       "      <th>age</th>\n",
       "      <th>fare</th>\n",
       "      <th>Age_random</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>15</th>\n",
       "      <td>0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>25.925</td>\n",
       "      <td>36.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    survived  age    fare  Age_random\n",
       "15         0  NaN  25.925        36.0"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# and again\n",
    "# we fill the NA with another random extracted value\n",
    "\n",
    "# extract a random value, just 1\n",
    "sampled_value = X_train['age'].dropna().sample(1)\n",
    "\n",
    "# re index to 5\n",
    "sampled_value.index = [15]  #pandas needs the same index to be able to merge\n",
    "\n",
    "# replace the NA with the sampled value\n",
    "observation['Age_random'] = sampled_value\n",
    "\n",
    "observation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can see that every time we repeat the operation, we get a different value replacement for exactly the same observation. In fact, if we repeat the process 1000 times:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'Number of times')"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# if we repeat the process 1000 times:\n",
    "\n",
    "values_ls = []\n",
    "\n",
    "# capture the non-Na values to speed\n",
    "# the computation\n",
    "tmp = X_train.age.dropna()\n",
    "\n",
    "for i in range(1000):\n",
    "    \n",
    "    # extract a random value, just 1\n",
    "    sampled_value = tmp.sample(1).values\n",
    "    \n",
    "    # add the extracted value to the list\n",
    "    values_ls.append(float(sampled_value))\n",
    "    \n",
    "pd.Series(values_ls).hist(bins=50)\n",
    "plt.xlabel('Randomly Extracted Values')\n",
    "plt.ylabel('Number of times')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We obtain very different values for the same observation. Note how the distribution of extracted values is similar to the distribution of Age.\n",
    "\n",
    "If this were patients looking for treatment, every time we run a predictive model, which would operate on the differently randomly extracted values, we would assign patients with the same characteristics to different treatments, and this is not OK.\n",
    "\n",
    "### How can we fix this behaviour?\n",
    "\n",
    "We can fix this randomness by assigning a seed:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([23.5])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "values_ls = []\n",
    "\n",
    "for i in range(100):\n",
    "\n",
    "    # extract a random value, just 1, now with seed\n",
    "    sampled_value = X_train.age.dropna().sample(1, random_state=10)\n",
    "\n",
    "    # add random value to the list\n",
    "    values_ls.append(float(sampled_value))\n",
    "\n",
    "# print the values\n",
    "pd.Series(values_ls).unique()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5,\n",
       " 23.5]"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "values_ls"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that we set the seed, every randomly extracted value for that observation is the same.\n",
    "\n",
    "However, if we set the same seed for every single observation, what would happen is that for every different observation, we would be filling the NA with exactly the same value (same seed == same random value extracted). This would be the equivalent to arbitrary value imputation!!!\n",
    "\n",
    "We don't want that behaviour either.\n",
    "\n",
    "Therefore, we want our seed to change observation per observation, but in a controlled manner, so that 2 observations that are exactly the same, receive the same imputed random values. But 2 observations that are different, receive different imputed random values."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Controlling the element of randomness by varying the seed\n",
    "\n",
    "We can attribute a different seed to each observation, and in fact, we can make this seed depend on an alternative variable of the same observation, thus, thinking in the Titanic dataset, if 2 passengers paid exactly the same Fare, they would get exactly the same probability of survival (when Age is missing)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>survived</th>\n",
       "      <th>age</th>\n",
       "      <th>fare</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>15</th>\n",
       "      <td>0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>25.925</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    survived  age    fare\n",
       "15         0  NaN  25.925"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# let's pick one observation with NA in Age\n",
    "# in this case we pick observation indexed 5\n",
    "\n",
    "observation = data[data.age.isnull()].head(1)\n",
    "observation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "25"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# the seed is now the Fare\n",
    "\n",
    "int(observation.fare)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>survived</th>\n",
       "      <th>age</th>\n",
       "      <th>fare</th>\n",
       "      <th>Age_random</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>15</th>\n",
       "      <td>0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>25.925</td>\n",
       "      <td>44.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    survived  age    fare  Age_random\n",
       "15         0  NaN  25.925        44.0"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# we assign the Fare as the seed in the random sample extraction\n",
    "sampled_value = X_train.age.dropna().sample(1,\n",
    "                                            random_state=int(observation.fare))\n",
    "sampled_value.index = [15]\n",
    "\n",
    "observation['Age_random'] = sampled_value\n",
    "observation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>survived</th>\n",
       "      <th>age</th>\n",
       "      <th>fare</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1305</th>\n",
       "      <td>0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>14.4542</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      survived  age     fare\n",
       "1305         0  NaN  14.4542"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# for a different observation with a different Fare,\n",
    "# we would get a different randomly extracted value\n",
    "\n",
    "observation = data[data.age.isnull()].tail(1)\n",
    "observation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "14"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# new seed\n",
    "int(observation.fare)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>survived</th>\n",
       "      <th>age</th>\n",
       "      <th>fare</th>\n",
       "      <th>Age_random</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1305</th>\n",
       "      <td>0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>14.4542</td>\n",
       "      <td>40.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      survived  age     fare  Age_random\n",
       "1305         0  NaN  14.4542        40.0"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# we assign the Fare as the seed in the random sample extraction\n",
    "sampled_value = X_train.age.dropna().sample(1,\n",
    "                                            random_state=int(observation.fare))\n",
    "sampled_value.index = [1305]\n",
    "\n",
    "observation['Age_random'] = sampled_value\n",
    "observation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is a way of controlling the randomness. Using the Fare to set the random state, you guarantee that for 2 passengers with equal Fare, the Age will be replaced with the same number, and therefore the 2 passengers will get the same probability of survival.\n",
    "\n",
    "### Note!!\n",
    "\n",
    "In real life, you will build models that use tens of variables or more. So in cases like those, you can think of picking the 3-5 more important variables, those that have the strongest impact on the output of the machine learning model, and combine them to create the random state. Therefore, customers that share the 3-5 main variable values, will get the same scores."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Random Sampling for Categorical Variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "SalePrice      0.000000\n",
       "BsmtQual       0.025342\n",
       "FireplaceQu    0.472603\n",
       "dtype: float64"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# let's load the dataset with a few columns for the demonstration\n",
    "cols_to_use = ['BsmtQual', 'FireplaceQu', 'SalePrice']\n",
    "\n",
    "data = pd.read_csv('../houseprice.csv', usecols=cols_to_use)\n",
    "\n",
    "# let's inspect the percentage of missing values in each variable\n",
    "data.isnull().mean().sort_values(ascending=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((1022, 3), (438, 3))"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# let's separate into training and testing set\n",
    "\n",
    "X_train, X_test, y_train, y_test = train_test_split(data,\n",
    "                                                    data.SalePrice,\n",
    "                                                    test_size=0.3,\n",
    "                                                    random_state=0)\n",
    "X_train.shape, X_test.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Sole\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:6: 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: http://pandas.pydata.org/pandas-docs/stable/indexing.html#indexing-view-versus-copy\n",
      "  \n",
      "C:\\Users\\Sole\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:7: 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: http://pandas.pydata.org/pandas-docs/stable/indexing.html#indexing-view-versus-copy\n",
      "  import sys\n",
      "C:\\Users\\Sole\\Anaconda3\\lib\\site-packages\\pandas\\core\\indexing.py:543: 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: http://pandas.pydata.org/pandas-docs/stable/indexing.html#indexing-view-versus-copy\n",
      "  self.obj[item] = s\n"
     ]
    }
   ],
   "source": [
    "# let's impute BsmtQual by random sampling both in\n",
    "# train and test sets\n",
    "\n",
    "# create the new variable where NA will be imputed\n",
    "# make a copy from the original variable, with NA\n",
    "X_train['BsmtQual_imputed'] = X_train['BsmtQual'].copy()\n",
    "X_test['BsmtQual_imputed'] = X_test['BsmtQual'].copy()\n",
    "\n",
    "# extract the random sample to fill the na:\n",
    "# remember we do this always from the train set, and we use\n",
    "# these to fill both train and test\n",
    "\n",
    "random_sample_train = X_train['BsmtQual'].dropna().sample(\n",
    "    X_train['BsmtQual'].isnull().sum(), random_state=0)\n",
    "\n",
    "random_sample_test = X_train['BsmtQual'].dropna().sample(\n",
    "    X_test['BsmtQual'].isnull().sum(), random_state=0)\n",
    "\n",
    "# what is all of the above code doing?\n",
    "# 1) dropna() removes the NA from the original variable, this\n",
    "# means that I will randomly extract existing values and not NAs\n",
    "\n",
    "# 2) sample() is the method that will do the random sampling\n",
    "\n",
    "# 3) X_train['BsmtQual'].isnull().sum() is the number of random values to extract\n",
    "# I want to extract as many values as NAs are present in the original variable\n",
    "\n",
    "# 4) random_state sets the seed for reproducibility, so that I extract \n",
    "# always the same random values, every time I run this notebook\n",
    "\n",
    "# pandas needs to have the same index in order to merge datasets\n",
    "random_sample_train.index = X_train[X_train['BsmtQual'].isnull()].index\n",
    "random_sample_test.index = X_test[X_test['BsmtQual'].isnull()].index\n",
    "\n",
    "# replace the NA in the newly created variable\n",
    "X_train.loc[X_train['BsmtQual'].isnull(), 'BsmtQual_imputed'] = random_sample_train\n",
    "X_test.loc[X_test['BsmtQual'].isnull(), 'BsmtQual_imputed'] = random_sample_test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Sole\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:6: 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: http://pandas.pydata.org/pandas-docs/stable/indexing.html#indexing-view-versus-copy\n",
      "  \n",
      "C:\\Users\\Sole\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:7: 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: http://pandas.pydata.org/pandas-docs/stable/indexing.html#indexing-view-versus-copy\n",
      "  import sys\n"
     ]
    }
   ],
   "source": [
    "# let's impute FireplaceQu by random sampling both in\n",
    "# train and test sets\n",
    "\n",
    "# create the new variable where NA will be imputed\n",
    "# make a copy from the original variable, with NA\n",
    "X_train['FireplaceQu_imputed'] = X_train['FireplaceQu'].copy()\n",
    "X_test['FireplaceQu_imputed'] = X_test['FireplaceQu'].copy()\n",
    "\n",
    "# extract the random sample to fill the na:\n",
    "# remember we do this always from the train set, and we use\n",
    "# these to fill both train and test\n",
    "\n",
    "random_sample_train = X_train['FireplaceQu'].dropna().sample(\n",
    "    X_train['FireplaceQu'].isnull().sum(), random_state=0)\n",
    "\n",
    "random_sample_test = X_train['FireplaceQu'].dropna().sample(\n",
    "    X_test['FireplaceQu'].isnull().sum(), random_state=0)\n",
    "\n",
    "# what is all of the above code doing?\n",
    "# 1) dropna() removes the NA from the original variable, this\n",
    "# means that I will randomly extract existing values and not NAs\n",
    "\n",
    "# 2) sample() is the method that will do the random sampling\n",
    "\n",
    "# 3) X_train['FireplaceQu'].isnull().sum() is the number of random values to extract\n",
    "# I want to extract as many values as NAs are present in the original variable\n",
    "\n",
    "# 4) random_state sets the seed for reproducibility, so that I extract \n",
    "# always the same random values, every time I run this notebook\n",
    "\n",
    "# pandas needs to have the same index in order to merge datasets\n",
    "random_sample_train.index = X_train[X_train['FireplaceQu'].isnull()].index\n",
    "random_sample_test.index = X_test[X_test['FireplaceQu'].isnull()].index\n",
    "\n",
    "# replace the NA in the newly created variable\n",
    "X_train.loc[X_train['FireplaceQu'].isnull(), 'FireplaceQu_imputed'] = random_sample_train\n",
    "X_test.loc[X_test['FireplaceQu'].isnull(), 'FireplaceQu_imputed'] = random_sample_test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# check that nulls were removed\n",
    "X_train['FireplaceQu_imputed'].isnull().sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "# and now let's evaluate the effect of the imputation on the distribution\n",
    "# of the categories and the target within those categories\n",
    "\n",
    "# we used a similar function in the notebook of arbitrary value imputation\n",
    "# for categorical variables\n",
    "\n",
    "def categorical_distribution(df, variable_original, variable_imputed):\n",
    "\n",
    "    tmp = pd.concat(\n",
    "        [\n",
    "            # percentage of observations per category, original variable\n",
    "            df[variable_original].value_counts() / len(df[variable_original].dropna()),\n",
    "\n",
    "            # percentage of observations per category, imputed variable\n",
    "            df[variable_imputed].value_counts() / len(df)\n",
    "        ],\n",
    "        axis=1)\n",
    "\n",
    "    # add column names\n",
    "    tmp.columns = ['original', 'imputed']\n",
    "\n",
    "    return tmp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>original</th>\n",
       "      <th>imputed</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>TA</th>\n",
       "      <td>0.463928</td>\n",
       "      <td>0.465753</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Gd</th>\n",
       "      <td>0.430862</td>\n",
       "      <td>0.428571</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Ex</th>\n",
       "      <td>0.082164</td>\n",
       "      <td>0.083170</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Fa</th>\n",
       "      <td>0.023046</td>\n",
       "      <td>0.022505</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    original   imputed\n",
       "TA  0.463928  0.465753\n",
       "Gd  0.430862  0.428571\n",
       "Ex  0.082164  0.083170\n",
       "Fa  0.023046  0.022505"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# run the function in a categorical variable\n",
    "categorical_distribution(X_train, 'BsmtQual', 'BsmtQual_imputed')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>original</th>\n",
       "      <th>imputed</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Gd</th>\n",
       "      <td>0.468750</td>\n",
       "      <td>0.469667</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>TA</th>\n",
       "      <td>0.420956</td>\n",
       "      <td>0.420744</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Fa</th>\n",
       "      <td>0.047794</td>\n",
       "      <td>0.046967</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Ex</th>\n",
       "      <td>0.033088</td>\n",
       "      <td>0.032290</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Po</th>\n",
       "      <td>0.029412</td>\n",
       "      <td>0.030333</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    original   imputed\n",
       "Gd  0.468750  0.469667\n",
       "TA  0.420956  0.420744\n",
       "Fa  0.047794  0.046967\n",
       "Ex  0.033088  0.032290\n",
       "Po  0.029412  0.030333"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# run the function in a categorical variable\n",
    "categorical_distribution(X_train, 'FireplaceQu', 'FireplaceQu_imputed')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As expected, the percentage of observations within each category is very similar in the original and imputed variables, for both BsmtQual where NA are low and FireplaceQu were NA are high."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "# now let's look at the distribution of the target within each\n",
    "# variable category\n",
    "\n",
    "def automate_plot(df, variable, target):\n",
    "    \n",
    "    fig = plt.figure()\n",
    "    ax = fig.add_subplot(111)\n",
    "    \n",
    "    for category in df[variable].dropna().unique():\n",
    "        df[df[variable]==category][target].plot(kind='kde', ax=ax)\n",
    "    \n",
    "    # add the legend\n",
    "    lines, labels = ax.get_legend_handles_labels()\n",
    "    labels = df[variable].dropna().unique()\n",
    "    ax.legend(lines, labels, loc='best')\n",
    "    \n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "automate_plot(X_train, 'BsmtQual', 'SalePrice')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "automate_plot(X_train, 'BsmtQual_imputed', 'SalePrice')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAaQAAAD8CAYAAAA45tAbAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzs3Xd4XEe5+PHvbNOq76pZzbbkXuUSx+mdJE51CiFOKAkJhECAewn3XhIuFwg/Wrj3JsAlQEgCBELihEAaaQSc7jT3LluWZVty00q7K63qlvn9cY76rrSSdyXZfj/P48fSnDkzs3pivZk5c95RWmuEEEKIsWYZ6wEIIYQQIAFJCCHEOCEBSQghxLggAUkIIcS4IAFJCCHEuCABSQghxLggAUkIIcS4IAFJCCHEuCABSQghxLhgG+sBHEvy8vJ0WVnZWA9DCCGOKWvXrvVorfOHqicBaRjKyspYs2bNWA9DCCGOKUqpvfHUkyU7IYQQ44IEJCGEEOOCBCQhhBDjgjxDEkKIcSAYDFJbW0t7e/tYD2XEnE4npaWl2O32Ed0vAUkIIcaB2tpaMjMzKSsrQyk11sMZNq01DQ0N1NbWUl5ePqI2ZMlOCCHGgfb2dnJzc4/JYASglCI3N/eoZngSkIQQYpw4VoNRl6MdvwQkMa5FOjrwrlxJx65dtAZbOdRyaKyHJIRIEglIYlyr//nPOfTde9h7y63c9rebuejpi3in7p2xHpYQx63Dhw9z4403MmXKFE466SROO+00nnnmmQH1zj333IQnCpCAJMYtHQzi/8tfsbpchOvrSX9/KxrNY9seG+uhCXFc0lpz1VVXcfbZZ1NdXc3atWtZuXIltbW1o9K/BCQxbrVt2kTY56PwnnvoyEhhcY2FG2fdyPsH36c12DrWwxPiuLNq1SocDge33357d9nkyZP5yle+QltbGytWrKCiooLrr7+etra2hPcv277FuNW2aTMAaYsXUV2WQkVtJ8GSM3h8x+Nsa9jGksIlYzxCIZLjnhe2su1AU0LbnFOcxXeumDtona1bt7J48eKo1371q1+RlpbGpk2b2LRpU8x6R0NmSGLcat+8CVtxEeS62ZTfhquhnbkpxvsNmz2bx3h0Qhz/7rjjDhYsWMDJJ5/MW2+9xac+9SkAKioqqKioSHh/MkMS41b7tu2kzp1Hjb+GPblhAFL3e8hLzaPaXz3GoxMieYaaySTL3Llz+ctf/tL9/QMPPIDH42HJkiWUlJQkfVu6zJDEuKRDITpra3GUl1Plq2J/vvEPoWPXLsqzy9nj3zPGIxTi+HP++efT3t7Or371q+6y1lbjee3ZZ5/Nn/70JwC2bNnCpk2bEt6/BCQxLgXr6iAUwjF5MrWBWjzZoFJT6aiqojzLCEha67EephDHFaUUzz77LG+++Sbl5eUsXbqUm266iXvvvZcvfvGLBAIBKioq+MlPfsLSpUsT3r8s2YlxqXOvcZ6Xo2wytc2bcKfm4pjoIlhbS3n26TR1NuHt8JLjzBnjkQpxfCkqKmLlypVRr8UqTxSZIYlxqXPvPgAckydTF6ijOL0Ye2kpwdpaSjNLATgQODCWQxRCJJgEJDEude7bhyUtDWtuLgcCByjJLMFeWkJnXR2FaYUAHGw5OMajFEIkkgQkMS6FDh3EXlJMREc40HKAkowSHKWl6NZWCjpSADgYkIAkxPFEniGJcSl46DC2ggnUt9UTioQoySjBXpoHgPOInzRbmsyQhDjOyAxJjEuhw4exFU6gvrUegIK0AuxFRea1IxSmF0rmbyGOMxKQxLijQyFCHg/2CRPwtHkAyE/Nx1ZQAEDoyBGK0otkhiTEcUYCkhh3Qh4PRCLdS3YAuam5WN1usNkIHZEZkhCJ1tDQwMKFC1m4cCGFhYWUlJR0f9/Z2ckzzzyDUoodO3YkbQwSkMS4Ezp8GABb4QQa2hoAIyApiwVbfj6h+nryUvPwdngJR8JjOVQhjhu5ubls2LCBDRs2cPvtt/O1r32t+3uHw8ETTzzBmWeemdR3kSQgiXEneMgISPYJxgzJneLGbrEDYCvIJ3TkCPmp+UR0hMb2xrEcqhAnhEAgwLvvvssjjzyS1IAku+zEuNMzQyrEc9BDXlpe9zV7QQGdNTXkpRplnjYP+Wn5YzJOIZLm5bvgUIIz2hfOh0t+PKJbn332WZYtW8aMGTPIyclh3bp1cvyEODGE6uvBbsfqcuFp85Dn7AlItvwCgkfqyU3NBeje9CCESJ4nnniCFStWALBixQqeeOKJpPST1BmSUmoZ8DPACjystf5xv+spwB+Ak4AG4HqtdY157W7gViAMfFVr/epgbSqlyoGVQA6wDvi01rpTKXU28FOgAlihtX66V/83Ad8yv/2+1vrRhP8QxLCFfV6srmyUUnjaPJRnl3dfsxUUEPH7ybVkARKQxHFqhDOZZGhoaGDVqlVs2bIFpRThcBilFD/5yU8SfhxF0mZISikr8ABwCTAHuEEpNadftVsBr9Z6GnA/cK957xxgBTAXWAb8UillHaLNe4H7tdbTAa/ZNsA+4Gbg8X7jywG+A5wCLAW+o5RyJ+bTi6MR9vmwuVxorfG0ebpnQwC2fGN5LjsQAaChvWFMxijEieLpp5/mM5/5DHv37qWmpob9+/dTXl7OO++8k/C+krlktxSo0lpXa607MWYvy/vVWQ50zUqeBi5QRshdDqzUWndorfcAVWZ7Uds07znfbAOzzasAtNY1WutNQKRf3xcDr2mtG7XWXuA1jOAnxljY68Oa7aKps4lgJEh+as8zImuukd3b7m8hw54hMyQhkuyJJ57g6quv7lN27bXX8vjjj8e4Y+SSuWRXAuzv9X0txmwkah2tdUgp5QdyzfL3+91bYn4drc1cwKe1DkWpP5zxDXWPGAVhvw9HWVn37Mft7Jm42nKMgBRqbCQvNa87k4MQInG++93vdn/9xhtvDLj+1a9+NSn9JnOGFG1xsf+JarHqJKp8MHHdo5S6TSm1Rim1pr5efvmNhpDPh9Xlwt/hB8Cd0hOQrGZACnt95KXmyQxJiONIMgNSLTCx1/elQP8DbLrrKKVsQDbQOMi9sco9gMtsI1ZfIxkfWuvfaK2XaK2X5OfL9uJk01oT9vmxulx4270AuJyu7utWlxGcwt5GCUhCHGeSGZA+AqYrpcqVUg6MTQrP96vzPHCT+fXHgVXaOJf6eWCFUirF3D03HfgwVpvmPa+bbWC2+dwQ43sVuEgp5TY3M1xklokxFGlphWCwzwzJldITkCzpaSiHg1BjIznOnO6gJYQ49iUtIJnPc76M8Ut+O/CU1nqrUup7SqkrzWqPALlKqSrgTuAu896twFPANuAV4A6tdThWm2Zb3wDuNNvKNdtGKXWyUqoWuA54UCm11eyjEfh/GEHuI+B7ZpkYQ2GfDwCry4Wvw/i6d0BSSmHNySHc6MXldNEcbCYYDo7JWIUQiZXU95C01i8BL/Ur+3avr9sxAkW0e38A/CCeNs3yaoxdeP3LP8JYjovWx2+B3w76IcSo6h2QvB17sVvspNnS+tSx5rgJNzaSk7IAAG+Hl4K0glEfqxAisSRTgxhXegckf4cfV4prwMt3NncOIa+3e/edLNsJcXyQXHZiXOkzQ9rr7bOhoYs1J4fOvXt7AlKHBCQhEsFqtTJ//vzu75999lnKyspGrX8JSGJc6TND2unv8/yoi9XtIuz1dm8HlxmSEImRmprKhg0bxqx/WbIT40p3QMrOxtfhixqQbDk5RFpacFnSAQlIQiRTTU0NZ511FosXL2bx4sWsXr06aX3JDEmMK2GfD0tmJspmixmQrG7j5diMlggKJUt24rhz74f3sqMxsSezzsqZxTeWfmPQOm1tbSxcuBCA8vJynnnmGQoKCnjttddwOp3s2rWLG264gTVr1iR0bF0kIIlxJWxmaYjoSPemhv6sOWbmBp+f7JRsmSEJkSDRluyCwSBf/vKX2bBhA1arlZ07dyatfwlIYlzpCkjNnc2EdTh6QMrKNuo2NeFKcUlAEsedoWYyo+n+++9nwoQJbNy4kUgkgtPpTFpf8gxJjCvhfnnsou6yc5kByd9kZGuQJTshksbv91NUVITFYuGPf/wj4XA4aX1JQBLjSldAipaloYs1yzicL+z34Xa6ZYYkRBJ96Utf4tFHH+XUU09l586dpKenJ60vWbIT40pcASnbmCFFmppwT3Sz4cjYbVMV4ngSCAQGlE2fPp1NmzZ1f/+jH/0oaf3LDEmMGzoYJBIIYHVlDxqQVGoq2O2E/X7cKW58HT4iuv/5i0KIY40EJDFuhP3Gc6OuTQ0AWY6sAfWUUlizswn7m3A73YR1uLu+EOLYJQFJjBu9szQ0dTYBkOHIiFrXCEh+yWcnxHFEApIYN3oHpEBngFRbKjZL9Mec1qwswk1+clKMl2Rlp50Qxz4JSGLc6B2QmjubyXRkxqzbNUPq2hbe2C5HWQlxrJOAJMaNroBkMwNStOdHXazZWUTM95AAfO2+URmjECJ5JCCJcaPPDCnYTIY9+vMjAEv/Z0iyZCfEUbNarSxcuJB58+Zx3XXX0draOqr9S0AS40bY50PZ7ai0tKGX7LKyiQQCOLSVNFuaLNkJkQBduey2bNmCw+Hg17/+9aj2LwFJjBsh86VYpRSBzkDMHXbQ83JsuLkZt9MtS3ZCJNhZZ51FVVUVAPfddx/z5s1j3rx5/PSnP01an5KpQYwbXVkagLieIXXd405x09ghMyRx/Dj0wx/SsT2xx0+kzJ5F4Te/GVfdUCjEyy+/zLJly1i7di2/+93v+OCDD9Bac8opp3DOOeewaNGihI4PZIYkxpGugKS1HvIZUp/0QZLPToiE6DoPacmSJUyaNIlbb72Vd955h6uvvpr09HQyMjK45pprePvtt5PSv8yQxLgR9vlIKZ9Ce7idUCQ06DMkS3eCVWNjQ5WvarSGKUTSxTuTSbRo5yFprUetf5khiXEj7PP3SRs0+HtIxtJe2N/Unc9OCJF4Z599Ns8++yytra20tLTwzDPPcNZZZyWlL5khiXFBa929ZBfoNDIODx6Qes2Qyty0hdpoC7WRaksdlfEKcaJYvHgxN998M0uXLgXgc5/7XFKeH4EEJDFORFpaIBTqk8du0ICUaVyLBJpxOwsAI59daoYEJCFGKtrxEwB33nknd955Z9L7lyU7MS70yWMXNP5RDLapQTkcKKeTcFMz7hR5OVaI40FSA5JSaplSqlIpVaWUuivK9RSl1JPm9Q+UUmW9rt1tllcqpS4eqk2lVLnZxi6zTcdgfSil7EqpR5VSm5VS25VSdyfvJyGGEvaaAck9+NETvVkyM4iY7yGBZPwW4liXtICklLICDwCXAHOAG5RSc/pVuxXwaq2nAfcD95r3zgFWAHOBZcAvlVLWIdq8F7hfaz0d8Jptx+wDuA5I0VrPB04CvtA7IIrR1T+xKsQ+eqKLNSOTcKC5O5+dBCQhjm3JnCEtBaq01tVa605gJbC8X53lwKPm108DFyillFm+UmvdobXeA1SZ7UVt07znfLMNzDavGqIPDaQrpWxAKtAJNCXu44vhiBaQBnuGBGDJyiTS1CwZv4U4TiQzIJUA+3t9X2uWRa2jtQ4BfiB3kHtjlecCPrON/n3F6uNpoAU4COwD/kdrLb/Rxkj/gGSz2HBanYPe0zVDyrRnYrPYZOu3EMe4ZAYkFaWs/xtWseokqnywPpYCYaAYKAe+rpSa0r+iUuo2pdQapdSa+vr6KE2JROgOSFlZBIIBMu2ZGBPZ2CyZmUSaAyilcKdItgYhjnXJDEi1wMRe35cCB2LVMZfOsoHGQe6NVe4BXGYb/fuK1ceNwCta66DW+gjwLrCk/4fQWv9Ga71Ea70kPz8/7g8vhifs82HJykLZbDR1Ng25XAfG1u9ws7HK6nK6ZMlOiKPUdfxE158f//jHo9p/Mt9D+giYrpQqB+owNinc2K/O88BNwHvAx4FVWmutlHoeeFwpdR/GDGY68CHGbGdAm+Y9r5ttrDTbfG6IPvYB5yulHgPSgFOB5KWxFYPqnVh1qEzfXbpmSAA5KTmyZCfEUYqWOmg0JW2GZD6v+TLwKrAdeEprvVUp9T2l1JVmtUeAXKVUFXAncJd571bgKWAb8Apwh9Y6HKtNs61vAHeabeWabcfsA2O3XgawBSN4/k5rvSkJPwoRh/6ZvuObIWWg29vRnZ2SYFWIJPH7/cycOZPKykoAbrjhBh566KGk9JXUTA1a65eAl/qVfbvX1+0Y26+j3fsD4AfxtGmWV2M8F+pfHrUPrXUgVt9i9IV9Pqy5xvbtQDBAXmrekPdYMoygFQ4EcDvdsmQnjhtvP7UTz/7oWRNGKm9iBmd9YsagdbqyfXe5++67uf766/nFL37BzTffzL/8y7/g9Xr5/Oc/n9CxdZHUQWJcCPt8OKYae0rifoaUZaYPOrQHt8NIORSMBLFb7EkdqxDHq1hLdhdeeCF//vOfueOOO9i4cWPS+peAJMaF/s+Q4glIFjOfXfjXF+OumAZ28Hf445pdCTGeDTWTGW2RSITt27eTmppKY2MjpaWlSelHctmJMac7O4m0tGB1uQhFQrSGWuPb1NBxCICIey5u7z5AsjUIkQz3338/s2fP5oknnuCWW24hGAwmpR+ZIYkxF/b7AfocPTFUHjsA655XjPuX3ok78Cdo3443cBDc05M3WCGOY/2fIS1btoxbbrmFhx9+mA8//JDMzEzOPvtsvv/973PPPfckvH8JSGLMdb0Ua3O58AfNPHaDZPo2bgphqXsDSCfSHsY971pY8328NW/AxLOTOl4hjlfhcDhq+fbt27u/vu+++5LWvyzZiTE3kjx2HFiHVRsvxYabm3CXnQeAd9/q5A1UCJFUEpDEmAv1PgspjtNiAah+A4s5v480B8hONY+gaNwNkej/lyeEGN8kIIkxN6IZ0t53UUXzsKSnEwk0Y7fYybI6aSQIB5O3LVWIZNK6f7rPY8vRjl8CkhhzfQJSMI6ApLURdEoWYcnMJNyVPig1D5/FAjVvJ33MQiSa0+mkoaHhmA1KWmsaGhpwOgfP0j8Y2dQgxlzY5zOOJE9N7Tmcb7BNDf5aaPNCYQXWzL1EzASr7rR8vM4DsOdtOONfRmPoQiRMaWkptbW1HMunCjidzqN6R0kCkhhzXS/FKqXiC0iHzJSDRQuwZL7RPUNypbioTUmF2g+NWdQQx1cIMZ7Y7XbKy8vHehhjSpbsxJgL+/x9Equm29OxWqyxbzi4CVAwYS6WzAwizUYQy3Hm4FNAux8aq5M/cCFEQklAEmNu2Jm+D22G3GngSMeamUXYDEhupxtvuN04mbFubXIHLYRIOAlIYsz1yWMXDAz9Umz9DiiYDdBnhuRKcRHSYZrtaVC3LqljFkIkngQkMeb6z5AGTRsUDoFvrzFDAqwZmYQDAbTW5DiN4yu8hXNkhiTEMUgCkhhTWmvC/r7PkAZNrOrbC5FQd0CyZGVCMIhub+8OSI3504yND+HkJIAUQiSHBCQxpiKBAIRC8T9Datht/J07FQBr1xEUzc3dx054XCUQaocj26M2IYQYnyQgiTHV+6VYgOZgM5n2QQJSY1dAMmdI5qmxkUDPKbP1aUZbHBx40JgQYvyKKyAppf6ilLpMKSUBTCRU2GucX2R1u9BaD304X0MVpGRDWq5xX9epsU1NuJ1urMqKRwGOTDggAUmIY0m8AeZXwI3ALqXUj5VSs5I4JnEC6T56wu2mLdRGWIeHXrLLndr90mvXDCncHMCiLOQ6c/G0e6B4IRxYn/TxCyESJ66ApLX+h9b6k8BioAZ4TSm1Win1WaWUPZkDFMe3nhmSuydLw2CbGhp2dy/XAVgzjbqRgHFvbmounjYPFC2Aw1tlY4MQx5C4l+CUUrnAzcDngPXAzzAC1GtJGZk4IYSiBKSYM6RQB/j3d29oALD02tQAkJ+WbwSk4kUQ7pCNDUIcQ+J9hvRX4G0gDbhCa32l1vpJrfVXgCHeYhQitrDXB1YrlsxMAkHzLKRYmxr8tYAG1+Tuoq5ddl0vx+al5vUEJJBlOyGOIfEmV31Ya/1S7wKlVIrWukNrvSQJ4xIniLDX251YtanTyNodc4bkrzX+zu7JJqzS0sBq7Z4h5aXm0dDeQDh7EtaULHOn3U3J/AhCiASJd8nu+1HK3kvkQMSJKez1YnX3vIME8QSkku4ipRSWjAwiZsbvvNQ8IjqCN+g3niPJTjshjhmDzpCUUoVACZCqlFoEdOXzz8JYvhPiqIS9Xmwu4/jxIY8vb6oz/s4q6VNszcggbJ6JlJ+aD4CnzUNe8UL44EEIdYLNkYTRCyESaagZ0sXA/wClwH3A/5p/7gS+OVTjSqllSqlKpVSVUuquKNdTlFJPmtc/UEqV9bp2t1leqZS6eKg2lVLlZhu7zDYdcfRRoZR6Tym1VSm1WSk18qMOxYiE/T6sbiMgDXlarL8W0gvAltKn2JKV1WeGBFDfWg9FCyHcCfWysUGIY8GgAUlr/ajW+jzgZq31eb3+XKm1/utg9yqlrMADwCXAHOAGpdScftVuBbxa62nA/cC95r1zgBXAXGAZ8EullHWINu8F7tdaTwe8ZtuD9WEDHgNu11rPBc4FZI/wKAt5ewWkzmbsFjsp1pTolf21fZbrulgzMvpsagBkY4MQx6BBA5JS6lPml2VKqTv7/xmi7aVAlda6WmvdCawElversxx41Pz6aeACpZQyy1eamyb2AFVme1HbNO8532wDs82rhujjImCT1nojgNa6QWsdHuIziQTSWndvaoA48tg11Q1YrgNj63c40HeG5GnzQM4UI6uDPEcS4pgw1JJduvl3BpAZ5c9gSoD9vb6vNcui1tFahwA/kDvIvbHKcwGf2Ub/vmL1MQPQSqlXlVLrlFL/McTnEQkWaW6GcLh7hjRo2iCtzRnSxAGXrJkZRJqMZ0hOm5NMe6YRkJSC4gWS006IY8Sgmxq01g+af98zgrZVlDIdZ51Y5dEC6GD1B+vDBpwJnAy0Av9USq3VWv+zzwCVug24DWDSpElRmhIj1TuPHUBTsCn2O0jtfugMRF2ys2Rmdc+QwMjWUN9Wb3xTtBA++LVsbBDiGBDvi7E/UUplKaXsSql/KqU8vZbzYqkFev/vbClwIFYd85lONtA4yL2xyj2Ay2yjf1+D9fGm1tqjtW4FXsLIPNGH1vo3WuslWusl+fn5Q3xkMRxdAcnW6xnScHfYgXlqrHlIH8CE9Akcbj1sXCw2NzYc2ZbYwQshEi7e95Au0lo3AZdj/CKfAfz7EPd8BEw3d785MDYpPN+vzvP0vLX4cWCVNn6rPA+sMHfIlQPTgQ9jtWne87rZBmabzw3Rx6tAhVIqzQxU5wDyW2sUhbqOnui1ZBczj133O0hRluwyMiESIdLSCkBhWiGHWg4ZF7s2NsiynRDjXrwBqSuB6qXAE1rrxqFuMJ/XfBnjF/924Cmt9Val1PeUUlea1R4BcpVSVRhbye8y790KPIURIF4B7tBah2O1abb1DeBOs61cs+3B+vBibGX/CNgArNNavxjnz0MkQNjbNyANenx5lJdiu1i6Eqya7yJNSJ+Ap81DKBICdzk4s2WnnRDHgHhTB72glNoBtAFfUkrlA+1D3WSmG3qpX9m3e33dDlwX494fAD+Ip02zvBpjF17/8sH6eAxj67cYA93PkMxddoFggAx7jBlSUx1YbJAxYcAla5YRxMLNzdiLiihMLySiI3jaPBSmF0rGBiGOEfEeP3EXcBqwRGsdBFoYuIVbiGEJe71gs2HJyCAYCdIWahv8pdjMYrBYB1zqfWosGEt2QN9lu8NbjWzhQohxK94ZEsBsjPeRet/zhwSPR5xAQt5GrG4jsWqgwwgmsZ8h1UVdroNeZyKZL8cWpvcLSKUnQyRoLNtNOjWBn0AIkUhxBSSl1B+BqRjPWrpeHtVIQBJHIexpwJZn7FzsSqwa8xlSUy2URE8sb8k0l+yaYgSkSacbf+99VwKSEONYvDOkJcAc3bWvVogECHk82HJzgSHy2EUixgxpzlUDrzHw1NgMewZptrSerd/puZA/G2rehbO+nuBPIYRIlHh32W0BCpM5EHHiCTU09ASkzp5gMkBLvbHk1uscpN56To01lv2UUhSm99r6DVB2Buz/AMKhaE0IIcaBeANSHrDNTLPzfNefZA5MHN+01oQ9Hmz5Ru65Qc9CajK3fEd5KRZApaSA3d79DAkYGJAmn25keji4MTEfQAiRcPEu2X03mYMQJ55IUxM6GMSaawSkrrOQoj5DinJSbG9KKayZmd1nIoERkHZ6d/ZUmnym8ffed6H0pKP/AEKIhIt32/ebQA1gN7/+CFiXxHGJ41yooQEAW56xZNd1fHnUXXZ+M21QjIAEZvqg5p58doVphTS0NRAMmyeKZE6A3Omw580EjF4IkQzx5rL7PMbRDQ+aRSXAs8kalDj+hTweAGx5PUt2CkW6PX1gZX8t2FIh1R2zPWtGJuFAz5LdhPQJaHTPxgaAaRdAzTsQbEvMhxBCJFS8z5DuAM4AmgC01ruAgmQNShz/wuYMydprU0OGIwOLivKfZFOtMTtS0RK3GyyZmUSaegJSUXoRAAdbDvZUmn4hhNqNoCSEGHfiDUgd5oF4QHfWbNkCLkYsVD9whhQ7j13PS7Faa7YdaGJNTSOdoUh3FWtmZve2b4DSDGN5r7a5tqedyWcaM61dryXyowghEiTeTQ1vKqW+CaQqpS4EvgS8kLxhieNdqKEBrNb4Tov118K0j+FvDXLH4+t4p8oIZiWuVH5x4yIWTXIbp8b2foaUUYhFWagL1PW0Y3dC+VlQJQFJiPEo3hnSXUA9sBn4AkZy028la1Di+Bdq8GDLyUFZjP8EmzqbogekUCcEDhPJKuG2P67hwz2NfOuy2fzixkVYLYpPP/IhW+r8xqmxvbZ92y12CtMK+wYkgGkXQmM1NOxO5scTQoxAXDMkrXVEKfUs8KzWuj7JYxIngLCnAau5XAdGpoaJGQPPOqL5IKBZ7XHywZ5G/ve6BVx7krEcd9JkN9f+cjV3PL6Ox1PTibS0oMNhlNVIwFqSWdJ3yQ5g+sfgZYxlu9ypSfp0QogySWKLAAAgAElEQVSRGHSGpAzfVUp5gB1ApVKqXin17cHuE2IowSOHsRf07IuJuWRnvoP0p+1hzpyWxzWLe16OLcpO5Wc3LGJ/Yytv1hk75yK9jjIvySgZOEPKmQJ5M6FSjr4SYrwZasnuXzF2152stc7VWucApwBnKKW+lvTRieNW6OAhbIU92agCnYEYWRqMgLKzPZtvLJuF6rfT7uSyHG5YOqk7IPV+jlSSUUJ9Wz3toX5Hd82+3Mhr1zrkOZNCiFE0VED6DHCD1npPV4F5EN6nzGtCDFuko4Ow14u90DhsLxwJEwhGD0gRnzFDKp40nfml2VHb+/pFMwmnGe8v9d5pV5JhzKYOtBzoe8Osy0GHofLlo/4sQojEGSog2bXWnv6F5nMke5T6QgwpdNh4WdVWaLwrFAgas5poAenQ/l34dDrXnzEzZns56Q7OP2kKADureoLPxEzjmVRdc79lu+JFkFUKO/428g8hhEi4oQJS5wivCRFT8KCR9LRrhjRYYlXfoRoOkcfHZg88ury3i0+ZBsAL7+3qLuuaIQ14jqQUzLoMdq+CzpaRfQghRMINFZAWKKWaovxpBuaPxgDF8Sd02AhItgnGM6RYAakzFMHaXEc4sxinfeDR5b1l5hrvM+3ec5iN+30A5KXmkWJNGbjTDoznSKF2qPrHUX0WIUTiDBqQtNZWrXVWlD+ZWmtZshMjEmuG1D9Tw7u7PUzQHrImlA/ZZteZSHmqk5/905glKaUozigeOEMC4xTZ1BzYLst2QowX8b4YK0TChA4fwpKdjSUtDYg9Q3p3aw0u1ULRpGlDtmnNMLKEn13kZNWOI2yp8wMxtn4DWG0w8xLY+arx8q0QYsxJQBKjLnjwUJ93kLqOnugfkHbu2gGAzR3lhdl+lMOBcjpZkGMjy2nj5+YsaWLmRPY370frKKkXZ10OHX6oeXukH0UIkUASkMSoC9buxz6xJ8hEO758X0MruuscpBgnxfZnyczA1tbKLWeW8/dth9l2oInJWZMJBAM0tDcMvGHqeWBPl912QowTEpDEqNJa07m/FkfvgBQcGJDe3FVPkTKDyCAH8/Vmzcgk3NzMZ08vJzPFxv+t2sXkrMkA7GvaN/AGe6pxRtKOlyASGXhdCDGqJCCJURU6Uo9ub8c+qe8MKcOegdXSs5PurZ31zEr1o1GQWRRX25asTCLNzWSn2fnsGWW8vOUQ4Q7jvKW9TXuj3zT7Cggcgro1I/9QQoiESGpAUkotU0pVKqWqlFJ3RbmeopR60rz+gVKqrNe1u83ySqXUxUO1qZQqN9vYZbbpGKoP8/okpVRAKfVvif8JiP6C+42ZimPSpO6y/nnsIhHNB9UNVGQGUJmFYHPE1XbvU2NvObOcdIeVJ1cHsClb7IA0/SKw2GG7nKYixFhLWkBSSlmBB4BLgDnADUqpOf2q3Qp4tdbTgPuBe8175wArgLnAMuCXSinrEG3eC9yvtZ4OeM22Y/bRy/0Y+Z/FKOjctx+g75Jdv4C080gzTe0hJlkb416uA/PUWDOXnSvNwa1nlvPSliPkOYtjB6RUF5SfbQSkaBsfhBCjJpkzpKVAlda62jxtdiWwvF+d5cCj5tdPAxcoI3vmcmCl1rrDzKNXZbYXtU3znvPNNjDbvGqIPlBKXQVUA1sT+LnFIDr37wOrFXtxcXdZ/4D0UY0XAHfoyLACkjUzg3BzU/f3t587laJsJ76mrNgBCYxlO+8eOLJtGJ9ECJFoyQxIJcD+Xt/XmmVR62itQ4AfyB3k3ljluYDPbKN/X1H7UEqlA98A7hnsQyilblNKrVFKramvl6OgjlZn9R7sJSUoR88yXP+AtKamkYIMB7bmumHOkLK6Z0gAaQ4b37psDk1NLvb49xLRMTYuzLoMULJsJ8QYS2ZAUlHK+q+JxKqTqPLB+rgHY4kvEOV6T0Wtf6O1XqK1XpKfnz9YVRGHjp07SZkxvU9Zc2dznywNa2q8nDfJggp3QPbQ7yB1sWZmoNvb0cFgd9ml8wuZkz+VkO7kn7t2Rr8xowAmnSpZG4QYY8kMSLVA798mpcCBWHWUUjYgG2gc5N5Y5R7AZbbRv69YfZwC/EQpVYNx7tM3lVJfHtlHFfGItLfTuXcvzhkz+pR37bIDqPO1Uedr48y8VuPiMAKSJcOYZYV7HdKnlOLLZ50KwDeef50aT4xkqrMuh8OboXFP9OtCiKRLZkD6CJhu7n5zYGxSeL5fneeBm8yvPw6s0sYr9c8DK8wdcuXAdODDWG2a97xutoHZ5nOD9aG1PktrXaa1LgN+CvxQa/2LRP4ARF8du3dDJEJKr4AU0ZE+ZyGtqTEOzVuQZQaVYS3ZGUEt0tTUp3xuvpF6KGw5zA0Pvc/mWv/Am2dfbvwtL8kKMWaSFpDM5zVfBl4FtgNPaa23KqW+p5S60qz2CMbznCrgTuAu896twFPANuAV4A6tdThWm2Zb3wDuNNvKNduO2YcYfR2VxpJZ74DU3NmMRncHpHV7vaQ5rJQM86VYAGuWsezX+9RYgIK0AlKsKVyyyI4Crv3Vav771R34WnvlsHOXQeF8eY4kxBiyDV1l5LTWLwEv9Sv7dq+v24HrYtz7A+AH8bRplldj7MLrXx6zj151vjvYdZEYbRs3YsnIwDF5cndZU4cxm3GlGMdHbKrzM684G2tznZHWJ9Udd/sWM8Fq71NjASzKwsTMiQQiB3nhK2fy/Re388Dru3n47T1csaCYG5ZOZPEkN2r2lfD6D6H5EGQWRutCCJFEkqlBjJq2dWtJXbgQZe3JyODvNJbPslOyCYYjbDvQREVpNvj3G7MjFW1PSnRW8wiKcL8lO4CyrDL2Nu0lNyOF+69fyMv/chbXnlTKy5sPcu2v3uOi+9/ihY5FgIYdLx7dBxVCjIgEJDEqwn4/HbuqSF28qE+5v6MnIFUeaqYjFKFiogv8tcNaroOeJbtIc/OAa+XZ5exv3k9n2Fimm12UxQ+vns8H//kx7r12PmkpNr6yqoM6SxGtm54bcL8QIvkkIIlR0bJ6NQDpS/uuqnYHJEc2m8zNBgtKs0cUkCzZxrJf2OcbcG2aaxphHaamqaZPeUaKjetPnsSzXzqdBz+9hNf0Uuz73mFtZc2ANoQQySUBSYyK5n+uwup2k7qo3wyp15Ld5jof2al2JmUqaKkf1pZvAEt6GtjthH0Dd9FNdU0FoNpXHfVepRQXzy3ksk/chl2F+fPjD3Uf8ieEGB0SkETShQMBAqtWkXH+eX2eHwH4OozZTFZKFhv3+6kozUY1HzQuDnOGpJTCmp0ddYZUll2GRVmo8lUN2kb+zNMJpxdysXUNtz+2Fn9rcND6QojEkYAkks739NNEWltxX3/9gGtNHU2k29MJhy1UHm7u2dAAww5IAFZXNmH/wJlNijWFiZkTqfZHnyF1s1iwzrmcc9QGfH4/33puy7DHIIQYGQlIIqk69+6l/uf/R9ppp5JaUTHgur/DT7Yjm60HmghHNBWlLvAdRUDKdkUNSABTs6cOOUMCYPYVWMLt/GhBPS9sPMDbu0aWw1BHJHu4EMOR1PeQxIlNB4PU/du/o+x2in/4w6h1/J1+4/lRrbHMtqDUBWtqQFlHGJCyCdbVRb021TWVN2vfJBgOYrfaYzcy+QxwurjUtob/zZ3Ofz27hVe/djYpNmvU6gFvO/u2NXJgp4/Ggy00edrobA+jIxqbw0JqpoPs/FTyJ2ZSOCWb0tluHE75pydEf/KvQiRN/S8eoH3zZkp++lPsRdFPffV3GAFpU62f/MwUJmSlgLfGCEaDBY0YrC4X7duiHyMx1TW1e6fddPf0qHWMRuww81KslS/y3eXf4eZHN/DkR/v5zGll3VUiEU31+nq2vFVH3U4vaEjNtJM/KZMJ5VmkpNqw2CwE20O0NnfiO9TKxtf3s/61fVhsiomzcph9RhFlFXlYrbJQIQRIQBJJ0rZ5Mw0PPUT2NdeQtezimPX8HX4K0wtZX+tjQWk2SikjILnLRtRvrE0N0LPTbrd/9+ABCYzcdhsf5xx7JUvLcvi/VVVcd9JEUh1W9mzy8N5fq/AeaiUrz8nSy8uZuqgAd1EaapAXecOhCIeq/dRs8lC19givPLiFtGwHiy+azNyzirE5os/AhDhRSEASCae15uB3voMtL48Jdw+eOtDf4SfNmkm1p4XlC80jrLw15hlFw2d1udDt7UTa27E4nX2ulWeXY1EWdvt2D93Q1PPBnoba8Te+ftF/cv1v3uexVbsprm6nZpMHd2EaF31uLlMXF2CxxJdNwmqzUDLDTckMN6ddM419WxvY8I99vPPnXax7dS9LryhnzhnFqDjbE+J4IwFJJFzLW2/RsW07RT/8YXc6n2giOoK/0097hxOtMXbYdTRDq+eoZkhgZIboH5BSrClMypzEzsYY5yL1Zk+FaR+DHS9yyqX/w6U52TQ/v59am5XTrpnKggsmHtVSm8WiKJufR9n8POp2evng+Wre+FMl21cf5JwbZpI/KfbPTYjjlSxei4RrfOxP2CZMIPvywWc5LcEWIjpCU4vx/0UVpS7wmkeN55SPqG+rqytbQ/SddrNzZrOjcUd8jc2+At18mPcee5e51Z34lCb3msksvmhyQp/7lMxwc/XXF/Oxm2fT5Gnj6R+vYe0rNURkl544wUhAEgkV8nppWb2a7Cuv7HNMeTRdaYPqm2yUulPJSXcYy3Uw8hmSy5whxXiONDt3NgdaDuBrj369t3D5x3it6WusWx1k9hlFfFBu45GNtRjHbyWWUoqZpxZx43dPZcqifN5/tprnf7aeFn9HwvsSYrySgCQSqvm11yAcJuuSZUPW7UobVNegjO3ekICAZM6Q/LEDEsD2xu2DttPZHuKFh/eyq+0sTs3/G+d9cia3njOV7QebeLeqYURji4cz3c5Fn5vL+Z+ZxeE9Tfz5R2uo3zcwWawQxyMJSCKhAm+9hb24mJTZs4es2z1D8lmZV2LMbPDWgDN7WOcg9db9DCnWDCnHGNe2huhbwwGCHWFefGATB3b5+Ng5Hk6yPoKq387yRcXkZaTwyDtDZHs4SkopZp9ezDX/fhJKwV//ey271x9Jap9CjAcSkETC6EiE1o/WkHbaqYNuf+7StWymw2nGhgY4qi3f0HdTQzTZKdmUZJTEnCEFO8O8+MtNHKzy8bHPzmbmFecCCra/QIrNyqdPnczrlfXsrg9EvT+R8idmct3dJ5M3MYNXf7OFbe8eSHqfQowlCUgiYTp27CDi95N+yilx1W9sbwQgEk5nXnFiApJKTUU5HERiBCSAOblz2N4wMCBFwhH+/vBW6nZ6ueDmOcw4uRAyCmDSqbDNOCPpk6dOwmG18Pt3a0Y8xuFIy3Jw5b8uYuKcHF7/4w42/nP/qPQrxFiQgCQSpuWDDwFIG1ZAsjDZlUt2mh3CIfDtPbqAZGb8DsVYsgNj2W5f877uJUMw3p16+8ld1GzycM6KGcw8pdcR5vOuhSPb4NAW8jJSWL6wmKfX1uJr7RzxOIfD7rBy6RcrmLo4n3f+vIv1r+0blX6FGG0SkETCtG/ejL24GPuECXHVb2xvRIXTqSjNMQp8eyHcCXkzjmocVpcr5jMkgIUFCwFYf2R9d9n6v+9jy1t1LL54EvPO6ZdDb+41YLHBppUA3HJmOW3BMCs/Gr3ZitVm4aJbjRdxV/+liq1vR8/XJ8SxTAKSSJj2nZWkzJoVd/1DAQ+hYBoVXRsaGsxM3EcbkNxuwt7YAWl+3nxsFhvrDq8DYNeaw7z3zG6mLyng1OVTB96QngvTL4LNT0MkzOyiLE6fmsujq2sIhiNHNdbhsFgtXHjLHCbNzeWNxyvZ+eGhUetbiNEgAUkkRKSjg849NaTMjD+YHGj2oMMZPTvsPGYGhdxpRzUWa24OYY8n5nWnzcn8vPmsPbKW+v3NrHp0O0XTsrngpjmx0/ZUXA/NB2HPmwDcckY5B/3tvLJldIOC1Wbhki/Mo3iai3/+fjv7dzSOav9CJJMEJJEQHVVVEA7jnBn/DKmhvREdymBeSZZR4NkJaXmQlnNUY7Hl5hFqHPwX9eKCxew+WMNLv95ESrqdZbfNx2of5J/DjGWQkg0bnwTg/FkFlOWm8dt39xzVWEfC5rBy6ZcqcBWm8cqDW2g82DLqYxAiGSQgiYTo2FEJMKwZUkvIR5bDRabTPGbCs+uol+sAbHm5RJqbiXTEznKwOH8x5+38FC2+Di75wnzSsgbPKoHdCXOXw/YXoLMFi0Xx2TPKWb/Px7p93qMe83ClpNq47EsVWG2KFx/YSFvz6GywECKZJCCJhOjYWYlKTcUxaVJc9TvDnYRpoygjr6fQsxPyhjgWIg7WHGOGFW4YJKPChwWU+mfSdtoeJpRnxddwxQoItsD2vwHw8ZNKyXTa+O07oz9LAsjKS+XSL1XQ4u/k5V9vJhwcvedZQiSDBCSREO2VO0mZPh1lje9Mn12egwCUuc0dea2N0NqQkIBkyzOCXKgh+rLdrjWH2fyPAzRO2c0/Up+OPzfdpNMgZwqs/R0A6Sk2Vpw8kZe3HOKAr+2oxz0SheXZXHDTbA7u9vPOn3eNyRiESJSkBiSl1DKlVKVSqkopNeBgHKVUilLqSfP6B0qpsl7X7jbLK5VSFw/VplKq3Gxjl9mmY7A+lFIXKqXWKqU2m3+fn7yfxPFNa03Hjh04h7Fct7bW2DI9e4J5kmz3hoYEBKTcXABCDQM3NjQcCLDqD9spnJLN9MuyqA3UsqcpzhmOxQJLboF978HhrQB85rQytNb84b29Rz3ukZq+ZAKLLpzElrfq2PHewTEbhxBHK2kBSSllBR4ALgHmADcopeb0q3Yr4NVaTwPuB+41750DrADmAsuAXyqlrEO0eS9wv9Z6OuA1247ZB+ABrtBazwduAv6YyM9/IgkdqSfs85EyjA0NGw8Y79HMLzQP5TN/wTOh/38iw2c1A1K43wypsz3EKw9uwe60sey2eZxbdg4Ar9W8Fn/jCz8J1hT46BEAJuaksWxeIU98uI/WztBRj32kTr1qCiUzXbzxeKUkYxXHrGTOkJYCVVrraq11J7ASWN6vznLgUfPrp4ELlJEEbTmwUmvdobXeA1SZ7UVt07znfLMNzDavGqwPrfV6rXVXcrCtgFMplZKwT38C6ag0zhcazgxpR73xf/LFmeYzpMNbjKSq2ROPejw28xlSqNczJK01q/6wA/+RVi6+dS7prhQK0wtZMmEJf6v+W/zLdmk5MO8a2PSkcZggxhZwf1uQv6wbu5dVLVYLF906D2e6nVd+s5n2luCYjUWIkUpmQCoBer/KXmuWRa2jtQ4BfiB3kHtjlecCPrON/n3F6qO3a4H1WusB27KUUrcppdYopdbU19cP8ZFPTO2VXTvsZsZVPxLR7PMb7+8UpBUYhYe2wIR5EEdS1qFY0tJQaWl9NjVsWlXL7nVHOPWqqZTM7MkkfuXUK6lpqmGzZ3P8HSy5FToDRlACTprspqI0m0feriY0ii/K9peW5WDZbfMIeDv4x++2oeWAP3GMSWZAivabpf+/kFh1ElU+5DiUUnMxlvG+EKUeWuvfaK2XaK2X5OfnR6tywuvYUYmtuAhrVny71arqA3Tiw2FJJd2eDpGIsWQ3YV7CxmTLze2eIR2o8rH6L1WUL8hj0UV9dwFeOPlCnFYnf9755/gbL10CxYth9S8gHEIpxZfPm0ZNQyt/XlubsM8wEoVTsjnj49PZu6WBDZKIVRxjkhmQaoHe6y+lQP/8+d11lFI2IBtoHOTeWOUewGW20b+vWH2glCoFngE+o7XePcLPecLr2Fk5rBdi1+31omxN5KWaAd67x9hOPWFuwsZkBCQPrU2dvPrQFjJznVxw85wBx2JkODJYPm05L1a/iKctdnaHPpSCs+40xr3tWQAunDOBkya7uf+1nbR1hhP2OUZi/rklTFmYz/vP7ObQnthZz4UYb5IZkD4Cppu73xwYmxSe71fneYwNBQAfB1ZpYzH/eWCFuUOuHJgOfBirTfOe1802MNt8brA+lFIu4EXgbq31uwn95CeQSEcHHdV7hvVC7Pp9PuyOZkoyzC3fXRsaChM3Q7Lm5hL0NPL3R7bQ2Rpi2Rfmk5Jqi1r3U7M/RTAS5MnKJ+PvYOZlkDcT3r4PtEYpxTeWzeJIcwcPvZ3cA/yGopTivE/PIt2Vwt8f2irPk8QxI2kByXxe82XgVWA78JTWeqtS6ntKqSvNao8AuUqpKuBO4C7z3q3AU8A24BXgDq11OFabZlvfAO4028o1247Zh9nONOC/lFIbzD8FSflhHMc6d+82UwbF9/wIYN0+L46UAAXp5o/78BZQFig4+h12XWwF+VTaFlJX6eOcG2eSV5oRs25Zdhnnlp7LkzuepC0U5/tEFosxSzqyFSpfAmBpeQ6Xzi/kF69XUeMZ23Q+XUeht/g6eP2xHfFv2hBiDCX1PSSt9Uta6xla66la6x+YZd/WWj9vft2utb5Oaz1Na71Ua13d694fmPfN1Fq/PFibZnm12cY0s82OwfrQWn9fa52utV7Y64+cEz1M7d0pg+JbsvO3Bdl1pJmw8lOQagakurWQPwvsqQkb1+GUqdRMOIc5pxUw67SiIevfPO9mvB1enqt6bsi63eZdaySC/cc9xllOwHeumEuK1cJ/Prt5zINA4ZRsTr1qKtXr69nyphxXIcY/ydQgjkpHZSXK6cQxOb6UQRv2+8DaSpgg+Wn5xoaG2o+g9OSEjclTG+D9/UVkNe3hlDPS4rpnccFiKvIr+P3W3xOKxPk+kdUOH/sueCphw2MATMhy8h+XzOLdqoYxfVm2y8KPTWTyvFzeeXqXvJ8kxj0JSOKotFdWDitl0Ed7GrHZjV+M+Wn50LAL2v0wcWlCxtPW3MlLv9xESoqF+Vt+g/bEN+lVSnHL3FuoC9Txj73/iL/DWZfDxFPg9R9CRwCATy6dxAWzCvj+i9vYuD/2uUyjQVkUF9w8m9QMB68+vIXO9rF7eVeIoUhAEiPWlTJoOBsa3qtuYEqhsQutILUA9hvHnlN69AEpHI7wym+20NrUyUXXFZPS2UTwYPznFZ036TzKssr47Zbfxr/cphRc9H0IHIa3fgKAxaL4308soCDTyRcfW8tB/9jkueuSmuHgolvn0lTfxht/qhzzpUQhYpGAJEasK2VQvFu+WztDbNzvY1KBseurIK0Aaj8Ep+uoD+XTWvP2k7s4sMvHeZ+eRdGiycYYD8cfkCzKws1zb2Z743Y+OPRB/J1PXAoLPwXvPQCHtwHgSnPw4KdPoqk9xKcf+ZDGlrE9HqJ4uoulV0xh10eH2b5a8t2J8UkCkhixjp3DOwNpTY2XUETjzgpgURYmpE+A/R8ZL5paju4/xfV/38fWt+pYfPEkZp5SiMXpxOp2D2uGBHD51MvJS83jt5t/O7wBXPg9SMmEF78O5gxkXkk2D9+0hP2NrXziwfeo9bYOr80EW7xsMqWz3Ly9ciee2sCYjkWIaCQgiRFr32HmsJsRX0B6r7oBm0WhbY0UphVib/VC/XaYfPpRjaPy/YO898xupp88gVOXT+0utxUWEjo0vICUYk3hk7M/yXsH32OXdxjHOaTnGhsc9q2GjSu7i0+dksvvP7uUw03tXP3L1XxQPcgZTUlmsSguvGUujjQbrzy4mY42eZ4kxhcJSGLEOrZvx15cjNXliqv++9UNLJjo4nDrAUoyS2DPW8aFKeeNeAz7tzWy6g87KJnp5oLPzEZZejIx2AsLCQ4zIAFcO/1abBYbz1Q9M7wbF33G2C34928Z5zuZTpuay1++eDppDis3PPQ+9722c8xy3qVlOVj2+Xk0N7Tzz99vk+dJYlyRgCRGrH37DlJmz46rbnN7kE21fk6dksOBwAGK04uh+nXj+VHRghH1f3C3n5ce3Iy7KJ1Lbp+P1d73P2d7URHBurph/9J1O92cN/E8/rb7bwTDw8hyYLHAZfdBWyO8/oM+l2ZMyOTFr57FVYtK+Pk/d3Htr1ZTdWRstmEXTXNx+rXT2LPRw/q/7xuTMQgRjQQkMSKR1lY6a2pwxhmQ3tnlIRzRnDY1iyNtRyjJKIHdb0D52WCJb8t4b4f2+Hnh/zaQnu3giq8uiJoWyDF5EpFAgLDXO+z2r552Nd4OL2/UvjG8G4sq4OTPw5rfwsGNfS5lpNi47xMLeeDGxexrbOWyn7/DI+/sITIGWbkrzi9l2kkFvP/sbuoqh//zESIZJCCJEWmvrAStcc6Ob4fdP3ccIctpozCnHYDSUBiaamH6RcPu+8jeJl74+UZSM+xc9bVFpGdHP8bKPtnYaddZM/wXVE8vPp2CtAKe2TXMZTuA874JqTnw0r8bL/72c1lFEa9+7WzOnJbH//vbNm546H32N47uhoeufHeuCWm8+vAWmhrGdmu6ECABSYxQR9eGhjhmSJGI5o3KI5wzs4CDrUYKm5IjO0FZYealw+q3bqeX5+5fT0qqjavuXEyG2xmzrqMrIO0dfkCyWqxcOfVKVh9YTX3rMM/BSnXBhffA/g+6z0zqryDTycM3LeEn11aw9UATy376Fis/3Deqz3QcThuX3D6fcEjz4gOb6JRNDmKMSUASI9K+bTuW7GxsRUPnidtc58cT6OSCWQXs8e8BoHzPe1B2hrE7LU7VG+p54ecbSXelcPW/LSYzJ3YwAnCUloLVSufemrj76O3KqVcS1mFerH5x+DcvuNHY4PDat41MFFEopfjEyRN55V/PoqLUxV1/3cytj67B3zZ62bndheksu20e3kOtvPrwViJjeMCgEBKQxIi0b92Kc87sAecLRfPatsNYFJwzI59qfzU5jizc9Tth9pVD3ttly5u1vPLgZnJLM7jm304aMhgBKLsde0nJiGZIAOXZ5VTkV/Dc7ueGP3OxWODS/4aWenj9R4NWLXWn8afPncJ3rpjD27vq+cSv3+OAb/SW0CbOzuHsFTPYt9krMbYAABeQSURBVLWBd5+ukp13YsxIQBLDFmltpb2yktSFC4esq7XmhU0HOG1qLu50B7t9u5mCHSy2uAJSOBThjT/t4M0ndjJpbi7L/3Uhzgx73GN1TJ48omdIXZZPXU6Vr4rtjduHf3PxIljyWfjwN3Bk8PstFsVnzyjn959dygFfG9f8cjWVh0ZvF968s0tYcP5ENr1ey7pXxz4prDgxSUASw9a2eQuEw6TFEZA21/nZ29DKlQuK0VpT7a9mqu8QzFgGmRMGvTfg7eC5n65n69sHWLxsMpd+qQKHM/ohe7GkzJhOZ1UVOjiyZbCLyy7GYXHw/O7+Z0vG6fz/MjI4vPwf3RkcBnPGtDyeuv00NJrrfr2atXtHbwfcGR+fxvSTJ/D+s9VsfmNsj2IXJyYJSGLY2tavByB1wdDvDz2/4QB2q2LZ3CI8bR6aOpsob2uGk24e9L7qDfU8+f0Pqd/XzIW3zuG0q6ZisQy9PNifc/YcdDBIR/XITnHNTsnm3Inn8lL1S8N7J6lLWg6c/y3jJeBt8Z21NLsoi6dvP52cdAefevgD3tw5zE0VI9SVGbysIo+3Vu5kx/uS806MLglIYtja1q/HMWXKkBkaOkJh/rq+jvNnFZCdZmdbg3G472x7zv9v78yjpKrOBP773qu9uqtXlu4GGpBNUCOyCC2ZOEbGLaMyYoIn44lLJpplkkn+MBDnzElMzkxijBMJKhKjowiucdQ4KnFXjCIgW4OssjdNA713V1fVq3fnj/caqrG76S56qZb7O+eed+u7+/LeV3d578JZl7QfJmrxzrKtvLp4E9kFAb7+s2mMmzY07by2bktv+TSNKTeXa8ZcQ02shvcPvp9eBFNvgSHnOl9wiHdte/fw/BDP3l7GqMIw335sNX/ZUJFe2t3ENA0u+5dJlIzP483HPmXz+/pgP03foRWSpluoRILmNWsITZ16Sr+vlVdS3RTnmxc626837XwFUykmTPvu516GVUqxc20Vy3/+EVtWVjB59giuu2MKeUPDp5Vf38iRSCBA7DQUUllxGQWBgvSn7QwTrrwb6vbDyv/ucrBB2X6eum0Gk4fn8cOn1vHER32ztuPxmnzt++dROqmAd5Zt45O/6jUlTd+gFZKmW0TXr8duaiI866JT+l364V5KC0LMGlMISlG+7x3GWIrQlJvb+DtW0cjLizay4o/lhCI+5s6fStl1YzA9p989xTQJTJhAdMPGtOPwGB6uGn0V7x54l9qWNA/cKy2Dc6+HD+6D6t1dDhYJeHn81ulcMn4w//5COYve2tEnu+A8PpMrbj+XMVMG8+Hzu3jvyW0k9ZZwTS+jFZKmWzSu/ABMk/DMmZ36+3DXMdbsreGmspEYhpDc/hobk02cU3gOeIMANFS38Objn/L0Lz+m8rM6Lpo7huvnT2VwaaRH8xyaNo1oeTl2c/pfQ7j6rKuxbItXdr+SfkZm3+XsLlzxsy5tcGgl4DVZfOMU5kwu4Z6/bufOF8ppSSTTz0cXMT0Gs2+dxOTZI9j07kH+snA90cb+PddJ88VGKyRNt2h8602Ck8/HzM7u1N99b25nULafG6aPACtG+RsLaDANZpx7IzWVTby19FOe+I8P2f5xJed9dTg3/nIm5186AsPs+S4ZuvBCsCyaP1mXdhzj88czIX8CL+7q2saEdokUw8U/hW2vwKZnuxXUaxr87vovcdtXRrN81T7+8Q8r2Xig949HNwyh7LoxXHrT2VTuqufpX61m/5bqUwfUaNJAKyRNl2nZtp3Yjp1ErriiU3+vbznMR59V892vnEXAa8Lb/8kH8WpK6sYRX1HE8l+sYvvHh5lYVsw3fzGDWXPHduvdou4SumAyeL00ffDBacUzZ8wcthzbwrqq9BUbM38AI2Y6B/nVdG9txjCEBVeczeO3TKc2muDqRR/w46fX98n7SuNnFHHdHVPwBUxeWrie957ars9T0vQ4ot/K7jpTp05Va9as6e9s9BtV99zDsUf/h7HvvYunoP1P/jTHLWbf+x5hv8n//fDLxLd8wNbHHuVt6wqCLQX4Qx7OvXgY5148jFDE12d533/b7bTs2M6YN95A0jydNmpFufzPlzMhfwIPzX4o/czU7IXFsyCvFG5+1XlPqZvUtyR48J1dPLJyNzHLZtrIPC6bNJS/nzCY0YXhLn1BIx2seJIPX9jFxrcPEMzycuHVozn7ouK0tuT3B0opbEuRtGwMUzA8xoDJ+0BGRNYqpU65E0orpG5wJisku6mJHZd8lfD06Qz7w8J2/Sil+MkzG3jjk4P859QxWLuOUrEnChgcjOxg3MxB/PNV1+Dxdf+4idOl7qWXqLjjp5Q+sbRLOwQ74tHyR7l37b08ctkjTBs6Lf0M7XgDln/dOX5j3jLwpbebsLopzrNr9vPc2gPsqHKOJc8LeTl3WC5fGpbDpOIczimJUJIb7FElVbW3npXP7uDQzjpyBgU5f/YIJswY2i9tC07fa6qNU3u4idqqKPVHojTXx2muj9FUFyfaECcRt0nGk59bvhMBj98kmOUlkOUjmO0lnOMnUhggUhgkZ1CQSGGQQLj3RvFfdLRC6gXOZIV0dMkfOXLvvZQuX+5MgaWQTNhU7q7jhdd2UbGtluKkMwLJ9x/irODHvDIzi5cbVvD63NfJC+T1R/aPK9TQ1KkMv39R2vFErShzXpyD1/Dy3NXP4TfbP/qiS6xbBi/9AIrOh7l/gvzR6ccF7K9u5v0dR9mwv5YNB2rZUdVI0j1rKTfkZVJxhHOKc5hYHOGckhxGFYRPa3SglOKz9Uf45LW9VO1twB/2MGbKEMZNH8LQ0Tm9MvKIt1jUHm6mtqqZ2spmag83U3O4mdqqKFbsxEYPwyOEIj7COX5CER/BiA+v38TrMzG9BqbHQNnOSMlOKuItFi2NCaKNCaINcZpqY0Qb2r4IHcz2kl+cRX5xmILi8HF7e2dxadqSEQpJRC4H7gNM4GGl1K9PcvcDjwNTgGPAN5RSe1y3BcCtQBL4oVJqRWdxisgo4CkgH/gEuFEpFU8njY44UxVSfO9ePrt2DuGyMobfv4jm+jhVe+o5vKeew7vrOLSrDituY6OIRTx8ZbLJmD13kie72X7NfXx99S+YN2Ee86fP79dyHFl0P0cXLaJ02ROEpkxJO56/VfyN216/jWvHXMtdZXed3shj6yvw/HfATjjbws++GgrHgi8LrBaINTjGToCddP7OhwogPNi5djL9GI0n2VpZT3lFPVsq6ig/WM+2ygbi7vbtsM9kQlGEiUURzi6KMLE4wvgh2QS7OcpRSnFwey1bVlawe/0RrISNP+ShZFweQ8/KoaAkTH5RFuFc3ynryrbVcYXQWBOj/miUmsPN1LmKp7kuZZefQHZ+gLwhIXJPMlm5/jbH2adDvMWi/mgL9Uej1FVFqals4lhFE9WHmtoov6w8P3lFYfKHhskrCh239+a66ECj3xWSiJjAdmA2cABYDdyglNqS4ud7wHlKqdtFZB4wRyn1DRGZCDwJTAeKgTeAcW6wduMUkWeA55VST4nIYmCDUurB7qahlOpwP+2ZpJBsWxGtj3Ns6wE++90faUiGUGWXUVNt0VgdA5xnY6AwwHY7zpqWKBdPCfOz/BUYqx6EnBKq/2kxN39yN7WxWl645oV+Gx21kmxsYve116LsJCOXLsVbUpJ2XA+uf5AHNjzA3HFzWTB9AT7zNNbD6ivgnV87O+8S3diabnggu9jZvZdqfFnOy7hiOH48fvCGwBskHhzMrlgum6pibD5Yx5ZD9Xx6qIHGmLNBQQQKs/wU5QQYEgmQ7ffg9xr4PSYeQzANwTAEU05cTcPZcGGI4FMQPpZADrfQuK+RaO0JBWIYQjDbSyDLgykWhijEMEhYBok4xGNJYo2Jz52gGwh7yR0SPKFwBjvXnMFBPN6+nyJUtqKhuoVqVzkdq2ik5lAzNZVNWPET72oFs73kDQ2TXxQmMihIdn6A7IIA2fkBgtneXlvny0QyQSHNBH6ulLrM/b0AQCn1Xyl+Vrh+PhQRD1AJDALmp/pt9ecG+1ycwK+BI8BQpZSVmnZ301BKfdhRmQaSQlLKmY5IJmyshHNNWo490ZIk1pwg1mwRa7Zoce3RhjiN1TEaa1toro23eTCYJkSGhvHn+4lHPBwQi9UH9xCt3c9FwX3cOGQPJVXvoGyLinOvY+W4WSzZspT6eD0PXPrA6a239CDRzZvZd9PNiM/H8CUPEZw0Ka14lFIsXLeQhzc9zPDs4dww4QZmFM1gZM5IvEaa/4zjTVCxDmr2QCLqKBJ/NviyweNzFIyyoemoc6xFQ6WjzOoPutcKsLp4bEV4MOSNhLyRqLxSqn0l7EwMorw5l91NPvY3KCrrYzTFLWKWTUsiSdJWJG2FrRS24vh0YEqtkEWUQVJHIXUMkRqG0cAwMcix/fiTJlgeEskgtvJgY6Aw8EoMj2nhC3gIhL1k5fkJF0bIGlJIZMQwAkNKnHowM3vE0aqoaiqbqT7URE1lEzWHmqipbCbW3HZHosdrkJUfcKYTs7wEsrwEs30Ewo7d6zfbNabXcDZjmANrM0ZXFVJvTn6WAPtTfh8ALuzIj6tI6oACV/7RSWFb/862F2cBUKuUstrxn04aPUr91o28/OAWdzFVcG5j96oEy72xFW4HU+Lapa08JSyqPTcnjK1MbLp383qlCb/RQMisptCoJhSoRm1rJMxRho7ZQyTnCIZlQxVIFYRowSM2sQBcX1TEG6aHaOlwmrGxGlbB2lVMKpjEwq8uZFJBeg/93iA4aRIjly+j6r778JWOTDseEeFHF/yIaUOnsfCThdy9+u7jblneLLJ8WXgNL6aYLJm9hKKsUx9kiC8MI2c5Jh2UgmiNM8pStjPFZyedqb9EFOKNjhKr2w+1+6B2L+z/CCl/jgJlU0DKDSqGowS8IfCaEBJn+CSGYwCSCZQVg2TcMVYMaWeCIWpkccQcxEG7gD2JPPYlC6hQ+Vh4CEqMXBopkaOUGkcoTByhpOoIoaoW2NI2nhg+miWIhQcbOa7QbAxskZR74VT07IO8MMtH2OdBgIhrSlsdQ6BGQcwO0hDPpSGRR0Mil4Z4Ho3RHKINWVT7h9NihWhpTHTnfWkQd2Rqint1lJUYQpvBl4C0ltltxhNucqI2hDajtpMHcCPOKWDW3LHdyGD36U2F1F6rn1zdHfnpSN7ehHln/tNJo20GRb4DfAdgxIgR7QQ5NabfT35O8wl1kpKyCNQ0x3B0kntLyXG143o6kS1p45AiT/UjSQzDxhALERvDSCKGjSFJxxgWHk8c04zjMeKYZuL4M+Z45CIwzAJ/AYcp4KhpEPCaBLwmkYCXUG4e5BThzRrM2IrXCAUHEfQGCXqCDMsexnmF5zEub1xGTkv4x45l+KL0NzakUlZcRllxGXvr97Lp6Cb21e+jId5AQ7wBS1kk7eTpTed1BxHn6+Lkdy+cFXeUVM0eR1G11J1Yu0o0O4pO2Y6h1a7A40dMH5g+Z/Ti8UMgF7KGQNZg55ozjGAgwghgBDBDKeqiCSpqWzhUF6UumqAxZtEYs1gbs3gvliSZtAlYNUSiFeTGKsiyqvEmm/AnmwjYzZjKcv9+2RjKUU2CwlB992mj1AdFdn6YcKjjNhYg4JpBKKDGNS5fugHGfxnbVsSbLaKNcay4TSJmkYjZJGLJ48ZKJFG2wk6mGFthJ+3jdpVUJ/KnlNNkKRk/7qpO+mCIUm39nfQ0zM479aGYp0tvKqQDwPCU38OAkz9Z3OrngDudlgNUnyJse/KjQK6IeNxRUqr/dNI4jlJqCbAEnCm7U5a6HcKjxnP5XePTCZrxGMDvJl3b39nod0ojpZRGSk/tMRPx+KDgLMf0MiJCbshHbsjHxOKe/UTUQMcwhIA7fXem0ptfalgNjBWRUSLiA+YBJ38u+SXgW659LvCWcha1XgLmiYjf3T03Fvi4ozjdMG+7ceDG+WKaaWg0Go2mH+i1EZK7XvMDYAXOFu1HlFKbReQuYI1S6iXgT8BSEdmJM2qZ54bd7O6a2wJYwPdbd7+1F6eb5E+Bp0TkV8A6N27SSUOj0Wg0fY9+MbYbDKRddhqNRpMpdHWXnf64qkaj0WgyAq2QNBqNRpMRaIWk0Wg0moxAKySNRqPRZARaIWk0Go0mI9C77LqBiBwBunrMZyHOC7sDGV2G/meg5x90GTKF/ixDqVJq0Kk8aYXUS4jImq5sc8xkdBn6n4Gef9BlyBQGQhn0lJ1Go9FoMgKtkDQajUaTEWiF1Hss6e8M9AC6DP3PQM8/6DJkChlfBr2GpNFoNJqMQI+QNBqNRpMRaIXUCSLyWxHZKiIbReR/RSQ3xW2BiOwUkW0iclmK/HJXtlNE5qfIR4nIKhHZISJPu8dn4B5/8bTrf5WIjDxVGr1NR2XoS0RkuIi8LSKfishmEfmRK88XkdfdenxdRPJcuYjIQjfPG0XkgpS4vuX63yEi30qRTxGRTW6YheKeJthRGmmWwxSRdSLysvu7x/pBd/tamvnPFZHn3PvgUxGZOQDb4MduHyoXkSdFJJDp7SAij4hIlYiUp8j6rd47S6NHUUpp04EB/gHwuPbfAL9x7ROBDYAfGAXswjkOw3TtowGf62eiG+YZYJ5rXwx817V/D1js2ucBT3eWRh+UucMy9HHdFwEXuPZsYLtbJ3cD8135/JQ2uRJ4FeeAzhnAKleeD3zmXvNce57r9jEw0w3zKnCFK283jTTL8RNgOfByT/aDdPpamvl/DPi2a/cBuQOpDYASYDcQTKmbmzK9HYC/Ay4AylNk/VbvHaXR4/d9b0T6RTTAHGCZa18ALEhxW+E27kxgRYp8gWsE54W0VuV23F9rWNfucf1JR2n0QTnbLUMG1P+LwGxgG1DkyoqAba79IeCGFP/bXPcbgIdS5A+5siJga4r8uL+O0kgjz8OAN4FLgJd7sh+k09fSyH8E52EuJ8kHUhuUAPtxHsoetx0uGwjtAIykrULqt3rvKI2evs/1lF3XuQXnHwKc6OStHHBlHckLgFrlHK+eKm8Tl+te5/rvKK7epr/S7RB32mQysAoYopQ6BOBeB7veutsmJa79ZDmdpNFdfg/cAdju757sB+n0te4yGjgCPCrOtOPDIhJmALWBUuogcA+wDziEU69rGVjt0Ep/1nufPBfOeIUkIm+4c8snm2tS/NyJc6rsslZRO1GpNOTpxNXb9Fe67SIiWcCfgX9TStV35rUdWbptctqIyNeAKqXU2lRxJ2n2VP57slwenGmjB5VSk4EmnGmcjsioNgBw10CuwZlmKwbCwBWdpJuJ7XAq+iJvfVKeM14hKaUuVUqd0455EZxFQeBrwDeVO1bF+XcwPCWaYUBFJ/KjQK6IeE6St4nLdc/BOWq9o7h6m/5K93OIiBdHGS1TSj3vig+LSJHrXgRUufLutskB136yvLM0usNFwNUisgd4Cmfa7vf0XD9Ip691lwPAAaXUKvf3czgKaqC0AcClwG6l1BGlVAJ4HihjYLVDK/1Z733zXOjpOcAvkgEuB7YAg06ST6LtAudnOIubHtc+ihMLnJPcMM/SdoHze679+7RdRH2mszT6oMwdlqGP616Ax4HfnyT/LW0XXe927VfRdtH1Y1eej7MOkuea3UC+67ba9du6sHtlZ2mcRlku5sSmhh7pB+n0tTTz/j4w3rX/3K2bAdMGwIXAZiDkpvEY8K8DoR34/BpSv9V7R2n0+H3fG5F+UQywE2fedL1rFqe43Ymzu2Yb7g4VV34lzo6wXcCdKfLRODtbdrod1e/KA+7vna776FOl0QflbrcMfVz3s3CmBDam1P+VOHPzbwI73GvrDSbA/W6eNwFTU+K6xa3fncDNKfKpQLkbZhEnXhRvN43TKMvFnFBIPdYPutvX0sz7+cAatx1ewHmwDag2AH4BbHXTWYqjVDK6HYAncda8Ejijk1v7s947S6Mnjf5Sg0aj0WgygjN+DUmj0Wg0mYFWSBqNRqPJCLRC0mg0Gk1GoBWSRqPRaDICrZA0Go1GkxFohaTRaDSajEArJI1Go9FkBFohaTQajSYj+H8664Hq+eNc8wAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "automate_plot(X_train, 'FireplaceQu', 'SalePrice')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "automate_plot(X_train, 'FireplaceQu_imputed', 'SalePrice')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For BsmtQual, where the NA are low, the distribution of the target is preserved for the categories in the original and imputed variable. However, for FireplaceQu, which contains more NAs, the distribution of the target per category is affected slightly.\n",
    "\n",
    "## Note on Random Sample Imputation code\n",
    "\n",
    "The code provided in this notebook for random sampling, is a bit complex. Don't worry! You can do random sample imputation using the package feature engine in just a couple of lines. I will show you how in a coming notebok\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  },
  "toc": {
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": "block",
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}