oversampling.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy import stats\n",
    "import seaborn as sns\n",
    "import missingno as msno\n",
    "from collections import Counter\n",
    "from itertools import chain, combinations\n",
    "import sklearn as sk\n",
    "from sklearn.metrics import accuracy_score, f1_score, recall_score, precision_score\n",
    "from sklearn.metrics import confusion_matrix, classification_report\n",
    "from random import shuffle\n",
    "from sklearn.model_selection import train_test_split"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Oversampling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "data5 = pd.read_csv(\"imputed_dataset_5.csv\", engine='python').drop(['Unnamed: 0'], axis = 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dataset shape Counter({0.0: 7719, 1.0: 281})\n",
      "(13734, 35)\n",
      "(13734,)\n",
      "dataset shape Counter({0.0: 13344, 1.0: 390})\n"
     ]
    }
   ],
   "source": [
    "data = pd.read_csv(\"imputed_dataset_5.csv\", engine='python').drop(['Unnamed: 0'], axis = 1)\n",
    "dep_data = data.copy()\n",
    "\n",
    "dep_num = np.array([12, 11, 10, 4])\n",
    "no_dep_num = np.setdiff1d(range(13), dep_num)\n",
    "\n",
    "dep_data[['prim_diag', 'secd_diag']] = dep_data[['prim_diag', 'secd_diag']].replace(list(no_dep_num), 0)\n",
    "dep_data[['prim_diag', 'secd_diag']] = dep_data[['prim_diag', 'secd_diag']].replace(list(dep_num), 1)\n",
    "\n",
    "full = data.dropna(axis = 0, how = 'any')\n",
    "dep = [x for x in data.columns if 'dep' in x or 'diag' in x or 'panic' in x]\n",
    "dep_data['dep'] = dep_data['secd_diag'] + dep_data['prim_diag'] + 0 * dep_data['has_dep_diag']\n",
    "dep_data['dep'] = dep_data['dep'].replace(range(2, 4), 1)\n",
    "full = dep_data.dropna(axis = 0, how = 'any')\n",
    "dep = [x for x in data.columns if 'dep' in x or 'diag' in x or 'panic' in x]\n",
    "\n",
    "has_dep = full.query('dep == 1')\n",
    "no_dep = full.query('dep == 0')\n",
    "size = int(np.round(0.8 * min(len(has_dep), len(no_dep))))\n",
    "sample = full.sample(8000)\n",
    "\n",
    "sample = sample.sort_index()\n",
    "sample = sample.reset_index(drop = True)\n",
    "\n",
    "\n",
    "X_comb = sample.drop(dep, axis = 1).drop('dep', axis = 1)\n",
    "Y_comb = sample['dep']\n",
    "print('dataset shape %s' % Counter(Y_comb))\n",
    "\n",
    "X_hasdep = data5.drop(['has_dep_diag'],axis=1).drop(['secd_diag'],axis=1).drop(['prim_diag'],axis=1).drop(['dep_score'],axis=1).drop(['dep_thoughts'],axis=1).drop(['panic_score'], axis=1).drop(['dep_band_15'], axis=1)\n",
    "print(X_hasdep.shape)\n",
    "Y_hasdep = np.array(data5['has_dep_diag'])\n",
    "print(Y_hasdep.shape)\n",
    "print('dataset shape %s' % Counter(Y_hasdep))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(6819, 35)\n",
      "(6819,)\n",
      "Resampled dataset shape Counter({0.0: 6399, 1.0: 420})\n",
      "(4000, 35)\n",
      "(4000,)\n",
      "Resampled dataset shape Counter({0.0: 3760, 1.0: 240})\n",
      "(800, 35)\n",
      "(800,)\n",
      "Resampled dataset shape Counter({0.0: 400, 1.0: 400})\n",
      "(4000, 35)\n",
      "(4000,)\n",
      "Resampled dataset shape Counter({0.0: 3760, 1.0: 240})\n",
      "(800, 35)\n",
      "(800,)\n",
      "Resampled dataset shape Counter({0.0: 400, 1.0: 400})\n"
     ]
    }
   ],
   "source": [
    "import imblearn\n",
    "from imblearn.over_sampling import SMOTE\n",
    "from imblearn.combine import SMOTEENN \n",
    "from imblearn import under_sampling\n",
    "\n",
    "nb = 400\n",
    "nl = 3760\n",
    "ns = 240\n",
    "\n",
    "\n",
    "#combined, imbalanced (original ratio), undersampling\n",
    "smoteenn = SMOTEENN(random_state = 42, sampling_strategy=0.1)\n",
    "rus = under_sampling.RandomUnderSampler(sampling_strategy={1.0: ns, 0.0: nl}, random_state=42)\n",
    "X_combined_imb, Y_combined_imb = smoteenn.fit_resample(X_comb, Y_comb)\n",
    "print(X_combined_imb.shape)\n",
    "print(Y_combined_imb.shape)\n",
    "print('Resampled dataset shape %s' % Counter(Y_combined_imb))\n",
    "X_combined_imb, Y_combined_imb = rus.fit_resample(X_combined_imb, Y_combined_imb)\n",
    "print(X_combined_imb.shape)\n",
    "print(Y_combined_imb.shape)\n",
    "print('Resampled dataset shape %s' % Counter(Y_combined_imb))\n",
    "\n",
    "#combined, imbalanced (original ratio), oversampling\n",
    "\n",
    "#combined, balanced, undersampling\n",
    "smoteenn = SMOTEENN(random_state = 42, sampling_strategy=0.1)\n",
    "rus = under_sampling.RandomUnderSampler(sampling_strategy={1.0: nb, 0.0: nb}, random_state=42)\n",
    "X_combined_b, Y_combined_b = smoteenn.fit_resample(X_comb, Y_comb)\n",
    "X_combined_b, Y_combined_b = rus.fit_resample(X_combined_b, Y_combined_b)\n",
    "#rusboost.fit(X_combined_b, Y_combined_b)\n",
    "#Y_combined_b = rusboost.predict(X_combined_b)\n",
    "print(X_combined_b.shape)\n",
    "print(Y_combined_b.shape)\n",
    "print('Resampled dataset shape %s' % Counter(Y_combined_b))\n",
    "\n",
    "#combined, balanced, oversampling\n",
    "\n",
    "#has_dep_diag, imbalanced (original ratio), undersampling\n",
    "smoteenn = SMOTEENN(random_state = 42, sampling_strategy=0.1)\n",
    "rus = under_sampling.RandomUnderSampler(sampling_strategy={1.0: ns, 0.0: nl}, random_state=42)\n",
    "X_hasdep_imb, Y_hasdep_imb = smoteenn.fit_resample(X_hasdep, Y_hasdep)\n",
    "X_hasdep_imb, Y_hasdep_imb = rus.fit_resample(X_hasdep_imb, Y_hasdep_imb)\n",
    "print(X_hasdep_imb.shape)\n",
    "print(Y_hasdep_imb.shape)\n",
    "print('Resampled dataset shape %s' % Counter(Y_hasdep_imb))\n",
    "\n",
    "#has_dep_diag, imbalanced (original ratio), oversampling\n",
    "\n",
    "#has_dep_diag, balanced, undersampling\n",
    "smoteenn = SMOTEENN(random_state = 42, sampling_strategy=0.1)\n",
    "rus = under_sampling.RandomUnderSampler(sampling_strategy={1.0: nb, 0.0: nb}, random_state=42)\n",
    "X_hasdep_b, Y_hasdep_b = smoteenn.fit_resample(X_hasdep, Y_hasdep)\n",
    "X_hasdep_b, Y_hasdep_b = rus.fit_resample(X_hasdep_b, Y_hasdep_b)\n",
    "print(X_hasdep_b.shape)\n",
    "print(Y_hasdep_b.shape)\n",
    "print('Resampled dataset shape %s' % Counter(Y_hasdep_b))\n",
    "\n",
    "#has_dep_diag, balanced, oversampling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3200, 35)\n",
      "(800, 35)\n",
      "(3200,)\n",
      "(800,)\n",
      "(640, 35)\n",
      "(160, 35)\n",
      "(640,)\n",
      "(160,)\n",
      "(3200, 35)\n",
      "(800, 35)\n",
      "(3200,)\n",
      "(800,)\n",
      "(640, 35)\n",
      "(160, 35)\n",
      "(640,)\n",
      "(160,)\n"
     ]
    }
   ],
   "source": [
    "from random import shuffle\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "def shuffle_dataset(N, X, y, X_shuffled, y_shuffled):\n",
    "    ind_list = [i for i in range(N)]\n",
    "    shuffle(ind_list)\n",
    "    X_shuffled  = X.iloc[ind_list]\n",
    "    y_shuffled = y.iloc[ind_list]\n",
    "    \n",
    "def split_dataset(split, N, X, y):\n",
    "    X_shuffled = X\n",
    "    y_shuffled = y\n",
    "    shuffle_dataset(N, pd. DataFrame(X), pd. DataFrame(y), pd. DataFrame(X_shuffled), pd. DataFrame(y_shuffled))\n",
    "    X_train, X_test, y_train, y_test = train_test_split(X_shuffled, y_shuffled,test_size=split, random_state=40)\n",
    "    return X_train, X_test, y_train, y_test\n",
    "\n",
    "#combined, imbalanced (original ratio), undersampling\n",
    "X_train_comb_imb, X_test_comb_imb, y_train_comb_imb, y_test_comb_imb = split_dataset(0.2, Y_combined_imb.size, X_combined_imb, Y_combined_imb)\n",
    "print(X_train_comb_imb.shape); print(X_test_comb_imb.shape)\n",
    "print(y_train_comb_imb.shape); print(y_test_comb_imb.shape)\n",
    "\n",
    "#combined, balanced, undersampling\n",
    "X_train_comb_b, X_test_comb_b, y_train_comb_b, y_test_comb_b = split_dataset(0.2, Y_combined_b.size, X_combined_b, Y_combined_b)\n",
    "print(X_train_comb_b.shape); print(X_test_comb_b.shape)\n",
    "print(y_train_comb_b.shape); print(y_test_comb_b.shape)\n",
    "\n",
    "#has_dep_diag, imbalanced (original ratio), undersampling\n",
    "X_train_hasdep_imb, X_test_hasdep_imb, y_train_hasdep_imb, y_test_hasdep_imb = split_dataset(0.2, Y_hasdep_imb.size, X_hasdep_imb, Y_hasdep_imb)\n",
    "print(X_train_hasdep_imb.shape); print(X_test_hasdep_imb.shape)\n",
    "print(y_train_hasdep_imb.shape); print(y_test_hasdep_imb.shape)\n",
    "\n",
    "#has_dep_diag, balanced, undersampling\n",
    "X_train_hasdep_b, X_test_hasdep_b, y_train_hasdep_b, y_test_hasdep_b = split_dataset(0.2, Y_hasdep_b.size, X_hasdep_b, Y_hasdep_b)\n",
    "print(X_train_hasdep_b.shape); print(X_test_hasdep_b.shape)\n",
    "print(y_train_hasdep_b.shape); print(y_test_hasdep_b.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn import svm\n",
    "from sklearn.svm import SVC\n",
    "\n",
    "\n",
    "\n",
    "def plot_smote_to_F1(smote_ratio_start, smote_ratio_end, ns, nl):\n",
    "    xs = np.array([])\n",
    "    ys = np.array([])\n",
    "    for n in range(smote_ratio_start, smote_ratio_end):\n",
    "        nd = n/100\n",
    "        xs = np.append(xs, nd)\n",
    "        #combined, imbalanced (original ratio), undersampling\n",
    "        smoteenn = SMOTEENN(random_state = 42, sampling_strategy=nd)\n",
    "        #rus = under_sampling.RandomUnderSampler(sampling_strategy={1.0: ns, 0.0: nl}, random_state=42)\n",
    "        X_combined_imb, Y_combined_imb = smoteenn.fit_resample(X_comb, Y_comb)\n",
    "        print('Resampled dataset shape %s' % Counter(Y_combined_imb))\n",
    "        #X_combined_imb, Y_combined_imb = rus.fit_resample(X_combined_imb, Y_combined_imb)\n",
    "\n",
    "        #train-test split\n",
    "        X_train_comb_imb, X_test_comb_imb, y_train_comb_imb, y_test_comb_imb = split_dataset(0.2, Y_combined_imb.size, X_combined_imb, Y_combined_imb)\n",
    "\n",
    "        svm = SVC(C=5, gamma='auto', kernel='rbf')\n",
    "\n",
    "        #train imbalanced, test imbalanced\n",
    "        svm.fit(X_train_comb_imb, y_train_comb_imb)\n",
    "        y_pred = svm.predict(X_test_comb_imb)\n",
    "        print(f1_score(y_pred, y_test_comb_imb, average = 'macro'))\n",
    "        ys = np.append(ys, f1_score(y_pred, y_test_comb_imb, average = 'macro'))\n",
    "        \n",
    "    plt.plot(xs, ys)\n",
    "    plt.title('SMOTE ratio to F1 score')\n",
    "    plt.xlabel('SMOTE ratio')\n",
    "    plt.ylabel('F1 score')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Resampled dataset shape Counter({0.0: 6399, 1.0: 420})\n",
      "0.9388084699126689\n",
      "Resampled dataset shape Counter({0.0: 6377, 1.0: 528})\n",
      "0.8901649514053478\n",
      "Resampled dataset shape Counter({0.0: 6341, 1.0: 634})\n",
      "0.9197742678968781\n",
      "Resampled dataset shape Counter({0.0: 6302, 1.0: 722})\n",
      "0.9459182730800024\n",
      "Resampled dataset shape Counter({0.0: 6234, 1.0: 805})\n",
      "0.9299312341657617\n",
      "Resampled dataset shape Counter({0.0: 6229, 1.0: 932})\n",
      "0.9586461713601078\n",
      "Resampled dataset shape Counter({0.0: 6185, 1.0: 1009})\n",
      "0.9524195744349788\n",
      "Resampled dataset shape Counter({0.0: 6175, 1.0: 1098})\n",
      "0.9569842609275181\n",
      "Resampled dataset shape Counter({0.0: 6137, 1.0: 1194})\n",
      "0.9471706297030464\n",
      "Resampled dataset shape Counter({0.0: 6125, 1.0: 1306})\n",
      "0.9509930073938213\n",
      "Resampled dataset shape Counter({0.0: 6112, 1.0: 1395})\n",
      "0.941728858895956\n",
      "Resampled dataset shape Counter({0.0: 6103, 1.0: 1458})\n",
      "0.9574008527069423\n",
      "Resampled dataset shape Counter({0.0: 6039, 1.0: 1552})\n",
      "0.9389143147724384\n",
      "Resampled dataset shape Counter({0.0: 6039, 1.0: 1636})\n",
      "0.9555037982830967\n",
      "Resampled dataset shape Counter({0.0: 6008, 1.0: 1697})\n",
      "0.9608040363680086\n",
      "Resampled dataset shape Counter({0.0: 6048, 1.0: 1805})\n",
      "0.9554285390041204\n",
      "Resampled dataset shape Counter({0.0: 5987, 1.0: 1872})\n",
      "0.9616030743594406\n",
      "Resampled dataset shape Counter({0.0: 5968, 1.0: 1969})\n",
      "0.9596587352556235\n",
      "Resampled dataset shape Counter({0.0: 5955, 1.0: 2045})\n",
      "0.9652876711932508\n",
      "Resampled dataset shape Counter({0.0: 5954, 1.0: 2136})\n",
      "0.9591274511065577\n",
      "Resampled dataset shape Counter({0.0: 5956, 1.0: 2210})\n",
      "0.9539341997688251\n",
      "Resampled dataset shape Counter({0.0: 5932, 1.0: 2280})\n",
      "0.9627001885195585\n",
      "Resampled dataset shape Counter({0.0: 5906, 1.0: 2362})\n",
      "0.9617334700525181\n",
      "Resampled dataset shape Counter({0.0: 5903, 1.0: 2453})\n",
      "0.9599053418735999\n",
      "Resampled dataset shape Counter({0.0: 5908, 1.0: 2537})\n",
      "0.9752281467961671\n",
      "Resampled dataset shape Counter({0.0: 5875, 1.0: 2598})\n",
      "0.9617711683030102\n",
      "Resampled dataset shape Counter({0.0: 5875, 1.0: 2682})\n",
      "0.9681547619047619\n",
      "Resampled dataset shape Counter({0.0: 5840, 1.0: 2777})\n",
      "0.9585075914519566\n",
      "Resampled dataset shape Counter({0.0: 5851, 1.0: 2845})\n",
      "0.9716727716727717\n",
      "Resampled dataset shape Counter({0.0: 5828, 1.0: 2911})\n",
      "0.9630843353840418\n",
      "Resampled dataset shape Counter({0.0: 5840, 1.0: 3008})\n",
      "0.966727901909685\n",
      "Resampled dataset shape Counter({0.0: 5833, 1.0: 3079})\n",
      "0.9721209278294447\n",
      "Resampled dataset shape Counter({0.0: 5779, 1.0: 3166})\n",
      "0.9693008532531728\n",
      "Resampled dataset shape Counter({0.0: 5799, 1.0: 3228})\n",
      "0.9601194025128316\n",
      "Resampled dataset shape Counter({0.0: 5799, 1.0: 3319})\n",
      "0.9620822986472543\n",
      "Resampled dataset shape Counter({0.0: 5780, 1.0: 3381})\n",
      "0.9654621006378741\n",
      "Resampled dataset shape Counter({0.0: 5787, 1.0: 3469})\n",
      "0.9712452389730337\n",
      "Resampled dataset shape Counter({0.0: 5775, 1.0: 3553})\n",
      "0.971454900578612\n",
      "Resampled dataset shape Counter({0.0: 5779, 1.0: 3625})\n",
      "0.9715481551278184\n",
      "Resampled dataset shape Counter({0.0: 5751, 1.0: 3709})\n",
      "0.9664259418449557\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYwAAAEWCAYAAAB1xKBvAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAAA/mUlEQVR4nO3dd3yb5bXA8d+RR7xHpicZZO+QySijrBBGWC1we0uhjNICpb3QMjouLW2h7W0vtKWlXEppS8veEFYDaSiEEWJn70G8kjixZTu25aXn/qFXjuxovLIlW7bO9/PRB+udj15AR886jxhjUEoppUJx9HcBlFJKDQwaMJRSStmiAUMppZQtGjCUUkrZogFDKaWULRowlFJK2aIBQ6kIEJHXReQr/V0OpaJJA4aKGBE5SUQ+EJE6EakRkfdFZL617yoRMSLy627nXGhtf8xn2xARuVdE9opIs4hsF5HviIhY+zeKyGHr1SEiLp/3d1n36vDZ5n0VROhz3i0ij/tuM8acY4z5Sw+udaqIlPeiLP4+6++sfaeJyLvWv489Pb2HUl4aMFREiEgW8CrwW2AoUAj8CGjxOWwncJmIJPpsuxLY1u1yzwCnA0uATODLwPXAAwDGmGnGmAxjTAbwHnCT970x5mfWNVb5bPO+Km18jsRQx8Sg7p/1Jmt7I/Ao8J1+LBswYJ+r6kYDhoqUiQDGmCeMMR3GmGZjzFvGmHU+x+wD1gNnA4jIUOAE4GXvASJyOnAWcIkxZoMxpt0Y8yHwn8CNIjI+0gW3ajg3ish2YLu17QERKRORehH5VEQ+Z21fDNyFJ/AdFpG11vYVInKt9bdDRL4vIp+JyAER+auIZPu5bzrwOlDgWwuyalj3i0il9bpfRIaE+7mMMR8bY/4G7LLxDFJE5HEROSQiThH5RERGWfuGisifrbLUisiLPuddJyI7rBrly761uADP9TwRKbXu8YGIzAz3c6n+owFDRco2oENE/iIi54hIboDj/oqnVgFwOfASXWshZwIfGWPKfE8yxnwElOOpeUTDhcBCYKr1/hNgNp7a0j+AZ0QkxRjzBvAz4Cnr1/wsP9e6ynqdBowDMoDfdT/IGNMInANUdqsFfQ9YZN1/FrAA+H4kPmQQXwGygWJgGHAD0Gzt+xuQBkwDRgL/CyAinwfuBb4I5AOfAU92u+6FWM9VRI7DU+P5mnWPPwIv9yQYqv6hAUNFhDGmHjgJMMD/AdXWL85R3Q59ATjV+sV9JZ4A4ms4UBXgNlXWfjsWWb9iva+dIY6/1xhTY4xptj7P48aYQ1YN51fAEGCSzXt/Cfi1MWaXMeYwcCdweRjNMl8CfmyMOWCMqcbTtPflIMd3/6yLbN7HVxueL/HxVg3xU2NMvYjk4wlqNxhjao0xbcaYf/mU81FjzBpjTIv1OY8XkTE+1/V9rtcBfzTGfGTd4y94fiz0pLyqH2jAUBFjjNlsjLnKGFMETAcKgPu7HdMMvIbnF/NwY8z73S5zEM+vVX/yrf12fGiMyfF5HRvi+C41GhG5VUQ2Wx3GTjy/vu0GqwI8v7a9PgMSge7BM5zzg3XYd/+sH9q8j6+/AW8CT1pNT78QkSQ8NY4aY0xtqHJawfEQnv4rL9/nOhq41Te4WdePyGAEFX0aMFRUGGO2AI/hCRzd/RW4Fc+XVHf/BBaKSLHvRhFZgOfL5Z3IlrRTZ9pmq7/idjxNLbnGmBygDpDuxwZQiefL0esYoB3YH+y+Ic4P2WHfG1bN4UfGmKl4+pXOw1MDLAOGikhOqHJafTLDgArfS/v8XQb8tFtwSzPGPBHhj6OiRAOGiggRmWz9Ki+y3hcDVwD+fu3+C09fxW+77zDG/BNYDjwnItNEJMFqYvk78AdjzPaofYgjMvF8wVcDiSLyQyDLZ/9+YIyIBPr/5wng2yIyVkQyONLn0e7n2P3AsG6d4k8A3xeRESIyHPgh8Lifc4OyOt9TgCTPW0kRkeQAx54mIjNEJAGox9NE1WGMqcLTMf97EckVkSQROdk67R/A1SIy2+qH+Bme/qc9AYr0f8ANIrJQPNJF5FwRyQz3s6n+oQFDRUoDns7Nj0SkEU+g2ICnJtGF8VhujKkJcK1LgHeBN4DDeL4s/wTcHEZ5jpej52HMt3num3i+JLfhaXJx0bVp5Rnrn4dEZI2f8x/FU3taCey2zvdbdqsm9gSwy2qmKQB+AqwG1uEZVbbG2hauk/F0XC/DU0tpBt4KcGwe8CyeYLEZT1D3Bqkv4wkgW4ADwLessi8HfgA8h6d/6Vg8Axn8MsasxtOP8TugFtiBZ3CAGiBEF1BSSillh9YwlFJK2aIBQymllC0aMJRSStmiAUMppZQtgyoh2PDhw82YMWP6uxhKKTVgfPrppweNMSPsHDuoAsaYMWNYvXp1fxdDKaUGDBH5LPRRHtokpZRSyhYNGEoppWzRgKGUUsoWDRhKKaVs0YChlFLKFg0YSimlbNGAoZRSyhYNGErFkc1V9Xyww+6ihUp1pQFDqTjyk9c2ceM/1uB267IGKnwaMJSKEx1uw9qyOmqb2th2oKG/i6MGIA0YSsWJHQcOc7jFs0rshzsP9XNp1ECkAUOpOFGytxaA9OQEPtwVaHVcpQLTgKFUnCjZ6yQnLYnF0/P5aPch7cdQYdOAoVScWLO3ljnFORx/7DDtx1A9ogFDqThQ19zG9gOHmXNMLgvHDgUGXz/GrurDNLd29HcxBjUNGErFgXXlTgDmHJND8dA0inJT+7wfo63DTVlNU1Suvb68jjN+/S8u+v37lNdG5x5qkC2gpJTyr2SvExGYVZwDwKJxw1i+eT9ut8HhkD4pw19XfcZ9r2/m3dtOpSg3LWLXbe9wc+cL68hNS6aitpkLH3yfh6+cx3HH5EbsHr2191AT2/Y3UO9qo765jXpXu/XPNuqb22loacPV5qa13Xp1eP7Z0u6mtb2DEZlD+Ns1CynISe3Xz6EBQ6k4ULK3lvEjMshKSQI8AePZT8vZdqCByXlZfVKGFVsP0NZheGZ1Od8+c2LErvvXVZ+xoaKe3/3HHCbnZfLVx1Zz+cMf8stLZ7J0dmHE7tNTO6sPc87979Ha4e6yPS05gayUJLJSE8lMSSIlyUFWSiLJiQ6SExNITnB4/k4Qnl5dzl0vrOfPV81HpG8CvD8aMJQa5IwxlJQ5OWvqqM5t3n6Mj3bV9EnAaG13s3qPZ1jvM6vL+ObpE0iIQM2mqq6ZX721lVMmjuDcGfmICC/eeCI3PP4ptzxZys7qRr51+oQ+q0X5c8+rmxiS6ODv1y1kRMYQslKTyExJJCnBfo/AmOHp/OiVTTy/poJL5hZFsbTBaR+GUoPcnkNNOJvamOPTRHOkH6NvOr7XlTtpbutg6ewCKutcvLe9OiLX/dHLm2h3G+5ZOr3zl/fQ9GQev2YhX5hbxG+Wb+fmJ0v6rTP83S0HWLG1mm+ePoH5Y4YyZng6Q9OTwwoWAF85fgxzR+fyo1c2cqDeFaXShqYBQ6lBzjthr3ub/qJxw/hod02fzMf4YOchROB7505hWHoyT35c1utr/nPTft7YuI9bzpjAMcO69okkJzr4xaUzufOcySxbX8XlD6/q8y/a1nY397y6iXHD0/nKCWN6dS2HQ/j5JTNxtbv5wUsbMKZ/5tBowFBqkCvZ6yRjSCLjR2Z02b5o3DBqGlvZfuBw1MuwauchpuRlMTIzhUvmFvHPzfupbmjp8fUaW9r575c3MnFUBtd9bpzfY0SEr51yLH/8z7lsP3CYC373Pvvq+i5oPPbBbnYdbOQH500lObH3X7XjR2bw7TMm8ubG/Sxbvy8CJQyfBgylBrmSslpmFWcf1WfQOR8jys1SrrYOPt1by/HHDgPgi/OKaXcbnl9T3uNr3v/PbVQ4m/nZRTNCNu+cNS2Pp64/nv0NLp74eG+P7xmO6oYWfrN8B6dNGsFpk0dG7LrXfW4sMwqz+eFLG6hpbI3Yde3SgKHUINbU2s7mqgbmFB89xLR4aBqFOeH1Y/Sk+WrN3lpa290cP84TMMaPzGD+mFye+qSsR00rmyrrefT9PVyxoJh5Y4baOmdGUTYnHDuMF0oq+qQ555dvbsHV1sEPzpsa0esmJjj45RdmUu9q40evbIzote3QgKHUILa+vI4Ot2HOMTl+94fTj3GgwcXcn7zN05+E1//w4c5DOAQWjDvy5X7Z/GPYdbCRT6yRU3Z1uA13vbCenNQkbl88OaxzL55TxN6aJj79LLx7hmtduZNnPi3n6hPHMG5ERugTwjQ5L4sbTxvPS6WVvL1pf8SvH4wGDKUGsZIyJwCzrQl73S0aN9R2P8bv3tlBbVMb/wizWWfVrkPMKMzunAMCsGRGHplDEnnyk/Cu9Y+PPqO0zMkPzptKTlpyWOcunp5HalICz62pCOu8cBhjuPvljQxLT+bm0ydE7T7fOHU8k/My+d4L66lrbovafbrTgKHUIFayt5bRw9IYljHE7/5FVjNRqGapspomnvh4L0PTkyktc7L3kL30G02t7ZSWOVlk9V94pSUncsHsApatr7L9hXeg3sUv3tjKSeOHs3R2ga1zfKUPSWTx9DxeW1eJqy06w2xfKq1kzV4n3zl7UpcAGWnJiQ5+eeksDjW28rPXNkftPt1pwFBqkDLGsGavkzkBahdwpB/jo93BA8b/vr0NhwiPfGUeAK+sq7RVhtV7amnrMJ39F76uWHAMrjY3L68NfS232/D9FzfQ0uHmngun93i288XHFVLvauedLQd6dH4wjS3t3Pv6ZmYUZvOFucURv353M4qyuf7kcTy1uixi81pC0YCh1CBVWeeiuqGly4Q9fxaNG8aHu2oCdgZv29/AC6UVXHXCGI47Jpd5o3N5udRewFi16xCJDmG+n87p6YXZTCvI4qkQzVLGGH786ibe2rSf7549ibHD023d258Tjh3OqKwhvRqhFcgfVuxkf30Ld18wtc9mlt9y+gTGjUjnjufW09TaHvX7acBQapDyTtgL1OHtFaof43/e3EpGciI3nHIsABfMLmDr/ga27gu9nsaqnYeYVZxD+hD/WYgun1/Mhop6NlTUBbzGb9/ZwWMf7OHak8ZyzUljQ94zmASHcOHsQlZsrebQ4Z7PA+lu76EmHn5vF0tnFzB3tL2RW5GQkpTALy+dxbfPnEhqUkLU76cBQ6kwNbjaWL0n9pc4LdnrZEiigyn5wXNFBevHKNlby1ub9nPdyePITfd0Mi+ZkU+CQ3h5bfDO4wZXG+sr6vw2R3ldMLuQIYmOgJ3ff1u1h1+/vY1LjiviriVTIpJ47+Ljimh3G16x0RRmR1uHm++/tIEEEe44J7yRW5Ewd3Qul84t6pOkhBowlArTt54s5dKHVlFqjUCKVSV7a5lZlB1yYluw+Ri/fHMrw9KT+arPL/vhGUM44dhhvLy2Muichk/21NDhNpxwbOCAkZ2axLkz8nmppPKofE8vr63khy9v5Iwpo/j5JTMi1swzKS+TaQVZPF/S+9FSbR1ubnmyhJXbqrnr3CnkZ/dv+vFo04ChVBiWb97P8i0HcAjcu2xzv+X0CaWlvYMNlfUh+y+8/PVjvL/jIB/sPMQ3ThtPRrcmpQtmFVBW09w5bNefVTsPkZzg4LjRwctw2fxiGlraWba+qnPbiq0H+K+nSpk/Zii/+485JIaZrC+Ui+YUsq68jh29WKa2vcPNt54qZdn6fXz/3Cl8edHoCJYwNmnAUMomV1sHP3plE+NHZvD9c6fy0e6aqIy2iYRNlfW0truDjpDy1b0fwxjDL97cSkF2Cl9aeMxRx589PY/kREfQzu8Pdh5izjE5pIRoW18wdihjh6fzlDUh8NPPavn642uYOCqTR74yL+T5PXHB7AISHMLzPZyT4Q0Wr62r4q4lk7k2QD6rwUYDhlI2PbxyF3trmvjxBdP48vGjGTs8nfte30J7t4VxYkHJXidAWDUMONKP8ebG/awtc/KtMyb6/cLOSkni85NG8tr6Kjr8zBJ3NrWyqaq+M39UMCLCZfOL+XhPDa+vr+Krj33CqKwh/OWrC6I2l2FkZgonTxjOiyUVYac7ae9w8+2n1/LquiruPGcy1598bFTKGIs0YChlQ1lNEw++u4NzZ+ZzwvjhJCU4+O7Zk9h+4DDPRWGIZm+VlDnJz04hLzvF1vFFuamd/RgdbsOv3trKuBHpXHxc4BXrLphdQHVDi9++j49212CMZxirHZccV0SiQ/j639cwJNHB365ZyIhM/5MNI+Wi44qorHPxYYg5KL463IZbn1nLK2sruX3xZL52SvwEC9CAoZQt97y6CYcI3z93Sue2xdPzmHNMDr9+e1tEF+h5b3s1GyvretU/UrK3NuRwWl8iwsJxQ/loVw0vlFSw/cBhbj1zUtC+g89PHknGkES/zVKrdh4iJcnBrOJsW/cfkTmEJTPyyU5N4m/XLKR4aOTW/A7krKmjyBySaLtZqsNtuPXpUl4qreS7iyfx9VPjK1iABgylQlqx9QBvbdrPzaeP7zIKRkS4a8kU9te38Oj7uyNyr81V9Xz5Tx9z7m/+zcKfLee7z65l2foq6l328wUdaHBRXtvsN0NtMIvGDeNQYyv3vLqJ6YVZnDM9L+jxKUkJnDV1FK9vqKKlvWvAXLXzEPNGD2VIov3+h19cOpP3bj+NSXmZYZW7p1KSElgyI5/X11eFDPgdbsN3nlnLi6WVfOfsSXzj1PF9UsZYowFDqSBa2j0d3eOGp3PtSUd3bM4fM5Qzp47iDyt2RmQi2NOry0hOcPDTi6Yzf+xQXt+wj2/8fQ3H/fhtLvvjKh7610627Q8+sqe0s/8iJ6x7e+dL1DW38Z2zJ9saxnr+7ALqXe2s3Hawc9uhwy1s3d9gq//CV0pSQlTzL/lz0XGFNLZ28NamwAsS7ao+zFV//pjnSyq47ayJ3HhafAYL0ICh4lC9q40rH/2YB9/dETIJ3SPv7Wb3wUbuvmBawFXTbl88mea2Dn77zo5elaulvYMXSyo4c+oovrRwNA/+x3GU/OBMnrnheK4/eRz1rnbue30LZ/3vSq557JOAgaOkzEmiQ5heaK85yKsoN5Uxw9JYNG4oJ0+w1/dw0vjh5KYldckH9eEuz6TGcANGf1gwZiiFOal+M9g2uNq4d9lmzr5/JSV7ndyzdBo3fT56GWgHAv/z9SNERBYDDwAJwCPGmPu67c8FHgWOBVzAV40xG6x9OcAjwHTAWPtWRbO8Kj48tGInK7dVs3JbNU9+spfvLZnK2dNGHTVTtsLZzO/e2cHZ00Zx8sQRAa83fmQGX5xXzOMffsZVJ4xhTA9zHS3ffIDapja+MK+oc1tigoP5Y4Yyf8xQvrt4MvvqXDxfUs4fVuxk8f0ruXRuEf915qQundsle2uZWpAV9nBUEeGprx1PanKC7VnDSQkOlszI57k15TS2tJM+JJEPdh4kPTmBGWEGrP7gcAgXH1fIg+/u4EC9i5FZKbjdhudLKvj5G1uobmjhC3OL+M7iSYzMtDeAYDCLWg1DRBKAB4FzgKnAFSLSffmpu4BSY8xM4Eo8wcXrAeANY8xkYBbQdzl8Vcy78/n1XPfX1WEPidxX5+LR93ezdHYBj1+zkNSkBG54/FO+9MhHbNlX3+XYn762CYOxtWrat8+YQFKCg1++tTWs8vh6enUZeVkpfG5C4OCUl53CN04dz8rvnMbVJ47lxZJKTv2fd/nFG1uod7XR3uFmXXkdx9kcTtvdqKyUsJuFLphVgKvNzT83exbzWbXrEPPHDg05wzxWXDSnELfxpCZfW+bk4j98wG3PrKUwJ5UXbzyRX35hlgYLSzT/jS4AdhhjdhljWoEngaXdjpkKLAcwxmwBxojIKBHJAk4G/mTtazXGOKNYVjWAvLVxH098vJe3N+3nqdXhrf72v29vw+2G286axEkThrPsm5/jx0unsbGyniUPvMcPX9pAbWMr/95+kGXr93HjqeMpyg09YmdkVgrXnTyO19ZV9ShlSFVdMyu3VXPp3KKj1t72Jzc9mR+cN5Xlt57C2dPy+P2KnZzyi3f52bItNLV2hN1/0RvzxwwlPzuFl0sr2V/vYld1Y9B0ILFm3IgMZhfn8Jvl21n64PtUOJv51Rdm8fzXTwi48FS8imbAKAR8/28ut7b5WgtcDCAiC4DRQBEwDqgG/iwiJSLyiIj0PKexGjQaXG388KWNTM7LZOHYody7bDPVDfY6m7fvb+CZT8v4z0WjO4dtJiY4uPL4May47VS+vGg0f/9oL6f+zwq+++xaRg9L47qT7c/gvf7kcQzPSO5RypDn11TgNnRpjrKjeGgaD1w+h1duOompBVmdo7XCHSHVGw6HcN7MfFZur+Z1K73H8ePs9YHEii8vGo2rvYOvnTyOd249hUvmFvVZivKBJJoBw9/T7v5/0X1AroiUAjcDJUA7nr6V44A/GGPmAI3AHX5vInK9iKwWkdXV1X2ziIjqP796axv7G1zce/EMfnrRDFxtbn7y2iZb5/78jS2kJydy0+ePHuWSm57Mj5ZOZ9k3P8f0wiyq6l3cff60sPoBMoYkcsvpE8JOGeJ2G55eXcaicUMZPaxnv4tmFGXz+DUL+ctXF/Df50+leGjfJsG7YFYhbR2G+5dvJyslkakFwTPkxppL5hax8UeLuXPJFDL7eKTWQBLNgFEO+C47VQR0meFjjKk3xlxtjJmNpw9jBLDbOrfcGPORdeizeALIUYwxDxtj5hlj5o0YEbjtVw18a/bW8pdVe/jK8WOYc0wu40dm8PVTj+Wl0kpWbgv+Y+GjXYf45+YDfP20YxmaHngt6El5mTx+zUJWf+8MTps8MuwyXr7gGMYOT+enyzbbXgb04z01fHaoiS/O690qbSLCKRNHcPWJY/sk1bWv6YVZjB2ejrOpjYXjhtlqVos1gUbBqSOi+YQ+ASaIyFgRSQYuB172PUBEcqx9ANcCK60gsg8oE5FJ1r7TAXs/IweZ//i/D3l45c7+Lka/a+twc+dz68nLSuG2syd1bv/6qccybng6339xQ8AvaGMM976+hbysFL56YugFeEQk4BrYoSQlOLj7gmnsqm7kwXftDbN9enUZGUMSOWd6fo/uGQtEhAtmedbZDrb+hRrYohYwjDHtwE3Am3hGOD1tjNkoIjeIyA3WYVOAjSKyBc9oqlt8LnEz8HcRWQfMBn4WrbLGKldbBx/sPMT/vr2dA/Wu/i5Ov3p45S627m/gx0und0m1nZKUwE8ums7emiZ++852v+e+vmEfpWVO/utM/4n0Iu2UiSO4eE4hf1ixk81V9UGPbXC1sWx9FefPKiA1Ofpli6bL5hdz/LhhLA4xQ1wNXFGtgxljlhljJhpjjjXG/NTa9pAx5iHr71XGmAnGmMnGmIuNMbU+55ZaTU0zjTEX+u6LF1V1niDR3NbB/cv9fxnGskitFbH7YCMPLN/Okhl5nDl11FH7Tzh2OJccV8Qf/7XrqMlsbR1ufvnmViaOyuCSueF1KPfGD86bSnZqErc/ty5oNttX11XhanPzxTA7u2NRQU4qT1y/iIKcwb2IUDzTRrsYVulsBmBaQRZPfVLGzmr/ay4HY7cdPdJqGluZefdbvLNlf6+uY4zhey+sZ0iig7vPnxbwuO+dO4WMlETuen59l7kZT368l90HG7l98eQ+bVfPTU/m7gumsa68jj+/vyfgcU+vLmPCyAwdvqkGBA0YMazCChg/uXA6KYkO/ufN8CaFPfHxXmbe/VaPAk1vrd5TQ0NLOx/ssJ862p9nPy3ng52HuOOcyYzMCjx5amh6MnctmcLqz2o752Ycbmnn/n9uZ+HYoXy+Bx3YvXXezHzOmDKKX729lc8ONR61f/v+Bkr2OvnivOI+76RWqic0YMSwKqcLEZhWkM11J4/j9Q37WLPXXsvc5qp6/vvljbR2uHkpAmsXh8s7eW3zvuBt+MEcPNzCT5dtZt7oXK6Yf/Sqb919YW4RC3zmZjy8cheHGlu5c8mUfvlCFhF+cuF0khwO7nhu/VFNdM98Wk6iQ7hwTuA1J5SKJRowYlils5kRGUNITnRw3ec8k8Lue31LyL6BptZ2bvrHGnJSk5hVlM0r66r6fO3pzoBR1dDje//k1U00trRz78UzbE2iEhF+dtEMmts6+O6za3nkvV2cOyO/X5t78rJTuHPJFFbtOtS5BCl4+laeX1PO5yePjPpCQUpFigaMGFZZ19zZgZhuTQr7eHcNK7YGn3Nw98sb2XWwkfsvm83lC45h98FGNlb2/Jd+uDrchnXldaQkOahpbLU9E9vXv7cf5MXSSr5+6ngmjLK/PoJnbsZ43t1aTWu7m+/4DMHtL5fPL2bh2KH8dNlm9luj3d7ZcoCDh1t7PfdCqb6kASOGVTibKfQZcXL5gmMYMyyNn7+xxe86ygAvlVbw9OpybjptPCeMH87iaXkkOoRX1h29Klq07Ko+zOGWds6f6RmXv3lf8PUb/Hl1XSVZKYnceFr4q5p949RjmTs6lxtPG9/jzLGR5HAI910yk9Z2Nz94cQPGGJ5ZXcaIzCGcOkknm6qBQwNGjDLGUOlspiDnSEdvUoKD286exJZ9Dbzop19iz8FG7np+PfPH5HLL6Z68/bnpyZw0YTivru27ZqkSqznq8gWefodQcxH8WVdex6zinLBWbPNKSUrg2RuO59tnTgz73GgZOzydb585kbc27ecvH+zh3a3VnnWsB0hGV6VAA0bMqm1qw9XmPmpM+5Lp+cwsyubXb2/rMmS2pb2Dm55YQ2KCgwcun9Pli+j8mQVUOJs7v8ijrbTMSWZKInOKc8jPTmFLmAHD1dbBtv0NvVpPIRZHHV170limF2Zx9yub6HCbsBMNKtXfNGDEKO8cjO4Bw+EQ7lg8mQpnM49/+Fnn9p+/vpUNFfX88tKZR51z5rRRJCc4eGVt3zRLle51Mrs4B4dDmJKfxeaq8JqkNlfV0+42zCyK/QV4wpGY4OAXl8wi0SHMHZ3LsSMy+rtISoVFA0aM8s7BKPQza/aE8cM5eeIIfvfuDuqa2/jnpv08+v5urjphDGdNOzotQ1ZKEqdOGsFr66oC9n1ESnNrB1v3NzCrKAeAyXmZ7Kw+TEu7/QmEGyrqAJhhXWMwmVqQxaNXzefnl8zo76IoFTYNGDEqUA3D6/bFk3A2tXHPq5u47dm1TCvI4s4lkwNe77xZBRxoaOGTPTVRKa/X+oo6OtymcyjrlPws2t2GHQfsTx5cV17HsPRkCrIH5ypnJ08cwfiR9kd+KRUrNGDEqEpnMylJDnLT/Ofmn1aQzYWzC3j203Ja29389oo5QTuIz5gyktSkBF6N8mip0jLPxMLZ1opvU/I9X4zhNEutr6hjemF2TPZDKBXPNGDEqEqni4Kc1KBfmreeNYmxw9O575KZjAvRHp6WnMjpU0aybP2+oMnwemttWR1FuakMt9KDjxmWzpBEh+2O7+ZWT4f3YOu/UGow0IARo7rPwfCneGga7952auc6BKGcN7OAmsZWPtjZu/xOwZSWObvMrE5McDBxVKbtFCGbqupwG3o1QkopFR0aMGJUpbOZguzIpok+ddIIMoYk2m6Wam1309jSbvv6BxpcVDibj0rFMSU/03aKkPXlng7vmYOww1upgU4DRgxqae/gQENLxNcVSElK4Kypo3hjwz5a24M3S9U2tnLOAyu58tGPbV+/dK8T4KiAMTkvy3aKkHUVdYzIHMKoLM2vpFSs0YARg/bXeb5YfWd5R8r5swqod7Xz3vbA+ahcbR1c99fV7Kxu5NPPao9alCiQ0jIniQ5herfmpCn5WYC9FCHry+uYqR3eSsUkDRgxKNgcjN46cfxwctKSAk7ic7sN//V0KZ/ureWepdNIcAjPr7GXHr20zMnk/MyjlkE9MlIqeD9GY0s7O6oPHxVwlFKxQQNGDKqqCz4HozeSEx0snpbH25v2+12N76fLNrNs/T6+t2QKXz5+DKdMHMFLpRVdVrHzx5uh1l8q8Zy0ZFspQjZW1mMMOkJKqRilASMGeSft5UVp4tr5swpobO3g3S0Humx/9N+7+dO/PTPGrzlpLAAXzimkqs7Fh7uDj6zaaWWonV2c63f/5LzMkHMx1ntneGsNQ6mYpAEjBlU4XQzPSD6qaSdSFo4dyvCM5C4pz19fX8U9r23i7Gmj+MF5Uzv7EM6aOoqMIYm8EKJZyrtgUqDFiqbkZ4VMEbK+3EleVkrQpViVUv1HA0YM8qQ1j3xzlFdigoMlM/J5Z8sBDre08+lnNXzrqVJmF+fwwOVzSPBZ3S4lKYFzpufx+oZ9NLcG/rL3ZqgdF2D9ick2UoSsq6hjhjZHKRWzNGDEoGjMweju/FkFuNrc/N/KXVz7l9XkZ6fwyJXz/NZqLjqukMMt7by9eX/A65XudTKrKCfgUqpTrY7vLQGapRpcbeyqbmSmNkcpFbM0YMSYIwsnRTdgzD0ml7ysFB5Yvh0R4bGrFzAsw//ch0Vjh5GfneJ30SY4kqE22NrZY4alk5zoCDhSakOFZ/t0rWEoFbM0YMSY+uZ2Gls7ojIHw5fDIXxhXhGpSQn86Svzgi5l6nAIS2cX8q9t1Rw8fPTku+4Zav1JTHAwaVQmWwLMxVhf4QS0w1upWKYBI8ZEcw5Gd98+YyIf3nU6c47xP7LJ18XHFdLhNn7nb3TPUBuIJ0VIvd8UIesr6inMOZK0UCkVezRgRNmhwy2dI4jsCLUORiQ5HEJ2qv/06d1NHJXJtIIsXvDTLFVa5uySoTaQyXlZHGpspdpfLaXcqbULpWKcBowo+/2KnVz2x1V+J8n5UxnFSXu9ddGcQtaV1x010sm7JGsonSlCunV81zW1sedQk46QUirGacCIst0HG2lpd4dMi+FV4WwmOdHBsPTkKJcsfBfMKsAhdOn8PlDvorLOZTNgeEdKdX0WGyp1wp5SA4EGjCgrq2kCPMuO2lHpdFGQnRJweGp/GpmVwkkTRvBCyZFUIaEm7PnypgjpHjy9z0YDhlKxTQNGFBljKK/1NDGttdmP0RdDanvj4jmFVDibO9cGD5ShNpDJeUePlNpQUUfx0FRyY7BWpZQ6QgNGFB1qbKXZ6rsoLXfaOifWA8ZZ00aRlpzQ2fkdKENtIFPys9hxoGuKkHUVTmYW5kSjuEqpCNKAEUXe5qhZxTnsqm6krrkt6PFtHW7217tiOmCkJSeyeFoer62vorm1I2CG2kC8KUJ2HmgEPAs1ldU0a4e3UgOABowoKrOao86fmQ94ml6C2V/vwm2gMMqT9nrrouMKaXC188eVO4NmqPVnare1MbwZajUliFKxTwNGFHlrGEtmeAJGqPkYVXUuIDaH1Po64djhjMoawkP/2gnA7GL7X/beFCFb9nUNGNM0YCgV8zRgRFF5bRPD0pMpyEll7PD0kB3f3kl7+VFOPNhbCVaqEFeb28pQm2H7XG+KEO9cjPXldYwZlmZ7AqFSqv9owIiisppmioamAZ5V5NaG6Piu6JzlHdtNUgAXzi4ECJqhNhDPSKkjNYwZRTmRLp5SKgo0YERRWW0Txbme2sKsohz217ewz2p28qfS2UxuWhJpyYl9VcQem1qQxWXzivni/OKwz52Sn8XBw61s2VdPhbNZ+y+UGiCiGjBEZLGIbBWRHSJyh5/9uSLygoisE5GPRWR6t/0JIlIiIq9Gs5zR0OH2pCkvtmoYs6yRRMFqGZXO2B4h1d3PL53JBbMKwj5vstXx/fQn5QA6QkqpAcJWwBCRk0TkauvvESIy1sY5CcCDwDnAVOAKEZna7bC7gFJjzEzgSuCBbvtvATbbKWOs2V/voq3DUJzrCRjTCrJIdEjQfoxYn4MRKVPyPDmlXigpR8TzbJRSsS9kwBCR/wZuB+60NiUBj9u49gJghzFmlzGmFXgSWNrtmKnAcgBjzBZgjIiMsu5bBJwLPGLjXjHHO0KqyGqSSklKYHJ+ZtAaRoWzuU/Smve33PRk8rJSqG1qY+zwdDJTtMNbqYHATg3jIuACoBHAGFMJZNo4rxAo83lfbm3ztRa4GEBEFgCjgSJr3/3AdwF3sJuIyPUislpEVldXV9soVt/wzsHwNkkBzCzKYV1ZXWceJl/1rjYaXO0DosM7EryJCLX/QqmBw07AaDWeFW8MgIgEXpqtK39DZ7p/U94H5IpIKXAzUAK0i8h5wAFjzKehbmKMedgYM88YM2/EiBE2ixZ9ZTVNiHQd8TS7KIeGlnZ2H2o86vgq58CYgxEpk61U5zpCSqmBw07AeFpE/gjkiMh1wD+B/7NxXjngO4SmCOiyXJsxpt4Yc7UxZjaePowRwG7gROACEdmDpynr8yJipxksbMYYPv+rFTz47o6IXrestom8rBSGJB7JsdTZ8e2nH6MvF06KBd7MtOGkFVFK9a+gAUNEBHgKeBZ4DpgE/NAY81sb1/4EmCAiY0UkGbgceLnb9XOsfQDXAiutIHKnMabIGDPGOu8dY8x/hvPB7BIRnE1tVFkLF0VKeU1zZ4e31/iRGaQlJ/gNGH25NGssOHtaHn+/diHHhVjWVSkVO4IO+DfGGBF50RgzF3g7nAsbY9pF5CbgTSABeNQYs1FEbrD2PwRMAf4qIh3AJuCannyI3spOTaKuuT2i1yyrbeL4Y4d12ZbgEGYUZlPqZ22MSmczSQnCiDhZ0zrBIZw4fnh/F0MpFQY7M8Q+FJH5xphPwr24MWYZsKzbtod8/l4FTAhxjRXAinDvHY7s1CScTa0Ru15Lewf76l1H1TDA0yz12Pt7aG13k5x4pIJX6WwmL0YXTlJKKbDXh3EanqCx05pgt15E1kW7YH0pJy0pZOrxcFQ6XRjTdYSU16yiHFo73J2pMXzPKYjxHFJKqfhmp4ZxTtRL0c+yU5PYffDokUs9VV7rmYPhTQvia5aV2XVtmZOZPiOEKpzNLBw7NGJlUEqpSAtZwzDGfAbkAOdbrxxr26CRk5qEsylyNYyyGk8HdpGfGkZhTirDM5IpLTvSj9HhNuyL8YWTlFLKzkzvW4C/AyOt1+MicnO0C9aXstOSqXe10eFnQl1PlNU2kZQg5GUdPQlPRJhVlNNlxnd1QwsdbqMBQykV0+z0YVwDLDTG/NAY80NgEXBddIvVt7JTkzAGGlyRqWWU1TRRkJNKQoAO7JlFOeysPtx5P++Q2vw4meWtlBqY7AQMATp83nfgfxb3gJVjLd4TqY7vstqj52D4mlWcjTFHVpurjLM5GEqpgclOwPgz8JGI3C0idwMfAn+Kaqn6WE6aJ2BEqh+jvKaJ4qGBv/xnWZ3da8u6Boz8bK1hKKViV8hRUsaYX4vICuAkPDWLq40xJdEuWF/yLg/qjEANo7GlnUONrRQFqWHkpiczelha54zvSmczWSmJmrVVKRXTQgYMEVkEbDTGrLHeZ4rIQmPMR1EvXR/x1jAi0SRV7idLrT+zinJYvacGgIoBtnCSUio+2WmS+gNw2Od9o7Vt0MhO9aSzqovAbO9gczB8zSzKprLOxYF6F5Vxsg6GUmpgs9XpbaU3B8AY48behL8Bo7NJKgJ9GN6Fk0LVMGZ3LtlaR2VdfKy0p5Qa2OwEjF0i8k0RSbJetwC7ol2wvpSc6CAtOSEiTVJltc2kJiUwLD056HHTCrJJcAirdh7C2dSmAUMpFfPsBIwbgBOACjxrXCwEro9mofpDTmpSRDq9y2qaKMpNxZMZPrDU5AQmjcrkjQ1VAHGz0p5SauCyM0rqAJ41KQa1rAilBymrbQ7ZHOU1qziHJz7eC+gcDKVU7LOTGuQXIpJlNUctF5GDIhKVxYz6U05aEvW9rGEYYzxzMEJ0eHvNKjqynrU2SSmlYp2dJqmzjDH1wHl4mqQmAt+Jaqn6QU5qMs7m3o2Sqmtuo6GlPawaBngWExqZGR8LJymlBi47o528s8mWAE8YY2pCtc8PRNkRaJLqzFIbZNKerwkjM0hNSmBoejKJCXZit1JK9R87AeMVEdkCNAPfEJERgCu6xep7kVhEqcw7ByNIWhBfiQkO5o3J7dU9lVKqr9jp9L5DRH4O1BtjOkSkCVga/aL1rey0JFra3bjaOkhJSujRNbyT9uzWMAB+e8UcTGSyqiulVFTZmoBnjKn1+bsRz2zvQcV38l5eds8CRlmNJyeU91p25KQFn6+hlFKxQhvOLTne9CC9aJYqq22y3eGtlFIDjQYMy5EU5z0fKVVW0xR0HQyllBrIehQwRGRypAvS33qb4twYQ3lts+0Ob6WUGmh6WsN4K6KliAHZvVx1r7qhhZZ2tzZJKaUGrYCd3iLym0C7gJyolKYfda6J0cO5GJ1DarVJSik1SAUbJXU1cCvQ4mffFdEpTv/JGJJIgkN6PNvbO2lPm6SUUoNVsIDxCbDBGPNB9x3W2t6DioiQndrzyXvedTDCmYOhlFIDSbCAcSkBZnQbY8ZGpzj9K6cX6UHKa5sZkTmkx5P+lFIq1gXr9M4wxjT1WUliQHYv0oOU1XrWwVBKqcEqWMB40fuHiDwX/aL0v141SdXqHAyl1OAWLGD4pqQdF+2CxIKeNkm1d7ipdLq0w1spNagFCxgmwN+DVk5aco9melfVuehwG61hKKUGtWCd3rNEpB5PTSPV+hvrvTHGZEW9dH0sKzWJhpZ2OtyGBIf9NT+OpDXXgKGUGrwCBgxjTNwN98lJTcIYaHC1hZVFttw7B0NrGEqpQUyTD/o4koAwvH6MstomHAL5OSnRKJZSSsUEDRg+eppPqry2mfzsVJJ0mVWl1CCm33A+OmsYYQaMspomHSGllBr0ohowRGSxiGwVkR0icoef/bki8oKIrBORj0VkurW9WETeFZHNIrJRRG6JZjm9sq1FlMIdKeWZtKf9F0qpwS1qAUNEEoAHgXOAqcAVIjK122F3AaXGmJnAlcAD1vZ24FZjzBRgEXCjn3MjztskVR9GDcPV1sH++hbt8FZKDXrRrGEsAHYYY3YZY1qBJ4Gl3Y6ZCiwHMMZsAcaIyChjTJUxZo21vQHYDBRGsaxA13W97apwapZapVR8iGbAKATKfN6Xc/SX/lrgYgARWQCMBop8DxCRMcAc4KNoFdQrOdFBenJCWH0Y3iy1OgdDKTXYRTNg+Jv51n3G+H1AroiUAjcDJXiaozwXEMkAngO+ZYypxw8RuV5EVovI6urq6l4XOtx8Ut4ahiYeVEoNdsFmevdWOVDs874IqPQ9wAoCVwOIiAC7rRcikoQnWPzdGPN8oJsYYx4GHgaYN29er1OYZKclh9UkVeV0keAQRmbqHAyl1OAWzRrGJ8AEERkrIsnA5cDLvgeISI61D+BaYKUxpt4KHn8CNhtjfh3FMh4lJzWJujBW3ausa2ZU5pCwUokopdRAFLWAYYxpB24C3sTTaf20MWajiNwgIjdYh00BNorIFjyjqbzDZ08Evgx8XkRKrdeSaJXVV7hNUlVOF/k52hyllBr8otkkhTFmGbCs27aHfP5eBUzwc96/8d8HEnU5aeGlOK+qa2Z6YXYUS6SUUrFBZ3p3k52WZHuUlDGGqjoXBVrDUErFAQ0Y3WSnJtHa7sbV1hHy2JrGVlra3eRna4e3Umrw04DRTU5nepDQtYyqOhcA+dlaw1BKDX4aMLo5koAw9EipSmsORoGmNVdKxQENGN10pjjXGoZSSnWhAaObznxSNjq+K+uaSU5wMCzd/up8Sik1UGnA6MbbJGWrhuF0kZedgkMn7Sml4oAGjG6O1DBC92FU1TXrCCmlVNzQgNFNxpBEEhxia7Z3pVPnYCil4ocGjG5EhJzU0LO9O9yG/fUurWEopeKGBgw/slNDz/aubmih3W00j5RSKm5owPAjOy0p5DKtlXXWHAytYSil4oQGDD/sNElVOXUOhlIqvmjA8MPTJBV8lFRVnc7yVkrFFw0YfuSkJYech1HpdJGalNA5DFcppQY7DRh+ZKcmUe9qp8MdeMXXqrpm8nNS8CwOqJRSg58GDD+8tYZgHd+VdS4KtP9CKRVHNGD40ZkeJEjAqHLqLG+lVHzRgOHHkRTn/gNGa7ub6sMtOgdDKRVXNGD40ZlPqsn/SKn99S6M0TkYSqn4ogHDj2xr1b1ATVKd62BoDUMpFUc0YPgRqg+jSmd5K6XikAYMP440SfkPGJVOrWEopeKPBgw/khIcpCcnBK1hZKYkkjEksY9LppRS/UcDRgA5aclBaxg6B0MpFW80YASQlZpEXYB8UlV1zZpDSikVdzRgBJCTmhR0lJT2Xyil4o0GjABy0vynOHe1dVDT2KojpJRScUcDRgCBVt3rnIOhfRhKqTijASOA7DRPk5QxXTPWVjk9czDytQ9DKRVnNGAEkJOaTGu7G1ebu8v2SquGoaOklFLxRgNGAEcSEHYdKeWtYeRpH4ZSKs5owAjAO9u7+0ipyjoXw9KTSUlK6I9iKaVUv9GAEUBOgPQg3pX2lFIq3mjACCA7LUDAcLp0hJRSKi5pwAgg0DKtlc5mnYOhlIpLGjACyEnzrInh2+nd4GqjoaVdZ3krpeKSBowA0pMTSHRIlyapI5P2tIahlIo/UQ0YIrJYRLaKyA4RucPP/lwReUFE1onIxyIy3e650SYiZHfLJ1VpDakt0BqGUioORS1giEgC8CBwDjAVuEJEpnY77C6g1BgzE7gSeCCMc6MuO61rehCtYSil4lk0axgLgB3GmF3GmFbgSWBpt2OmAssBjDFbgDEiMsrmuVGXk5pEnW+TlLMZERiVpQFDKRV/ohkwCoEyn/fl1jZfa4GLAURkATAaKLJ5LtZ514vIahFZXV1dHaGiexzVJFXnYmTmEJIStOtHKRV/ovnNJ362mW7v7wNyRaQUuBkoAdptnuvZaMzDxph5xph5I0aM6EVxj5aTltxllFRVXbPOwVBKxa1oLkpdDhT7vC8CKn0PMMbUA1cDiIgAu61XWqhz+0J2atc1MaqcLibnZ/Z1MZRSKiZEs4bxCTBBRMaKSDJwOfCy7wEikmPtA7gWWGkFkZDn9oXs1CQaXO10uA3GGCq1hqGUimNRq2EYY9pF5CbgTSABeNQYs1FEbrD2PwRMAf4qIh3AJuCaYOdGq6yBeDPWemd7u9rcOkJKKRW3otkkhTFmGbCs27aHfP5eBUywe25fO5LivI2m1nZA52AopeJXVAPGQOeb4vxgQwugczCUUvFLx4cGkZ1q5ZNqaqWqTmd5K6XimwaMILxNUnXNbVTWuUh0CMMzhvRzqZRSqn9owAjCt0mqytnMqKwUEhz+pogopdTgpwEjiGyfVfcq61wU6Ep7Sqk4pgEjiKQEBxlDEnE2teksb6VU3NOAEYJntncr++pcupa3UiquacAIITs1iZ3Vh2nrMBRoDUMpFcc0YISQk5bE1v0NgM7BUErFNw0YIWSnJuFqcwM6B0MpFd80YITgnYsBWsNQSsU3DRgheGd7D0l0MDQ9OcTRSik1eGnACME7FyM/OwXPkh1KKRWfNGCE4G2S0jkYSql4pwEjhBxvDUPnYCil4pwGjBC8TVI6B0MpFe80YISQnaY1DKWUAg0YIU0alcnXThnH2dPy+rsoSinVr3TFvRASExzcec6U/i6GUkr1O61hKKWUskUDhlJKKVs0YCillLJFA4ZSSilbNGAopZSyRQOGUkopWzRgKKWUskUDhlJKKVvEGNPfZYgYEakGPuvh6cOBgxEsTiRp2XpGy9YzWraeGahlG22MGWHnIoMqYPSGiKw2xszr73L4o2XrGS1bz2jZeiYeyqZNUkoppWzRgKGUUsoWDRhHPNzfBQhCy9YzWrae0bL1zKAvm/ZhKKWUskVrGEoppWzRgKGUUsqWQR8wRGSxiGwVkR0icoef/ZNFZJWItIjIbeGc289l2yMi60WkVERW90PZviQi66zXByIyy+65/Vy2/n5uS61ylYrIahE5ye65/Vy2fn1uPsfNF5EOEbk03HP7qWz9/d/bqSJSZ92/VER+GO7n6sIYM2hfQAKwExgHJANrgandjhkJzAd+CtwWzrn9VTZr3x5geD8+txOAXOvvc4CPYui5+S1bjDy3DI70Hc4EtsTQc/Nbtlh4bj7HvQMsAy6NlecWqGyx8NyAU4FXe/q5ur8Gew1jAbDDGLPLGNMKPAks9T3AGHPAGPMJ0Bbuuf1YtmizU7YPjDG11tsPgSK75/Zj2aLNTtkOG+v/WCAdMHbP7ceyRZvdz34z8BxwoAfn9kfZoq03n71H5w72gFEIlPm8L7e2Rfvcvri+Ad4SkU9F5PoIlgvCL9s1wOs9PLcvywYx8NxE5CIR2QK8Bnw1nHP7qWzQz89NRAqBi4CHwj23H8sGMfDfG3C8iKwVkddFZFqY53aR2NOSDhDiZ5vdX029Obcvrn+iMaZSREYCb4vIFmPMyr4um4ichudL2dveHTPPzU/ZIAaemzHmBeAFETkZuAc4w+65/VQ26P/ndj9wuzGmQ6TL4bHw3O7Hf9mg/5/bGjy5og6LyBLgRWCCzXOPMthrGOVAsc/7IqCyD86N+vWNMZXWPw8AL+CpYvZp2URkJvAIsNQYcyicc/upbDHx3HzKshI4VkSGh3tuH5ctFp7bPOBJEdkDXAr8XkQutHluf5Wt35+bMabeGHPY+nsZkNSr/96i0RkTKy88NahdwFiOdOxMC3Ds3XTt9LZ9bj+ULR3I9Pn7A2BxX5YNOAbYAZzQ08/VD2WLhec2niMdy8cBFXh+7cXCcwtUtn5/bt2Of4wjnd79/tyClK3fnxuQ5/PvdAGwtzf/vUWk4LH8ApYA2/CMCPiete0G4AafB1oO1ANO6++sQOfGQtnwjGxYa7029lPZHgFqgVLrtTrYubFQthh5brdb9y4FVgEnxdBz81u2WHhu3Y59jK4jkfr1uQUqWyw8N+Am695r8QwAOSHYuaFemhpEKaWULYO9D0MppVSEaMBQSilliwYMpZRStmjAUEopZYsGDKWUUrZowFBxRUS+JyIbfbKyLrS2rxCRveIzVVdEXhSRwz7vp4nIOyKyTUS2i8gPxONqn2ygrT7ZSe8TkatEpNpnf6mITO1F+b8lImk+75eJSE5Pr6dUOHRYrYobInI88GvgVGNMizXjNdl4UjesAIYC3zDG/Nv6En4Tz2SmDBFJBTYAXzfGvGV9aT+HJxPogz732APMM8YctN5fZb2/yWYZBc//l+4A+7tcX6m+pDUMFU/ygYPGmBYAY8xBY6VusDwJXG79fTHwvM++/wDeN8a8ZZ3bhGdSVK/XXxCRMSKyWUR+jyf3T7GI/EE8a1JsFJEfWcd9EygA3hWRd61te7zpO0Tkv0Rkg/X6Vm/LpVR3GjBUPHkLz5fxNhH5vYic0m3/cuBkEUnAEzie8tk3DfjU92BjzE4gQ0SyQtz3sm5NUql+jpkE/NUYM8cY8xmembfz8KxLcYqIzDTG/AZPvp/TjDGn+Z4sInOBq4GFwCLgOhGZE6JcSoVFA4aKG8aThG0ucD1QDTxlNRl5dQD/Bi4DUo0xe3z2CYGzeYZq133KGDPb59Xs55jPjDEf+rz/ooisAUrwBKtQ/R4nAS8YYxqtz/k88LkQ5ygVlsGe3lypLowxHcAKYIWIrAe+gif/j9eTeLKK3t3t1I3Ayb4bRGQccNgY0xCBojX6XHcscBsw3xhTKyKPASkhzveXrlqpiNIahoobIjJJRCb4bJoNfNbtsPeAe4Enum3/O3CSiJxhXSsV+A3wiygUNQtPAKkTkVF4lpn1agAy/ZyzErhQRNJEJB3Pgj7vRaFsKo5pDUPFkwzgt9YIqHY8KdC7rIJmPMMG/6f7icaYZhFZap3/IJ41kf8G/M7GfS8TEd9FnL5hjPkg0MHGmLUiUoKnVrMLeN9n98PA6yJS5duPYYxZY9VEPrY2PWKMKbFRNqVs02G1SimlbNEmKaWUUrZowFBKKWWLBgyllFK2aMBQSilliwYMpZRStmjAUEopZYsGDKWUUrb8P7ReD+TJtlPUAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_smote_to_F1(10, 50, 240, 3760)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_smote_to_variance(smote_ratio_start, smote_ratio_end, ns, nl):\n",
    "    xs = np.array([])\n",
    "    ys = np.array([])\n",
    "    for n in range(smote_ratio_start, smote_ratio_end):\n",
    "        nd = n/100\n",
    "        xs = np.append(xs, nd)\n",
    "        #combined, imbalanced (original ratio), undersampling\n",
    "        smoteenn = SMOTEENN(random_state = 42, sampling_strategy=nd)\n",
    "        #rus = under_sampling.RandomUnderSampler(sampling_strategy={1.0: ns, 0.0: nl}, random_state=42)\n",
    "        X_combined_imb, Y_combined_imb = smoteenn.fit_resample(X_comb, Y_comb)\n",
    "        print('Resampled dataset shape %s' % Counter(Y_combined_imb))\n",
    "        #X_combined_imb, Y_combined_imb = rus.fit_resample(X_combined_imb, Y_combined_imb)\n",
    "\n",
    "\n",
    "        ys = np.append(ys, Y_combined_imb.var())\n",
    "        \n",
    "    plt.plot(xs, ys)\n",
    "    plt.title('SMOTE ratio to variance')\n",
    "    plt.xlabel('SMOTE ratio')\n",
    "    plt.ylabel('variance')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Resampled dataset shape Counter({0.0: 6399, 1.0: 420})\n",
      "Resampled dataset shape Counter({0.0: 6377, 1.0: 528})\n",
      "Resampled dataset shape Counter({0.0: 6341, 1.0: 634})\n",
      "Resampled dataset shape Counter({0.0: 6302, 1.0: 722})\n",
      "Resampled dataset shape Counter({0.0: 6234, 1.0: 805})\n",
      "Resampled dataset shape Counter({0.0: 6229, 1.0: 932})\n",
      "Resampled dataset shape Counter({0.0: 6185, 1.0: 1009})\n",
      "Resampled dataset shape Counter({0.0: 6175, 1.0: 1098})\n",
      "Resampled dataset shape Counter({0.0: 6137, 1.0: 1194})\n",
      "Resampled dataset shape Counter({0.0: 6125, 1.0: 1306})\n",
      "Resampled dataset shape Counter({0.0: 6112, 1.0: 1395})\n",
      "Resampled dataset shape Counter({0.0: 6103, 1.0: 1458})\n",
      "Resampled dataset shape Counter({0.0: 6039, 1.0: 1552})\n",
      "Resampled dataset shape Counter({0.0: 6039, 1.0: 1636})\n",
      "Resampled dataset shape Counter({0.0: 6008, 1.0: 1697})\n",
      "Resampled dataset shape Counter({0.0: 6048, 1.0: 1805})\n",
      "Resampled dataset shape Counter({0.0: 5987, 1.0: 1872})\n",
      "Resampled dataset shape Counter({0.0: 5968, 1.0: 1969})\n",
      "Resampled dataset shape Counter({0.0: 5955, 1.0: 2045})\n",
      "Resampled dataset shape Counter({0.0: 5954, 1.0: 2136})\n",
      "Resampled dataset shape Counter({0.0: 5956, 1.0: 2210})\n",
      "Resampled dataset shape Counter({0.0: 5932, 1.0: 2280})\n",
      "Resampled dataset shape Counter({0.0: 5906, 1.0: 2362})\n",
      "Resampled dataset shape Counter({0.0: 5903, 1.0: 2453})\n",
      "Resampled dataset shape Counter({0.0: 5908, 1.0: 2537})\n",
      "Resampled dataset shape Counter({0.0: 5875, 1.0: 2598})\n",
      "Resampled dataset shape Counter({0.0: 5875, 1.0: 2682})\n",
      "Resampled dataset shape Counter({0.0: 5840, 1.0: 2777})\n",
      "Resampled dataset shape Counter({0.0: 5851, 1.0: 2845})\n",
      "Resampled dataset shape Counter({0.0: 5828, 1.0: 2911})\n",
      "Resampled dataset shape Counter({0.0: 5840, 1.0: 3008})\n",
      "Resampled dataset shape Counter({0.0: 5833, 1.0: 3079})\n",
      "Resampled dataset shape Counter({0.0: 5779, 1.0: 3166})\n",
      "Resampled dataset shape Counter({0.0: 5799, 1.0: 3228})\n",
      "Resampled dataset shape Counter({0.0: 5799, 1.0: 3319})\n",
      "Resampled dataset shape Counter({0.0: 5780, 1.0: 3381})\n",
      "Resampled dataset shape Counter({0.0: 5787, 1.0: 3469})\n",
      "Resampled dataset shape Counter({0.0: 5775, 1.0: 3553})\n",
      "Resampled dataset shape Counter({0.0: 5779, 1.0: 3625})\n",
      "Resampled dataset shape Counter({0.0: 5751, 1.0: 3709})\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_smote_to_variance(10, 50, 240, 3760)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X_train_comb_imb: (2800, 35)\n",
      "y_train_comb_imb: (2800,)\n",
      "X_val_comb_imb: (600, 35)\n",
      "X_test_comb_imb: (600, 35)\n",
      "y_val_comb_imb: (600,)\n",
      "y_test_comb_imb: (600,)\n",
      "X_train_comb_b: (560, 35)\n",
      "y_train_comb_b: (560,)\n",
      "X_val_comb_b: (120, 35)\n",
      "X_test_comb_b: (120, 35)\n",
      "y_val_comb_b: (120,)\n",
      "y_test_comb_b: (120,)\n",
      "X_train_hasdep_imb: (2800, 35)\n",
      "y_train_hasdep_imb: (2800,)\n",
      "X_val_hasdep_imb: (600, 35)\n",
      "X_test_hasdep_imb: (600, 35)\n",
      "y_val_hasdep_imb: (600,)\n",
      "y_test_hasdep_imb: (600,)\n",
      "X_train_hasdep_b: (560, 35)\n",
      "y_train_hasdep_b: (560,)\n",
      "X_val_hasdep_b: (120, 35)\n",
      "X_test_hasdep_b: (120, 35)\n",
      "y_val_hasdep_b: (120,)\n",
      "y_test_hasdep_b: (120,)\n",
      "[0.1504105031490326, 0.9449999928474426]\n"
     ]
    }
   ],
   "source": [
    "from keras.models import Sequential\n",
    "from keras.layers import Dense\n",
    "\n",
    "import tensorflow as tf\n",
    "\n",
    "from tensorflow.keras import layers, models\n",
    "from tensorflow.keras.layers import Dropout\n",
    "\n",
    "def NN_Model_Dropout(neuron, activation, in_shape, classes, output_activation, optimizer, loss, dr):\n",
    "\n",
    "    model = models.Sequential()\n",
    "\n",
    "    ##Input Layer\n",
    "    model.add(Dense(37, activation = activation, input_shape = in_shape))\n",
    "\n",
    "    #Hidden Layers\n",
    "    for i in neuron:\n",
    "\n",
    "        model.add(Dense(i, activation = activation))\n",
    "        #model.add(Dropout(dr))\n",
    "\n",
    "    ##Ouput Layer\n",
    "    model.add(Dense(classes, activation = output_activation))\n",
    "\n",
    "    ##Compiling\n",
    "    model.compile(optimizer = optimizer,\n",
    "                  loss = loss,\n",
    "                  metrics=['acc'])\n",
    "\n",
    "    return model\n",
    "\n",
    "from sklearn.model_selection import train_test_split\n",
    "X_train_comb_imb, X_val_test_comb_imb, y_train_comb_imb, y_val_test_comb_imb = train_test_split(X_combined_imb, Y_combined_imb, test_size = 0.3, random_state = 40)\n",
    "X_val_comb_imb, X_test_comb_imb, y_val_comb_imb, y_test_comb_imb = train_test_split(X_val_test_comb_imb, y_val_test_comb_imb, test_size = 0.5, random_state = 40)\n",
    "\n",
    "print(\"X_train_comb_imb:\", X_train_comb_imb.shape)\n",
    "print(\"y_train_comb_imb:\", y_train_comb_imb.shape)\n",
    "print(\"X_val_comb_imb:\", X_val_comb_imb.shape)\n",
    "print(\"X_test_comb_imb:\", X_test_comb_imb.shape)\n",
    "print(\"y_val_comb_imb:\", y_val_comb_imb.shape)\n",
    "print(\"y_test_comb_imb:\", y_test_comb_imb.shape)\n",
    "\n",
    "#combined, balanced, undersampling\n",
    "X_train_comb_b, X_val_test_comb_b, y_train_comb_b, y_val_test_comb_b = train_test_split(X_combined_b, Y_combined_b, test_size = 0.3, random_state = 40)\n",
    "X_val_comb_b, X_test_comb_b, y_val_comb_b, y_test_comb_b = train_test_split(X_val_test_comb_b, y_val_test_comb_b, test_size = 0.5, random_state = 40)\n",
    "\n",
    "print(\"X_train_comb_b:\", X_train_comb_b.shape)\n",
    "print(\"y_train_comb_b:\", y_train_comb_b.shape)\n",
    "print(\"X_val_comb_b:\", X_val_comb_b.shape)\n",
    "print(\"X_test_comb_b:\", X_test_comb_b.shape)\n",
    "print(\"y_val_comb_b:\", y_val_comb_b.shape)\n",
    "print(\"y_test_comb_b:\", y_test_comb_b.shape)\n",
    "\n",
    "#has_dep_diag, imbalanced (original ratio), undersampling\n",
    "X_train_hasdep_imb, X_val_test_hasdep_imb, y_train_hasdep_imb, y_val_test_hasdep_imb = train_test_split(X_hasdep_imb, Y_hasdep_imb, test_size = 0.3, random_state = 40)\n",
    "X_val_hasdep_imb, X_test_hasdep_imb, y_val_hasdep_imb, y_test_hasdep_imb = train_test_split(X_val_test_hasdep_imb, y_val_test_hasdep_imb, test_size = 0.5, random_state = 40)\n",
    "\n",
    "print(\"X_train_hasdep_imb:\", X_train_hasdep_imb.shape)\n",
    "print(\"y_train_hasdep_imb:\", y_train_hasdep_imb.shape)\n",
    "print(\"X_val_hasdep_imb:\", X_val_hasdep_imb.shape)\n",
    "print(\"X_test_hasdep_imb:\", X_test_hasdep_imb.shape)\n",
    "print(\"y_val_hasdep_imb:\", y_val_hasdep_imb.shape)\n",
    "print(\"y_test_hasdep_imb:\", y_test_hasdep_imb.shape)\n",
    "\n",
    "#has_dep_diag, balanced, undersampling\n",
    "X_train_hasdep_b, X_val_test_hasdep_b, y_train_hasdep_b, y_val_test_hasdep_b = train_test_split(X_hasdep_b, Y_hasdep_b, test_size = 0.3, random_state = 40)\n",
    "X_val_hasdep_b, X_test_hasdep_b, y_val_hasdep_b, y_test_hasdep_b = train_test_split(X_val_test_hasdep_b, y_val_test_hasdep_b, test_size = 0.5, random_state = 40)\n",
    "\n",
    "print(\"X_train_hasdep_b:\", X_train_hasdep_b.shape)\n",
    "print(\"y_train_hasdep_b:\", y_train_hasdep_b.shape)\n",
    "print(\"X_val_hasdep_b:\", X_val_hasdep_b.shape)\n",
    "print(\"X_test_hasdep_b:\", X_test_hasdep_b.shape)\n",
    "print(\"y_val_hasdep_b:\", y_val_hasdep_b.shape)\n",
    "print(\"y_test_hasdep_b:\", y_test_hasdep_b.shape)\n",
    "\n",
    "##from FFNeuralNetwork import NN_models\n",
    "\n",
    "neurons = [35, 35]\n",
    "fnn = NN_Model_Dropout(neuron = neurons, activation = 'relu', in_shape = (35,), classes = 2, output_activation = 'sigmoid', optimizer = 'Adam', loss = 'sparse_categorical_crossentropy', dr = 0.4)\n",
    "final_history = fnn.fit(X_train_comb_imb, y_train_comb_imb, epochs = 100, validation_data = (X_val_comb_imb, y_val_comb_imb), verbose = 0)\n",
    "score = fnn.evaluate(X_test_comb_imb, y_test_comb_imb, verbose = 0, batch_size = 32)\n",
    "print(score)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "from keras import backend as K\n",
    "\n",
    "def recall_m(y_true, y_pred):\n",
    "    true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\n",
    "    possible_positives = K.sum(K.round(K.clip(y_true, 0, 1)))\n",
    "    recall = true_positives / (possible_positives + K.epsilon())\n",
    "    return recall\n",
    "\n",
    "def precision_m(y_true, y_pred):\n",
    "    true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\n",
    "    predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\n",
    "    precision = true_positives / (predicted_positives + K.epsilon())\n",
    "    return precision\n",
    "\n",
    "def f1_m(y_true, y_pred):\n",
    "    precision = precision_m(y_true, y_pred)\n",
    "    recall = recall_m(y_true, y_pred)\n",
    "    f1 = 2*((precision*recall)/(precision+recall+K.epsilon()))\n",
    "    return f1\n",
    "\n",
    "def fnn_print_metrics(model, X_train, y_train, X_val, y_val, X_test, y_test, model_name):\n",
    "    model.fit(X_train, y_train, epochs = 100, validation_data = (X_val, y_val), verbose = 0)\n",
    "    preds = model.predict(X_test)\n",
    "    preds_choice = preds.argmax(1)\n",
    "    #preds_choice = preds[:, 0]\n",
    "    #f1 = f1_m(y_test, preds_choice)\n",
    "    f1 = f1_score(y_test, preds_choice, average = 'macro')\n",
    "    recall = recall_score(y_test, preds_choice, average = 'macro')\n",
    "    precision = precision_score(y_test, preds_choice, average = 'macro')\n",
    "    print(model_name + ': ')\n",
    "    #print(f'F1: {f1}')\n",
    "    #print(f'recall: {recall_m(y_test, preds_choice)}')\n",
    "    #print(f'precision: {precision_m(y_test, preds_choice)}')\n",
    "    print(f'F1: {f1}')\n",
    "    print(f'recall: {recall}')\n",
    "    print(f'precision: {precision}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "FNN, combined, imbalanced: \n",
      "F1: 0.6882145084182083\n",
      "recall: 0.6936026936026936\n",
      "precision: 0.6831858407079646\n",
      "FNN, combined, b/imb: \n",
      "F1: 0.6743274222696186\n",
      "recall: 0.9107744107744108\n",
      "precision: 0.6368979766315189\n",
      "FNN, combined, balanced: \n",
      "F1: 0.8582447362935167\n",
      "recall: 0.8644781144781144\n",
      "precision: 0.8617376775271512\n",
      "FNN, has_dep_diag, imbalanced: \n",
      "F1: 0.6211539446065633\n",
      "recall: 0.596360429693763\n",
      "precision: 0.6721076746849943\n",
      "FNN, has_dep_diag, balanced: \n",
      "F1: 0.8582447362935168\n",
      "recall: 0.8695286195286196\n",
      "precision: 0.8742540494458653\n"
     ]
    }
   ],
   "source": [
    "fnn_print_metrics(fnn, X_train_comb_imb, y_train_comb_imb, X_val_comb_imb, y_val_comb_imb, X_test_comb_imb, y_test_comb_imb, \"FNN, combined, imbalanced\")\n",
    "fnn_print_metrics(fnn, X_train_comb_b, y_train_comb_b, X_val_comb_b, y_val_comb_b, X_test_comb_imb, y_test_comb_imb, \"FNN, combined, b/imb\")\n",
    "fnn_print_metrics(fnn, X_train_comb_b, y_train_comb_b, X_val_comb_b, y_val_comb_b, X_test_comb_b, y_test_comb_b, \"FNN, combined, balanced\")\n",
    "fnn_print_metrics(fnn, X_train_hasdep_imb, y_train_hasdep_imb, X_val_hasdep_imb, y_val_hasdep_imb, X_test_hasdep_imb, y_test_hasdep_imb, \"FNN, has_dep_diag, imbalanced\")\n",
    "fnn_print_metrics(fnn, X_train_hasdep_b, y_train_hasdep_b, X_val_hasdep_b, y_val_hasdep_b, X_test_hasdep_b, y_test_hasdep_b, \"FNN, has_dep_diag, balanced\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sklearn.metrics\n",
    "\n",
    "def plot_roc(model, X_train, y_train, X_val, y_val, X_test, y_test, title):\n",
    "    model.fit(X_train, y_train, epochs = 100, validation_data = (X_val, y_val), verbose = 0)\n",
    "    preds = model.predict(X_test)\n",
    "    preds_choice = preds.argmax(1)\n",
    "    fpr, tpr, threshold = sklearn.metrics.roc_curve(y_test, preds_choice)\n",
    "    roc_auc = sklearn.metrics.auc(fpr, tpr)\n",
    "\n",
    "\n",
    "    plt.title(title)\n",
    "    plt.plot(fpr, tpr, 'b', label = 'AUC = %0.2f' % roc_auc)\n",
    "    plt.legend(loc = 'lower right')\n",
    "    plt.plot([0, 1], [0, 1],'r--')\n",
    "    plt.xlim([0, 1])\n",
    "    plt.ylim([0, 1])\n",
    "    plt.ylabel('True Positive Rate')\n",
    "    plt.xlabel('False Positive Rate')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYoAAAEWCAYAAAB42tAoAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAAA8WUlEQVR4nO3dd3gU5fbA8e+R3kQFLIAIClJUQIxYwXbtBRUL1mv7IRe7FztNwN6wI6AXK1z1IvYOiB2DIE1UBIQIKE0EQktyfn+ciVlistmE7M6W83mefbK7MztzdpLMO/OW84qq4pxzzpVmm7ADcM45l9y8oHDOOReVFxTOOeei8oLCOedcVF5QOOeci8oLCuecc1F5QZHiRKS5iKiIVA07lkIiMlBEXgg7jmS0NcemPJ8N+3cgIhNF5LIE7m+L/wMReVdE/pmo/ae7pDm5ZDIRWQDsBOQDm4EvgF6quijMuJxLVap6fNgxpBO/o0geJ6tqXWAX4Dfg0ZDjSRti/G/duQryf54ko6obgFeBdoXviciJIjJVRP4UkUUiMrC0z4vIxSLyvYisEZF5InJ5xLLDRSRHRP4tIr+LyBIRuThieS0ReUBEfhGR1SLymYjUCpYdKCJfiMgfIvKdiBwe8bkWIvJJsM8PgYaxfl8RqSEiQ0VkcfAYKiI1gmXfi8hJEetWFZHlItIphpgmisgdIvI5kAvsLiIXBcdkjYjMF5HzgnX3EJHxIrIi2P6LIrJdxLYWiMgNIjJdRNaJyNMislNQvbFGRD4Ske2DdQurQHoG32eJiPw7yvePy3ENVBeR54LPzxKRrIht3ywiPwfLZovIaRHLWgb7XR0cj/+WtSMROVpE5gSfeQyQYssvCX6fq0TkfRHZLWKZisjVwe9muYjcV1bBLiJVROT+YP15wInFlv9V9RXD77eT2P/XGhF5RUT+KyJDyvrOGUVV/RHyA1gA/CN4Xht4FnguYvnhwD5Ywd4eu+M4NVjWHFCgavD6RGAP7B/1MOwk2SliO3nAIKAacEKwfPtg+ePARKAJUAU4GKgRvF4RrL8NcHTwulHwuS+BB4N1uwJrgBdi/O6DgK+AHYFGWLXb4GBZf+DFiHVPBOYEz8uKaSKwENgLq2KtD/wJtA6W7wLsFTxvGXy+RhDDJGBosd/PV1j1YBPgd+BbYN/gM+OBAcV+H6OBOsHvbVnE73dg4bGJ83EdCGwItl0FuAv4KmL5mUDjYL9nA+uAXYJlo4HbgmU1gUPL2FfD4Niegf1dXYf9nV0WLD8VmAu0DX4XfYEvIj6vwARgB6AZ8GPhZ6PssxcwB9g1+NwEtvw/mBix/1J/v0B14BfgmiD204FNwJCwzwvJ9Ag9AH/8dSJaC/wR/IMtBvaJsv5Q4KHgeeGJqWop644DrgmeHw6sj1wXO+kdGJwU1gMdStjGTcDzxd57H/hn8I+dB9SJWPZSOU5oPwMnRLw+FlgQPG8ZnBxrB69fBPqXFVPwfCIwKGJZneD4dgdqlRHTqcDUYr+f8yJe/w94MuL1VcC4Yr+PNhHL7wWeDp4PpKigiOdxHQh8FPG6HbA+yvrTgG7B8+eA4UDTGPd1IVsWQgLkUHSifhe4NGL5NtgFym7BawWOi1jeG/i4jH2Ox9rxCl8fQykFRbTfL1YA/wpIxPLP8IJii4dXPSWPU1V1O+yq50rgExHZGUBEDhCRCSKyTERWY1dTJVZDiMjxIvKViKwUkT+wK8rIdVeoal7E61ygbrBOTezEXdxuwJlB9cgfwXYPxa7KGwOrVHVdxPq/lON7Ny62/i/Be6jqXOB74GQRqQ2cgp0sy4qp0F+dAYL4zsaO3RIReVtE2gCIyI4iMkZEfhWRP4EX+Pvx/S3i+foSXtcttn5kR4S/vlMx8TyuAEsjnucCNaWoV9CFIjItYr97U/Sdb8RO9pODKqtLythPY7Y81sqW33834OGIfa0Mtt8kYp1Yjlep+yTKsSnj99sY+DWIuaRYHN5GkXRUNV9Vx2I9oA4N3n4JeAPYVVXrA8MoVgcMVt+PXe3eD+wUFDzvlLRuCZZjVRV7lLBsEXblu13Eo46q3g0sAbYXkToR6zeLYX+FFmMnksjPLo54PRo4B+gGzA4Kj7JiKrRFamRVfV9Vj8ZOxHOAEcGiu4J126vqtsD5xHbMotk1yncqFM/jWqqgfWAEdkHSIPg7mUnwnVV1qar+n6o2Bi4HnhCRllE2uYSI7ysiwpbffxFwebHvWUtVv4hYJ5bjVeo+iX5sov1+lwBNgphLisXhBUXSEdMN2B67mgaoB6xU1Q0i0hk4t5SPV8fuSJYBeSJyPHZLXiZVLQCeAR4UkcZBY+FBQeHzAnZVf2zwfk2xhvGmqvoLkA3cLiLVReRQ4ORi32mBiFxUyq5HA31FpJGINMTaJSL7/48JvsO/KLqbIFpMJe1ErPH5lODEuxGr6ssPFtcLXv8hIk2AG2I5ZmXoJyK1RWQv4GKgpAbheB7XaOpgJ85lwXYuxu4oCrd7ZsRxXBWsm198IxHeBvYSkdODO5argZ0jlg8DbgmOBSJSX0TOLLaNG0RkexHZFWsvKKsB/WXgahFpKtaR4OYo60b7/X4ZfLcrxTpLdAM6l7HvjOMFRfJ4U0TWYo2Cd2B17bOCZb2BQSKyBjuRvlzSBlR1DfZP+jL2D34udicSqz7ADOAbrHrgHmAbtfEc3YBbsZPLIuyfrfDv51zggOAzA7A6bgBEpDrQAGsMLskQ7IQ4Pdj3t8F7hd9pCfbPfDARJ48YYipuG+Df2JXqSqyhv3ew7HagE7AaO+mNLWUb5fEJ1oD7MXC/qn5QfIU4H9dSqeps4AHsuP6GNbh/HrHK/sDXwd/jG1gb1/wo21uONY7fjTXGt4rcnqq+hv0tjQmqfmYCxcc5vA5MwdpK3gaeLuNrjMDac77D/mai/c5K/f2q6iasAftSrA3rfOAt7GLCBWTLqjnnKldwJXyFqp4TdiyJICLNgflAtWJtQZW9n7Q5riKiQKuIasVQicjXwDBV/U/YsSQLLyicq0SJKijSSdgFhYgcBvyAtdOdh1WV7R7czTriWPUkIs+IDeqaWcpyEZFHRGSu2ECmTvGKxTm3dUSki4isLekRx30OK2Wfwyp5V62xKqzVWPXkGV5IbCludxQi0hVrQHpOVfcuYfkJWP/zE7B62IdV9YC4BOOcc67C4nZHoaqTsEa40nTDChFV1a+A7URklyjrO+ecC0GY2WObsOXAlpzgvb/d8olIT6AnQJ06dfZr06ZNQgJ0zrlkkJ8PeXmwebP9LP4o/n5BQdFnd2YJu7CUqRQsV9VGFdl/mAVFSQOaSqwHU9XhWEoBsrKyNDs7O55xOedc3GzeDCtWwLJl9li+PPrz5cvt5F+SWrWgUSN7NGxY7HlDpdGOwp5z3mCXGR+ww0uPl3dk/1/CLChy2HIEZFPKHo3pnHNJQxXWrSv7ZB/5/I8/St/e9tsXnex33x0OOKCUQiB4Xrt2CRtZtQr69AHdHXrehmW+OQVeerzC3zPMguINbDTkGKwxe7X3NHDOhamgAFauLN+Jf8OGkrdVrdqWJ/VOnaJc/TeCBg2g6taekV97DXr3tsD69t3KjRWJW0EhIqOxbKUNRSQHG1laDUBVh2E5iE7ARq/mYmkOnHOu0mzcGNvJvvD5ihVb1u9Hqlev6KTeuDG0bx/9xL/ttiBbmzEsVr/9BlddBa+8Ah07wttvW8lUSeJWUJQ1YjTI1nhFvPbvnEsvqvDnnyXX4Zd24l+zpuRtbbONXcEXntTbtSu9eqdhQ3vUrJnY71suixZZ4XDHHXDDDXY7U4l8zmznXCjy8srfqLt5c8nbqllzyxN8q1bRT/zbbw9VqiT2+1a6X36BN9+EK6+ErCxYuNBKvzjwgsI5VynK26i7alXp29puu6KTevPmsP/+0U/8deoksJonbAUF8OSTcHOQMLd7d9hll7gVEuAFhXOuBAUFdiIvz4l//fqSt1W1atGJvWFDq0KP1pOnQYNKrzlJHz/8AJddBp99BsceC089ZYVEnHlB4VwG2LSp/I26+aXMQFGnTtFJfaedYO+9o5/469fPoKv9eMrNhUMPtV/MqFFw4YUJO7BeUDiXYlStkbY8J/4//yx5WyKwww5FJ/XWre1cVNqJv2FDG+TlEujHH63RpXZteP55uyXbeecyP1aZvKBwLmT5+UWNurGe+DdtKnlb1asXndwLB21F68K5ww5p0KibrjZsgMGD4Z577A7i/PPhuONCCcULCucq2fr1sdfrFzbqlpbEuX79opN6s2ZlD9qqW9eredLC55/DpZdam8TFF8OJJ4YajhcUzkVRUACrV5fvxJ+bW/K2qlQp6pPfqJEN2Cqr73716on9vi4JDB4MAwbYlcH778MxMU17H1deULiMsmmTndRL66df0nulNerWrr3lCb5t2+gn/u22s4FezpVI1W4HO3a0UdZ33GG3iEnACwqXslRh7dry1e2vXl369gobdRs2hJYt4aCDop/4S0zI5lx5rVwJ111nf3T9+sHJJ9sjiXhB4ZJGfr79z5TnxL9xY8nbqlZty5N68+bRu3DusEMlJGRzrrxefRWuuML+8Pv1CzuaUvm/houbDRvKV7e/cmXpjbr16hWd1Js0KXvQVr163qjrktiSJZZ6Y+xY2G8/+OAD6NAh7KhK5QWFqxT33QcTJmx54l+3ruR1CxOyFZ7U99orek+ehg2hRo3Efh/n4mrxYmuovuceuP76pL+dTe7oXEqYMAFuvBHatIHddoM994x+4t9+e2/UdRlowQJL4nfVVXYXsWiR/TOkAC8o3FZRtarVJk1g6tQkT8XsXBjy8+Hxx+HWW+0K6cwzbWR1ihQSAH5d57bKe+/Z2KC+fb2QcO5vvv8eunaFa66BLl1g5syEp9+oDH5H4SpM1QqIFi3gkkvCjsa5JJOba4VEQQE895yl4EjRHhZeULgKGzcOvv3W0tD4CGLnAnPmWHbF2rXhxRetN9NOO4Ud1VbxqidXIfn51jbRujWcd17Y0TiXBNavh5tusm58L75o7x1zTMoXEuB3FK6CXn4ZZs2CMWOSvmefc/E3aZJNKPTTT/bzpJPCjqhS+R2FK7e8PMtZ1r69deBwLqPdfjscdpj9Y3z0EYwYYYm90ohfC7pye+45u3B6/XUfD+EyWGESv6wsy9U0eLBN/5eGREvLmZCksrKyNDs7O+wwMtbGjTagbqed4OuvU7YTh3MVt3y5FQytWkH//mFHEzMRmaKqWRX5rF8PunJ5+mlYuBCGDPFCwmUYVWuca9fOGucy6Hbaq55czNavtwKiSxc4+uiwo3EugRYvht69rb41K8vaItq3DzuqhPGCwsXsySct6eWYMX434TLM0qUwfrxlv7z22ozr6pdZ39ZV2Jo1cNdd1i28a9ewo3EuAebNgzfesIKhUyerc02z3kyxypxKNrdVHnnE2vAGDw47EufiLD8fHnoI9t7b+oEvXWrvZ2ghAV5QuBisWmV33KecAp07hx2Nc3E0axYccojNEXHkkfY6BZP4VTavenJlevBBm2t60KCwI3EujnJzbeCcCLz0EvTo4Y1xAS8oXFTLlsHQoXDWWUk9U6NzFTd7NrRta0n8xoyxP/RGjcKOKql41ZOL6p577ELr9tvDjsS5SpabCzfcAPvsAy+8YO/94x9eSJTA7yhcqRYvtom5LrjApjl1Lm1MnAj/938wdy5cfrk1wLlS+R2FK9Wdd1qesxTKUuBc2QYMgCOOsJHW48fDsGFQv37YUSU1LyhciX75BYYPh0svhd13Dzsa5ypBYV67zp3h3/+G6dOtwHBlimtBISLHicgPIjJXRG4uYXl9EXlTRL4TkVkicnE843GxGzzYUtn07Rt2JM5tpWXL4Nxzi7rtnXgi3H+/NV67mMStoBCRKsDjwPFAO+AcEWlXbLUrgNmq2gE4HHhARHxSzZD99JNNb9qrFzRtGnY0zlWQqnVzbdsWXn3V5+vdCvG8o+gMzFXVeaq6CRgDdCu2jgL1RESAusBKIC+OMbkYDBwINWrALbeEHYlzFZSTYw3U550HLVvC1Kn+B70V4llQNAEWRbzOCd6L9BjQFlgMzACuUdWC4hsSkZ4iki0i2cuWLYtXvA6YORNGj4arr06LqX5dplq2zKYnffBB+Pxzm8faVVg8C4qShjQWnyXpWGAa0BjoCDwmItv+7UOqw1U1S1WzGnkf57gaMADq1bPu5c6llLlzLUcTwL77wqJFNsFQlSrhxpUG4llQ5AC7Rrxuit05RLoYGKtmLjAf8B77IZkyBcaOtTQ3O+wQdjTOxSgvzxqn99nHRob+9pu9v+3frjldBcWzoPgGaCUiLYIG6h7AG8XWWQgcBSAiOwGtgXlxjMlF0a+fFRDXXRd2JM7FaMYMOPhguwU+5hhL4ud1ppUubiOzVTVPRK4E3geqAM+o6iwR6RUsHwYMBkaJyAysquomVV0er5hc6T7/HN5911J2+IWYSwm5uTYOYpttLEfTWWd5Er84EdXizQbJLSsrS7Ozs8MOI+0ceaTlRvv5Z6hTJ+xonIti5kxrnBaBjz+2JH4NG4YdVdITkSmqmlWRz/rIbMf48TBhAtx6qxcSLomtW2cNaO3bFyXxO+ooLyQSwJMCZjhVG33dtCn07Bl2NM6V4uOPLYnf/PnQuzd0Kz4ky8WT31FkuHfegS+/tIbsmjXDjsa5EvTrZ+m/q1aFTz6xlMbekJZQXlBksIIC+x/cfXe42LNsuWRTEIy9PfhguPFG+O476No13JgylFc9ZbDXXrPMBs89B9WqhR2Nc4Hff7fUAK1b27iI44+3hwuN31FkqPx8m2eiTRtLrOlc6FStkbptW7uK8eyuScPvKDLUmDHWHfbllz3DgUsCixZZuuJ33oGDDoKRI6Fd8WTTLix+R5GBNm+2DLEdOkD37mFH4xywYoWN+nz4Yfj0Uy8kkozfUWSgZ5+1/GlvvGGDWp0LxY8/2h9hnz7QsaPdVdSrF3ZUrgR+msgwGzfaRF8HHAAnnRR2NC4j5eVZrpj27eGOO4qS+HkhkbS8oMgwI0bYhduQIZ4Wx4Xgu+/sKuXmm+GEE6yhzJP4JT2vesogubl2AXfYYZb5wLmEys21P7yqVW1qUm8gSxleUGSQJ56ApUutp5PfTbiEmT7d5oqoXRteecV6UfiEJynFq54yxJ9/wt13w7HHQpcuYUfjMsLatXDNNdZQ/fzz9t4RR3ghkYL8jiJDPPyw9UAcMiTsSFxG+PBDyzK5YAFceSWcdlrYEbmt4HcUGWDlSpsp8tRTIatC2eidK4fbbrPZ5mrUsDERjz7qPZpSXMwFhYj4TAUp6oEHYM0a6xbrXNwUJvE79FC45RaYNs2eu5RXZkEhIgeLyGzg++B1BxF5Iu6RuUrx++9W7XT22dae6FylW7oUzjjDhvuDJfC7807PW59GYrmjeAg4FlgBoKrfAZ7rN0XcfTesX1/0P+xcpVGFUaMs3cZbb/kcEWkspsZsVV0kW/anzI9POK4y/fqrdYm98ELL2OxcpfnlF2us/uADq14aOdL/yNJYLHcUi0TkYEBFpLqI9CGohnLJ7Y47rNp4wICwI3Fp548/4Jtv4LHHbNY5LyTSWix3FL2Ah4EmQA7wAdA7nkG5rTd/vl3kXXYZNG8edjQuLfzwgyXxu+EGGzS3cCHUrRt2VC4BYrmjaK2q56nqTqq6o6qeD7SNd2Bu6wwebJlhb7st7Ehcytu8Ge66ywqHu++2HhLghUQGiaWgeDTG91yS+OEHSyXeuzc0aRJ2NC6lTZ1qSfxuvRVOPtmS+O24Y9hRuQQrtepJRA4CDgYaicj1EYu2BXxOtCQ2cCDUqmUJOp2rsNxcOPpom1D9f/+D008POyIXkmhtFNWBusE6kcMq/wTOiGdQruKmT7dpTm+91S/8XAVNnWr5mWrXtiyvHTrA9tuHHZULkahq9BVEdlPVXxIUT5mysrI0Ozs77DCS1mmnwYQJ1pjt/9uuXNassRHVjz9udZcXXhh2RK4SicgUVa1QEp9Yej3lish9wF7AX0MtVfXIiuzQxU92NowbZ6k6vJBw5fLee3D55Tar1TXXeDWT20IsjdkvAnOAFsDtwALgmzjG5CqoXz9o0MD+z52L2S23WNqNOnXg889h6FDv0eS2EMsdRQNVfVpErlHVT4BPROSTeAfmyuezz+yi8N57PZOCi1F+PlSpAocfbrPO9e1rGV+dKyaWgmJz8HOJiJwILAaaxi8kV16qNl5i553hiivCjsYlvSVL7A9lr71swM2xx9rDuVLEUlAMEZH6wL+x8RPbAtfGMyhXPh9/DJMmWdr/2rXDjsYlrcIkftdfDxs2eApwF7MyCwpVfSt4uho4AkBEDolnUC52qlZjsOuu8H//F3Y0LmktWGB/IB99ZHPhjhwJe+4ZdlQuRUQbcFcFOAvL8fSeqs4UkZOAW4FawL6JCdFF8/bb8PXXMGKEVy+7KFavhm+/tXTCl19u+V2ci1Gp4yhEZBSwKzAZOAD4BTgIuFlVx8W0cZHjsISCVYCRqnp3CescDgwFqgHLVfWwaNv0cRRFCgqgUyebw/77720ArXN/mT3bkvgVDtFft856NrmMFK9xFFlAe1UtEJGawHKgpaoujTGoKsDjwNFY1tlvROQNVZ0dsc52wBPAcaq6UER8LHE5/O9/8N138PzzXki4CJs2Wfe3wYNtrupLLrFh+l5IuAqKdv+5SVULAFR1A/BjrIVEoDMwV1XnqeomYAzQrdg65wJjVXVhsJ/fy7H9jJafD/372+Ri55wTdjQuaWRnw/7726Ca00/3JH6uUkS7o2gjItOD5wLsEbwWQFW1fRnbbgIsinidg1VhRdoTqCYiE7F8Ug+r6nPFNyQiPYGeAM2aNStjt5nhpZdgzhxLxVPFUzQ6sKqlY4+1uapffx1OOSXsiFyaiFZQbO2cE1LCe8UbRKoC+wFHYQ3kX4rIV6r64xYfUh0ODAdro9jKuFLe5s2WIXbffS23k8tw335rSfzq1IHXXoP27WG77cKOyqWRUguKSkgEmIM1hhdqig3WK77OclVdB6wTkUlAB+BHXKn+8x+YN8/ms/fOKxnszz+tofrJJ4uS+HXtGnZULg3F8zTzDdBKRFqISHWgB/BGsXVeB7qISFURqY1VTfl83FFs2GBtlAceCCecEHY0LjTvvGMjq596ygbQde8edkQujcUyMrtCVDVPRK4E3se6xz6jqrNEpFewfJiqfi8i7wHTgQKsC+3MeMWUDoYPh5wcu4CUkir3XPq76Sbr1dSunTVSHVC86c+5ylXmfBQAIlILaKaqP8Q/pOgyeRzFunWwxx52fhg/PuxoXEKp2sCZKlXggw8sy+utt/ooSxezrRlHUWbVk4icDEwD3gtedxSR4lVILgEefxx++82qnlwG+fVXOPVUGDDAXh9zDNx+uxcSLmFiaaMYiI2J+ANAVacBzeMVkCvZ6tVwzz02bcAhnmkrM6habpZ27ewuomHDsCNyGSqWNoo8VV0tXiEeqqFDYeVKv5vIGPPnw6WX2ry2hx9uBUbLlmFH5TJULAXFTBE5F6giIq2Aq4Ev4huWi7RiBTz4oA203W+/sKNxCbF2LUyfbr2aLrvM+0G7UMXy13cVNl/2RuAlLN34tXGMyRVz//027/3tt4cdiYurmTPhzjvt+T77wMKF0LOnFxIudLH8BbZW1dtUdf/g0TfI/eQS4Lff4JFHLJ/T3nuHHY2Li02b7CqgUyd46CH4PUh55rNQuSQRS0HxoIjMEZHBIrJX3CNyW7j7bti4sajDi0sz33xj9YkDB8KZZ3oSP5eUYpnh7ggR2RmbxGi4iGwL/FdVh8Q9ugyXk2PZGf75T5+MLC2tWwfHHQe1atm8ESefHHZEzpUopspPVV2qqo8AvbAxFf3jGZQzQ4bYGKt+/cKOxFWq7Gz7xdapY1leZ83yQsIltVgG3LUVkYEiMhN4DOvx1DTukWW4efPg6aetLbN587CjcZVi9WqbhnT//eGFF+y9Qw+F+vXDjcu5MsTSPfY/wGjgGFUtnv3VxcmgQVC1qmVpcGngzTehVy9YuhT69IEzzgg7IudiFksbxYGJCMQVmTPHpje97jpo3DjsaNxWu+EG6+O8zz4wbpzdUTiXQkotKETkZVU9S0RmsOWEQ7HOcOcqaMAAa9+86aawI3EVpmrz1VatarmZtt3WfqHVq4cdmXPlFu2O4prg50mJCMSZ776Dl1+G226DRo3CjsZVSE4O/OtfNtPcHXfA0Ufbw7kUVWpjtqouCZ72VtVfIh9A78SEl3n697dZLPv0CTsSV24FBZZyozAP/M47hx2Rc5Uilu6xJV0KHV/ZgTiYPNm60/fp41Mep5x58+DII63BunNnmDEDrroq7KicqxTR2ij+hd057C4i0yMW1QM+j3dgmahfP8skffXVYUfiym3dOhtVPXIkXHKJTz/o0kq0NoqXgHeBu4CbI95fo6or4xpVBpo0yaYcuP9+qFcv7GhcTGbMsAFzfftaj6ZffrFeCM6lmWhVT6qqC4ArgDURD0Rkh/iHljlU7Vyzyy7Q21t/kt/GjdaY1KmTZWwsTOLnhYRLU2XdUZwETMG6x0beSyuwexzjyigffgiffmpTnfq5Jsl99ZVNKDR7NlxwgWV7bdAg7Kici6tSCwpVPSn42SJx4WSewruJ3Xaz849LYuvWwYknWo6md96xeWmdywCx5Ho6RETqBM/PF5EHRaRZ/EPLDG++aZmm+/eHGjXCjsaV6Ouvi5L4vfmmJfHzQsJlkFi6xz4J5IpIB+BG4Bfg+bhGlSEKM8O2bAkXXhh2NO5v/vjDpiE98MCiJH4HH+y9DVzGiSUpYJ6qqoh0Ax5W1adF5J/xDiwTvPKKTYv84ouW6cElkXHjrGfB779b6o0zzww7IudCE8vpaY2I3AJcAHQRkSpAtfiGlf7y8iyn0957Q48eYUfjtnD99dZI3aGDVTXtt1/YETkXqlgKirOBc4FLVHVp0D5xX3zDSn8vvgg//ABjx8I2MU0f5eIqMonfCSdYT6Ybb4Rqfk3knKhq2SuJ7AQU5kaerKq/xzWqKLKysjQ7Ozus3VeKTZugTRvYfnub7MwH8YZs4UJLvbHvvpbEz7k0JCJTVDWrIp+NpdfTWcBk4Exs3uyvRcRnXdkKzzwD8+fbVKdeSISooACeeAL22gs++cQn/3CuFLFUPd0G7F94FyEijYCPgFfjGVi6Wr8eBg+2zjPHHRd2NBls7lzLyfTpp5YCfPhwn3PWuVLEUlBsU6yqaQWxdat1JXjqKVi82Hpb+t1EiDZsgB9/hP/8B/75T/9lOBdFLAXFeyLyPjZvNljj9jvxCyl9rV0Ld90FRx0FRxwRdjQZaNo0S+JX2N1swQKoWTPsqJxLemXeGajqDcBTQHugAzBcVX2Szgp47DHrlj94cNiRZJgNG2zKwKwsePLJoiR+Xkg4F5No81G0Au4H9gBmAH1U9ddEBZZuVq+Ge++1VEEHHRR2NBnkiy8sidacOVbF9OCDsIMnP3auPKLdUTwDvAV0xzLIPpqQiNLUgw/CqlUwaFDYkWSQdevg5JMhNxfeew9GjfJCwrkKiNZGUU9VRwTPfxCRbxMRUDpavtwG+nbvblMYuDj78ks44ABL4vfWW9Ye4fmZnKuwaHcUNUVkXxHpJCKdgFrFXpdJRI4TkR9EZK6I3Bxlvf1FJD9dx2fcd581ZPvdRJytWmVdXg8+GJ4P8lYedJAXEs5tpWh3FEuAByNeL414rcCR0TYc5IR6HDgayAG+EZE3VHV2CevdA7xfvtBTw9Kl8OijcN550K5d2NGksbFj4YorYNkyuOUWOPvssCNyLm1Em7hoaztwdgbmquo8ABEZA3QDZhdb7yrgfxSlCEkrd91lKTsGDAg7kjR23XUwdCh07GgTCu27b9gROZdW4pncugmwKOJ1DnBA5Aoi0gQ4Dbs7KbWgEJGeQE+AZs1SZ86khQth2DC4+GKbc8JVosgkfiedBDvuCH36eBI/5+IgniOsSxrqWjwD4VDgJlXNj7YhVR2uqlmqmtWoUaPKii/uhgyxn/36hRtH2lmwwPKfFB7Yo46y6iYvJJyLi3gWFDnArhGvmwKLi62TBYwRkQXAGcATInJqHGNKmLlzLfnf5ZdDCt0EJbeCAmvw2XtvGx+x225hR+RcRiiz6klEBDgP2F1VBwXzUeysqpPL+Og3QCsRaQH8CvTA5rX4i6q2iNjPKOAtVR1Xrm+QpAYNgurV7ULXVYKffrI6vM8/t7uJYcO8oHAuQWK5o3gCOAg4J3i9BuvNFJWq5gFXYr2ZvgdeVtVZItJLRHpVMN6UMHu2Jf278krYZZewo0kTmzbBzz/Dc89Zg7UXEs4lTJkTF4nIt6raSUSmquq+wXvfqWqHhERYTCpMXHTmmTYQeP58aNgw7GhS2NSplsRv4EB7vXEj1KgRakjOpaq4TlwEbA7GOmiws0ZAQUV2lgmmToVXX7Uem15IVNCGDVZnt//+lpd92TJ73wsJ50IRS0HxCPAasKOI3AF8BtwZ16hSWP/+sN12cP31YUeSoj77DDp0gLvvhgsvtHq8FOrp5lw6KrMxW1VfFJEpwFFYl9dTVfX7uEeWgr76ylIL3XmnFRaunNauhW7dYNtt4YMPbOY551zoYun11AzIBd6MfE9VF8YzsFTUr59d/F51VdiRpJjPPrP8THXrwttvW/fXunXDjso5F4il6ultLN3428DHwDzg3XgGlYomToSPPrKqdT/HxWjFCqte6tKlKInfgQf6AXQuycRS9bRP5Osgc+zlcYsoBalC377QuDH0SuuOv5VE1Vr8r7wSVq60W7EePcKOyjlXinLnelLVb0UkLRP4VdT779s4sCeegFq1wo4mBVx3HTz8MOy3n7VFdAilp7VzLkaxtFFE9t/ZBugELItbRCmm8G6ieXObcdOVQhXy8iwf0ymn2O3X9ddbUj/nXFKL5b80ctaXPKyt4n/xCSf1vP46TJkC//mPpexwJZg/H3r2tDuIu++GI4+0h3MuJUQtKIKBdnVV9YYExZNSCgqsen3PPeH888OOJgnl58Njj8Gtt0KVKjZk3TmXckotKESkqqrmxTrtaSb6739h5kwYPdprUP7mxx/hoots/urjj7cR1rvuWubHnHPJJ9rpbTLWHjFNRN4AXgHWFS5U1bFxji2p5eXZrHX77ANnnRV2NEkoLw9++cWyI557LkhJ05M451JBLNfBOwArsFnoFBudrUBGFxTPP2+Zr8eNg23iOatHKsnOtkabwYNtgvB58zw/k3NpIFpBsWPQ42kmRQVEoegpZ9Pcpk1w++2QlWUdeDLe+vV2e/XAA7DzznD11TZE3QsJ59JCtIKiClCX2KY0zShPP221Kk895TUqfPIJXHaZTen3f/8H997ria6cSzPRCoolqjooYZGkiPXrbS7sQw+FY44JO5qQrV0Lp59uBcPHH3uXV+fSVLSCItOvlUv05JOweDG89FIG3018+ikccojlZHr3XdhrL6hTJ+yonHNxEq0Z9qiERZEi1q6Fu+6Cf/wDDjss7GhCsHy5DRjp2rUoiV/nzl5IOJfmSr2jUNWViQwkFTzyiJ0rhwwJO5IEU4WXX7b86atWWcO1J/FzLmP4MLEY/fEH3HcfnHwyHHBA2NEk2DXXwKOP2tSkH39sg0eccxnDC4oYPfCAFRaDMqV5XxU2b7YEVqedBrvtBtdea6k4nHMZxYeKxWDZMhg61FIVdewYdjQJ8PPPcNRRlhYX4Igj4N//9kLCuQzlBUUM7r0XcnNtkF1ay8+HBx+0qqUpU6B167Ajcs4lAa96KsOSJZYA9fzzoW3bsKOJozlz4J//hMmTrSHmySehSZOwo3LOJQEvKMpw552W365//7AjibOCAhsgMno0nH12Bg8Scc4V5wVFFIVpOi65BPbYI+xo4mDyZEvid8cdlsTv55999iXn3N94G0UUgwfbhXVhm27ayM2FPn3goIPg2WettR68kHDOlcgLilL89BOMGgW9eqXZfDsTJlhj9QMPWBK/WbMs06tzzpXCq55KcfvtliX7llvCjqQSrV1rfXy3284KjMMPDzsi51wK8DuKEsyaZUn/rrrKpldIeRMnWmN1YRK/6dO9kHDOxcwLihL072/n1BtuCDuSrbRsGZxzjg2Ye+EFe2///aF27XDjcs6lFC8oipkyBcaOheuvhwYNwo6mglTtlqhtW/sygwd7Ej/nXIV5G0Ux/fvD9tvDddeFHclWuOoqePxxOPBAm46vXbuwI3LOpTAvKCJ88QW8847NOVG/ftjRlFNBgY0MrF4dzjgDWra0AsPzMznntlJcq55E5DgR+UFE5orIzSUsP09EpgePL0SkQzzjKUu/frDjjnZ+TSk//WTTkN52m70+/HDP9OqcqzRxKyhEpArwOHA80A44R0SK14HMBw5T1fbAYGB4vOIpy/jx9rj11hSasC0vD+6/H9q3h2nT0jwZlXMuLPGseuoMzFXVeQAiMgboBswuXEFVv4hY/yugaRzjKZWqjb5u0gQuvzyMCCrg++/hwgshOxu6dYMnnoDGjcOOyjmXhuJZUDQBFkW8zgGizQ13KfBuSQtEpCfQE6BZs2aVFd9f3n0XvvwShg2DmjUrffPx89tv8N//2iA6T+LnnIuTeLZRlHTm0hJXFDkCKyhuKmm5qg5X1SxVzWpUyekmCu8mWrSAiy+u1E1Xvq++Khoq3ratJfE76ywvJJxzcRXPgiIHiMyS1BRYXHwlEWkPjAS6qeqKOMZTotdeg6lTYeDAJM6Jt26d9dc9+GB48cWiJH7VqoUbl3MuI8SzoPgGaCUiLUSkOtADeCNyBRFpBowFLlDVH+MYS4ny823cRJs2cN55id57jD76CPbe2+Zi7d3bk/g55xIubm0UqponIlcC7wNVgGdUdZaI9AqWDwP6Aw2AJ8SqT/JUNSteMRU3Zoydd//73yTtSbp2rY2o3mEHmDQJunQJOyLnXAYS1RKbDZJWVlaWZmdnb/V2Nm+2Acu1a1vV0zbJlMxk/Hg47DArvaZMsUBr1Qo7KudcChORKRW9EE+m02NCPfcczJ1raZCSppD47TdrnD7qqKIkfvvt54WEcy5UyXKKTKiNG2HQIOjcGU4+OexosK5Xzz9vdw6FU5Oee27YUTnnHJChuZ5GjoSFC+1nUvQsveIKePJJm5r06ad9hLVzLqlkXEGRmwtDhkDXrvCPf4QYSEGBNZTUqAFnn22FQ+/eSdqq7pzLZBlXUDzxBCxdaj2dQrub+OEHuOwyOOAAy9V02GH2cM65JJRRbRRr1sDdd8Mxx9gdRcJt3mwBdOgAM2fCPvuEEIRzzpVPRt1RPPwwrFhhPZ0SbtYsuOAC64t7+uk2sVBaTMjtnEt3GVNQrFpltTzdullvp4SrUgVWroRXX4Xu3UMIwDnnKiZjqp7uvx9Wr7ZusQnzxRdwU5DnsE0bG7jhhYRzLsVkREHx++9W7XT22TbHT9ytXQtXXw2HHmqt5suX2/tVM+YGzjmXRjKioLjnHli/3jLExt0HH1gSv8cegyuvtEbrhg0TsGPnnIuPtL/E/fVX6xJ7wQVW+xNXa9daGtoGDeDTT+GQQ+K8Q+eci7+0v6O4806bWnrAgDju5MMPLWd53bp2RzFtmhcSzrm0kdYFxYIFMGKEjW1r0SIOO1iyxBqnjznGJhQC2HffFJtP1TnnokvrgmLQIMsMe9ttlbxhVRg1ypL4vf22DaLzJH7OuTSVtm0UP/4Izz5rnY+aNq3kjf/rX/DUU9araeRIaN26knfgXHrYvHkzOTk5bNiwIexQMkbNmjVp2rQp1SpxquS0LSgGDrQaoJtvrqQNRibxO/dc62fbq1cSTWbhXPLJycmhXr16NG/eHEmKVM3pTVVZsWIFOTk5tKjE+va0PMvNmGHTnF5zDey0UyVs8PvvbRrSW2+11127WqZXLySci2rDhg00aNDAC4kEEREaNGhQ6XdwaXmmGzAA6tWDPn22ckObN1u3qY4dYc4ca6h2zpWLFxKJFY/jnXZVT9nZ8NprcPvtsMMOW7GhWbPg/POtq+uZZ8Kjj1bS7YlzzqWWtLuj6NfPCohrr93KDVWtasmhxo6Fl1/2QsK5FPbaa68hIsyZM+ev9yZOnMhJJ520xXoXXXQRr776KmAN8TfffDOtWrVi7733pnPnzrz77rtbHctdd91Fy5Ytad26Ne+//36J60ybNo0DDzyQjh07kpWVxeTJk8v1+cqWVgXFZ5/Be+9ZHr5tt63ABj79tKi+qnVr6zp12mmVGqNzLvFGjx7NoYceypgxY2L+TL9+/ViyZAkzZ85k5syZvPnmm6xZs2ar4pg9ezZjxoxh1qxZvPfee/Tu3Zv8/Py/rXfjjTcyYMAApk2bxqBBg7jxxhvL9fnKljZVT6rQt69d+F9xRTk/vGaNdY964gkbmXfzzZafyZP4OVdprr3WanIrU8eOMHRo9HXWrl3L559/zoQJEzjllFMYGEPSt9zcXEaMGMH8+fOpUaMGADvttBNnnXXWVsX7+uuv06NHD2rUqEGLFi1o2bIlkydP5qCDDtpiPRHhzz//BGD16tU0bty4XJ+vbGlzJhw/Hj75BB55BOrUKccH330XLr8ccnLsL3nIkHJuwDmXzMaNG8dxxx3HnnvuyQ477MC3335Lp06don5m7ty5NGvWjG1jqJq47rrrmDBhwt/e79GjBzcX65//66+/cuCBB/71umnTpvz6669/++zQoUM59thj6dOnDwUFBXzxxRfl+nxlS4uCQtVGX++6K/TsWY4PrlkDF14IO+5oc0dE/AKcc5WrrCv/eBk9ejTXBo2WPXr0YPTo0XTq1KnU3kHl7TX00EMPxbyuqsa0vyeffJKHHnqI7t278/LLL3PppZfy0Ucfxfz5ypYWBcXbb8PXX8Pw4TYeLipVeP99OPpo60P70UeWVrbMDzrnUs2KFSsYP348M2fORETIz89HRLj33ntp0KABq1at2mL9lStX0rBhQ1q2bMnChQtZs2YN9erVi7qP8txRNG3alEWLFv31Oicn569qpUjPPvssDz/8MABnnnkml112Wbk+X+lUNaUe++23n0bKz1ft2FF1991VN23S6BYvVj31VFVQffbZMlZ2zm2t2bNnh7r/YcOGac+ePbd4r2vXrjpp0iTdsGGDNm/e/K8YFyxYoM2aNdM//vhDVVVvuOEGveiii3Tjxo2qqrp48WJ9/vnntyqemTNnavv27XXDhg06b948bdGihebl5f1tvTZt2uiECRNUVfWjjz7STp06levzJR13IFsreN5N+TuKsWOtgey556DU1Caq8J//wPXXw8aNcO+9nsTPuQwwevTov13Vd+/enZdeeokuXbrwwgsvcPHFF7NhwwaqVavGyJEjqV+/PgBDhgyhb9++tGvXjpo1a1KnTh0GbeVcynvttRdnnXUW7dq1o2rVqjz++ONUqVIFgMsuu4xevXqRlZXFiBEjuOaaa8jLy6NmzZoMHz68zM/Hk2gJdV7JLCsrS7OzswGbAmKffez9GTOg1ON1+eVWL9W1qyXxa9UqMcE6l+G+//572rZtG3YYGaek4y4iU1Q1qyLbS+k7ipdesjRMr7xSQiGRn28pOGrWtBHW++5rLd2en8k558olZc+amzdbhtiOHeH004stnDXLZpgrTOLXpYtnenXOuQpK2TPnqFEwbx4MHhxx/t+0yd7Yd1+YOxf23z/MEJ1zlNwl1MVPPI53SlY9bdhgs9cdcACceGLw5owZcN559rNHDxt516hRqHE6l+lq1qzJihUrPNV4gmgwH0XNSp6OOSULihEjbCD1qFHw199e9eqQmwuvvw6nnBJmeM65QNOmTcnJyWHZsmVhh5IxCme4q0wp1+upU6csXbw4m7ZtYfyAT5A334AHHrCF+flRuj4551zm2ppeT3FtoxCR40TkBxGZKyJ/m5RUzCPB8ukiEj0BC/D775D725+8VP9fyBGHw7hxsHy5LfRCwjnnKl3cCgoRqQI8DhwPtAPOEZF2xVY7HmgVPHoCT5a13dwlq/m55l7s8uZwG0A3Y4ZlenXOORcX8byj6AzMVdV5qroJGAN0K7ZON+C5YIT5V8B2IrJLtI02K1hA3cb1LYnfAw9A7drxid455xwQ38bsJsCiiNc5wAExrNMEWBK5koj0xO44ADbWnjdrpmd6BaAhsDzsIJKEH4sifiyK+LEo0rqiH4xnQVFSX7jiLeexrIOqDgeGA4hIdkUbZNKNH4sifiyK+LEo4seiiIhkV/Sz8ax6ygF2jXjdFFhcgXWcc86FKJ4FxTdAKxFpISLVgR7AG8XWeQO4MOj9dCCwWlWXFN+Qc8658MSt6klV80TkSuB9oArwjKrOEpFewfJhwDvACcBcIBe4OIZND49TyKnIj0URPxZF/FgU8WNRpMLHIuUG3DnnnEuslE0K6JxzLjG8oHDOORdV0hYU8Uj/kapiOBbnBcdguoh8ISIdwogzEco6FhHr7S8i+SJyRiLjS6RYjoWIHC4i00Rkloh8kugYEyWG/5H6IvKmiHwXHItY2kNTjog8IyK/i8jMUpZX7LxZ0cm24/nAGr9/BnYHqgPfAe2KrXMC8C42FuNA4Ouw4w7xWBwMbB88Pz6Tj0XEeuOxzhJnhB13iH8X2wGzgWbB6x3DjjvEY3ErcE/wvBGwEqgeduxxOBZdgU7AzFKWV+i8max3FHFJ/5GiyjwWqvqFqq4KXn6FjUdJR7H8XQBcBfwP+D2RwSVYLMfiXGCsqi4EUNV0PR6xHAsF6olNilEXKyjyEhtm/KnqJOy7laZC581kLShKS+1R3nXSQXm/56XYFUM6KvNYiEgT4DRgWALjCkMsfxd7AtuLyEQRmSIiFyYsusSK5Vg8BrTFBvTOAK5R1YLEhJdUKnTeTNaJiyot/UcaiPl7isgRWEFxaFwjCk8sx2IocJOq5qf5jGqxHIuqwH7AUUAt4EsR+UpVf4x3cAkWy7E4FpgGHAnsAXwoIp+q6p9xji3ZVOi8mawFhaf/KBLT9xSR9sBI4HhVXZGg2BItlmORBYwJComGwAkikqeq4xISYeLE+j+yXFXXAetEZBLQAUi3giKWY3ExcLdaRf1cEZkPtAEmJybEpFGh82ayVj15+o8iZR4LEWkGjAUuSMOrxUhlHgtVbaGqzVW1OfAq0DsNCwmI7X/kdaCLiFQVkdpY9ubvExxnIsRyLBZid1aIyE5YJtV5CY0yOVTovJmUdxQav/QfKSfGY9EfaAA8EVxJ52kaZsyM8VhkhFiOhap+LyLvAdOBAmCkqpbYbTKVxfh3MRgYJSIzsOqXm1Q17dKPi8ho4HCgoYjkAAOAarB1501P4eGccy6qZK16cs45lyS8oHDOOReVFxTOOeei8oLCOedcVF5QOOeci8oLCpeUgsyv0yIezaOsu7YS9jdKROYH+/pWRA6qwDZGiki74PmtxZZ9sbUxBtspPC4zg2yo25WxfkcROaEy9u0yl3ePdUlJRNaqat3KXjfKNkYBb6nqqyJyDHC/qrbfiu1tdUxlbVdEngV+VNU7oqx/EZClqldWdiwuc/gdhUsJIlJXRD4OrvZniMjfssaKyC4iMiniirtL8P4xIvJl8NlXRKSsE/gkoGXw2euDbc0UkWuD9+qIyNvB3AYzReTs4P2JIpIlIncDtYI4XgyWrQ1+/jfyCj+4k+kuIlVE5D4R+UZsnoDLYzgsXxIkdBORzmJzkUwNfrYORikPAs4OYjk7iP2ZYD9TSzqOzv1N2PnT/eGPkh5APpbEbRrwGpZFYNtgWUNsZGnhHfHa4Oe/gduC51WAesG6k4A6wfs3Af1L2N8ogrkrgDOBr7GEejOAOlhq6lnAvkB3YETEZ+sHPydiV+9/xRSxTmGMpwHPBs+rY5k8awE9gb7B+zWAbKBFCXGujfh+rwDHBa+3BaoGz/8B/C94fhHwWMTn7wTOD55vh+V9qhP279sfyf1IyhQezgHrVbVj4QsRqQbcKSJdsXQUTYCdgKURn/kGeCZYd5yqThORw4B2wOdBepPq2JV4Se4Tkb7AMiwL71HAa2pJ9RCRsUAX4D3gfhG5B6uu+rQc3+td4BERqQEcB0xS1fVBdVd7KZqRrz7QCphf7PO1RGQa0ByYAnwYsf6zItIKywZarZT9HwOcIiJ9gtc1gWakZw4oV0m8oHCp4jxsZrL9VHWziCzATnJ/UdVJQUFyIvC8iNwHrAI+VNVzYtjHDar6auELEflHSSup6o8ish+WM+cuEflAVQfF8iVUdYOITMTSXp8NjC7cHXCVqr5fxibWq2pHEakPvAVcATyC5TKaoKqnBQ3/E0v5vADdVfWHWOJ1DryNwqWO+sDvQSFxBLBb8RVEZLdgnRHA09iUkF8Bh4hIYZtDbRHZM8Z9TgJODT5TB6s2+lREGgO5qvoCcH+wn+I2B3c2JRmDJWPrgiWyI/j5r8LPiMiewT5LpKqrgauBPsFn6gO/Bosvilh1DVYFV+h94CoJbq9EZN/S9uFcIS8oXKp4EcgSkWzs7mJOCescDkwTkalYO8LDqroMO3GOFpHpWMHRJpYdquq3WNvFZKzNYqSqTgX2ASYHVUC3AUNK+PhwYHphY3YxH2BzG3+kNnUn2Fwis4FvRWQm8BRl3PEHsXyHpdW+F7u7+Rxrvyg0AWhX2JiN3XlUC2KbGbx2LirvHuuccy4qv6NwzjkXlRcUzjnnovKCwjnnXFReUDjnnIvKCwrnnHNReUHhnHMuKi8onHPORfX/cxnbb1l8Gh8AAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_roc(fnn, X_train_comb_b, y_train_comb_b, X_val_comb_b, y_val_comb_b, X_test_comb_b, y_test_comb_b, \"Balanced, oversampled, combined\")\n",
    "plot_roc(fnn, X_train_hasdep_b, y_train_hasdep_b, X_val_hasdep_b, y_val_hasdep_b, X_test_hasdep_b, y_test_hasdep_b, \"Balanced, oversampled, has_dep_diag\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}