GroupStratifiedShuffleSplitBinary.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "outputs": [],
   "source": [
    "#!pip install tabulate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tabulate import tabulate\n",
    "import numpy as np\n",
    "from time import time\n",
    "from numpy.random import choice\n",
    "import pandas as pd\n",
    "from collections import Counter\n",
    "from datetime import datetime\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.patches as patches\n",
    "import matplotlib.gridspec as gridspec\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.model_selection import StratifiedShuffleSplit, GroupShuffleSplit, ShuffleSplit, RandomizedSearchCV, KFold, StratifiedKFold, GroupKFold\n",
    "from scipy.stats import randint as sp_randint\n",
    "from sklearn.metrics import confusion_matrix, average_precision_score, f1_score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [],
   "source": [
    "class GroupStratifiedShuffleSplitBinary:\n",
    "    \"\"\" A cross-validator (CV) object akin to sklearn's native GroupShuffleSplit or \n",
    "        StratifiedShuffleSplit where both groups AND stratification (currently only \n",
    "        with binary classification) are taken into account.\n",
    "        \n",
    "        target_var : the dataframe column which is the target to stratify by, \n",
    "        group_var  : the dataframe column which specifies the groups kept seperate\n",
    "                     in training and test splits, \n",
    "        frac_train : fraction to put as CV train set (frac_test = 1 - frac_train)\n",
    "        verbose    : provide textual feedback to user\n",
    "        beta       : (see below) \n",
    "        max_evals  : (see below)\n",
    "        n_splits   : number of splits to perform\n",
    "        \n",
    "        GroupStratifiedShuffleSplitBinary is initialized with group and target info,\n",
    "        using this we create a 'group_table' which has the format:\n",
    "        \n",
    "                                n_target | n_entries | ratio <-------- i.e. imbalance of group\n",
    "                             ===================================\n",
    "            group_id (index)|            |           | \n",
    "                            |            |           |\n",
    "                            |            |           |\n",
    "\n",
    "        The subsequent .split method then creates a training and test set\n",
    "        by randomly sampling groups from group_table with the goal that:\n",
    "\n",
    "                (i)  the number of entries in train/test are approx equal to \n",
    "                     those defined by the specified train fraction 'frac_train'\n",
    "                (ii) the ratio n_target/n_entries in train (and therefore test)\n",
    "                     is approx equal to that ratio for the entire dataset\n",
    "\n",
    "        Sampling from group_table continues until frac_train has been approx reached \n",
    "        (from below) OR until it has performed max_evals samples.\n",
    "            \n",
    "        Specifically, the train subset is formed by sampling from the group_table in\n",
    "        such a way that the probability of choosing a given group is related to the \n",
    "        difference Delta, where \n",
    "            \n",
    "            Delta := -([ratio-curr_train_imbalance] x sgn(curr_train_imbalance-data_set_imbalance))\n",
    "        \n",
    "        that is, when the current (partially filled) training set has a group \n",
    "        imbalance greater than that of the actual dataset we're sampling from, \n",
    "        groups with imbalance less than the current train imbalance are \n",
    "        preferentially selected (and vice versa). Concretely, the probabilty\n",
    "        of next selecting group i to add to our training set is:\n",
    "        \n",
    "            P(i) = softmax(Delta(i) x beta)\n",
    "        \n",
    "        By sampling from the group_table we are guaranteed to have the desired\n",
    "        property that groups are never mixed between train and test. However, we\n",
    "        can't simply draw groups randomly, because we want a train set with the \n",
    "        same imbalance as the overall data set. This probabalistic method of \n",
    "        choosing means that the partial training set's imbalance oscillates, \n",
    "        hopefully converging on the desired (i.e. data set) imbalance.\n",
    "        \n",
    "        This can have the downside that groups with extreme values of imbalance\n",
    "        (high or low) are preferentially chosen. It is therefore necessary to\n",
    "        modify the parameter beta to find a satisfactory balance between groups\n",
    "        being uniformly selected, and the training set being stratified (e.g.\n",
    "        by using the method test_make_one_group_stratified_shuffle_split).\n",
    "        \n",
    "        The fact that GroupStratifiedShuffleSplitBinary is initialized with \n",
    "        all required info makes it a bit different from the usual sklearn\n",
    "        cross-validators. The result is that the split method returns train-test\n",
    "        indeces even without input. But of course when called through an sklearn\n",
    "        method e.g. RandomSearchCV().fit(X,y), the X and y must match to the data\n",
    "        passed in to initialize GroupStratifiedShuffleSplitBinary.\n",
    "        \n",
    "    \"\"\"\n",
    "    \n",
    "    def __init__(self, target_var, group_var, frac_train = 0.8, verbose = False, \n",
    "                 beta=100, max_evals = 1e6, n_splits = 3):\n",
    "        \"\"\" target_var is the dataframe coloum which is the target, group_var is the \n",
    "            dataframe column which specifies the group, n_splits is number of splits to perform\n",
    "        \"\"\"\n",
    "        \n",
    "        self.target_var = target_var \n",
    "        self.group_var = group_var\n",
    "        self.frac_train = frac_train\n",
    "        self.n_splits = n_splits\n",
    "        self.verbose = verbose\n",
    "        self.beta = beta\n",
    "        self.max_evals = max_evals\n",
    "        # we'll often want to know the data set imbalance\n",
    "        self.data_set_imbalance = np.sum(self.target_var==1)/len(self.target_var)\n",
    "        if self.verbose:\n",
    "            print('Created GroupStratifiedShuffleSplit object for stratified splitting of binary class data with groups.')\n",
    "            print('Total df entries = {}, total groups = {}, N(y=0)/(N(y=0)+N(y=1)) = {:.4f}'.format(\n",
    "                len(self.target_var),\n",
    "                len(self.group_var.unique()),\n",
    "                self.data_set_imbalance\n",
    "            ))\n",
    "        # make the group table we'll use for sampling\n",
    "        self.make_group_table()\n",
    "        # train_groups and test groups are lists of group labels for train and test\n",
    "        self.train_groups = []\n",
    "        self.test_groups = []\n",
    "    \n",
    "    def __iter__(self):\n",
    "        return self\n",
    "    \n",
    "    def __next__(self):\n",
    "        result = self.split()\n",
    "        return result\n",
    "    \n",
    "    def make_group_table(self):\n",
    "        \"\"\" make a pandas table with info on each group which will be used later\n",
    "        \"\"\"\n",
    "        \n",
    "        self.group_table = pd.DataFrame({'group_id':self.group_var,\n",
    "             'flag':self.target_var}).groupby('group_id').agg(['sum', 'count'])\n",
    "        self.group_table.columns = self.group_table.columns.droplevel()\n",
    "        self.group_table.rename(columns={'sum':'n_target', 'count':'n_entries'}, inplace=True)\n",
    "        self.group_table['ratio'] = self.group_table['n_target']/self.group_table['n_entries']\n",
    "        # make a numpy version with columns [ group_id | n_target | n_entries | ratio ]\n",
    "        self.group_numpyarray = self.group_table.reset_index().values\n",
    "        if self.verbose:\n",
    "            print('Generated group_table')\n",
    "        \n",
    "    def make_one_group_stratified_shuffle_split(self):\n",
    "        \"\"\" Given a numpy 'group_numpyarray' which has columns:\n",
    "            [ group_id | n_target | n_entries | ratio ], make a \n",
    "            train test split in the manner described in the docstring\n",
    "                                \n",
    "        \"\"\"\n",
    "\n",
    "        # choose group at random to kick things off\n",
    "        train_groups = [choice(self.group_numpyarray[:,0])]\n",
    "        curr_train_frac = np.sum(self.group_numpyarray[np.isin(self.group_numpyarray[:,0],train_groups),2])/np.sum(self.group_numpyarray[:,2])\n",
    "        curr_train_imbalance = np.sum(self.group_numpyarray[np.isin(self.group_numpyarray[:,0],train_groups),1])/np.sum(self.group_numpyarray[np.isin(self.group_numpyarray[:,0],train_groups),2])\n",
    "\n",
    "        iterator = 0\n",
    "        while (curr_train_frac < self.frac_train) & (iterator<=self.max_evals): # \n",
    "\n",
    "            if self.verbose:\n",
    "                print('(Step {}) Train fraction = {:.4f}, Train imbalance = {:.4f} (full set = {:.4f})'.format(iterator,\n",
    "                                                                                                           curr_train_frac, \n",
    "                                                                                                           curr_train_imbalance, \n",
    "                                                                                                           self.data_set_imbalance))\n",
    "            # calculate preference for choosing next customer (boltz dist)\n",
    "            next_choice_vec = -1.0*(self.group_numpyarray[~np.isin(self.group_numpyarray[:,0], train_groups), 3]-curr_train_imbalance)*np.sign(curr_train_imbalance-self.data_set_imbalance)\n",
    "            next_choice_vec = np.array(next_choice_vec, dtype=np.float64)\n",
    "            boltz_prob = np.exp(next_choice_vec*self.beta)/np.sum(np.exp(next_choice_vec*self.beta))\n",
    "            # now make choice\n",
    "            train_groups = np.append(train_groups, choice(self.group_numpyarray[~np.isin(self.group_numpyarray[:,0], train_groups), 0], p = boltz_prob))\n",
    "            # calculate updated properties\n",
    "            curr_train_frac = np.sum(self.group_numpyarray[np.isin(self.group_numpyarray[:,0],train_groups),2])/np.sum(self.group_numpyarray[:,2])\n",
    "            curr_train_imbalance = np.sum(self.group_numpyarray[np.isin(self.group_numpyarray[:,0],train_groups),1])/np.sum(self.group_numpyarray[np.isin(self.group_numpyarray[:,0],train_groups),2])\n",
    "            iterator = iterator +1 \n",
    "\n",
    "        # test set is then anything not in train set\n",
    "        test_groups = self.group_numpyarray[~np.isin(self.group_numpyarray[:,0], train_groups), 0]\n",
    "\n",
    "        if self.verbose:\n",
    "            if iterator == self.max_evals:\n",
    "                print('\\nExited having reached max number of evaluations ({})'.format(self.max_evals))\n",
    "            else:\n",
    "                print('\\nCompleted succesfully with:')\n",
    "                print('Train fraction = {:.4f}, Train imbalance = {:.4f} (full set = {:.4f})'.format(curr_train_frac, \n",
    "                                                                                                         curr_train_imbalance, \n",
    "                                                                                                         self.data_set_imbalance))\n",
    "\n",
    "                curr_test_frac = np.sum(self.group_numpyarray[~np.isin(self.group_numpyarray[:,0],train_groups),2])/np.sum(self.group_numpyarray[:,2])\n",
    "                curr_test_imbalance = np.sum(self.group_numpyarray[~np.isin(self.group_numpyarray[:,0],train_groups),1])/np.sum(self.group_numpyarray[~np.isin(self.group_numpyarray[:,0],train_groups),2])\n",
    "\n",
    "                print('Test fraction = {:.4f}, Test imbalance = {:.4f} (full set = {:.4f})'.format(curr_test_frac, \n",
    "                                                                                                       curr_test_imbalance, \n",
    "                                                                                                       self.data_set_imbalance))\n",
    "                print('|Train_groups| = {}, |Test_groups| = {}'.format(len(train_groups), len(test_groups)))\n",
    "        \n",
    "        self.train_groups = train_groups\n",
    "        self.test_groups = test_groups\n",
    "        self.curr_train_frac = curr_train_frac\n",
    "        self.curr_train_imbalance = curr_train_imbalance\n",
    "\n",
    "    def split(self, X=[], y=[], groups = None):\n",
    "        \"\"\" Return indices of train and test splits\n",
    "        \"\"\"\n",
    "        \n",
    "        for isplit in range(self.n_splits):\n",
    "            # make a train test split\n",
    "            self.make_one_group_stratified_shuffle_split()\n",
    "            # get the appropriate indices\n",
    "            \n",
    "            train_indx = self.group_var[self.group_var.isin(self.train_groups)].index\n",
    "            test_indx = self.group_var[self.group_var.isin(self.test_groups)].index\n",
    "            # N.B. sklearn wants positional locations (iloc)! Not indices (loc)!\n",
    "            # they also must be numoy arrays so that they have a \"flag\" property\n",
    "            train_indx = np.array([self.group_var.index.get_loc(idx) for idx in train_indx])\n",
    "            test_indx = np.array([self.group_var.index.get_loc(idx) for idx in test_indx])\n",
    "            \n",
    "            \n",
    "            yield train_indx, test_indx\n",
    "        \n",
    "    def get_n_splits(self, X, y, groups = None):\n",
    "        return self.n_splits\n",
    "\n",
    "    \n",
    "    def test_make_one_group_stratified_shuffle_split(self, iterations = 100, save_loc = ''):\n",
    "        \"\"\" make a plot to see how well make_one_group_stratified_shuffle_split is shuffling\n",
    "            the groups\n",
    "        \"\"\"\n",
    "        \n",
    "        t1 = time()\n",
    "        self.make_one_group_stratified_shuffle_split()\n",
    "        train_group_multiple = self.train_groups.copy()\n",
    "        stratification_arr = [self.curr_train_imbalance]\n",
    "        for l in range(iterations-1):\n",
    "            self.make_one_group_stratified_shuffle_split()\n",
    "            train_group_multiple = np.append(train_group_multiple, self.train_groups)\n",
    "            stratification_arr = np.append(stratification_arr, self.curr_train_imbalance)\n",
    "        \n",
    "        train_group_multiple.sort()\n",
    "        count_groups=Counter(train_group_multiple)\n",
    "        fig, ax = plt.subplots(figsize=[32, 16])\n",
    "        ax.bar(x = np.arange(len(count_groups)), height=[count_groups[count] for count in count_groups], color = np.array([95, 75, 139])/255)\n",
    "        ax.set_xticks(np.arange(len(count_groups)))\n",
    "        ax.set_xticklabels([group for group in count_groups], rotation = 90)\n",
    "        \n",
    "        ax_r = ax.twinx()\n",
    "        ax_r.scatter(np.arange(len(count_groups)), self.group_table.loc[self.group_table.index.isin([group for group in count_groups])].sort_index().ratio, color = np.array([228, 93, 191])/255)\n",
    "        ax_r.set_ylabel('N(y=0)/(N(y=0)+N(y=1))')\n",
    "        ax.set_title('n_iterations = {}, train_frac = {}, beta = {}'.format(iterations, self.frac_train, self.beta))\n",
    "        ax.set_ylabel('n_times occurred in training set')\n",
    "        ax.set_xlim(-1, len(count_groups))\n",
    "        \n",
    "        if len(save_loc)>0:\n",
    "            plt.savefig(save_loc, dpi = 600, bbox_inches = 'tight') \n",
    "        \n",
    "        plt.show()\n",
    "        \n",
    "        print('Stratification = {:.4f} +/- {:.4f} (target = {:.4f})'.format(np.mean(stratification_arr), np.std(stratification_arr), self.data_set_imbalance))\n",
    "        print('(Time taken for calcualtion = {:.2}s)'.format((time()-t1)))\n",
    "\n",
    "# the following aren't codes related to the splitter itself, but are required to run the example\n",
    "def went_to_top_uni_TF(poly_params, df, imbalance, final_year_arr, change_year_factor, noise):\n",
    "    \"\"\" Calculate Boolean indicator\n",
    "    \"\"\"\n",
    "    \n",
    "    non_linear_model = (poly_params[0]*(df.weight_kg**poly_params[1])+poly_params[2]*(df.height_cm**poly_params[3])+poly_params[4]*(df.iq**poly_params[5]))*(df['final_year'].apply(lambda x: dict(zip(final_year_arr, change_year_factor))[x]))\n",
    "    non_linear_model_noisy = non_linear_model + np.random.normal(0, np.std(non_linear_model)*noise, len(non_linear_model))\n",
    "\n",
    "    return non_linear_model_noisy>np.percentile(non_linear_model_noisy, (1-imbalance)*100)\n",
    "\n",
    "def make_student_table(n_subjects, n_groups, imbalance, noise, yrly_std, poly_params = None):\n",
    "    \"\"\" Make the student_table\n",
    "    \"\"\"\n",
    "    \n",
    "    final_year_arr = np.arange(datetime.today().year-n_groups, datetime.today().year)\n",
    "    if len(final_year_arr) == 1:\n",
    "        final_year_arr = final_year_arr+1\n",
    "    \n",
    "    change_year_factor = np.random.normal(1, yrly_std, n_groups)\n",
    "    # poly params are of format [coeff_1, exponent_1, coeff_2, exponent_2, ...]\n",
    "    exp_lims = [-2, 2]\n",
    "    coeff_lims = [-10, 10]\n",
    "    \n",
    "    if poly_params is None:\n",
    "        poly_params = [\n",
    "                        np.random.random()*(coeff_lims[1]-coeff_lims[0])+coeff_lims[0], np.random.random()*(exp_lims[1]-exp_lims[0])+exp_lims[0], \n",
    "                        np.random.random()*(coeff_lims[1]-coeff_lims[0])+coeff_lims[0], np.random.random()*(exp_lims[1]-exp_lims[0])+exp_lims[0],\n",
    "                        np.random.random()*(coeff_lims[1]-coeff_lims[0])+coeff_lims[0], np.random.random()*(exp_lims[1]-exp_lims[0])+exp_lims[0]\n",
    "                      ]\n",
    "\n",
    "    name_array = pd.read_csv(\"./data/baby-names.csv\", header = 0).name.values\n",
    "    student_df = pd.DataFrame(data = {  'name' : np.random.choice(name_array, n_subjects),\n",
    "                                        'weight_kg' : np.random.normal(50, 10, n_subjects),\n",
    "                                        'height_cm' : np.random.normal(130, 30, n_subjects),\n",
    "                                        'iq' : np.random.normal(100, 20, n_subjects),\n",
    "                                        'final_year' : np.random.choice(final_year_arr, n_subjects),\n",
    "                                      })\n",
    "\n",
    "    # calculate indicator\n",
    "    student_df['uni (y/n)'] = went_to_top_uni_TF(poly_params, student_df, imbalance, final_year_arr, change_year_factor, noise)\n",
    "    \n",
    "    return student_df, poly_params\n",
    "\n",
    "def went_to_top_uni_TF(poly_params, df, imbalance, final_year_arr, change_year_factor, noise):\n",
    "    \"\"\" Calculate Boolean indicator\n",
    "    \"\"\"\n",
    "    \n",
    "    non_linear_model = (poly_params[0]*(df.weight_kg**poly_params[1])+poly_params[2]*(df.height_cm**poly_params[3])+poly_params[4]*(df.iq**poly_params[5]))*(df['final_year'].apply(lambda x: dict(zip(final_year_arr, change_year_factor))[x]))\n",
    "    non_linear_model_noisy = non_linear_model + np.random.normal(0, np.std(non_linear_model)*noise, len(non_linear_model))\n",
    "\n",
    "    return non_linear_model_noisy>np.percentile(non_linear_model_noisy, (1-imbalance)*100)\n",
    "\n",
    "\n",
    "def plot_hyper_parameter_search_result(random_search_result, title = '', pyplot_ax = None, pyplot_fig = None):\n",
    "    \"\"\" Given a random search object (e.g. created by the function do_random_hyper_parameter_search),\n",
    "        plot model score as function of iterations\n",
    "    \"\"\"\n",
    "    \n",
    "    plt.rcParams.update({'font.size': 14})\n",
    "    \n",
    "    if pyplot_ax is None:\n",
    "        fig, ax = plt.subplots(1,1, figsize = [8,8])\n",
    "    else:\n",
    "        ax = pyplot_ax\n",
    "        fig = pyplot_fig\n",
    "    \n",
    "    iter_dat = random_search_result.cv_results_['mean_test_score']\n",
    "    dashbest = max(iter_dat)\n",
    "    ax.plot(range(0, len(iter_dat)), np.repeat(dashbest, len(iter_dat)), '--', c='xkcd:light green')\n",
    "    ax.scatter(range(0, len(iter_dat)), iter_dat, c='xkcd:purple', s = 50)\n",
    "    ax.set_xlabel('Iterations')\n",
    "    ax.set_ylabel('Area under precision-recall curve')\n",
    "    ax.set_title(title)\n",
    "    \n",
    "    \n",
    "def plot_multiple_hyperplots(result_dict, save_loc = ''):\n",
    "    \"\"\" result_dict is a dictionary {title for result: result object, ...}\n",
    "    \"\"\"\n",
    "    \n",
    "    \n",
    "    # see what the axis limits will be\n",
    "    y_ax_lims = np.array([])\n",
    "    for result in result_dict:\n",
    "        y_ax_lims = np.append(y_ax_lims, result_dict[result].cv_results_['mean_test_score'])\n",
    "        y_ax_lims= [np.min(y_ax_lims), np.max(y_ax_lims)]\n",
    "    \n",
    "    y_ax_lims = [np.floor(y_ax_lims[0]*10)/10, np.ceil(y_ax_lims[1]*10)/10]\n",
    "    \n",
    "    fig, ax = plt.subplots(1,len(result_dict), figsize = [22,8])\n",
    "    for idx, result in enumerate(result_dict):\n",
    "        plot_hyper_parameter_search_result(result_dict[result], title = result, pyplot_ax = ax[idx], pyplot_fig = fig)\n",
    "        ax[idx].set_ylim(y_ax_lims)\n",
    "    \n",
    "    if len(save_loc)>0:\n",
    "        plt.savefig(save_loc, dpi = 300, bbox_inches = 'tight') \n",
    "        \n",
    "    plt.show()\n",
    "    \n",
    "def make_markdown_confusion_matrix(cm):\n",
    "    # make a markdown version of the confusion matrix\n",
    "    print(\" |        | PN | PY | \\n | ---    | --- | --- | \\n | **AN** | {0} | {1} | \\n | **AY** | {2} | {3} |\".format(cm[0][0],cm[0][1],cm[1][0],cm[1][1]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "## set parameters for our final test case at the end of this notebook\n",
    "\n",
    "# number of students in dataset\n",
    "n_subjects = 1000\n",
    "# number of year groups (these will be our groups)\n",
    "n_groups = 20\n",
    "# how imbalanced is the data set? I.e. what fraction went to top uni\n",
    "imbalance = 0.1\n",
    "# put some noise in the generated data by adding samples from a gaussian with \n",
    "# mean 0 and std given by (noise x  std(calculated data))\n",
    "noise = 0.1\n",
    "# size of deviation between years -- scores from each year are multiplied \n",
    "# by a factor N(1, yrly_std)\n",
    "yrly_std = 0.1\n",
    "\n",
    "## names for generated datasets\n",
    "name_array = pd.read_csv(\"./data/baby-names.csv\", header = 0).name.values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![alt text](images/yoydyne_data_science_logo.png \"Yoydyne Data Science\")\n",
    "\n",
    "\n",
    "# Group Stratified Shuffle Split (Binary)\n",
    "\n",
    "Before jumping into the specifics of this cross-validator, perhaps it's wise to remind ourselves why we use cross-validation when training our models, and to discuss which types of cross-validators are open to us. \n",
    "\n",
    "## Life without cross-validation\n",
    "\n",
    "When presented with a dataset containing various features along with some target variable, typically our goal is not simply to fit a model leading to the lowest loss function on the dataset. Rather, we are interested in finding a model which will perform well on unseen data. For example, after training a model on some historical stock price data, we would most likely judge that model's success on how well it predicts tomorrow's stock prices, rather than the $R^2$ coefficient it acheived on historical data.\n",
    "\n",
    "To this end, we typically segregate our data into train and test splits, where the former is used to train our model, and the latter is used to evaluate its performance. That is, the test split is data excluded from the training process for the explicit purpose of validating our model's generalizability. So far, so good. \n",
    "\n",
    "![alt text](fig_train_test_cubes.png \"Train-test split\")\n",
    "\n",
    "However, within the three words *train our model* lies a great deal of detail, and so as the [saying goes](https://en.wikipedia.org/wiki/The_devil_is_in_the_detail), also lies, the devil. For, even if we restrict ourselves to a single algorithm, we still have a (usually infinite) number of models to choose from. Take for example a [Random Forest](https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.RandomForestClassifier.html), we could train a given forest with a specified number of trees, class weight, maximum tree depth etc. on our training data, and then ascertain it's performance by evaluating it on the test data. Now however, say we have a feeling that altering some properties of our random forest (e.g. increasing the number of trees), will improve the performance of our model. We can again train this new forest on our training set, and decide to keep it or stick with our previous random forest depending on how well each performed on our test data.\n",
    "\n",
    "But why stop there? We could repeat the same process, performing a search over an entire hyper parameter space, by choosing points (e.g. on a grid or by random sampling) in that space, training a forest with those hyperparameters, and evaluating its performance on held-out test data. After searching over what we deem to be a sufficient number of hyperparameters, we'll just choose the model which scored best on the test data.\n",
    "\n",
    "The problem however, is that in optimizing our model in such a manner, we have gone against our entire premise of splitting data into training and test; by holding out a portion of the data we were trying to ascertain how well a model would perform on unseen data, *but by refining hyperparameters on the test score we have unwittingly optimized a model which performs very well on the data we were given, and have no idea how it will generalize*. Essentially we have re-combined the train and test splits.\n",
    "\n",
    "![alt text](images/fig_train_notest_cubes.png \"Train and test no longer split\")\n",
    "\n",
    "## Cross-validation saves the day\n",
    "\n",
    "Fortunately, cross-validation provides us with a solution to this problem. Though, as we will see, there are many cross-validators available to us as data scientists, they all work under the same basic premise; by (repeatedly) segregating the training data into a portion for testing and a portion for evaluating a model, we're able to compare various models, whilst reserving the test data for a final evaluation of the best performing model.\n",
    "\n",
    "To make this concrete, we can consider 4-fold cross-validation, as shown diagramatically below\n",
    "\n",
    "![alt text](images/fig_4_fold_cv.png \"4-fold cross-validation\")\n",
    "\n",
    "Here, we split our data into 4-folds, train a model on three of the folds (white cubes), and evaluate it on the fourth (grey cubes). We carry out this procedure four times, and can estimate the model's test error by evaluating the average test error of these four trials. (As a technical aside, it is interesting to note that there exists no unbiased estimator of the variance of such a k-fold cross-validation [(Bengio and Grandvalet, 2004)](www.jmlr.org/papers/volume5/grandvalet04a/grandvalet04a.pdf)).\n",
    "\n",
    "Using this procedure, we can happily perform our exploration of hyperparameter space, cross-validating at each point, computing a test error estimate from this, and selecting our best performing model. We can then evaluate this model on the held-out test data to give us an estimate of how well it will perform in the real world. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Cross-validators\n",
    "\n",
    "There are a number of cross validators available to us as data scientists, here I'll review some of those provided by the `sklearn` library, loosely based on the summary shown here [here](https://scikit-learn.org/stable/auto_examples/model_selection/plot_cv_indices.html#sphx-glr-auto-examples-model-selection-plot-cv-indices-py).\n",
    "\n",
    "For this example, we'll consider a generated dataset of 30 students, each student has a name (which we randomly sample from the dataset provided [here](https://github.com/hadley/data-baby-names/blob/master/baby-names.csv)), a year of graduation, and a boolean indicator showing whether they went on to study at university or not. The first 5 rows of the dataframe are as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "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>name</th>\n",
       "      <th>uni (y/n)</th>\n",
       "      <th>year</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Billie</td>\n",
       "      <td>y</td>\n",
       "      <td>2014</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Carson</td>\n",
       "      <td>y</td>\n",
       "      <td>2014</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Evaline</td>\n",
       "      <td>n</td>\n",
       "      <td>2014</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Viviana</td>\n",
       "      <td>n</td>\n",
       "      <td>2014</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Penelope</td>\n",
       "      <td>n</td>\n",
       "      <td>2014</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "       name uni (y/n)  year\n",
       "0    Billie         y  2014\n",
       "1    Carson         y  2014\n",
       "2   Evaline         n  2014\n",
       "3   Viviana         n  2014\n",
       "4  Penelope         n  2014"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len_array = 30\n",
    "names = np.random.choice(name_array,len_array)\n",
    "school_year = np.concatenate([np.repeat('2014', len_array*0.4),np.repeat('2015', len_array*0.3),np.repeat('2016', len_array*0.3)])\n",
    "went_to_uni = np.concatenate([np.repeat('y', np.ceil(len_array*0.4*0.1)), np.repeat('n', np.floor(len_array*0.4*0.9)),\n",
    "np.repeat('y', np.ceil(len_array*0.3*0.2)), np.repeat('n', np.floor(len_array*0.3*0.8)),\n",
    "np.repeat('y', np.ceil(len_array*0.3*0.2)), np.repeat('n', np.floor(len_array*0.3*0.8))])\n",
    "student_df = pd.DataFrame(data = {'name':names, 'year':school_year, 'uni (y/n)':went_to_uni})\n",
    "student_df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "| name     | uni (y/n)   |   year |\n",
      "|:---------|:------------|-------:|\n",
      "| Billie   | y           |   2014 |\n",
      "| Carson   | y           |   2014 |\n",
      "| Evaline  | n           |   2014 |\n",
      "| Viviana  | n           |   2014 |\n",
      "| Penelope | n           |   2014 |\n"
     ]
    }
   ],
   "source": [
    "# print out in markdown version for readme\n",
    "print(tabulate(student_df.set_index('name').head(), tablefmt=\"pipe\", headers=\"keys\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also plot our dataset:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "box_width = 0.4\n",
    "c_arr = ['#0957C3',\n",
    "         '#D14124',\n",
    "         '#008330',\n",
    "         '#F2A900',\n",
    "         '#6B3077',\n",
    "         '#2CD5C4',\n",
    "        '#6CACE4']\n",
    "\n",
    "fig, ax = plt.subplots(figsize = [10, 8])\n",
    "\n",
    "\n",
    "for subject, yr in enumerate(school_year):\n",
    "        if yr == '2014':\n",
    "            ax.add_patch(patches.Rectangle((subject-0.5,0-box_width/2),1,box_width,facecolor = c_arr[2],\n",
    "                                          label = '2014'))\n",
    "            \n",
    "        if yr == '2015':\n",
    "            ax.add_patch(patches.Rectangle((subject-0.5,0-box_width/2),1,box_width,facecolor = c_arr[3],\n",
    "                                          label = '2015'))\n",
    "        if yr == '2016':\n",
    "            ax.add_patch(patches.Rectangle((subject-0.5,0-box_width/2),1,box_width,facecolor = c_arr[6],\n",
    "                                          label = '2016'))\n",
    "            \n",
    "for subject, unibool in enumerate(went_to_uni):\n",
    "        if unibool == 'y':\n",
    "            ax.add_patch(patches.Rectangle((subject-0.5,-1-box_width/2),1,box_width,facecolor = c_arr[4],\n",
    "                                          label = 'y'))\n",
    "        if unibool == 'n':\n",
    "            ax.add_patch(patches.Rectangle((subject-0.5,-1-box_width/2),1,box_width,facecolor = c_arr[5],\n",
    "                                          label = 'n'))\n",
    "\n",
    "ax.set_xticks(np.arange(0, len_array))\n",
    "ax.set_xticklabels(names, rotation = 90)\n",
    "ax.set_ylim([-1.3, 0.3])\n",
    "ax.set_xlim([-1.5,len_array])\n",
    "ax.set_yticks(np.arange(-1,1))\n",
    "ax.set_ylabel('CV iteration')\n",
    "yticks = ['uni (y/n)', 'year']\n",
    "ax.set_yticklabels(yticks)\n",
    "plt.savefig('images/initial_data_plot.png', dpi = 300, bbox_inches = 'tight') #\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Where the graduation year (<span style=\"color:#008330\">2014</span>, <span style=\"color:#F2A900\">2015</span>, <span style=\"color:#6CACE4\">2016</span>) for each student and whether they went on to attend uni (<span style=\"color:#6B3077\">yes</span>, <span style=\"color:#2CD5C4\">no</span>) is noted."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### k-fold CV"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's see how different cross-validators partition this dataset. First of all we'll consider the k-fold cross validation described above, just as in that description, we'll use 4-folds."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "n_splits = 4\n",
    "\n",
    "cv_iter = KFold(n_splits=n_splits).split(np.arange(0,len_array))\n",
    "\n",
    "fig, ax = plt.subplots(figsize = [10, 8])\n",
    "\n",
    "box_width = 0.8\n",
    "\n",
    "for subject, yr in enumerate(school_year):\n",
    "        if yr == '2014':\n",
    "            ax.add_patch(patches.Rectangle((subject-0.5,0-box_width/2),1,box_width,facecolor = c_arr[2],\n",
    "                                          label = '2014'))\n",
    "            \n",
    "        if yr == '2015':\n",
    "            ax.add_patch(patches.Rectangle((subject-0.5,0-box_width/2),1,box_width,facecolor = c_arr[3],\n",
    "                                          label = '2015'))\n",
    "        if yr == '2016':\n",
    "            ax.add_patch(patches.Rectangle((subject-0.5,0-box_width/2),1,box_width,facecolor = c_arr[6],\n",
    "                                          label = '2016'))\n",
    "            \n",
    "for subject, unibool in enumerate(went_to_uni):\n",
    "        if unibool == 'y':\n",
    "            ax.add_patch(patches.Rectangle((subject-0.5,-1-box_width/2),1,box_width,facecolor = c_arr[4],\n",
    "                                          label = 'y'))\n",
    "        if unibool == 'n':\n",
    "            ax.add_patch(patches.Rectangle((subject-0.5,-1-box_width/2),1,box_width,facecolor = c_arr[5],\n",
    "                                          label = 'n'))\n",
    "\n",
    "for split in range(n_splits):\n",
    "    single_fold = next(cv_iter)\n",
    "    for idx, group in enumerate(single_fold):\n",
    "        for subject in group:\n",
    "            ax.add_patch(patches.Rectangle((subject-0.5,split+1-box_width/2),1,box_width,facecolor = c_arr[idx]))\n",
    "\n",
    "ax.set_xticks(np.arange(0, len_array))\n",
    "ax.set_xticklabels(names, rotation = 90)\n",
    "ax.set_ylim([-1.8, n_splits+0.8])\n",
    "ax.set_xlim([-1.5,len_array])\n",
    "ax.set_yticks(np.arange(-1,n_splits+2))\n",
    "ax.set_title('KFold')\n",
    "ax.set_ylabel('CV iteration')\n",
    "yticks = ['uni (y/n)', 'year']\n",
    "for n in range(n_splits): yticks.append(n)\n",
    "ax.set_yticklabels(yticks)\n",
    "plt.savefig('images/k_cv.png', dpi = 300, bbox_inches = 'tight')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we can see, at each 1/k cross-validation iteration, a 1/k (i.e. a quarter in this example) of the data is held out for testing (shown in <span style=\"color:#D14124\">red</span>) while the rest is used for training (shown in <span style=\"color:#0957C3\">blue</span>).\n",
    "\n",
    "The `year` and `uni (y/n)` are ignored in determining the train-test splits of the k-fold cross-validation, but we might imagine a situation where we'd like to take them into account. Perhaps we're training a model to predict which students will go on to study at university. As we can see, our dataset is very imbalanced with regards to this target variable. We'd like our training-test splits to reflect this. Luckily, `StratifiedKFold` does just that."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Stratified k-fold"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "cv_iter = StratifiedKFold(n_splits=n_splits).split(np.arange(0,len_array),y=student_df['uni (y/n)'])\n",
    "\n",
    "\n",
    "fig, ax = plt.subplots(figsize = [10, 8])\n",
    "\n",
    "box_width = 0.8\n",
    "\n",
    "for subject, yr in enumerate(school_year):\n",
    "        if yr == '2014':\n",
    "            ax.add_patch(patches.Rectangle((subject-0.5,0-box_width/2),1,box_width,facecolor = c_arr[2],\n",
    "                                          label = '2014'))\n",
    "            \n",
    "        if yr == '2015':\n",
    "            ax.add_patch(patches.Rectangle((subject-0.5,0-box_width/2),1,box_width,facecolor = c_arr[3],\n",
    "                                          label = '2015'))\n",
    "        if yr == '2016':\n",
    "            ax.add_patch(patches.Rectangle((subject-0.5,0-box_width/2),1,box_width,facecolor = c_arr[6],\n",
    "                                          label = '2016'))     \n",
    "for subject, unibool in enumerate(went_to_uni):\n",
    "        if unibool == 'y':\n",
    "            ax.add_patch(patches.Rectangle((subject-0.5,-1-box_width/2),1,box_width,facecolor = c_arr[4],\n",
    "                                          label = 'y'))\n",
    "        if unibool == 'n':\n",
    "            ax.add_patch(patches.Rectangle((subject-0.5,-1-box_width/2),1,box_width,facecolor = c_arr[5],\n",
    "                                          label = 'n'))\n",
    "\n",
    "for split in range(n_splits):\n",
    "    single_fold = next(cv_iter)\n",
    "    for idx, group in enumerate(single_fold):\n",
    "        for subject in group:\n",
    "            ax.add_patch(patches.Rectangle((subject-0.5,split+1-box_width/2),1,box_width,facecolor = c_arr[idx]))\n",
    "\n",
    "ax.set_xticks(np.arange(0, len_array))\n",
    "ax.set_xticklabels(names, rotation = 90)\n",
    "ax.set_ylim([-1.8, n_splits+0.8])\n",
    "ax.set_xlim([-1.5,len_array])\n",
    "ax.set_yticks(np.arange(-1,n_splits+2))\n",
    "ax.set_title('StratifiedKFold')\n",
    "ax.set_ylabel('CV iteration')\n",
    "yticks = ['uni (y/n)', 'year']\n",
    "for n in range(n_splits): yticks.append(n)\n",
    "ax.set_yticklabels(yticks)\n",
    "plt.savefig('images/k_stratified_cv.png', dpi = 300, bbox_inches = 'tight')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can see that the train-test splits reflect the stratification of the dataset with regards to the target variable `uni (y/n)` (though only approximately in this case as we have 6 `uni (y/n)=y` cases to split between 4 folds)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Grouped k-fold\n",
    "\n",
    "We might also want a k-fold stratifier that takes account of how our data is grouped, `GroupKFold` keeps groups separated from eachother in the train-test splits. In this case the group is graduation year, and we only have three such years, so only three splits are possible:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "n_splits = 3\n",
    "cv_iter = GroupKFold(n_splits=n_splits).split(np.arange(0,len_array),groups=student_df['year'])\n",
    "\n",
    "\n",
    "fig, ax = plt.subplots(figsize = [10, 8])\n",
    "\n",
    "box_width = 0.8\n",
    "\n",
    "for subject, yr in enumerate(school_year):\n",
    "        if yr == '2014':\n",
    "            ax.add_patch(patches.Rectangle((subject-0.5,0-box_width/2),1,box_width,facecolor = c_arr[2],\n",
    "                                          label = '2014'))\n",
    "            \n",
    "        if yr == '2015':\n",
    "            ax.add_patch(patches.Rectangle((subject-0.5,0-box_width/2),1,box_width,facecolor = c_arr[3],\n",
    "                                          label = '2015'))\n",
    "        if yr == '2016':\n",
    "            ax.add_patch(patches.Rectangle((subject-0.5,0-box_width/2),1,box_width,facecolor = c_arr[6],\n",
    "                                          label = '2016'))\n",
    "            \n",
    "for subject, unibool in enumerate(went_to_uni):\n",
    "        if unibool == 'y':\n",
    "            ax.add_patch(patches.Rectangle((subject-0.5,-1-box_width/2),1,box_width,facecolor = c_arr[4],\n",
    "                                          label = 'y'))\n",
    "        if unibool == 'n':\n",
    "            ax.add_patch(patches.Rectangle((subject-0.5,-1-box_width/2),1,box_width,facecolor = c_arr[5],\n",
    "                                          label = 'n'))\n",
    "\n",
    "for split in range(n_splits):\n",
    "    single_fold = next(cv_iter)\n",
    "    for idx, group in enumerate(single_fold):\n",
    "        for subject in group:\n",
    "            ax.add_patch(patches.Rectangle((subject-0.5,split+1-box_width/2),1,box_width,facecolor = c_arr[idx]))\n",
    "\n",
    "ax.set_xticks(np.arange(0, len_array))\n",
    "ax.set_xticklabels(names, rotation = 90)\n",
    "ax.set_ylim([-1.8, n_splits+0.8])\n",
    "ax.set_xlim([-1.5,len_array])\n",
    "ax.set_yticks(np.arange(-1,n_splits+2))\n",
    "ax.set_title('GroupKFold')\n",
    "ax.set_ylabel('CV iteration')\n",
    "yticks = ['uni (y/n)', 'year']\n",
    "for n in range(n_splits): yticks.append(n)\n",
    "ax.set_yticklabels(yticks)\n",
    "plt.savefig('images/k_grouped_cv.png', dpi = 300, bbox_inches = 'tight')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Beyond k-fold cross-validators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The previous classifiers use some form of k-fold methodology, where the dataset is split into k-times, and each data point (students in our example) appears in the testing split once, and the training split (k-1) times. These folds and splits are uniquely defined from the moment we choose our classifier. However, to imporve generalization we may want to randomly sample train and test groups from our data at each validation iteration. This will have the disadvantage, for example, that data points may pop-up multiple times in the test split. The flip side is that it will give us much more freedom in our cross-validation, e.g. we might choose a 9:1 train:test split to be run for 5 iterations, whereas running this ratio for k-fold validation would require 10 iterations, and therefore be twice as computationally expensive.\n",
    "\n",
    "These types of cross-validators are denoted by the word \"Shuffle\" in `sklearn`, as they randomly shuffle the dataset before each cross-validations iteration. Let's look at how they apply to our example data.\n",
    "\n",
    "### Shuffle Split\n",
    "\n",
    "As described above, `ShuffleSplit` allows us to specify a test size (here it's 0.25, as before), and a number of iterations to perform (we choose 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAn8AAAIOCAYAAADJMGufAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzs3XeYpGWV/vH7nhnyEFQGAzACStBFEG2CgoqICiqymABxVQyoqwu4rq5r+IGo6xpXxTUQRUQQA4qIBCVJpgdmCAKiqAuKMLKSJAjD+f3xPEXXNB3et+qt0P18P9fVV3eF99Sp6gqnnuiIEAAAAMowZ9AJAAAAoH8o/gAAAApC8QcAAFAQij8AAICCUPwBAAAUhOIPAACgIBR/ACDJ9pttn9/F8XvYvsn2Pba3sr2p7Sts3217f9vftP2JJnOeJI9zbL8t/72P7TN6fZsAZhaKPwBFsb2D7Qtt32n7/2xfYHvrBkJ/TtJ7ImJ+RFwh6QOSzomI1SPiy4PIMSKOi4iXtMUN20+tGwfA7DJv0AkAQL/YXkPSKZLeJelESStKep6kBxoI/2RJ14w7fcKQ5QgAtPwBKMomkhQRx0fEsoi4LyLOiIgrW1ew/Tnbf7X9O9u7tp3/e9s7t50+2Pa3ba9k+x5JcyUtsf1b22dJeqGkr+Ru4E3GJ2L7FbYX274jt/JtUSXH3D19ge1Dc8vgdbZfNNGdbe/Ktn1ePntJzmnPzh9GADMZxR+Akvxa0jLbx9je1fZjxl2+raTrJa0t6TOSjrTtqQJGxAMRMT+f3DIinhIRO0n6pca6gX/dfoztZ0k6StI7JD1O0jcknWx7pQo5tvK8Med5kKQf2n7sNHk+vy3H+RHx3amuD2D2ovgDUIyIuEvSDpJC0uGSlto+2fbj81X+EBGHR8QyScdIeqKkx08crStvl/SNiLgkt+4do9Stu12FHCXpNklfjIgHcxF3vaSX9yBPALMQxR+AokTEtRHx5ohYT9Lmkp4k6Yv54j+3Xe/e/Od8Ne/Jkt6Xu3zvsH2HpPVzLtPlKEl/jIhoO/2H1rEAMB2KPwDFiojrJH1TqcCazt8krdp2+gld3PRNkj4ZEWu1/awaEcdXzHHdcd3RCyX9qYt8ABSE4g9AMWxvZvt9ttfLp9eXtLekiyscvljSXrZXsD0i6TVdpHK4pHfa3tbJarZfbnv1ijmuI2n/nMtrJT1N0qkVbvdWSRt1kTeAWYDiD0BJ7laaLHGJ7b8pFVRXS3pfhWM/Kukpkv4q6WOSvtNpEhExqjTu7ys53m8kvblGjpdI2ljSXyR9UtJrIuL2Cjd9sKRjclfz6zrNH8DM5uWHjQAAhpntN0t6W0TsMOhcAMxMtPwBAAAUhOIPAACgIHT7AgAAFISWPwAAgIJQ/AEAABRk3qATGCa295O0nyStttpqz95ss80GnBEAAMD0Fi1a9JeIWFDluoz5m8TIyEiMjo4OOg0AAIBp2V4UESNVrku3LwAAQEEo/gAAAApC8QcAAFAQij8AAICCUPwBAAAUhOIPAACgIBR/AAAABaH4AwAAKAjFHwAAQEEo/gAAAApC8QcAAFAQij8AAICCUPwBAAAUhOIPAACgIBR/AAAABaH4AwAAKAjFHwAAQEEo/gAAAApC8QcAAFAQij8AAICCUPwBAAAUhOIPAACgIBR/AAAABaH4AwAAKAjFHwAAQEEo/gAAAApC8QcAAFAQij8AAICCUPwBAAAUhOIPAACgIBR/AAAABaH4AwAAKAjFHwAAQEEo/gAAAApC8QcAAFAQij8AAICCzBt0ArPdqnudP+gUZr2Lb9u36xjbrXN0A5k0k4vUXD5NGLb7NEz/76ZwnyY3bPdrWAzb4zts+cw2956wQ6PxaPkDAAAoCMUfAABAQSj+AAAACkLxBwAAUBCKPwAAgIJQ/AEAABSE4g8AAKAgFH8AAAAFofgDAAAoCMUfAABAQSj+AAAACkLxBwAAUBCKPwAAgIJQ/AEAABSE4g8AAKAgFH8AAAAFofgDAAAoCMUfAABAQSj+AAAACkLxBwAAUBCKPwAAgIIUU/zZXtn2pbaX2L7G9scGnRMAAEC/zRt0An30gKSdIuIe2ytIOt/2zyLi4kEnBgAA0C/FFH8REZLuySdXyD8xuIwAAAD6r5huX0myPdf2Ykm3STozIi4Zd/l+tkdtjy5dunQwSQIAAPRQUcVfRCyLiGdKWk/SNrY3H3f5YRExEhEjCxYsGEySAAAAPVRU8dcSEXdIOkfSLgNOBQAAoK+KKf5sL7C9Vv57FUk7S7pusFkBAAD0VzETPiQ9UdIxtucqFb0nRsQpA84JAACgr4op/iLiSklbDToPAACAQSqm2xcAAAAUfwAAAEWh+AMAACgIxR8AAEBBKP4AAAAKQvEHAABQEIo/AACAglD8AQAAFITiDwAAoCAUfwAAAAWh+AMAACgIxR8AAEBBKP4AAAAKQvEHAABQEIo/AACAglD8AQAAFITiDwAAoCAUfwAAAAWh+AMAACgIxR8AAEBBHBGDzmEojYyMxOjo6KDTAAAAmJbtRRExUuW6tPwBAAAUhOIPAACgIBR/AAAABaH4AwAAKAjFHwAAQEEo/gAAAApC8QcAAFAQij8AAICCUPwBAAAUhOIPAACgIBR/AAAABaH4AwAAKMi8QScw26261/mNxLn4tn27jrHdOkc3kEkzuQybph4bzAxNPYeH6TU1W5/DPDYYlGF6n7j3hB0ayGQMLX8AAAAFofgDAAAoCMUfAABAQSj+AAAACkLxBwAAUBCKPwAAgIJQ/AEAABSE4g8AAKAgFH8AAAAFofgDAAAoCMUfAABAQSj+AAAACkLxBwAAUBCKPwAAgIJQ/AEAABSE4g8AAKAgFH8AAAAFofgDAAAoCMUfAABAQSj+AAAACkLxBwAAUJBiij/b69s+2/a1tq+xfcCgcwIAAOi3eYNOoI8ekvS+iLjc9uqSFtk+MyJ+NejEAAAA+qWYlr+IuCUiLs9/3y3pWknrDjYrAACA/iqm+GtnewNJW0m6ZNz5+9ketT26dOnSQaQGAADQU8UVf7bnS/qBpAMj4q72yyLisIgYiYiRBQsWDCZBAACAHiqq+LO9glLhd1xE/HDQ+QAAAPRbMcWfbUs6UtK1EfGFQecDAAAwCMUUf5K2l/RPknayvTj/vGzQSQEAAPRTMUu9RMT5kjzoPAAAAAappJY/AACA4lH8AQAAFITiDwAAoCAUfwAAAAWh+AMAACgIxR8AAEBBKP4AAAAKQvEHAABQEIo/AACAglD8AQAAFITiDwAAoCAUfwAAAAWh+AMAACgIxR8AAEBBKP4AAAAKQvEHAABQEIo/AACAglD8AQAAFITiDwAAoCAUfwAAAAVxRAw6h6E0MjISo6Ojg04DAABgWrYXRcRIlevS8gcAAFAQij8AAICCUPwBAAAUhOIPAACgIBR/AAAABaH4AwAAKAjFHwAAQEEo/gAAAApC8QcAAFAQij8AAICCUPwBAAAUhOIPAACgIPMGncBsd+VOGzcSZ7t1jm4kDmaGi2/bt+sYw/acaeI+NWXYHpsmDNPjK83OxxgzQ1Ovhaaew03ks8VZNzSQyRha/gAAAApC8QcAAFAQij8AAICCUPwBAAAUhOIPAACgIBR/AAAABaH4AwAAKAjFHwAAQEEo/gAAAApC8QcAAFAQij8AAICCUPwBAAAUhOIPAACgIBR/AAAABaH4AwAAKAjFHwAAQEEo/gAAAApC8QcAAFAQij8AAICCUPwBAAAUhOIPAACgIMUUf7aPsn2b7asHnQsAAMCgzKtyJdvrSnpy+/Uj4rxeJdUj35T0FUnfGnAeAAAAAzNt8Wf705L2lPQrScvy2SFpRhV/EXGe7Q0GnQcAAMAgVWn5+0dJm0bEA71OZtBs7ydpP0lauHDhgLMBAABoXpUxfzdKWqHXiQyDiDgsIkYiYmTBggWDTgcAAKBxVVr+7pW02PYvJD3S+hcR+/csKwAAAPREleLv5PwDAACAGW7a4i8ijrG9oqRN8lnXR8SDvU2rebaPl7SjpLVt3yzpoIg4crBZAQAA9FeV2b47SjpG0u8lWdL6tt8005Z6iYi9B50DAADAoFXp9v28pJdExPWSZHsTScdLenYvEwMAAEDzqsz2XaFV+ElSRPxahcz+BQAAmG2qtPyN2j5S0rH59D6SFvUuJQAAAPRKleLvXZLeLWl/pTF/50n6ai+TAgAAQG9Ume37gKQv5B8AAADMYJMWf7ZPjIjX2b5KaS/f5UTEFj3NDAAAAI2bquXvgPz7Ff1IBAAAAL036WzfiLgl//nPEfGH9h9J/9yf9AAAANCkKku9vHiC83ZtOhEAAAD03lRj/t6l1MK3ke0r2y5aXdIFvU4MAAAAzZtqzN93JP1M0qckfbDt/Lsj4v96mhUAAAB6YtLiLyLulHSnpL0lyfY6klaWNN/2/Ij43/6kCAAAgKZMO+bP9m62b5D0O0nnSvq9UosgAAAAZpgqEz4+IWk7Sb+OiA0lvUiM+QMAAJiRqhR/D0bE7ZLm2J4TEWdLemaP8wIAAEAPVNnb9w7b85X29D3O9m2SHuptWgAAAOiFKi1/u0u6V9J7JZ0m6beSdutlUgAAAOiNKVv+bM+V9OOI2FnSw5KO6UtWAAAA6IkpW/4iYpmke22v2ad8AAAA0ENVxvzdL+kq22dK+lvrzIjYv2dZAQAAoCeqFH8/zT/owBZn3dBInHsbiYKZo/vnzfA9Z5p5LTRh+B6bJgzP4yvN1scYM8Owfe4O12tTqlD8RcQxtleRtDAiru9DTgAAAOiRSjt8SFqsNNNXtp9p++ReJwYAAIDmVVnq5WBJ20i6Q5IiYrGkDXuYEwAAAHqkSvH3UETcOe686EUyAAAA6K0qEz6utv16SXNtbyxpf0kX9jYtAAAA9EKVlr9/kfQPkh6Q9B1Jd0o6oJdJAQAAoDeqtPy9PCI+LOnDrTNsv1bS93qWFQAAAHqiSsvff1Q8DwAAAENu0pY/27tKepmkdW1/ue2iNSQ91OvEAAAA0Lypun3/JGlU0islLWo7/25J7+1lUgAAAOiNSYu/iFgiaYnt4yKClj4AAIBZYKpu3xMj4nWSrrD9qHX9ImKLnmYGAACAxk3V7dtazuUV/Uhktlp1r/MHncKsd/Ft+3YdY7t1jm4gk+YM031qIhdp+B7jYTJM/+/ZiOfw5IbtsZmNr4Um7tMWZ93QQCZjpur2vSX//kOjtwgAAICBqbLUCwAAAGYJij8AAICCTFr82f432+v3MxkAAAD01lQtf+tKutD2ebbfZXvtfiUFAACA3pi0+IuI90paKOmjkraQdKXtn9l+o+3V+5UgAAAAmjPlmL9Izo2Id0laX9IXlXb3uLUfyQEAAKBZU63z9wjbz5C0l6Q9Jd0u6UO9TAoAAAC9MdUOHxtL2lup6Fsm6QRJL4mIG/uUGwAAABo2Vcvf6ZKOl7RnRFzVp3wAAADQQ1MVfy+V9PjxhZ/t50n6U0T8tqeZAQAAoHFTTfj4b0l3TXD+fUoTPwAAADDDTFX8bRARV44/MyJGJW3Qs4wAAADQM1MVfytPcdkqTScCAACA3puq+LvM9tvHn2n7rZIW9S4lAAAA9MpUEz4OlHSS7X00VuyNSFpR0h69TgwAAADNm7T4i4hbJT3X9gslbZ7P/mlEnNWXzAAAANC4aXf4iIizJZ3dh1wAAADQY1Pu7QsAAIDZheIPAACgIBR/AAAABSmq+LO9i+3rbf/G9gcHnQ8AAEC/FVP82Z4r6X8k7Srp6ZL2tv30wWYFAADQX8UUf5K2kfSbiLgxIv4u6QRJuw84JwAAgL4qqfhbV9JNbadvzuc9wvZ+tkdtjy5durSvyQEAAPRDScWfJzgvljsRcVhEjETEyIIFC/qUFgAAQP+UVPzdLGn9ttPrSfrTgHIBAAAYiJKKv8skbWx7Q9srStpL0skDzgkAAKCvpt3ebbaIiIdsv0fS6ZLmSjoqIq4ZcFoAAAB9VUzxJ0kRcaqkUwedBwAAwKCU1O0LAABQPIo/AACAglD8AQAAFITiDwAAoCAUfwAAAAWh+AMAACgIxR8AAEBBKP4AAAAKQvEHAABQEIo/AACAglD8AQAAFITiDwAAoCAUfwAAAAWh+AMAACgIxR8AAEBBKP4AAAAKQvEHAABQEIo/AACAglD8AQAAFITiDwAAoCCOiEHnMJRGRkZidHR00GkAAABMy/aiiBipcl1a/gAAAApC8QcAAFAQij8AAICCUPwBAAAUhOIPAACgIBR/AAAABaH4AwAAKAjFHwAAQEEo/gAAAApC8QcAAFAQij8AAICCUPwBAAAUZN6gE5jt/ImtBp0CMKvctcniQaeAQn1o7s2DTgGFOvTV6zYaj5Y/AACAglD8AQAAFITiDwAAoCAUfwAAAAWh+AMAACgIxR8AAEBBKP4AAAAKQvEHAABQEIo/AACAglD8AQAAFITiDwAAoCAUfwAAAAWh+AMAACgIxR8AAEBBKP4AAAAKQvEHAABQEIo/AACAglD8AQAAFITiDwAAoCAUfwAAAAWh+AMAACgIxR8AAEBBii3+bM8ddA4AAAD9NiOKP9sft31A2+lP2t7f9vttX2b7Stsfa7v8R7YX2b7G9n5t599j+xDbl0h6Tp/vBgAAwMDNiOJP0pGS3iRJtudI2kvSrZI2lrSNpGdKerbt5+frvyUini1pRNL+th+Xz19N0tURsW1EnD/+RmzvZ3vU9ujSpUt7e48AAAAGYEYUfxHxe0m3295K0kskXSFp67a/L5e0mVIxKKWCb4mkiyWt33b+Mkk/mOJ2DouIkYgYWbBgQS/uCgAAwEDNG3QCNRwh6c2SniDpKEkvkvSpiPhG+5Vs7yhpZ0nPiYh7bZ8jaeV88f0RsaxfCQMAAAybGdHyl50kaRelFr/T889bbM+XJNvr2l5H0pqS/poLv80kbTeohAEAAIbNjGn5i4i/2z5b0h259e4M20+TdJFtSbpH0hsknSbpnbavlHS9UtcvAAAANIOKvzzRYztJr22dFxFfkvSlCa6+60QxImJ+b7IDAACYGWZEt6/tp0v6jaRfRMQNg84HAABgppoRLX8R8StJGw06DwAAgJluRrT8AQAAoBkUfwAAAAWh+AMAACgIxR8AAEBBKP4AAAAKQvEHAABQEIo/AACAglD8AQAAFITiDwAAoCAUfwAAAAWh+AMAACgIxR8AAEBBKP4AAAAKQvEHAABQEIo/AACAglD8AQAAFITiDwAAoCAUfwAAAAWZN+gEZrv4yBWDTgEA0IBDB50A0BBa/gAAAApC8QcAAFAQij8AAICCUPwBAAAUhOIPAACgIBR/AAAABaH4AwAAKAjFHwAAQEEo/gAAAApC8QcAAFAQij8AAICCUPwBAAAUZN6gE5jt3rPVBwedwiPOPW63QacAdO0F+/xk0Ck8gtdUWXjuYVCuevr2jcaj5Q8AAKAgFH8AAAAFofgDAAAoCMUfAABAQSj+AAAACkLxBwAAUBCKPwAAgIJQ/AEAABSE4g8AAKAgFH8AAAAFofgDAAAoCMUfAABAQSj+AAAACkLxBwAAUBCKPwAAgIJQ/AEAABSE4g8AAKAgFH8AAAAFofgDAAAoCMUfAABAQSj+AAAACjI0xZ/tEdtfnuSyrWwfUSHGE22fMc11TrC9cad5AgAAzGRDU/xFxGhE7D/JxR+SdGiFMLtIOn2a63xN0gfq5AYAADBb9KT4s72B7avbTv+b7YPz3+fY/rTtS23/2vbz8vk72j5lglirS9oiIpbYnmP7BtsL8mVzbP/G9tr56rtI+lmOdY7t79u+zvZxtp2v80tJO9ue14v7DgAAMMwG1fI3LyK2kXSgpIOmue6IpKslKSIelvRtSfvky3aWtCQi/mJ7rqRNI+JX+bKtcvynS9pI0vZtMX4jacvxN2R7P9ujtkeXLl3azf0DAAAYSoMq/n6Yfy+StME0132ipPZK7ChJb8x/v0XS0fnvbSVd0na9SyPi5lzsLR53O7dJetL4G4qIwyJiJCJGFixYUOFuAAAAzCy9Kv4eGhd75XGXP5B/L5M0Xffrfe3HR8RNkm61vZNSwfezfNGukk6b4DYmup2Vc1wAAICi9Kr4u1XSOrYfZ3slSa/oIta1kp467rwjlLp/T4yIZfm8F0n6RcWYm0i6poucAAAAZqSeFH8R8aCkQ5S6YU+RdF0Xsa6TtGae+NFysqT5yl2+eQLI/RFx13TxbD9e0n0RcUunOQEAAMxUPZvxGhFflvSodfsiYse2v/+iPBYvIs6RdM4k4Y6StKdSi5+UJmssyYWhJL1U0iPr+42PFRHvaYv1eknfqHxHAAAAZpGZstzJ1yS9VpJsf1DSuzQ241cR8e0ase6QdGyj2QEAAMwQQ7PI81Qi4v6IODb//V8R8eSIOL/DWEdHxEPNZggAADAzzIjiDwAAAM2g+AMAACgIxR8AAEBBKP4AAAAKQvEHAABQEIo/AACAglD8AQAAFITiDwAAoCAUfwAAAAWh+AMAACgIxR8AAEBBKP4AAAAKQvEHAABQEIo/AACAglD8AQAAFITiDwAAoCAUfwAAAAWh+AMAACiII2LQOQylkZGRGB0dHXQaAAAA07K9KCJGqlyXlj8AAICCUPwBAAAUhOIPAACgIBR/AAAABaH4AwAAKAjFHwAAQEEo/gAAAApC8QcAAFAQij8AAICCUPwBAAAUhOIPAACgIBR/AAAABaH4AwAAKAjFHwAAQEEo/gAAAApC8QcAAFAQij8AAICCUPwBAAAUhOIPAACgIBR/AAAABaH4AwAAKAjFHwAAQEEo/gAAAApC8QcAAFAQR8SgcxhKtpdK+kOfbm5tSX8ZkjjDlEtTcYYpl2GLM0y5NBVnmHIZtjjDlEtTcYYpl2GLM0y5NBVnmHIZtjhPjogFVa5I8TcEbI9GxMgwxBmmXJqKM0y5DFucYcqlqTjDlMuwxRmmXJqKM0y5DFucYcqlqTjDlMswxqmKbl8AAICCUPwBAAAUhOJvOBw2RHGGKZem4gxTLsMWZ5hyaSrOMOUybHGGKZem4gxTLsMWZ5hyaSrOMOUyjHEqYcwfAABAQWj5AwAAKAjFHwAAQEEo/gAAAApC8YdZx/YPbL/cNs/vHrG9qu2P2j48n97Y9isGnReA2cX2HNvPbSDO05rIZ7ZgwgcaY/sxkjaWtHLrvIg4r8NYT5a0cUT83PYqkuZFxN0Vj91Z0r6StpP0PUnfjIjrOsxjVNLRkr4TEX/tJEZbrFdJ2kFSSDo/Ik7qMM5zJW0gaV7rvIj4Vo3jHy/pPyU9KSJ2tf10Sc+JiCNrxPiupEWS3hgRm+f/0UUR8cyqMcbF21zS07X8c6fyfWoqRo7T1eObY6wiaWFEXF/39vPx/zrV5RHxhZrx1tHyj8v/dphX169x28+OiEXjztstIn5SM07X/6ccp+P3mqbZ3j4iLpjuvAmOe9VUl0fEDyve/t1K70+TxVmjSpwJ4nb1vLF9UUQ8p5PbbotxsdJ9O1rS8YP6Hw+LedNfBb1gexNJX5P0+PzhuYWkV0bEJ2rE2F7SwZKerPS/tKSIiI0GkMvbJB0gaT1Ji5UKr4sk7VQnlxzr7ZL2k/RYSU/JMb8u6UVVjo+In0v6ue01Je0t6UzbN0k6XNK3I+LBGunspVRIXtZWCJ4RNb812f6qpKdKOj6f9Q7bO0fEu2vGOVbpMVksaVk+OyTV+dD7ptL9+HA+/WtJ35VUufiT9JSI2NP23pIUEffZdo3jH2H7IEk7KhVup0raVdL5qnGfmoiR43T9+NreTdLnJK0oaUPbz5R0SES8skYqq9e47lS5vFLS5yU9SdJtSu8V10r6hw5iNfUaP9z2myLiqhx3b0kHSqpc/DX0Ouj6vcb2TzR1sVTnfy5Jh0p6VoXzxtttistCUqXiLyJWlyTbh0j6s6RjlT5X9lGHz8mGnjdn2H61pB/Wfe9tiYjtcuvfWyQttn2BpKMj4uy6sZr4zMxxtlP6/z5N6f1irqS/dVpk1xIR/AzgR9K5kraRdEXbeVfXjHGd0ofcOpIe1/oZUC5XKX2rW5xPbybpux0+NovzC6E9n6tqxnic0hvOqKSTJe2p9CI7p8Oc5kh6paQ/SrpJ0sckPbbG8dcot7S3xbumgzyubY/T4X25LP9uf3wX14xxoaRVJF2eTz9F0qUd5nNVfjyW5NOPl/STfsdo8PFdJGnNcY/vld3E7CKXJfm1cEU+/UJJh3Xxf+r6NS5pI0mXK33gvV3SLyWt2e//U47T1XuNpBdM9VMjznMkvS+/t/xr28/Bred0n583l1Q5r1/PG0l3S3pY0oOS7sqn7+ownzmS9sjv5TdI+pWk3WvG6PozMx8zqtQocIVS4bevpE/2439My9/grBoRl45rLHmoZow7I+JnQ5LL/RFxv23ZXikirrO9aYf5PBARf2/lY3uepvh2PZ7tHyq9wRwrabeIuCVf9N3celdL/la3r6SXSfqBpOOUum/PklS1m/N6SQsl/SGfXl/SlXVzkXS1pCdIumW6K07hb7Yfp/yY5m+fd9aMcZCk0yStb/s4SdtLenOH+dwXEQ/bfsj2GkotVLVarxuKITXz+D4UEXd22BC6HNtHa4LnfkS8pWKIByPi9jxuak5EnG370x2m08hrPCJutL2XpB8pFTsviYj7aoZp4v8kdfleExHndnn7LStKmq/Ug9PewnaXpNdMd3DTwwQkLbO9j6QTlB6PvTXWwlpX18+byC2S3cjDW/ZV+hJ/jqQ98ufe+kq9BD+uEa6Jz0xJUkT8xvbciFgm6WjbF3YSpy6Kv8H5i+2naOwD+DWq/0Z2tu3PKjXpP9A6MyIuH0AuN9teS+kN/Uzbf5X0p5oxWs61/SFJq9h+saR/Vo0uIUlfiYizJrogam6cbXuRpDuUukQ/GBGtx/mS3O0+3fGtbqE1JV1r+9J80TZKrWdV82jFWV3Sr3Kc9v95ne6lf1VqDX1K7vpYoAofMO0i4kzblyt14VjSARHxlzox2ozm587hSq1m90i6dOpDmo3R8ON7te3XS5pre2NJ+6vG/3qcU9r+XlmpxaLO6+oO2/MlnSfpONu3qcMPKXX5Grd9lZYvrB7dPisEAAAgAElEQVSr1NpxiW1FxBYVYjT5f5K6fK+Z4D49clFKZ/r7JD1SRJ5r+5sR8Qfbq0XE36rmoYaGCbR5vaQv5Z+QdEE+rxONfDbkIQzPzyfPiYhTprr+BA6XdISkgyLi3taZEXFTHjZSRxOfmZJ0r+0VlbqhP5NjrNZBnNqY8DEgtjdS2s7luZL+Kul3kt4QEb+vEWOisQoREbXG4DSRy7h4L1Aqdk6LiL93cPwcSW+V9BKlN9HTJR0R0zxZ3dCg53ExN4qIG+se13b8C6bJqVLLQVNx2uLNk7Sp0uN7fdQbB9mKsa7Gxpu28uhogk9bzA0krRERnbSKdhyjycfX9qpK4ynbn78fj4j7q8aYIvYcST+v+hq3vZqk+zU2bmtNScdFxO1d5lH7Ne40sWJSEfGHqS5vu92pYtR9HXT0XtN2fNf3aVy85yh90ZwfEQttbynpHRHxz3XiDKtOPxts/5ekrZV6XaTUErkoIj5YI8YqSi29D+fTlrRSJ6/Lpj4z8/PnVqWW3/cqPTZfjYjf1M2pLoq/ActvznNiCGYedZuL7blKY63ai4FOZxWuqNR1G0rFybRvFLmLTEpjIJ+r1C0rpXFO50TElMXhuFhNd6O0ZtlunU9eGhG31Y2R4zxBqeUwlMbv/bnm8SsrtXC0Zh7/UtLX67wJ5q7DPZXGMj6cz446LS+2pxzEXrcFuxfF6LDJ3WU/jYin9vE2HzvV5RHxfzXjbac03vXufHp1SU+PiEtqxNhQ0i2t52z+YH98zS/PcyUdExFvqJP/FPG6njVs+xKlVviTI2KrfN7VEbF5xeObmoiwslJR/A9afoZu1eEG4+M9RmmoS/trs/Lr2/aVkp7ZVrjNVRpvV6llNR9zkdIQg/bn3ekR0fEyMsP0+V0X3b59ZvsNEfHt8cVFa+xAnaLCaTbrQRprCj9XaVZhrfFbtleS9GrlZRPacjmkRox/ybncqrZiQFLlF2dbrJcrzbj7rdK38Q1tv2O68Y0RsW8+/hSlD5Nb8uknSvqfmmk02o1i+3WSPqs01sSSDrX9/oj4fs04b5P0/5QK21acQyLiqBphvqU0YPrQfHpvpfGRr60R4x8lbdrWDd6Jz+ffK0saUZqcYKXnzCVKxWklbcXor7T87M+6y5BMtNTFnUoDs983VSuw7S9GxIGeZAZoB12S7fk4//6zpH+vcdyEot5swkVtOSxUaumwpLUk/a+kDWvEklJx0l74/22C86bzPaUveC3L8nlbT3z1R4uIZbYX2F6xkx6Kdu5y1vC4vG7y8mPJ6oy1O1zS+yV9I8e60vZ3JNUq/pTeD66T9FJJhyi1Gl9bM4YkyfbHlcYD36jlPxvqzhJfS1Lri8aaHaSySnuRFhF351b6ypr8/M7HjV+xoxWnk/HKtVD89V+rP7+J4uIopYHPr8un/0lpCY/KLVzZj5U+4BapbfxMTQcoFQNddSdln5f0wlbTdx5b8VNJVSe3bBBjkzykVJBuUieBiPhY/na5f0T8d51jJ/FhSVu3WvtsL5D0c0m1ij+lN/atWo+z08SNC5WeC1VtGhFbtp0+2/aSmnncKGkFdf58UUS8UJJsnyBpvxhb+mNzSf9WM1wTxagkfUFpPNJ3lAqcvZQmFlyv9BjvOMWxx+bfn+syh0d0OtA9GlyyIyI2zLG+rtQidWo+vauknTtIz+3dqpEm6tT9LJrXXrBFmrSxYge5/F7SBbZPVipCW/Hqtuy/W6k1/pJ8/A1OayvWdZPT+oWR78/+qld0NTUR4akR8Vrbu0fEMbmAPL2DOFL6fHpKlwX2pyRdkYc6WanB40M1Y9xre8uIWCJJTksw1e3ybRWLTTUOHKnU3btInU+o6QjFX59FROsb2ccaCPeUiHh12+mP2V7cQZz1ImKXLnO5SfVnjE7mtnFjHm5Umr1Z1Tm2T1daUy+UPsBrr+WUWwZeKamJ4m/OuG7e29XZDjs3K7Xatdyt9NjXcYXt7SLiYkmyva3SgO467lUapPwLLT/gfv+acSRps1bhl2Ncnd+Y6+i6GM12iYht204fZvviiDjEaWLApCIvXFx33Nl03N0CuS8dd3++lrsWP9NBKltHxDvbcvhZbtWp60bb+yu19klpCELdcbVLbb8yIk6WJNu7S+pkwtGf8s8cdfeB3tWs4TbvVJpksa7Sa/0MpcKyqqYmIrTGAN+Rv4z9WalnqBNXK7XadTTMRZIi4njb5yi17FrSv9cd7qJUZJ1kuzUOc6FSr0cdT8m/fxUR36t57ESaWrGjNoq/PrP95akur/nheZ/tHSLi/Bx7e0l1l0yQpAttP6P9A7gDNyoVXT/V8sVA7bFxkq6xfaqkE5XexF6rtMjyq3LMKSduRMR7bO+hse7ww6LD3TSUHpuvKC2C3N4yUHdG9WltBamUuihP7SCfPyrNjvyx0mOzu6RLW90QFR/vbSW90XZrPOZCpZnIV6n6DMWT808TrrV9hKRvK92nN6h+F1NTxejDuYu+1SLbPgt6uglHk838bOXSyRCIbhfIbXLJjr/Y/oiW/z910tL/TklflvSRHOcXSl2mdWMcl1+bVvoC9Ma6ibS+hOfxXxER99SNkZ3r7lYoaI1j+6eI2KfDHKRUKB4maTPbf1SeiNBBnMPyl46PKr3O5ysNN+lEq9XuanU4M9v2LyLiRWp7z2k7r5KIuMRpkeenKT1nrumgNfJl+TXwH0rDDLrV1IodtTHho89sv2mqyyPimBqxninpGKXxD1YaD/HmVrN2jTi/Ulpo8ndKT8BayxTkGBNOle+khdNjEzcmCTn9oGOnyRWtSRHdTK5oZEZ1jtXa3s2SzuukIJ3scW5LbNrH2w3PUOyW0+Dyd2msWD9P0tei3gSUCV9XdV5POc5GSi0vz1F67lys1GLwR0nPbn3RmuTYxh/XXFBuLeniiHim7c0kfSwi9qx4/AZK92d7jS3ZcWB0MJPfaeJH+xjj83IutSZ8NMlpGRt3OuA+t2odqzRWT0qth2+MiGtqxulq1nBbnHMiYsc6x0wSZ2gmIti+RmkM4lUaG/NXqYU8vzesqtRzs6PSYytJa0j6WUTU2q83v37GbwH5nRrHf1bpi8pqSl84H7kohaq3M0eTny91UfzNAk6L2ioi7urw+Ak/tPpdBDTFj55c8TxJtSdX9IrttSXdXveDocHbXzjR+VFhZrbtEyPidZO1cnXSuoXJ2b4sIrbOwzm2jYgHbC+ODvdQHiTbH4iIz9g+VBM/dyq30nrcJLW2GJUnqeU4F0r6cOQtvmzvKOk/o4MZoHkcryJiad1j22J8UunLfK2eBje/F3Qjj2+OdW5ETLlEzxTHHqC09d+TlL6AtYq/uyQdHhFfqRHrI0rF+WZKxflLlfZYr7MKxEr5NfjjiNi96nHDiG7fPnODe0HmF8bRSuO+DndaOuODEXFGxePXyAVj198O8xvfB/TopQE6aSFbT2kmaqu14nylRYRvrhiiqckVrXxerkffr0pvgk7LWvyXUqvsx5VaGdaWNMf2GyPitIpxmtxD9Kcam725stJszetVbb/XA/LvV9S4vSm5ixlvTRWjTRQmnnyGbUetAlm3Cys3svRHjtXta7zVlV97l50JNDFJTZJWi7a9XSPinNxqVonTIL+DJL1H6f9s28skHdpJoaSxGcztx1aZGdsar7ipUktxq3t0N9Wc8Z419fhK0iLbn8o51erajIgvSfqS7X+JiEOnu/409lTakenyiPgnp1UgvlEzxkVKs9I7amhp8SSzhls6HC5VC8Vf/zU2E1DSWyLiS7ZfqrS23b5KxWCl4k9pRuMrtPxSDi2hettjHaf0bfUVSuNx3iSp02/AR+fcWkuPvCGf9+KKxzc1uaI1w3FVpbUCj1AaA1Zn94mvKM1KW1NpeZZdI+Li3P1wvNIWaVU0OYP0Ge2n85eGd1Q89pb8u8lW4W5mvDVVjHZdmEQDW1BNEHOP/OfBuYtoTVV/zkjNLf0hdfkaj4if5HFtm0fE+zu4/XZNTFKT0uSTj2pspvYblIa/VHWg0pfUrSPid9IjQwe+Zvu9UXOlgMgz4OtqG7t4hqRnxdhadgers7FpTT2+krRV/r1d23l1l3p52PZaEXGH9MgkqL0j4qs1YtwXaRLfQ3mM559VfwvIFfMQk+d6gk0FovpGAk2u+tGZ6ONm0fw0+6O8WbzSmJ498t9XDCiXRe055b/P7TDW4irnTXH8Z5Wa9d+cf06T9JkuH+PW7/mSzujkvki6dtxlHf2vlFaD3zz/rNDQ/+/ymtd/ldKm6Heq+43WO9owvpc/Si1C3cZYR2kyzUJJC2seu7JSYfEVpcJ8Xoc5XJZ/t29AX/m1NC5WI69xSWc18NgeJukZDcR5jNLkk8slXZHfSx9T4/grJK09wfkLunh9v1yphfX/tX5qHHud0q4VrdMrSbpugI/vHEmvayDORJ8JtR5fpS9AaylNirle0mWSvlUzxg5KLem3KzVItP8c1cH9WtDtY9PpDy1/fdbwmKlF+ZvehpL+I3+beXiaY9pzaXKHhdbSALfkbtI/Kc1Q7MRfbL9BYzNj91aNWYUR8f78rWx7pdbMr0fEjzrMpTV7+l7bT8p51FnUtv3/MX4mdu0xf3lM0jFK65NZ0vq23xQ1drIY19UwR6kbo24r7Wck7RYRHS38Ok7HM96a7mp12/ZakjraXstpeaDPK41Tuk2pO/taVetWbzlG6TX1S0m7Kg1SP2DKIybW1NIfUnOv8Suc1tX7npYf11Zn+8UdJL3ZdseT1PJt/lVpLb1OrRAT7GkdEUttr1A3WAM9Dccqzf4/Sel/vofSc6nq7V+t9J41T9K+tm9Ud4/vw7bfo7RyQzfm2H5kfcjcglx5XcfcPX9wpJbD/3FaeWGNmp9xijTh63zboxFxZJ1jJ3Fhfg5/V9IP8/OxL5jw0We2nxgRt3Q7ySI/mddT+oZ5Y0Tc4bTg77pRcU/TSWYataVSfbye7VcofVCtrzRebw2lmYC1lwPJExK+orEZlxcqjfmb8rEZVwh43MX3K+0Y8uGI+EWNXD6qdH9epLRLSCjN4vtoxeOXKX3AWdIqGpshZkkrR0StDwjbiyS9PiKuz6c3kXR8RDy7Roz2GcMPKRWSP4h6s2sviIjtq15/mlgDm/E2QS5dba+Vr79EqUvr5xGxle0XKnVRVV7OxPZVkbvnndaMuzQi6uyA0YrT2L7dTb3GPfFs/ogaW4c18P7ZyBha25dP9n+Z6rIp4l0ZEVu0/Z6vVBS8pEaMZylNcpPSqgJX1Dj2r0rj4iZU9fEdF/OjSl98x09iqTxLPH853EBp15RQGnZwU0S8r0aMRXXeJyeJ8YGI+Ez++7XRttaf7f+MiLoLT8v2Nkpr0f6j0g5FJ0TEt7vJs9LtUvwNnjuc/dnEk7kUrbFGSpvaV/4gHxdjJaWCranFrDvJ4crx374nOq8PeXxJaeeLH2n51ro6rTetWHMjopHV7Z12VWifjFBrb2nbl0TEtravaCv+lsTyO6JMF2M0IkZyEbhVbv24NCK2qRFjucKhk0JiXLyul/6wvSC6mMnaNNs7KO2le3SejDI/8ri7Cse2Zp++Sul53Pqw3VvS76t+iLd9uXvURersy13r+Xdxzu12SVdHxMYVjp2j1CXf0ftbjtHV82ySmBP9TyJqbGGW79s7lL6EW2lc+xF13jdsf01phnDHa+i1Pz49eI2urbTD0D4RMbfTOFXR7dtnbmj2Z3ax7a0j4rIG8tpcj17/6FsVjmty+YYJY3QSa4Jjl0lakm+jSi6P+oYXaeuwBzr9hteQUdtHamyA+j5KEyWm1VRrR7aGUitme4tEKHXd1vUb299XGjPT6f6hTXS1St1vryWlXRHmK82yPM72baq/xdaWtlszCq20ePBdqtmd7TRT+I169L7dnbyWGumicgMzkHPr9YjS7NajlXZ3+bbSUI9pRV5jzvbHI+L5bRf9xHblIRQ9+JA+Jf/PPqs0DjGUun+r5PKw7SW2F9b90tNmHU+xbEx0MAs18vaA3YiIh5WeM1+b7rrj2Z4XEQ8pDRV4u+3faqw3JmoWbJ7k74lOV8ltDaWu+b2Udg85SWl92p6j5a/PbI9qbPbnYRo3+7PV2lAx1q+U9qz9g5Z/MtdqBcpvpDsqFX+nKo0xOj8iXjPVcfnY3SLN4ut6kd3JYnQSq1u9/IbXZV4rKQ1YfmSxaElfjQp72ra1dkwoGt6WrCqnsap7Kc1Wn6O0h+4JUWPdyia6WnOctZUG/e+ssRaGA6LCntW2nyrp8Uo7cdyX78s+SoXoTyNv/9ZPTuvYXaxHL7Db0WupiS4q2+cqz0Duomt9sdIs0svbYtRuAbd9raSXR8SN+fSGkk6NmosH90InPQ22z1Ja6uVSjbVIRlRck872LUoF1oSFTNRYtL+JLlI3MEa+9X7tNPb1USLit9PFGB9r/N8Tna4Y73dKvScnRsRFdY7tFsVfn7ltgVbb17a/ybR3NVWM1cjizPmFtaXS7KktnXbHOCIidqsRY6s6Y0sqxlwtIibqUum5cd1+y/1f6v6fZqPczfZ2PXoR2MrjtiaJ+3yliT5rKa3L+PFYfp/nyY7ruqu1W7ZPkfShGDfm1vaIpIPqvJ4azKknX1S66aLy2MLV7a+xWgtXt/63bR/sq0m6qIPibxelL+GtvYU3UJrgc3qdOE3xBMuHKM2ovyoq7FI07guelb4k7h0RlVrAm3y+NFEo5V6Oo5QWeJ6o+Jv2s67J92s3P4b7kUks/Ua3b/81Nvuz9cT3uHFOHbgvf1g+lJuhb1P99Y++4LRo5veUWgNqbY/Uzg3MuGxATPL3RKd7brJvvi11PvRsb6y03+b4bv46//MfKw3+/7k63yu2lc9cpeUt9lX68P280ppyz1Nqid6kQpiuulobGnKwwfjCLx876rTN2iAca/vtkk7R8mMza2/J1mAXVRMzkE+0/Q1Ja+X79xalNQ1riYjT8uths3zWdVVa0XvorUoT3VqToHZUarndxPYhEXHsZAdKqfXeadvP10t6ndIEn6/XuP3aXZcVY3XaRXql0hqnT1QabnB8RCyumceCprqym+rmbx+C0xqKMe526gzB6QjFX/+1xvK0j+NRPl2rgGtwnNNoHmdyuNL4sXtUb3kBRcQLbT9B6Q3nsPxB8d0643jafFFp652Tc+wluUWonxr7PzWktYjxu/Pv9jF/9z766lM6WmlXgv9WWlJiX9V/0181Iv695jGTuUHpw+6zEXFh2/nfr/F/313py9R7lR6TNSXV2Ve6iV0npnperNJA/E78XWn82Ic1VtzWXcC9ZYlSF9UhXXZRvVuptW0z239UnoFcJ0BEfM72i5XWmNxUaS28MzvMZ+McY2Wl132l8c498rCkp0XErZKUe2G+JmlbpS82ExZ/TuMo99LYsljfVerZq7to9Is6zHsiXX+BjrEdPp6sdP+Odtrv93ilRoZfVwgzV6khocnCtltNbvbQmRjQAoP8dP+j9Gb8OOXFLpU+yA/rMuYGkrboMsYzlN6k/t7h8Zfk3+0L0y4Z9OM9DD+SLqhy3jQxWov1XtV23i9rxviEpJc1dJ/mT3DegTVjfLrKeT3+3xwv6e0TnP9WpS9Cg3i+/FYTLELcYSw3nNtqklbv4Li5SmM7m8jhIKUvHrcqfSn6s6TvD+J/lfO5atxpK832Xe79cILjHpZ0rqSntp1346DuR779ZRpbAP6h/Hfr9INdxN1KaXHtZRWvX2sB+wE8TqtI2rTft0vL38z2YETcbnuO7TkRcbbtT9cNYvvHSt8UfxwdrP+VYzxNae/E1yh98zxBUuU1mMZpYsblbLWa7R0iLTaq/DhV3os0u99p6YQbnBZg/aPSbhR1HCDpQ7YfUFr8t+P9ayPingnO/lelFuCqXixpfEvkrhOcN6U8lvHf9egu8SprDh4o6STb7TOwR5QWo91j0qN66xrVbxmezNq2O97bd7KuN4/NQK7U/RZpi657ba8Z3S+79BqNjXfetzXeucuY3fhlHjvamhzxaknn5TGNd0xx3KuVWsbOtn2a0vvvQFu6osGZ0E4LZu+idB9fpFToVm3ZH6YWv+XY3k2pFXBFSRvmLvtDgm5fTKOJJSWkNHB7T0mfsn2pUiF4StRY9FfpW/Pxkl4SEZU3np/EO5VmXK4r6WalGZfvnvKIcrxV0lG218yn71Aa71THgUq7COyvtNzQTkr7tFYWPdjHdpxKb9i23yXpnyVtZLt9vN3qki7o4HZb+9e+XDX3r43UVfdcp5nGrZmrP42IszrIoynLJC12Wki7fcxfJ0u9dLt/d+s5s6nSjNTW4tC7Kb2H1XG/pKtsn6nlFw6ue7+aGO/cpHcrre/Xms3/LaUF2EOpZ2dCEXGS0heP1ZRmYr9X0uOd1rY7KSKq7vc+VHLX/t5Kr8dLlYra/aLeRMAmu7KbdrDSuNlzJCkiFvdrfDCzfWcg92hJiTzwfielWZy7dNKKg/7IH1RuoOWjmxweozReqr0VqO6H+GSx/zciFla43ppK+7N+StIH2y66Ozqb1LAoIp7ttmVDbJ8bEVMukzOs3MASTG2xGnlsnLakfHXkBaedlvr5XkTsUiNGI/fL9leVlt7aS6mn4h6lfWT3rROnCfn99/SI2LmheI+V9FpJe1ZtnR02+UvLd5QK4Nqv52HniReV78ui/bT8zUxfVFpSovXt52FJxzgtKXGw0jfpWmyvko/bU2mv10pvop58HaaO1hzMMXuyjMhs4LT216v16EV7D6lwbGOLPNt+m1LX73pKX0K2k3SR0peHqjGm2pe30gSJXPzeqdQ60D7zfb7t+VF/sdsm96geuE6KvCk09dgsVJqI0vJ3pefztJwXMG7qfsXYCgJfz92la0TF7TGb1nB3tnKx9I38MyNF/QkrM83Vtl8vaW6edb6/0namPUfxNzNtMNEbVHS4pITt7yrNJjtNaf/acyKtqF7F3ba3Vyocm2pGbmwZkVnox0rFziK1deNV1JphNuGWVjVjHaDUdXdxpJnem6ne7NpGu47z2JkvqPuZ75/IrYnv09j+tQc2lWe/TPBlrF1Eje3q2jT12Bwr6VLbJ+Uc91Dq3qziR0pfTmX7BxHx6g5u/xH5vWtx/iK9g6Rn2f5SdLCHbUOa6s7GzPAvSjPxH1AaNnW60lCcnqPbdway/ZuIeGrdy6aIt4ukM6OD/VVtH6DUZdLNOkzjY9Za8LUkrrkTwiQxzovlt7Sa8LxpYrQW6l0saduIeGCQ/zd3ucOH7fUi4uZJLtstIn7SYLo954kXgLdSS92HIuJlDd3OgRFRZ2JO67hnKa3jKEnnRcUF4j3F4uudyONEt5S0hVJReqSkVw2qm7/JbnpgKnMGnQA6cpnTwqbLsf1WVdznNV//A1Ja6FSpNaj9sv+sEiMivhQRz5H0AqX9io+2fa3t/+e09lQnTrHdyIfTLHSh7Wd0GWOB7UcGtTttabWgZoybndaG/JGkM51mjHc70acbD0bagu2Rme+S6hSiv5io1dz2vqo363goRMQfWj9KYyLfrTSo/ONKC2c3ZdLFc6exqqS7Iq3jdnN+DlYx1dpxnXgoT6bYXdKXcj69nsw0qYg4ZqKfQeWD3rB98lQ/fcmBlr+Zx2k5gpOUxso8akmJiPhzxTg92b/W9lZKW/Js0cl0/zwWbDWl+/d3dbGMyGzjtJ/zU5UWxn1AHYytdMNbWjltKbWmpNMi4u/TXb8XbP9caZbjpyStrdT1u3VEPLfi8S9TmmH+soi4IZ/3H0o7Jew6WavgsPLEi/7+W0RMuCVkF7dzU0SsX/OYg5TerzaNiE1sP0lpwsf2FY6danut2u8RTvsMn6a00PnzlWYvL46Ibr9gdcTN7L6DIWd7qaSblLp6L9G41Q2iD/usM+ZvBormlpRoYvuddOXu1mFaTpNjwWahXbsNEA1taWV7B0kbR8TReZLOukpFad94bOb7+B0+nqw0nqaSiDjVac3Cn9n+R0lvUxrT+PyI+GvjiffedUrjZneLvDey7ff24HY6aT3YQ2mh3sslKSL+lGf8Tn9jDa4dl+2pVOC/NSL+bHuh0o4og9LE7jsYfk9QWpt0b6Xn30+Vhkx1vC1qXbT8FayJlj9PvA7Tj6LeOkzjY1rpA3zDiPi47fUlPTEiam05N5t53H7OdWe12t5cj25dqLylVTetN01yWhD3Q+MnQOWZ7wdFRK2Z77mg/ZHSjLvXRb21LoeG7dYevM9Vatk6QdIREVG1e7U91pSzsiOiViOC7UsjYpvWe4zT2nQX9WN5i2HnseV0rmq1Ptr+ZUQ8b7pjMTM5reCwt9KXjkMi4tC+3C7FX7mm6UJZOSJWqBCj8XWYnBYmfVjSThHxNKf15M6IiK2biD+TeZL9nCOi8qzWXLjtqFT8narUmnh+RLymRozFyq030ef1qcblMekEmPYP0ApxWgWOJa2ktKzJMs3wIQceW/R3b6UJMcdowIv+2v43pfUhX6zUxfkWSd/p14dezmGqgnZg/2/bFyhNhPm+pLOUdt/5r4jYdBD5oHdy0fdypdfmBkqLnh8VEX/sy+1T/GHYtLUItM/sWxKdLU8xq3Q7qzXHuEpjW1ptmceQHlGnlWxYWm+anvk+m3mIFv3NPQYvUSq2To+IMweZz7CwvbXSEkVrKU3OWVPSZyLi4oEmhkbZPkZpyNbPJJ0QEVf3OwfG/GEYPei02n3a2TyNJ6u67uBs18R+zk1saXWi7W9IWivPPH+rBrMn6mW23x4Rh7efWXfmewliCBb99fK7WFDwjRMRl+U/71Ea74fZ6Z+Uet02kbS//ciwzr61PFP8YRh9WWk28zq2P6m0+fpHBpvS0GhiP+fRvEzL4UoF0j1K4zUri4jP5dabu5TewD4SET+vmUcTDlTa03QfTTDzfQD5YArR8C4Ws8V0y3tEjd13MPwiYuDL7NHti6HktGPEi5S+Cf0iIjEYK9oAAAKJSURBVK4dcEpDIXevtu/nvKak4yKtcddJvA1UY0urcWOlxs9CvF/SbyV9OCJ+0Uk+nRo38/2aDma+o09sn6i0HSC7WGTDsPQHykLxh6Fhe2VJ71Rax+4qSUdGRN1WraLkbrS9IuK4GsdMuJNHRJzXQC6bKxWjXe1CgtnL7GLxKPm101o5YQsNYOkPlIXiD0PDaY/hB5XWJ9tV0u8jYsbtq9oLeWzeu5XW0jtZqdXk3ZLer7Qo7e41YrVvVbaypG0kLWpqEoDtd0TEjN1MHr1he2HdJYlKNKilP1AWij8MjXFrW82TdGmVtQZL4LR92l8lXaTUHf4YpXFtB0T3eymvrzSjcO+uEwUmMW5d0R9ExKsHndMwGfTSHygLEz4wTB5s/RERD7XNgIK0UVthfISkv0haGBF3NxD7Zo2NlwN6pf0FzXZlbcYt/fGxQSz9gbJQ/GGYbGn7rvy3Ja2ST8/ohXYb0l4YL7P9u04LP9uHamzSxhylxZqXdJ8iMKWY5G8MwdIfKAvdvsAM0LYbi7T8jiy1PxzaBtyH0jIxv4+ICxtMF3iUaXYUosAB+ojiDyiE7d0lrRcR/5NPXyppgVIR+IGI+P4g8wMA9MfAFxoE0DcfUBpE3rKipGcr7fP7rkEkBADoP8b8AeVYMSJuajt9ft7y6//y4tEAgALQ8geU4zHtJyLiPW0nF/Q5FwDAgFD8AeW4xPbbx59p+x2qubcvAGDmYsIHUAjb60j6kaQHJF2ez362pJUk/WNE3Dqo3AAA/UPxBxTG9k6S/iGfvCYizhpkPgCA/qL4AwAAKAhj/gAAAApC8QcAAFAQij8A/7/dOhAAAAAAEORvPchFEQAj8gcAMCJ/AAAjAbP/A655++FZAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 720x576 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "n_splits = 4\n",
    "cv_iter = ShuffleSplit(n_splits=n_splits, test_size = 0.25).split(np.arange(0,len_array))\n",
    "\n",
    "\n",
    "fig, ax = plt.subplots(figsize = [10, 8])\n",
    "\n",
    "box_width = 0.8\n",
    "\n",
    "for subject, yr in enumerate(school_year):\n",
    "        if yr == '2014':\n",
    "            ax.add_patch(patches.Rectangle((subject-0.5,0-box_width/2),1,box_width,facecolor = c_arr[2],\n",
    "                                          label = '2014'))\n",
    "            \n",
    "        if yr == '2015':\n",
    "            ax.add_patch(patches.Rectangle((subject-0.5,0-box_width/2),1,box_width,facecolor = c_arr[3],\n",
    "                                          label = '2015'))\n",
    "        if yr == '2016':\n",
    "            ax.add_patch(patches.Rectangle((subject-0.5,0-box_width/2),1,box_width,facecolor = c_arr[6],\n",
    "                                          label = '2016'))            \n",
    "for subject, unibool in enumerate(went_to_uni):\n",
    "        if unibool == 'y':\n",
    "            ax.add_patch(patches.Rectangle((subject-0.5,-1-box_width/2),1,box_width,facecolor = c_arr[4],\n",
    "                                          label = 'y'))\n",
    "        if unibool == 'n':\n",
    "            ax.add_patch(patches.Rectangle((subject-0.5,-1-box_width/2),1,box_width,facecolor = c_arr[5],\n",
    "                                          label = 'n'))\n",
    "\n",
    "for split in range(n_splits):\n",
    "    single_fold = next(cv_iter)\n",
    "    for idx, group in enumerate(single_fold):\n",
    "        for subject in group:\n",
    "            ax.add_patch(patches.Rectangle((subject-0.5,split+1-box_width/2),1,box_width,facecolor = c_arr[idx]))\n",
    "\n",
    "ax.set_xticks(np.arange(0, len_array))\n",
    "ax.set_xticklabels(names, rotation = 90)\n",
    "ax.set_ylim([-1.8, n_splits+0.8])\n",
    "ax.set_xlim([-1.5,len_array])\n",
    "ax.set_yticks(np.arange(-1,n_splits+2))\n",
    "ax.set_title('ShuffleSplit')\n",
    "ax.set_ylabel('CV iteration')\n",
    "yticks = ['uni (y/n)', 'year']\n",
    "for n in range(n_splits): yticks.append(n)\n",
    "ax.set_yticklabels(yticks)\n",
    "plt.savefig('images/shuffle_split_cv.png', dpi = 300, bbox_inches = 'tight')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that due to the randomized nature, some students appear in the test split multiple times.\n",
    "\n",
    "### Stratified Shuffle Split\n",
    "\n",
    "`StratifiedShuffleSplit` takes account of the stratification of the entire dataset with regards to some target variable (which here is `uni (y/n)` again)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "n_splits = 4\n",
    "cv_iter = StratifiedShuffleSplit(n_splits=n_splits, test_size = 0.25).split(np.arange(0,len_array), y = student_df['uni (y/n)'])\n",
    "\n",
    "\n",
    "fig, ax = plt.subplots(figsize = [10, 8])\n",
    "\n",
    "box_width = 0.8\n",
    "\n",
    "for subject, yr in enumerate(school_year):\n",
    "        if yr == '2014':\n",
    "            ax.add_patch(patches.Rectangle((subject-0.5,0-box_width/2),1,box_width,facecolor = c_arr[2],\n",
    "                                          label = '2014'))\n",
    "            \n",
    "        if yr == '2015':\n",
    "            ax.add_patch(patches.Rectangle((subject-0.5,0-box_width/2),1,box_width,facecolor = c_arr[3],\n",
    "                                          label = '2015'))\n",
    "        \n",
    "        if yr == '2016':\n",
    "            ax.add_patch(patches.Rectangle((subject-0.5,0-box_width/2),1,box_width,facecolor = c_arr[6],\n",
    "                                          label = '2016'))\n",
    "            \n",
    "for subject, unibool in enumerate(went_to_uni):\n",
    "        if unibool == 'y':\n",
    "            ax.add_patch(patches.Rectangle((subject-0.5,-1-box_width/2),1,box_width,facecolor = c_arr[4],\n",
    "                                          label = 'y'))\n",
    "        if unibool == 'n':\n",
    "            ax.add_patch(patches.Rectangle((subject-0.5,-1-box_width/2),1,box_width,facecolor = c_arr[5],\n",
    "                                          label = 'n'))\n",
    "\n",
    "for split in range(n_splits):\n",
    "    single_fold = next(cv_iter)\n",
    "    for idx, group in enumerate(single_fold):\n",
    "        for subject in group:\n",
    "            ax.add_patch(patches.Rectangle((subject-0.5,split+1-box_width/2),1,box_width,facecolor = c_arr[idx]))\n",
    "\n",
    "ax.set_xticks(np.arange(0, len_array))\n",
    "ax.set_xticklabels(names, rotation = 90)\n",
    "ax.set_ylim([-1.8, n_splits+0.8])\n",
    "ax.set_xlim([-1.5,len_array])\n",
    "ax.set_yticks(np.arange(-1,n_splits+2))\n",
    "ax.set_title('StratifiedShuffleSplit')\n",
    "ax.set_ylabel('CV iteration')\n",
    "yticks = ['uni (y/n)', 'year']\n",
    "for n in range(n_splits): yticks.append(n)\n",
    "ax.set_yticklabels(yticks)\n",
    "plt.savefig('images/strat_shuffle_split_cv.png', dpi = 300, bbox_inches = 'tight')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Group Shuffle Split\n",
    "\n",
    "`GroupShuffleSplit` ignores the stratification of the dataset with regards to target variable, but ensures that different groups are seperated in training and testing (our groups here are the graduation years)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "n_splits = 5\n",
    "cv_iter = GroupShuffleSplit(n_splits=n_splits, test_size = 0.25).split(np.arange(0,len_array), groups = student_df['year'])\n",
    "\n",
    "\n",
    "fig, ax = plt.subplots(figsize = [10, 8])\n",
    "\n",
    "box_width = 0.8\n",
    "\n",
    "for subject, yr in enumerate(school_year):\n",
    "        if yr == '2014':\n",
    "            ax.add_patch(patches.Rectangle((subject-0.5,0-box_width/2),1,box_width,facecolor = c_arr[2],\n",
    "                                          label = '2014'))\n",
    "            \n",
    "        if yr == '2015':\n",
    "            ax.add_patch(patches.Rectangle((subject-0.5,0-box_width/2),1,box_width,facecolor = c_arr[3],\n",
    "                                          label = '2015'))\n",
    "        if yr == '2016':\n",
    "            ax.add_patch(patches.Rectangle((subject-0.5,0-box_width/2),1,box_width,facecolor = c_arr[6],\n",
    "                                          label = '2016'))\n",
    "            \n",
    "for subject, unibool in enumerate(went_to_uni):\n",
    "        if unibool == 'y':\n",
    "            ax.add_patch(patches.Rectangle((subject-0.5,-1-box_width/2),1,box_width,facecolor = c_arr[4],\n",
    "                                          label = 'y'))\n",
    "        if unibool == 'n':\n",
    "            ax.add_patch(patches.Rectangle((subject-0.5,-1-box_width/2),1,box_width,facecolor = c_arr[5],\n",
    "                                          label = 'n'))\n",
    "\n",
    "for split in range(n_splits):\n",
    "    single_fold = next(cv_iter)\n",
    "    for idx, group in enumerate(single_fold):\n",
    "        for subject in group:\n",
    "            ax.add_patch(patches.Rectangle((subject-0.5,split+1-box_width/2),1,box_width,facecolor = c_arr[idx]))\n",
    "\n",
    "ax.set_xticks(np.arange(0, len_array))\n",
    "ax.set_xticklabels(names, rotation = 90)\n",
    "ax.set_ylim([-1.8, n_splits+0.8])\n",
    "ax.set_xlim([-1.5,len_array])\n",
    "ax.set_yticks(np.arange(-1,n_splits+2))\n",
    "ax.set_title('GroupShuffleSplit')\n",
    "ax.set_ylabel('CV iteration')\n",
    "yticks = ['uni (y/n)', 'year']\n",
    "for n in range(n_splits): yticks.append(n)\n",
    "ax.set_yticklabels(yticks)\n",
    "plt.savefig('images/group_shuffle_split_cv.png', dpi = 300, bbox_inches = 'tight')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ok, so for 3 groups (school years in our case) the result is rather trivial, but we can see how this cross validator keeps groups seperated in train and test, doing this randomly with each CV iteration."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Group Stratified Shuffle Split\n",
    "\n",
    "Following the last two examples, we might expect the next cross-validator to follow would be one which captured the essence of its two predecesors. That is, a cross-validator which keeps groups seperated between train and test splits, as well as ensuring that the proportion of 'positive' or 'negative' samples (i.e. based on a defined target variable) in the train and test split (ensuring this is the case for either the train or test is clearly sufficient) are representative of the dataset as a whole (i.e. stratified).\n",
    "\n",
    "### A (too) simple example\n",
    "\n",
    "For our previous example, each group (school year) had the same proportion of students going on to study at university, therefore the `GroupStratifiedShuffleSplit` cross-validator performs similarly to `GroupShuffleSplit`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "n_splits = 5\n",
    "\n",
    "cv_iter = GroupStratifiedShuffleSplitBinary([np.int(x) for x in student_df['uni (y/n)'] == 'y'], student_df['year'], n_splits = n_splits, frac_train = 0.6).split()\n",
    "\n",
    "fig, ax = plt.subplots(figsize = [10, 8])\n",
    "\n",
    "box_width = 0.8\n",
    "\n",
    "for subject, yr in enumerate(school_year):\n",
    "        if yr == '2014':\n",
    "            ax.add_patch(patches.Rectangle((subject-0.5,0-box_width/2),1,box_width,facecolor = c_arr[2],\n",
    "                                          label = '2014'))\n",
    "            \n",
    "        if yr == '2015':\n",
    "            ax.add_patch(patches.Rectangle((subject-0.5,0-box_width/2),1,box_width,facecolor = c_arr[3],\n",
    "                                          label = '2015'))\n",
    "        if yr == '2016':\n",
    "            ax.add_patch(patches.Rectangle((subject-0.5,0-box_width/2),1,box_width,facecolor = c_arr[6],\n",
    "                                          label = '2016'))\n",
    "            \n",
    "for subject, unibool in enumerate(went_to_uni):\n",
    "        if unibool == 'y':\n",
    "            ax.add_patch(patches.Rectangle((subject-0.5,-1-box_width/2),1,box_width,facecolor = c_arr[4],\n",
    "                                          label = 'y'))\n",
    "        if unibool == 'n':\n",
    "            ax.add_patch(patches.Rectangle((subject-0.5,-1-box_width/2),1,box_width,facecolor = c_arr[5],\n",
    "                                          label = 'n'))\n",
    "\n",
    "for split in range(n_splits):\n",
    "    single_fold = next(cv_iter)\n",
    "    for idx, group in enumerate(single_fold):\n",
    "        for subject in group:\n",
    "            ax.add_patch(patches.Rectangle((subject-0.5,split+1-box_width/2),1,box_width,facecolor = c_arr[idx]))\n",
    "\n",
    "ax.set_xticks(np.arange(0, len_array))\n",
    "ax.set_xticklabels(names, rotation = 90)\n",
    "ax.set_ylim([-1.8, n_splits+0.8])\n",
    "ax.set_xlim([-1.5,len_array])\n",
    "ax.set_yticks(np.arange(-1,n_splits+2))\n",
    "ax.set_title('GroupStratifiedShuffleSplit')\n",
    "ax.set_ylabel('CV iteration')\n",
    "yticks = ['uni (y/n)', 'year']\n",
    "for n in range(n_splits): yticks.append(n)\n",
    "ax.set_yticklabels(yticks)\n",
    "plt.savefig('images/group_stratified_shuffle_split_cv.png', dpi = 300, bbox_inches = 'tight')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(N.B. We've specified a train-test split of 0.6:0.4, hence the first year group is never selected as a test set.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The Difficulty in splitting by Group and keeping things Stratified\n",
    "\n",
    "In a more realistic scenario, each group will typically contain a different proportion of 'positive' and 'negative' (as defined by the target variable) samples. What we'd like is to specify a train:test ratio (e.g. 0.8:0.2), then let our cross-validator go ahead and sort the data into train and test portions, with each group being in either of (but not both) the train or test split, and the train and test split being representative of the entire data set with respect to the target variable (i.e. stratified). We can then state our requirements as follows; our `GroupStratifiedShuffleSplit` cross validator should adhere to the following conditions:\n",
    "\n",
    "1. Each group occurs in either the test or train splits. The number of samples in train-test is specified as a ratio by the user, though we allow our cross validator to reach this ratio approximately, as the size of groups may make reaching an exact train-test split impossible. This is the `Group` part.\n",
    "\n",
    "2. Both the train and test splits contain a proportion of 'positive' and 'negative' (as defined by the target variable) samples which is representative of the entire data set. We let our cross-validator be approximately representative as condition 1. already constrains the CV quite strongly. This is the `Stratified` part.\n",
    "\n",
    "3. The train and test splits should be randomized on each iteration, otherwise we make redundant all the statistical merits of running multiple CV iterations. This is the `Shuffle` part.\n",
    "\n",
    "If we simply let our cross-validator randomly choose a number of groups for the train and test splits which achieve the closest value possible of the desired train-test split (i.e. conditions 1 and 3 are satisfied), we have no guarantee that the train and test data will be correctly stratified (i.e. condition 2 is not satisfied). Moreover, if we simply constrain the validator to find the best train-test split under the constraint that groups cannot be split between train and test (i.e. conditions 1 and 2 are satisfied), we have a unique solution and get the same split each time (i.e. condition 3 is not satisfied)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### How we select samples for the training set\n",
    "\n",
    "Here we'll go into detail about how we circumvent some of the problems raised in the previous section. We'll talk about forming the training set, the test set will then simply be formed of all the entries not used in the training set (we could equivalently build the test set in this manner, then form a training set from all entries not selected for the training set).\n",
    "\n",
    "Firstly, we calculate some aggregates for all groups in our data, namely; the number of entries ($N_{entries}$), the number of those entries with target variable `= True` ($N_{target}$), and the proportion of target variable `= True` within the group ($N_{target}$/$N_{entries}$). This gives us a table which looks something like this:\n",
    "\n",
    "![alt text](images/table_1.png \"Aggregate table for groups appearing in data set\")\n",
    "\n",
    "Next we randomly select (without replacement) one group and add it (i.e. all entries belonging to that group) to the training set:\n",
    "\n",
    "![alt text](images/table_2.png \"Randomly select a single group\")\n",
    "\n",
    "The first thing to check now that we've begun contructing our training set is the ratio of train to test splits. The user specifies a ratio $R_{tt} := N_{test}/N_{train}$ and we want to get as close to that as possible, so we check that the current number of entries in our (under construction) training set, let's call it $N_{train,1}$ (it's simply = 45 in our example here), is sufficient. That is, if: \n",
    "\n",
    "$$\\frac{N-N_{train,1}}{N_{train,1}} > R_{tt} $$\n",
    "\n",
    "Then we must add further groups to our training set. Let's safely assume that for our ficticious dataset this is the case. Then we need to add some more entries, i.e. another group, to our training set. But which group should we choose? \n",
    "\n",
    "The stratified nature of the cross-validator means that we are constrained to have a class imbalance in our training set (approximately) equal to the class imbalance of the total data set. Let's call the total class imbalance, $I(t_N)$, and the current (under construction) training set imbalance $I(t_1)$. \n",
    "\n",
    "Though this notation seems a little cumbersome, it's trying to get across that the imbalance is a function acting on some set of entries in our dataset. This function outputs the class imbalance of that set (a real number between 0 and 1). Additionally, we've denoted the set of entries in our (under construction) training set after the first iteration -- i.e. having only chosen entries from a single group -- by $t_1$. Generalizing, $t_i$ is the set of entries in our (under construction) training set after adding entries from $i$ different groups (i.e. the $i^{th}$ iteration). Similarly, we denote the set of entries in group $j$ as $g_j$. Hopefully this will make sense as we go on, but to give some concrete values from the example we have here; $I(t_1)$ = 0.178, $I(g_1)$ = 0.01, $I(g_3)$ = 0.25, ...\n",
    "\n",
    "Now, back to the matter of bulking up our training set. When choosing the next group to add to our training set, we'd clearly like to make the choice such that the next iteration of our training set has an imbalance $I(t_2)$ which is closer to $I(t_N)$ than $I(t_1)$ was. Simply put, if our training set currently contains too small a proportion of positive training examples, we'd like that the next group we add to our training set have a high proportion of positive training examples, and vice versa. \n",
    "\n",
    "Concretely, let's define a value $\\Delta_{1,j}$ for each group in our dataset as:\n",
    "\n",
    "$$\\Delta_{1,j} = (I(t_1)-I(g_j)) \\times sgn(I(t_1)-I(t_N)))$$\n",
    "\n",
    "If you inspect this value carefully, you'll see it has some properties we'd like for choosing the next group to add. Concretely, if our training set currently contains too small a proportion of positive training examples (i.e. $sgn(I(t_1)-I(t_N)))<0$) then, as we've already said, we'd like to add groups with a large proportion of positive examples (i.e. $I(t_1)-I(g_j)< 0$), i.e. groups with a large positive value of $\\Delta_{1,j}$. You should be able to work out that the converse scenario also leads to desiring groups with large positive $\\Delta_{1,j}$ for our next addition to the training set. We can transform this $\\Delta_{1,j}$ into a probability via:\n",
    "\n",
    "\n",
    "$$ P_1(j) = softmax(\\Delta_{1,j}\\beta) $$\n",
    "\n",
    "where $\\beta$ is a hyperparameter, or if you like, an inverse temprature. Now we simply calculate this value for all groups not yet selected in our (under construction) training set...\n",
    "\n",
    "![alt text](images/table_3.PNG \"Assign probabilities to all other groups\")\n",
    "\n",
    "... and then select the next group based on these probablities $P_1$.\n",
    "\n",
    "![alt text](images/table_4.png \"Randomly select another group to add based on probailities P1\")\n",
    "\n",
    "Now we simply go ahead and repeat this process, calculating the current number of entries in our (under construction) training set, $N_{train,2}$, (it's = 152 in our example here),\n",
    "and ensuring the inequality:\n",
    "\n",
    "$$\\frac{N-N_{train,2}}{N_{train,2}} > R_{tt}$$\n",
    "\n",
    "holds, calculate updated probabilities for the remaining groups using the generalized forms of $\\Delta$ and $P$:\n",
    "\n",
    "$$\\Delta_{i,j}=(I(t_i)-I(g_j))\\times sgn(I(t_i)-I(t_N)))$$\n",
    "\n",
    "$$P_i(j) = softmax(\\Delta_{i,j}\\beta)$$\n",
    "\n",
    "![alt text](images/table_5.png \"Once more, assign probabilities to all other groups\")\n",
    "\n",
    "This process continues until we've added $k$ groups to our (under construction) training set s.t. the inequalities:\n",
    "\n",
    "$$ \\frac{N-N_{train,k}}{N_{train,k}} \\leq R_{tt}$$\n",
    "\n",
    "and\n",
    "\n",
    "$$\\frac{N-N_{train,k-1}}{N_{train,k-1}} > R_{tt}$$\n",
    "\n",
    "hold. Our completed training set then contains either $k$ or $k-1$ entries, whichever gives a ratio closer to $R_{tt}$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A better example\n",
    "\n",
    "Let's consider a more complex version of the previous dataset. Namely, we'll generate a dataset with 1000\n",
    "students who are distributed between 20 different year groups, and this time we'll include some features to train our model on. Our target variable will again be `uni (y/n)`. Let's take a look at the first few rows: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "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>final_year</th>\n",
       "      <th>height_cm</th>\n",
       "      <th>iq</th>\n",
       "      <th>name</th>\n",
       "      <th>weight_kg</th>\n",
       "      <th>uni (y/n)</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2010</td>\n",
       "      <td>163.074716</td>\n",
       "      <td>83.629949</td>\n",
       "      <td>Rosemary</td>\n",
       "      <td>35.240448</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2008</td>\n",
       "      <td>149.774261</td>\n",
       "      <td>81.249862</td>\n",
       "      <td>Jackie</td>\n",
       "      <td>46.919891</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2004</td>\n",
       "      <td>176.356205</td>\n",
       "      <td>143.567329</td>\n",
       "      <td>Devon</td>\n",
       "      <td>68.926693</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>2006</td>\n",
       "      <td>128.204217</td>\n",
       "      <td>85.486262</td>\n",
       "      <td>Wilburn</td>\n",
       "      <td>44.181996</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>2016</td>\n",
       "      <td>73.212990</td>\n",
       "      <td>128.170976</td>\n",
       "      <td>Anastasia</td>\n",
       "      <td>39.424008</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   final_year   height_cm          iq       name  weight_kg  uni (y/n)\n",
       "0        2010  163.074716   83.629949   Rosemary  35.240448      False\n",
       "1        2008  149.774261   81.249862     Jackie  46.919891      False\n",
       "2        2004  176.356205  143.567329      Devon  68.926693      False\n",
       "3        2006  128.204217   85.486262    Wilburn  44.181996      False\n",
       "4        2016   73.212990  128.170976  Anastasia  39.424008       True"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "student_df, poly_params = make_student_table(n_subjects, n_groups, imbalance, noise, yrly_std)\n",
    "# n.b. names taken from https://github.com/hadley/data-baby-names/blob/master/baby-names.csv\n",
    "\n",
    "# also make splits for training models \n",
    "X = student_df.drop(columns = ['name', 'final_year', 'uni (y/n)'])\n",
    "y = student_df['uni (y/n)']\n",
    "\n",
    "display(student_df.head(5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "| name      |   final_year |   height_cm |       iq |   weight_kg | uni (y/n)   |\n",
      "|:----------|-------------:|------------:|---------:|------------:|:------------|\n",
      "| Rosemary  |         2010 |     163.075 |  83.6299 |     35.2404 | False       |\n",
      "| Jackie    |         2008 |     149.774 |  81.2499 |     46.9199 | False       |\n",
      "| Devon     |         2004 |     176.356 | 143.567  |     68.9267 | False       |\n",
      "| Wilburn   |         2006 |     128.204 |  85.4863 |     44.182  | False       |\n",
      "| Anastasia |         2016 |      73.213 | 128.171  |     39.424  | True        |\n"
     ]
    }
   ],
   "source": [
    "print(tabulate(student_df.set_index('name').head(), tablefmt=\"pipe\", headers=\"keys\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's plot this dataset in the same way we did with our smaller one earlier. There are too many names to be resolved clearly, but we include them just to drive home the idea that each point on the x-axis corresponds to a different entry in our dataset (i.e. a different student in this example)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "yrs_in_table = student_df.sort_values('final_year')['final_year'].unique()\n",
    "yrs_col = [plt.get_cmap('rainbow')(x) for x in np.arange(0, 1, 1./len(yrs_in_table))]\n",
    "yr_col_dict = dict(zip(yrs_in_table, yrs_col))\n",
    "\n",
    "student_df = student_df.sort_values('final_year')\n",
    "\n",
    "c_arr = ['#0957C3',\n",
    "         '#D14124',\n",
    "         '#008330',\n",
    "         '#F2A900',\n",
    "         '#6B3077',\n",
    "         '#2CD5C4',\n",
    "        '#6CACE4']\n",
    "\n",
    "n_splits = 5\n",
    "#cv_iter = GroupShuffleSplit(n_splits=n_splits, test_size = 0.25).split(np.arange(0,len_array), groups = student_df['year'])\n",
    "\n",
    "cv_iter = GroupStratifiedShuffleSplitBinary(student_df['uni (y/n)'].astype(int), student_df['final_year'], n_splits = n_splits, frac_train = 0.8).split()\n",
    "\n",
    "fig, ax = plt.subplots(figsize = [10, 8])\n",
    "\n",
    "box_width = 0.8\n",
    "\n",
    "for subject, yr in enumerate(student_df['final_year']):\n",
    "    ax.add_patch(patches.Rectangle((subject-0.5,0-box_width/2),1,box_width,facecolor = yr_col_dict[yr],\n",
    "                                  label = str(yr)))\n",
    "\n",
    "            \n",
    "for subject, unibool in enumerate(student_df['uni (y/n)']):\n",
    "        if unibool:\n",
    "            ax.add_patch(patches.Rectangle((subject-0.5,-1-box_width/2),1,box_width,facecolor = c_arr[4],\n",
    "                                          label = 'y'))\n",
    "        else:\n",
    "            ax.add_patch(patches.Rectangle((subject-0.5,-1-box_width/2),1,box_width,facecolor = c_arr[5],\n",
    "                                          label = 'n'))\n",
    "\n",
    "for split in range(n_splits):\n",
    "    single_fold = next(cv_iter)\n",
    "    for idx, group in enumerate(single_fold):\n",
    "        for subject in group:\n",
    "            ax.add_patch(patches.Rectangle((subject-0.5,split+1-box_width/2),1,box_width,facecolor = c_arr[idx]))\n",
    "\n",
    "ax.set_xticks(np.arange(0, len(student_df)))\n",
    "ax.set_xticklabels(student_df['name'], rotation = 90, alpha = 0.1)\n",
    "ax.set_ylim([-1.8, n_splits+0.8])\n",
    "ax.set_xlim([-1.5,len(student_df)])\n",
    "ax.set_yticks(np.arange(-1,n_splits+2))\n",
    "ax.set_title('GroupShuffleSplit')\n",
    "ax.set_ylabel('CV iteration')\n",
    "yticks = ['uni (y/n)', 'year']\n",
    "for n in range(n_splits): yticks.append(n)\n",
    "ax.set_yticklabels(yticks)\n",
    "plt.savefig('images/group_stratified_shuffle_split_cv_full.png', dpi = 300, bbox_inches = 'tight')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [],
   "source": [
    "clf = RandomForestClassifier(verbose=True,n_jobs=-1)\n",
    "\n",
    "# and we'll do a search in hyper parameter space for the best params,\n",
    "# here specify parameters and distributions to sample from\n",
    "param_dist = {\"n_estimators\": sp_randint(10, 500),\n",
    "              \"max_depth\": [3, None],\n",
    "              \"min_samples_split\": sp_randint(2, 11),\n",
    "              \"min_samples_leaf\": sp_randint(1, 11),\n",
    "              \"bootstrap\": [True, False],\n",
    "              \"criterion\": [\"gini\", \"entropy\"],\n",
    "             'class_weight':[{1: w} for w in [1, 3, 10, 30, 50, 100,1000]]}\n",
    "\n",
    "# run randomized search for a given number of iterations\n",
    "n_iter_search = 50\n",
    "\n",
    "# find best model scoring on area under precision recall curve, aka average precision\n",
    "model_scoring = 'average_precision'\n",
    "\n",
    "# params for the cross validators\n",
    "number_of_cv_splits = 3\n",
    "test_size = 0.33\n",
    "\n",
    "# a few cross-validators to try:\n",
    "sss = StratifiedShuffleSplit(n_splits = number_of_cv_splits, test_size = test_size)\n",
    "gss = GroupShuffleSplit(n_splits = number_of_cv_splits, test_size = test_size)\n",
    "# this is the cross validator we've made\n",
    "gsssb = GroupStratifiedShuffleSplitBinary(y, student_df['final_year'], n_splits = number_of_cv_splits, frac_train = (1-test_size))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's go ahead and train a Random Forest model on this data (where we're attempting to predict whether a given student will go to uni). We'll want to tweak the hyperparameters, and for that we'll need a cross validator. Specifically, we'll perform a random hyper parameter search using `sklearn`'s `RandomizedSearchCV` function, and we'll do this three seperate times, using three seperate cross validators; `StratifiedShuffleSplit`, `GroupShuffleSplit`, and our very own `GroupStratifiedShuffleSplitBinary`.\n",
    "\n",
    "Let's take a look at the scoring metric (we chose area under the precision recall curve here, which is normally a pretty good choice for imbalanced data) for after each iteration for each CV:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-1)]: Done  34 tasks      | elapsed:    0.0s\n",
      "[Parallel(n_jobs=-1)]: Done  52 out of  52 | elapsed:    0.0s finished\n",
      "[Parallel(n_jobs=-1)]: Done  34 tasks      | elapsed:    0.0s\n",
      "[Parallel(n_jobs=-1)]: Done  91 out of  91 | elapsed:    0.0s finished\n",
      "[Parallel(n_jobs=-1)]: Done  34 tasks      | elapsed:    0.0s\n",
      "[Parallel(n_jobs=-1)]: Done 177 out of 177 | elapsed:    0.0s finished\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "RandomizedSearchCV(cv=<__main__.GroupStratifiedShuffleSplitBinary object at 0x0000021292DBC5F8>,\n",
       "          error_score='raise',\n",
       "          estimator=RandomForestClassifier(bootstrap=True, class_weight=None, criterion='gini',\n",
       "            max_depth=None, max_features='auto', max_leaf_nodes=None,\n",
       "            min_impurity_decrease=0.0, min_impurity_split=None,\n",
       "            min_samples_leaf=1, min_samples_split=2,\n",
       "            min_weight_fraction_leaf=0.0, n_estimators=10, n_jobs=-1,\n",
       "            oob_score=False, random_state=None, verbose=True,\n",
       "            warm_start=False),\n",
       "          fit_params=None, iid=True, n_iter=50, n_jobs=-1,\n",
       "          param_distributions={'n_estimators': <scipy.stats._distn_infrastructure.rv_frozen object at 0x0000021292DBE978>, 'max_depth': [3, None], 'min_samples_split': <scipy.stats._distn_infrastructure.rv_frozen object at 0x0000021292DBE198>, 'min_samples_leaf': <scipy.stats._distn_infrastructure.rv_frozen object at 0x0000021292DBC1D0>, 'bootstrap': [True, False], 'criterion': ['gini', 'entropy'], 'class_weight': [{1: 1}, {1: 3}, {1: 10}, {1: 30}, {1: 50}, {1: 100}, {1: 1000}]},\n",
       "          pre_dispatch='2*n_jobs', random_state=None, refit=True,\n",
       "          return_train_score='warn', scoring='average_precision',\n",
       "          verbose=0)"
      ]
     },
     "execution_count": 148,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# StratifiedShuffleSplit\n",
    "random_search_sss = RandomizedSearchCV(clf, param_distributions=param_dist, n_iter=n_iter_search,\n",
    "                                   cv=sss, n_jobs=-1, scoring=model_scoring)\n",
    "random_search_sss.fit(X, y, groups = student_df['final_year'])\n",
    "\n",
    "# GroupShuffleSplit\n",
    "random_search_gss = RandomizedSearchCV(clf, param_distributions=param_dist, n_iter=n_iter_search,\n",
    "                                   cv=gss, n_jobs=-1, scoring=model_scoring)\n",
    "random_search_gss.fit(X, y, student_df['final_year'])\n",
    "\n",
    "# GroupStratifiedShuffleSplitBinary\n",
    "random_search_gsssb = RandomizedSearchCV(clf, param_distributions=param_dist, n_iter=n_iter_search,\n",
    "                                   cv=gsssb, n_jobs=-1, scoring=model_scoring)\n",
    "random_search_gsssb.fit(X, y, student_df['final_year'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1584x576 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "res_dict = {'StratifiedShuffleSplit': random_search_sss, \n",
    "            'GroupShuffleSplit' : random_search_gss,\n",
    "           'GroupStratifiedShuffleSplitBinary' : random_search_gsssb}\n",
    "plot_multiple_hyperplots(res_dict, save_loc='images/3_CVs_hyperparam_search.png')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ok, so following this, we now have three different Random Forest models, each with their own 'optimal' parameters (i.e. the model giving the highest area under the precision recall curve in each of the above three plots). But what we really want to know is how well they perform on unseen data. With this in mind, let's try them out on the next academic year's students. Again, let's show the first few rows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "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>final_year</th>\n",
       "      <th>height_cm</th>\n",
       "      <th>iq</th>\n",
       "      <th>name</th>\n",
       "      <th>weight_kg</th>\n",
       "      <th>uni (y/n)</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2020</td>\n",
       "      <td>150.739956</td>\n",
       "      <td>78.272263</td>\n",
       "      <td>Davis</td>\n",
       "      <td>44.422353</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2020</td>\n",
       "      <td>107.642684</td>\n",
       "      <td>120.279417</td>\n",
       "      <td>George</td>\n",
       "      <td>49.323057</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2020</td>\n",
       "      <td>97.337951</td>\n",
       "      <td>99.454156</td>\n",
       "      <td>Kerry</td>\n",
       "      <td>59.769669</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>2020</td>\n",
       "      <td>123.797472</td>\n",
       "      <td>121.837970</td>\n",
       "      <td>Jean</td>\n",
       "      <td>59.504878</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>2020</td>\n",
       "      <td>86.573862</td>\n",
       "      <td>120.254181</td>\n",
       "      <td>Lavonne</td>\n",
       "      <td>60.811853</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   final_year   height_cm          iq     name  weight_kg  uni (y/n)\n",
       "0        2020  150.739956   78.272263    Davis  44.422353      False\n",
       "1        2020  107.642684  120.279417   George  49.323057      False\n",
       "2        2020   97.337951   99.454156    Kerry  59.769669      False\n",
       "3        2020  123.797472  121.837970     Jean  59.504878      False\n",
       "4        2020   86.573862  120.254181  Lavonne  60.811853       True"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# next year's data becomes available\n",
    "\n",
    "latest_student_df, poly_params = make_student_table(np.round(n_subjects/n_groups).astype(int), 1, imbalance, noise, yrly_std, poly_params)\n",
    "\n",
    "latest_student_df = pd.DataFrame(data = {  'name' : np.random.choice(name_array, np.round(n_subjects/n_groups).astype(int)),\n",
    "                                    'weight_kg' : np.random.normal(50, 10, np.round(n_subjects/n_groups).astype(int)),\n",
    "                                    'height_cm' : np.random.normal(130, 30, np.round(n_subjects/n_groups).astype(int)),\n",
    "                                    'iq' : np.random.normal(100, 20, np.round(n_subjects/n_groups).astype(int)),\n",
    "                                    'final_year' : np.repeat(2019, np.round(n_subjects/n_groups).astype(int)),\n",
    "                                  })\n",
    "\n",
    "# calculate indicator\n",
    "latest_student_df['uni (y/n)'] = went_to_top_uni_TF(poly_params, latest_student_df, imbalance, [2019], np.random.normal(1, yrly_std , 1), noise)\n",
    "\n",
    "latest_student_df.final_year = datetime.today().year\n",
    "\n",
    "display(latest_student_df.head())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "| name    |   final_year |   height_cm |       iq |   weight_kg | uni (y/n)   |\n",
      "|:--------|-------------:|------------:|---------:|------------:|:------------|\n",
      "| Davis   |         2020 |    150.74   |  78.2723 |     44.4224 | False       |\n",
      "| George  |         2020 |    107.643  | 120.279  |     49.3231 | False       |\n",
      "| Kerry   |         2020 |     97.338  |  99.4542 |     59.7697 | False       |\n",
      "| Jean    |         2020 |    123.797  | 121.838  |     59.5049 | False       |\n",
      "| Lavonne |         2020 |     86.5739 | 120.254  |     60.8119 | True        |\n"
     ]
    }
   ],
   "source": [
    "print(tabulate(latest_student_df.set_index('name').head(), tablefmt=\"pipe\", headers=\"keys\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's run our three models on our unseen data and see what happens, the confusion matrices will give us a great idea of how each model is performing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=8)]: Done  34 tasks      | elapsed:    0.0s\n",
      "[Parallel(n_jobs=8)]: Done  91 out of  91 | elapsed:    0.0s finished\n",
      "[Parallel(n_jobs=8)]: Done  34 tasks      | elapsed:    0.0s\n",
      "[Parallel(n_jobs=8)]: Done  52 out of  52 | elapsed:    0.0s finished\n",
      "[Parallel(n_jobs=8)]: Done  34 tasks      | elapsed:    0.0s\n",
      "[Parallel(n_jobs=8)]: Done 177 out of 177 | elapsed:    0.0s finished\n",
      "[Parallel(n_jobs=8)]: Done  34 tasks      | elapsed:    0.0s\n",
      "[Parallel(n_jobs=8)]: Done  91 out of  91 | elapsed:    0.0s finished\n",
      "[Parallel(n_jobs=8)]: Done  34 tasks      | elapsed:    0.0s\n",
      "[Parallel(n_jobs=8)]: Done  52 out of  52 | elapsed:    0.0s finished\n",
      "[Parallel(n_jobs=8)]: Done  34 tasks      | elapsed:    0.0s\n",
      "[Parallel(n_jobs=8)]: Done 177 out of 177 | elapsed:    0.0s finished\n"
     ]
    }
   ],
   "source": [
    "y_pred_gss = random_search_gss.best_estimator_.predict(latest_student_df.drop(columns = ['name', 'final_year', 'uni (y/n)']))\n",
    "y_pred_sss = random_search_sss.best_estimator_.predict(latest_student_df.drop(columns = ['name', 'final_year', 'uni (y/n)']))\n",
    "y_pred_gsssb = random_search_gsssb.best_estimator_.predict(latest_student_df.drop(columns = ['name', 'final_year', 'uni (y/n)']))\n",
    "# probabilities\n",
    "y_prob_gss = random_search_gss.best_estimator_.predict_proba(latest_student_df.drop(columns = ['name', 'final_year', 'uni (y/n)']))\n",
    "y_prob_sss = random_search_sss.best_estimator_.predict_proba(latest_student_df.drop(columns = ['name', 'final_year', 'uni (y/n)']))\n",
    "y_prob_gsssb = random_search_gsssb.best_estimator_.predict_proba(latest_student_df.drop(columns = ['name', 'final_year', 'uni (y/n)']))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {},
   "outputs": [],
   "source": [
    "cm_gss = confusion_matrix(latest_student_df['uni (y/n)'], y_pred_gss)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {},
   "outputs": [],
   "source": [
    "cm_sss = confusion_matrix(latest_student_df['uni (y/n)'], y_pred_sss)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {},
   "outputs": [],
   "source": [
    "cm_gsssb = confusion_matrix(latest_student_df['uni (y/n)'], y_pred_gsssb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Model optimized using `GroupShuffleSplit`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " |        | PN | PY | \n",
      " | ---    | --- | --- | \n",
      " | **AN** | 45 | 0 | \n",
      " | **AY** | 2 | 3 |\n"
     ]
    }
   ],
   "source": [
    "make_markdown_confusion_matrix(cm_gss)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Model optimized using `StratifiedShuffleSplit`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " |        | PN | PY | \n",
      " | ---    | --- | --- | \n",
      " | **AN** | 45 | 0 | \n",
      " | **AY** | 3 | 2 |\n"
     ]
    }
   ],
   "source": [
    "make_markdown_confusion_matrix(cm_sss)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Model optimized using `GroupStratifiedShuffleSplitBinary`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " |        | PN | PY | \n",
      " | ---    | --- | --- | \n",
      " | **AN** | 45 | 0 | \n",
      " | **AY** | 1 | 4 |\n"
     ]
    }
   ],
   "source": [
    "make_markdown_confusion_matrix(cm_gsssb)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 159,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "average_precision_score(latest_student_df['uni (y/n)'], y_prob_gss[:,1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9666666666666666"
      ]
     },
     "execution_count": 160,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "average_precision_score(latest_student_df['uni (y/n)'], y_prob_sss[:,1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 161,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "average_precision_score(latest_student_df['uni (y/n)'], y_prob_gsssb[:,1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7499999999999999"
      ]
     },
     "execution_count": 163,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f1_score(latest_student_df['uni (y/n)'], y_pred_gss)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.5714285714285715"
      ]
     },
     "execution_count": 164,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f1_score(latest_student_df['uni (y/n)'], y_pred_sss)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.888888888888889"
      ]
     },
     "execution_count": 165,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f1_score(latest_student_df['uni (y/n)'], y_pred_gsssb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So we see for this example, the model optimized using a grouped and stratified cross-validator out-performs the other two (if you prefer a single number, the f1 scores were 0.57, 0.75, and 0.89 for models optimized using  `StratifiedShuffleSplit`, `GroupShuffleSplit`, and `GroupStratifiedShuffleSplitBinary`, respectively). If you run this code in the notebook, your randomly generated dataset will be different, and you may not see such a clear distinction between the three.\n",
    "\n",
    "### Conclusion\n",
    "\n",
    "I hope this example and my explanations made it a little clearer how this `GroupStratifiedShuffleSplitBinary` cross-validator performs."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Brushing over &#946;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Earlier, when we were explaining how the test portion of the cross-validator fold we brushed over the parameter &#946; in the softmax function. Perhaps now that we have a concrete example, we can give a more substantial sense as to the meaning of &#946;.\n",
    "\n",
    "We're going to make use of the `GroupStratifiedShuffleSplitBinary` class' `test_make_one_group_stratified_shuffle_split` method. This method constructs a single training set, several times, keeping track of how often each group occurs in this training set. This is important, because we'd like to sample many different groups over the course of cross-validation -- with the constraint that the train and test splits have a stratification close enough to that of the full dataset. Let's see how this looks for the `GroupStratifiedShuffleSplitBinary` cross-validator we just trained:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 2304x1152 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Stratification = 0.1002 +/- 0.0012 (target = 0.1000)\n",
      "(Time taken for calcualtion = 1.3e+01s)\n"
     ]
    }
   ],
   "source": [
    "gsssb.test_make_one_group_stratified_shuffle_split(save_loc = 'images/beta_plot_100.png')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We see that some groups are chosen more than others (different sizes of purple bars). You'll notice that the groups which are chosen most frequently are those with extreme values of stratification (magenta dots). Having explained how the training set is built, this makes sense; the training set oscillates between a too low and too high stratification until it settles on a stable value. The &#946; gives us a way to smooth out this tendency.\n",
    "\n",
    "We can see this by lowering &#946; from its default value of 100 to 10:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "metadata": {},
   "outputs": [],
   "source": [
    "gsssb_10 = GroupStratifiedShuffleSplitBinary(y, student_df['final_year'], n_splits = number_of_cv_splits, frac_train = (1-test_size),beta = 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 2304x1152 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Stratification = 0.1008 +/- 0.0045 (target = 0.1000)\n",
      "(Time taken for calcualtion = 1.3e+01s)\n"
     ]
    }
   ],
   "source": [
    "gsssb_10.test_make_one_group_stratified_shuffle_split(save_loc = 'images/beta_plot_10.png')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Conversely, raising &#946; to 1000 amplifies this disparity:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "metadata": {},
   "outputs": [],
   "source": [
    "gsssb_1000 = GroupStratifiedShuffleSplitBinary(y, student_df['final_year'], n_splits = number_of_cv_splits, frac_train = (1-test_size),beta = 1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 2304x1152 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Stratification = 0.1001 +/- 0.0009 (target = 0.1000)\n",
      "(Time taken for calcualtion = 1.3e+01s)\n"
     ]
    }
   ],
   "source": [
    "gsssb_1000.test_make_one_group_stratified_shuffle_split(save_loc = 'images/beta_plot_1000.png')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The key is to find a balance; a small enough &#946; to give a relatively homogeneous distribution of groups, but not so small that the training set's stratification doesn't mirror that of the full dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  },
  "name": "GroupStratifiedShuffleSplitBinary",
  "notebookId": 4109705956193200
 },
 "nbformat": 4,
 "nbformat_minor": 1
}