PI_temporal_CV_repeated.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "import seaborn as sb\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "import sklearn as sk\n",
    "import numpy as np\n",
    "import eli5\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.metrics import mean_squared_error\n",
    "from sklearn import metrics\n",
    "from sklearn.model_selection import cross_validate, RandomizedSearchCV, RepeatedStratifiedKFold\n",
    "from sklearn.utils import resample\n",
    "from sklearn.neural_network import MLPClassifier\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.inspection import permutation_importance\n",
    "from scipy.stats import loguniform\n",
    "from imblearn.over_sampling import RandomOverSampler\n",
    "from sklearn.metrics import confusion_matrix\n",
    "from eli5.sklearn import PermutationImportance\n",
    "\n",
    "hfont = {'fontname':'Helvetica'}\n",
    "## read data \n",
    "CIP_data_no_drop = pd.read_csv(\"CIP_data_encode_prev_not_dropped.csv\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_features_based_on_importance_rank(features, importance_col_name, importance_value, n_features_wanted):\n",
    "    \"\"\" create a sorted table containing feature name and its importance score\n",
    "    :param features: list of feature names\n",
    "    :param importance_col_name: the name of the column which shows the importance value or rank for each feature\n",
    "    :param importance_value: the importance value or rank for each feature\n",
    "    :param n_features_wanted: number of features you want to select\n",
    "    :return a sorted DataFrame containing the name of feature and its corresponding importance\n",
    "    \"\"\"\n",
    "\n",
    "    # creat a DataFrame\n",
    "    d = {'Features': features, importance_col_name: importance_value}\n",
    "    df = pd.DataFrame(d)\n",
    "    # sort by descending\n",
    "    df = df.sort_values(by=[importance_col_name], ascending=False)\n",
    "    selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
    "    return selected_feature_names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## PI - frequency of importance \n",
    "\n",
    "n_iterations = 500\n",
    "PI_dataframe = pd.DataFrame({\n",
    "'MSM':0,\n",
    "'MSMW':0,\n",
    "'MSW':0,\n",
    "'Other':0,\n",
    "'Midwest':0,\n",
    "'Northeast':0,\n",
    "'West':0,\n",
    "'Southeast':0,\n",
    "'Southwest':0,\n",
    "'Region':0,\n",
    "'Clinic':0, \n",
    "'Delta':0},index=[0])\n",
    "\n",
    "PI_dataframe_all = pd.DataFrame()\n",
    "\n",
    "model_nn = MLPClassifier(solver = 'lbfgs', activation = 'tanh', max_iter = 3000 ,hidden_layer_sizes= 13, alpha = 1.291549665014884, random_state=10, learning_rate = 'constant' )\n",
    "feature_names = ['MSM','MSMW', 'MSW', 'Oth/Unk/Missing','Northeast', 'Southeast', 'Southwest', 'West', 'Midwest','PREV_REGION', 'PREV_CLINIC', 'DELTA_REGION']\n",
    "#Generate new test and train data \n",
    "            # train\n",
    "train_data = CIP_data_no_drop.loc[CIP_data_no_drop['YEAR'].isin([2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010])]\n",
    "X_train_standard = train_data[['MSM','MSMW', 'MSW', 'Oth/Unk/Missing','Northeast', 'Southeast', 'Southwest', 'West', 'Midwest','PREV_REGION', 'PREV_CLINIC', 'DELTA_REGION']]\n",
    "y_train_standard = train_data['Susceptible']\n",
    "\n",
    "oversample = RandomOverSampler(sampling_strategy = 0.5)\n",
    "X_train, y_train = oversample.fit_resample(X_train_standard,y_train_standard)\n",
    "\n",
    "            # test\n",
    "test_data = CIP_data_no_drop.loc[CIP_data_no_drop['YEAR'].isin([2011])]\n",
    "X_test_standard = test_data[['MSM','MSMW', 'MSW', 'Oth/Unk/Missing','Northeast', 'Southeast', 'Southwest', 'West', 'Midwest','PREV_REGION', 'PREV_CLINIC', 'DELTA_REGION']]\n",
    "y_test_standard = test_data['Susceptible']\n",
    "oversample = RandomOverSampler(sampling_strategy = 0.5)\n",
    "X_test, y_test = oversample.fit_resample(X_test_standard,y_test_standard)\n",
    "\n",
    "model_fit_train = model_nn.fit(X_train_standard, y_train_standard)\n",
    "\n",
    "for i in range(n_iterations):\n",
    "\n",
    "    # Train model on training data - don't need to test on test data \n",
    "    X_train, y_train = oversample.fit_resample(X_train_standard,y_train_standard)\n",
    "    X_test, y_test = oversample.fit_resample(X_test_standard,y_test_standard)\n",
    "\n",
    "    model_fit_train = model_nn.fit(X_train, y_train)\n",
    "    # Permutation importance \n",
    "    PI = permutation_importance(model_fit_train, X_test, y_test, n_repeats = 10, random_state = 42)\n",
    "    important_features = get_features_based_on_importance_rank(feature_names, 'Importance', PI.importances_mean, 5)\n",
    "    for feature in important_features:\n",
    "        if feature == 'PREV_CLINIC':\n",
    "                PI_dataframe[\"Clinic\"] += 1\n",
    "        elif feature == \"PREV_REGION\":\n",
    "                PI_dataframe[\"Region\"] += 1\n",
    "        elif feature == \"MSM\":\n",
    "                PI_dataframe[\"MSM\"] += 1\n",
    "        elif feature == \"MSMW\":\n",
    "                PI_dataframe[\"MSMW\"] += 1\n",
    "        elif feature == \"MSW\":\n",
    "                PI_dataframe[\"MSW\"] += 1\n",
    "        elif feature == \"Oth/Unk/Missing\":\n",
    "                PI_dataframe[\"Other\"] += 1  \n",
    "        elif feature == \"Northeast\":\n",
    "                PI_dataframe[\"Northeast\"] += 1 \n",
    "        elif feature == \"Southeast\":\n",
    "                PI_dataframe[\"Southeast\"] += 1    \n",
    "        elif feature == \"Southewest\":\n",
    "                PI_dataframe[\"Southwest\"] += 1   \n",
    "        elif feature == \"Midwest\":\n",
    "                PI_dataframe[\"Midwest\"] += 1    \n",
    "        elif feature == \"West\":\n",
    "                PI_dataframe[\"West\"] += 1   \n",
    "        elif feature == \"DELTA_REGION\":\n",
    "                PI_dataframe[\"Delta\"] += 1\n",
    "\n",
    "    #Save results. 1 = +ve, -1 = -ve \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   MSM  MSMW  MSW  Other  Midwest  Northeast  West  Southeast  Southwest  \\\n",
      "0  353     0  229      0      156        103   455        168          0   \n",
      "\n",
      "   Region  Clinic  Delta  \n",
      "0     474     448     74  \n"
     ]
    }
   ],
   "source": [
    "print(PI_dataframe)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAr4AAAKuCAYAAABHUR/uAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/P9b71AAAACXBIWXMAAA9hAAAPYQGoP6dpAABsdUlEQVR4nO3dd3RU1f7+8WdSSEIJhBZCCzVEDL0EJfQOGsRLu4AUUWxcBaUISkeRqnxF70Wlg4WLgBSlSABBSgCpUgKEIk1K6IHU/fuDlfkRk0A4mZhw5/1aa9bi7LPPnM9MkjMPZ/bZx2aMMQIAAAD+x7lkdQEAAADA34HgCwAAAKdA8AUAAIBTIPgCAADAKRB8AQAA4BQIvgAAAHAKBF8AAAA4BYIvAAAAnIJbVheQ3SUmJurcuXPKkyePbDZbVpcDAACAvzDG6ObNmypatKhcXNI+r0vwfYhz586pRIkSWV0GAAAAHuKPP/5Q8eLF01xP8H2IPHnySLr3Rnp7e2dxNQAAAPirGzduqESJEvbclhaC70MkDW/w9vYm+AIAAGRjDxuWysVtAAAAcAoEXwAAADgFgi8AAACcAsEXAAAAToHgCwAAAKdA8AUAAIBTIPgCAADAKRB8AQAA4BQIvgAAAHAKBF8AAAA4BYIvAAAAnALBFwAAAE6B4AsAAACnQPAFAACAUyD4AgAAwCkQfAEAAOAUCL4AAABwCgRfAAAAOAWCLwAAAJwCwRcAAABOgeALAAAAp0DwBQAAgFMg+AIAAMApEHwBAADgFAi+AAAAcAoEXwAAADgFt6wuAAAAANZ8vDYiq0tIVf9mAVldQqo44wsAAACnQPAFAACAUyD4AgAAwCkQfAEAAOAUCL4AAABwCgRfAAAAOAWCLwAAAJwCwRcAAABOgeALAAAAp0DwBQAAgFMg+AIAAMApEHwBAADgFAi+AAAAcAoEXwAAADgFgi8AAACcAsEXAAAAToHgCwAAAKdA8AUAAIBTIPgCAADAKRB8AQAA4BQIvgAAAHAKBF8AAAA4BYIvAAAAnIJbVhcAAACQVT5eG5HVJaSpf7OArC7hfw5nfAEAAOAUCL4AAABwCgRfAAAAOAWCLwAAAJwCwRcAAABOgeALAAAAp0DwBQAAgFNgHl8AAJAh2XUuXObBxV9xxhcAAABOgeALAAAAp0DwBQAAgFMg+AIAAMApEHwBAADgFAi+AAAAcAoEXwAAADgFgi8AAACcAsEXAAAAToHgCwAAAKdA8AUAAIBTIPgCAADAKRB8AQAA4BQIvgAAAHAKBF8AAAA4BYIvAAAAnALBFwAAAE6B4AsAAACnQPAFAACAUyD4AgAAwCkQfAEAAOAUCL4AAABwCgRfAAAAOAWCLwAAAJwCwRcAAABOgeALAAAAp0DwBQAAgFMg+AIAAMApEHwBAADgFAi+AAAAcAoEXwAAADgFgi8AAACcAsEXAAAAToHgCwAAAKdgKfjOnTtX69evf2i/devW6YcffrCyCwAAAMChLAXfnj176pNPPnlov4kTJ+qFF16wsgsAAADAodzS23H06NHJlo8cOZKi7X63bt3Sxo0b5enpab06AAAAwEHSHXxHjhwpm80mSbLZbDp69KhGjRqVZn9jjCSpXbt2GSwRAAAAyLh0B9+hQ4fKZrPJGKMPP/xQ5cuXV8eOHdPs7+7uroCAAD3//PMOKRQAAADIiHQH37Fjx9r//eGHH6pChQoaM2ZMphQFAAAAOFq6g+/9EhMTHV0HAAAAkKksBd8kd+/e1fHjx3Xt2jUlJCSk2a9+/foZ2Q0AAACQYZaCb2xsrN566y3NnTtXd+/efWBfm82m+Ph4S8UBAAAAjmIp+I4ePVrTp0+XJBUvXlzFixeXq6urQwsDAAAAHMlS8F2wYIHc3Ny0aNEihYaGOromAAAAwOEs3bnt/PnzqlOnDqEXAAAAjw1LwdfX11dubhm6Lg4AAAD4W1kKvs8995zCw8N18eJFR9cDAAAAZApLwXfkyJHy8/NTq1atFBkZ6eiaAAAAAIezNF7hlVdeUZEiRfTrr7+qQoUKCggIkI+Pj1xcUuZom82mjRs3ZrhQAAAAICMsBd9FixbZ/52QkKBDhw6l2ddms1nZBQAAAOBQloLv+vXrHV0HAAAAkKksBd8GDRo4ug4AAAAgU1m6uC29unXrprp161rePiYmRoMHD1bRokXl5eWl4OBgrV27Nl3b/vzzz2rUqJEKFiyofPnyqXbt2po3b57lWgAAAPB4szwZ79GjRzVz5kxdvHhRxpgU6+Pj47V8+XLFx8dbLq5nz55atGiR+vXrp/Lly2v27Nlq3bq11q9fr5CQkDS3W7ZsmZ577jk99dRTGjlypGw2mxYuXKju3bvr8uXL6t+/v+WaAAAA8HiyFHwjIyNVq1Yt3bx5U8YY+wVsSQH4/uXevXtbKiw8PFzffvutJk6cqAEDBkiSunfvrqCgIA0aNEhbtmxJc9tp06bJz89PYWFh8vDwkHRvJorAwEDNnj2b4AsAAOCELA11+Oyzz3Tjxg01adJEX375pZo3by5PT09Nnz5d06ZNU4cOHWSM0fjx4/Xll19aKmzRokVydXVVnz597G2enp7q3bu3tm7dqj/++CPNbW/cuCEfHx976JUkNzc3FSxYUF5eXpbqAQAAwOPN0hnfn376Sfny5dPy5cvl4eGhatWqqVatWgoKCtJTTz2l119/XQEBARozZow6deqkkiVLPvI+du/erYCAAHl7eydrr127tiRpz549KlGiRKrbNmzYUOPHj9ewYcPUo0cP2Ww2ff3119q5c6cWLlz46C8YAAAAjz1LZ3zPnj2rypUr28+olitXTsYY7d69297n3XfflTFG48aNs1TY+fPn5efnl6I9qe3cuXNpbjts2DB17NhRH3zwgcqXL69y5crpo48+0vfff6/nn3/+gfuNiYnRjRs3kj0AAADw+LMUfF1cXJSYmGhf9vb2Vr58+ZLdvjhnzpyqVq2afvzxR0uF3blzJ9lQhSSenp729Wnx8PBQQECA2rdvr2+++Ubz589XzZo11a1bN23btu2B+x03bpzy5s1rf6R1VhkAAACPF0tDHcqVK6f9+/fr+vXryps3rySpfPnyyc74Svdmdrh8+bKlwry8vBQTE5Oi/e7du/b1aenbt6+2bdum3377zX4b5Y4dO+rJJ5/UW2+9pe3bt6e57ZAhQ/T222/bl2/cuEH4BQAA+B9g6Yxvly5ddP36dYWGhmrNmjWSpLp16+qXX37RypUrJUnr1q3T9u3bVaZMGUuF+fn56fz58ynak9qKFi2a6naxsbGaMWOG2rRpYw+9kuTu7q5WrVpp586dio2NTXO/Hh4e8vb2TvYAAADA489S8O3Tp4+qVq2qTZs2aeTIkZKk1157Ta6urgoNDVW+fPnUvHlzSdKrr75qqbCqVasqIiIixRjbpLO1VatWTXW7K1euKD4+XgkJCSnWxcXFKTExMdV1AAAA+N9mKfjmypVL27dv18KFC/XKK69IujfUYeHChSpSpIhu3LihHDlyqF+/fnr99dctFda+fXslJCToiy++sLfFxMRo1qxZCg4Otg8/OH36tA4fPmzvU7hwYeXLl09LlixJdmb31q1bWr58uQIDA5nSDAAAwAlZvnObu7u72rdvn6wtNDRUoaGhunLlinLlymW/EM2K4OBgdejQQUOGDNHFixdVrlw5zZkzRydPntSMGTPs/bp3766NGzfab57h6uqqAQMG6P3331edOnXUvXt3JSQkaMaMGTpz5ozmz59vuSYAAAA8viyd8U1y6tQpffnll8mGI+zfv1+//vqr/e5tGTF37lz169dP8+bN05tvvqm4uDitWLFC9evXf+B27733nhYsWCB3d3eNGjVKw4YNk7e3txYtWqSuXbtmuC4AAAA8fiyf8R00aJA+/vhjJSYmqkWLFvaLwMLDw/Xyyy+rcOHCmj59utq2bWu5OE9PT02cOFETJ05Ms8+GDRtSbe/SpYu6dOlied8AAAD432LpjO/333+vSZMmyd3dXa+99poKFChgXxccHKzWrVvr4sWL6tChg3bu3OmwYgEAAACrLAXfTz/9VG5ubgoLC9O0adOUK1cu+7qgoCCtWLFCX3zxheLj4y3fuQ0AAABwJEvB99ChQ6pcubLq1KmTZp+XXnpJFSpU0KZNmywXBwAAADiKpeB769atdN3YoUSJEinm4QUAAACygqXgGxgYqJ07dyoqKirNPjExMdq7d6+KFy9uuTgAAADAUSwF3969e+vWrVtq2bKl9u3bl2L92bNn1aVLF12+fFkdOnTIcJEAAABARlmazuzVV1/VqlWrtGLFClWrVk3lypVTQECAvLy89Mcff2jXrl2Kj49XlSpV9N577zm6ZgAAAOCRWQq+Li4uWrJkicaPH6+pU6fq6NGjOnr0qH29h4eHevfurfHjxyt37twOKxYAAACwyvINLFxdXTV06FANHjxY+/bt04kTJ3T37l35+vqqdu3aypMnjyPrBAAAADLEcvBN4urqqmrVqqlatWqOqAcAAADIFOkKvsOHD1dgYKD9FsDDhw9P9w5sNptGjRplrToAAADAQdIVfMeOHatnnnnGHnzHjh0rm80mY0ya2yStJ/gCAAAgO0j3Gd8KFSokW7bZbJlWFAAAAOBo6Qq+I0eOfOAyAAAAkN2l6wYWTZs21fvvv29fbty4cbJlAAAAILtLV/DdvHmzli9fbl/esGFDqndsAwAAALKrdA11CAgI0IEDB5Q3b17lz59fkhQWFqYyZco8dFubzabjx49nrEoAAAAgg9IVfN9//3316tVLN2/e1M2bN2Wz2RQdHa2TJ08+dFsuggMAAEB2kK7g27FjR4WGhurChQuKj49XQECAGjdurOnTp2d2fQAAAIBDpPvObZ6enipVqpQkqX79+goODlbZsmUzqy4AAADAoSzdsnjDhg0OLgMAAADIXNyyGAAAAE6BWxYDAADAKaQr+I4YMUIBAQHJlgEAAIDHSbqD74OWAQAAgOwuXXduAwAAAB53lmZ1kKTr169ryZIl+v3333Xt2jUlJCSk2s9ms2nGjBmWCwQAAAAcwVLwjYiIUKNGjXThwoUHXuAmEXwBAACQPVgKvgMHDtT58+dVqlQpdevWTcWLF5erq6ujawMAAAAcxlLw3bx5swoWLKjdu3crb968jq4JAAAAcDhLF7fdvXtX1atXJ/QCAADgsWEp+D755JO6cOGCo2sBAAAAMo2l4PvGG29o3759Wr58uaPrAQAAADKFpTG+HTp0UFhYmDp27KjBgwerTZs28vHxkYtL6jm6TJkyGSoSAAAAyChLwTdPnjySJGOMxowZozFjxqTZ12azKT4+3lp1AAAAgINYCr4lSpSQzWZzdC0AAABAprEUfE+ePOngMgAAAIDMZeniNgAAAOBxY+mM7y+//JKufjabTbly5VLBggUZHgEAAIAsZSn4NmzY8JFDbMGCBdWpUyeNHTtW3t7eVnYLAAAAWGYp+A4fPlxhYWH2Wxe3aNFCJUuWVExMjI4ePap169YpOjpaDRo0UPny5XXu3DmFh4dr2rRpCgsL0/bt25UrVy5HvxYAAAAgTZaCb6tWrTRu3Dh16dJFX331lTw9PZOtv3Tpkrp06aKtW7dq8uTJql69umJiYtS3b1/NnDlTEydO1MiRIx1RPwAAAJAuli5uGz16tHx8fDRz5swUoVeSChUqpP/+97+y2WwaOnSoJMnDw0Off/658ufPr++//z5jVQMAAACPyFLw3bZtm6pUqaIcOXKk2SdfvnyqWbOmtm/fbm9zd3dXlSpVdOrUKSu7BQAAACyzFHzj4+N15syZh/aLiYlRbGxssrZbt249MDADAAAAmcFS8H366ad1+PBhLVq0KM0+W7duVXh4uCpVqmRvO3HihPbu3auAgAAruwUAAAAssxR8R40aJTc3N3Xp0kW9evXSkiVLtHfvXh06dEhr167V22+/rWbNmskYo7feekuSNG/ePNWrV0+xsbF68cUXHfoiAAAAgIexNKtD7dq19d///lc9evTQnDlzNHfu3GTrjTGSpLfeekv//Oc/JUlr1qzRuXPn9Mwzz6hXr14ZLBsAAAB4NJaCrySFhobq6NGjmjlzpjZs2KDTp08rLi5OPj4+qlKlirp27ar69evb+3fu3Fm9evVS48aNHVI4AAAA8CgsB1/p3t3YBg0apEGDBj20b5s2bTKyKwAAACBD0hV8ExMT5eLikmz5Udy/LQAASO7jtRFZXUKq+jfjYnT8b0lXInV3d1fbtm2TLaf3wdRlAAAAyA7SdcbXGGO/YC1pOb0epS8AAACQWdI91OFBywAAAEB2x+BbAAAAOIUMBd9169Zpw4YN9uXNmzerSZMmqlixonr27KnTp09ntD4AAADAISwF35iYGLVu3VrNmzfX4sWLJUl//vmnWrVqpfXr1+vw4cOaO3eu6tSpo3Pnzjm0YAAAAMAKS8F38uTJWrVqlerXr6/u3btLkubPn6/bt2/r7bff1tWrVzVmzBhduHBBY8eOdWjBAAAAgBWWgu93330nb29vLV26VDVr1pQk/fjjj3Jzc9P777+vvHnzaujQoSpatKhWr17t0IIBAAAAKywF32PHjqlixYrKmzevJCkuLk5bt25VrVq1lC9fPkmSzWZTxYoVdfbsWYcVCwAAAFhlKfh6enoqZ86c9uXw8HDdvXtXdevWTdbvzp07cnV1zViFAAAAgANYCr7ly5fXb7/9plu3bkmSvvjiC9lsNjVt2tTeJyoqSr/99pv8/f0dUykAAACQAZaC7yuvvKJr166pevXqatKkiebPny9fX181atRIkrR8+XK1adNGd+/eVZs2bRxaMAAAAGBFuu7c9lc9evTQmjVr9N133+nYsWNydXXVJ598Ind3dyUkJKht27aSpKCgIL3//vsOLRgAAACwwlLwdXFx0TfffKOBAwcqIiJC1apVU4UKFezrunTpopCQEPXs2VOenp4OLRgAAACwwlLwTVK9enVVr149WZvNZtP8+fMzVBQAAADgaBm6ZTEAAADwuCD4AgAAwCkQfAEAAOAUCL4AAABwCgRfAAAAOAWCLwAAAJxChoLvsWPHtG/fPvvykSNH1Lt3b7Vu3VojR47UjRs3MlwgAAAA4AiWgq8xRq+99poCAwP11VdfSZJu3LihBg0aaPbs2Vq1apXGjBmjOnXq6Pr16w4tGAAAALDCUvD997//renTpyswMFBt2rSRJH399de6ePGi/vnPf2r37t16+eWXdfjwYX344YcOLRgAAACwwlLwnT17tnLmzKk1a9aoRYsWkqQVK1bIxcVFkyZNUpUqVTRt2jQVLFhQy5Ytc2jBAAAAgBWWgu/hw4dVsWJFFS1aVJKUmJioTZs2qUqVKipSpIgkyc3NTZUqVdKpU6ccVy0AAABgkaXga7PZlC9fPvvynj17dPPmTYWEhCTrl5iYKGNMhgoEAAAAHMFS8C1btqz279+vhIQESdL8+fNls9nUuHFje5/o6Gjt3r1bxYoVc0ylAAAAQAZYCr7dunXTn3/+qUaNGql3796aOnWq8ubNq2bNmkmS9u/fr65du+rmzZtq2rSpQwsGAAAArHCzslHfvn21ZMkSbd68WZs3b5YkjRw5Ujlz5lRCQoKqVKkiSSpatKiGDx/uuGoBAAAAiywF3xw5cmjjxo1aunSpIiIiVLNmTfuZXZvNpqefflohISF6++23VbhwYYcWDAAAAFhhKfhKkouLi55//vlU25POAgMAAADZRYZuWfwwTZo0UfHixTNzFwAAAEC6WD7ju2nTJn3++ee6ePFiqlOWxcfHa/v27fL09MxQgQAAAIAjWAq++/btU9OmTRUfH28PvTabLVkAttlsstls6t+/v2MqBQAAADLA0lCHadOmKS4uTt27d9fatWvVvXt3eXp66scff9SKFSs0aNAgubq6auLEiRo5cqSDSwYAAAAenaUzvhs2bJCvr69mzJghFxcX+fr6au7cufLw8FCjRo3UunVrlShRQm+//baaNWumoKAgR9cNAAAAPBJLZ3zPnTunihUrysXl3uZlypSRdG8IRJI+ffood+7cGj9+vAPKBAAAADLGUvD18vJSdHS0fTlnzpwqWLCgTpw4YW9zd3dXlSpVtG7duoxXCQAAAGSQpeAbEBCgAwcO6Ny5c/a2ChUqKDw8PFm/a9eu6ebNmxmrEAAAAHAAS8G3V69eun37tpo2bao5c+ZIkurXr6/t27frs88+07Vr1zRjxgzt2bNHFSpUcGjBAAAAgBWWgm/Pnj3VunVrHT58WNOnT5ck/etf/1KuXLn05ptvqkCBAurTp49sNpsGDBjg0IIBAAAAKyzN6uDm5qYVK1Zo586dioqKkiQVKVJEYWFheuutt7Rv3z4VKFBA77zzjjp37uzQggEAAAArLN+5TZJq1qyZYvnXX3/NUEEAAABAZrA01AEAAAB43BB8AQAA4BQIvgAAAHAKBF8AAAA4BYIvAAAAnALBFwAAAE6B4AsAAACnkK55fEePHm15BzabTcOGDbO8PQAAAOAI6Qq+I0eOlM1mkzHG3maz2ez/vr/9/nXGGIIvAAAAsoV0Bd9Zs2alaPviiy+0detWNWjQQO3atVOJEiV069YtnTp1SvPnz1dERIT69u2rf/zjHw4vGgAAAHhU6Qq+PXr0SLb83Xffadu2bfrggw80ZMiQFP3fe+89DR8+XOPGjdPzzz/vmEoBAACADLB0cdvEiRNVunTpVEOvdG+ow5gxY+Tv768xY8ZkqEAAAADAESwF38OHD6tcuXIP7VeuXDnt3LnTyi4AAAAAh7IUfL28vHTw4MEUF7X9VURERLKL4AAAAICsYin41q9fX2fPntWIESPS7DN+/HidOnVKDRs2tFobAAAA4DCWgu+YMWPk5eWlDz74QA0aNNBnn32mn376SUuXLtWUKVNUo0YNDR06VDlz5tTYsWMtFxcTE6PBgweraNGi8vLyUnBwsNauXZvu7b/77js99dRTypUrl/Lly6enn35aYWFhlusBAADA4ytdszr8VcWKFRUWFqYePXpo06ZN2rx5c7L1xhgVKVJEX3/9tYKCgiwX17NnTy1atEj9+vVT+fLlNXv2bLVu3Vrr169XSEjIA7cdOXKkRo8erfbt26tnz56Ki4vTgQMHdPbsWcv1AAAA4PFlKfhKUu3atXXgwAGtXLlSa9euVWRkpBISEuTn56f69eurU6dOypkzp+XCwsPD9e2332rixIkaMGCAJKl79+4KCgrSoEGDtGXLljS33bZtm0aPHq3Jkyerf//+lmsAAADA/w7LwVeSXF1dFRoaqtDQUEfVY7do0SK5urqqT58+9jZPT0/17t1bQ4cO1R9//KESJUqkuu0nn3yiIkWK6K233pIxRrdv31bu3LkdXiMAAAAeH5bG+CZJTEzUmjVrNHbsWPXt21efffaZJGnFihWKiYnJUGG7d+9WQECAvL29k7XXrl1bkrRnz540t123bp1q1aql//u//1OhQoWUJ08e+fn5adq0aQ/db0xMjG7cuJHsAQAAgMef5TO+e/bsUYcOHRQZGSljjGw2m9q0aaM33nhDr732mtzc3PTtt98qODjY0vOfP39efn5+KdqT2s6dO5fqdlevXtXly5f166+/KiwsTCNGjFDJkiU1a9Ys/etf/5K7u7teeeWVNPc7btw4jRo1ylLNAAAAyL4snfG9dOmSmjZtquPHj6tBgwYaN25csjl9Q0NDdfr0abVp00ZnzpyxVNidO3fk4eGRot3T09O+PjW3bt2SJF25ckVfffWVBgwYoI4dO2rlypWqWLHiQ2eZGDJkiK5fv25//PHHH5bqBwAAQPZiKfiOHz9eUVFRmjJlisLCwjR48OBk6z/77DNNnDhRUVFRmjBhgqXCvLy8Uh0ucffuXfv6tLaTJHd3d7Vv397e7uLiok6dOunMmTM6ffp0mvv18PCQt7d3sgcAAAAef5aC79KlS+Xv769+/fql2ad///4qUqSI1qxZY6kwPz8/nT9/PkV7UlvRokVT3S5//vzy9PRUgQIF5Orqmmxd4cKFJd0bDgEAAADnYin4njlzRuXLl39gH5vNpsDAQMtDHapWraqIiIgUF5dt377dvj41Li4uqlq1qi5duqTY2Nhk65LGBRcqVMhSTQAAAHh8WQq+BQsWVGRk5EP7nTt3LtVxuunRvn17JSQk6IsvvrC3xcTEaNasWQoODrZPZXb69GkdPnw42badOnVSQkKC5syZY2+7e/euFixYoIoVK6Z5thgAAAD/uyzN6tCkSRPNnz9fX3/9tbp06ZJqn/Xr1+vo0aNq3bq1pcKCg4PVoUMHDRkyRBcvXlS5cuU0Z84cnTx5UjNmzLD36969uzZu3Jjs4rpXXnlFX331ld544w1FRESoZMmSmjdvnk6dOqXly5dbqgcAAACPN0vB9/3339eiRYvUs2dP/fbbb2rZsqUkKTo6Wlu3btW6des0efJkubi46N1337Vc3Ny5czVs2DDNmzdPV69eVeXKlbVixQrVr1//gdt5eXkpLCxMgwYN0syZM3X79m1VrVpVK1euVIsWLSzXAwAAgMeXzdx/qvQRrFq1Sv/85z/TvMGDi4uLPv30U7366qsZKjCr3bhxQ3nz5tX169eZ4QEAkCk+XhuR1SWkqn+zgHT1e5zrz661S493/en93XGU9OY1y3dua9mypQ4ePKiBAwcqKChIOXPmlLu7u0qWLKlu3bopPDz8sQ+9AAAA+N9h+c5t0r0pxz766CN99NFHjqoHAAAAyBSWz/gCAAAAj5N0nfGtX7++QkJC9OGHH9qX08tms2njxo3WqgMAAAAcJF3Bd/PmzcqXL1+y5fSy2WyPXBQAAADgaOkKvuvXr1eBAgWSLQMAAACPk3QF3wYNGjxwGQAAAMju0nVxm7u7u5599ln7squrq9q2bZtpRQEAAACOlq4zvp6entq7d6927dqlggULyhij6OhonT59Ol07KVmyZIaKBAAAADIqXcG3Zs2a2rhxo2rXri3p3gVrYWFhKl269EO3tdlsio+Pz1iVAAAAQAalK/hOnTpVb775pk6ePKmEhASdO3dOHh4eyS54AwAAALKzdAXfypUra8OGDfZlFxcXNW3aVMuWLcusugAAAACHsnTL4hEjRiggIMDRtQAAAACZxnLwBQAAAB4n3LIYAAAAToFbFgMAAMApcMtiAAAAOAVuWQwAAACnkK5bFv9VmTJl1KdPn4f2e/HFF1W3bl0ruwAAAAAcytKsDidPntSFCxce2Cc6Olrbtm1TZGSkpcIAAAAAR0p38HV1dbX/22azaeXKlcna0lK2bFlrlQEAAAAOlO7ga4yx/9tmsyVbTo2Li4vKlSunqVOnWq8OAAAAcJB0B9+4uDhJ9wJwjhw51KZNGy1dujTN/i4uLkxlBgAAgGzD0lCHpFsWp2eoAwAAAJAdcMtiAAAAOAVLwVeSTpw4oTlz5uj333/XtWvXlJCQkGo/m82mdevWWS4QAAAAcARLwXf79u1q2rSpoqOjH3qRG+N8AQAAkB1YCr5Dhw7V7du3FRwcrJdfflnFixdnvC8AAACyNUvBd9euXSpevLg2btyoHDlyOLomAAAAwOEs3bI4ISFBTz75JKEXAAAAjw1LwbdatWo6ceKEo2sBAAAAMo2l4Dtw4EBFRERo+vTpjq4HAAAAyBSWxviWLVtWL7zwgl5//XVt3bpVbdq0kY+Pj1xcUs/RjRs3zlCRAAAAQEZZCr5BQUGy2WwyxmjevHmaN29emn1tNpvi4+MtFwgAAAA4gqXgW79+febnBQAAwGPFUvDdsGGDg8sAAAAAMpeli9sAAACAx02Ggu+xY8c0dOhQNW3aVEFBQXr11VclSe+9957279/vkAIBAAAAR7AcfGfOnKmKFStq/PjxCgsL08GDB3Xu3DlJ0ty5c1WjRg39+9//dlihAAAAQEZYCr579+7Vq6++Kg8PD40YMUJbtmxJtn7cuHHy9vbWm2++qW3btjmkUAAAACAjLF3cNnHiRCUkJOinn35SSEhIivXdunVT4cKF1bJlS33yySf69ttvM1woAAAAkBGWzviuW7dOlSpVSjX0JmnevLnKly+vrVu3Wi4OAAAAcBRLwffatWsqUKDAQ/sVK1ZMFy9etLILAAAAwKEsBV9/f38dOHDgoXdki4iISFdABgAAADKbpeDbrl07Xbp0SQMGDEizz5QpU3Tu3Dm1atXKcnEAAACAo1i6uO3dd9/Vd999p08//VRbtmxR8+bNJUl//PGHxo0bp3Xr1mn9+vXy8fHRsGHDHFowAAAAYIWl4Js3b16tX79eHTt21I4dO7Rr1y5J0r59+7Rv3z4ZY1SsWDEtWrRIJUuWdGjBAAAAgBWWgq90b5zv9u3btXr1av3444+KjIxUXFyc/Pz8VL9+fXXu3FleXl6OrBUAAACwzHLwTdKiRQu1aNHCEbUAAAAAmcbyLYsBAACAx0m6zvi6urpa3oHNZnvotGcAAABAZktX8C1RooRsNluyttu3b+vy5cuSJB8fHxUvXly3bt3S2bNnFRsbK5vNptq1a8vT09PxVQMAAACPKF3B9+TJk8mWL168qHr16ilfvnz68ssv1aBBA/u6hIQEffvtt3rvvfdkjNHKlSsdWjAAAABghaUxvkOHDtXp06e1du3aZKFXujcsomvXrvr555+1Z88ejRo1yiGFAgAAABlhKfiuXLlSderUkb+/f5p9ypUrpzp16mjhwoWWiwMAAAAcxVLwvX79umJjYx/aLyEhQRcuXLCyCwAAAMChLAXfMmXKaOfOnTp69GiafU6fPq0dO3Y88KwwAAAA8HexFHxffPFFxcXFqWXLllq/fn2K9cuXL1fz5s0VFxenl156KcNFAgAAABll6c5t/fr107Zt27Ro0SI1bdpUBQoUUOnSpRUTE6NTp07pxo0bMsbomWeeUf/+/R1dMwAAAPDILJ3xdXFx0cKFCzV37lxVqVJFly9f1o4dO7Rv3z5dv35dxYsX1+TJk7V06dIM3fwCAAAAcBRLZ3yTdOvWTd26ddOVK1cUGRmphIQE+fn5Ma4XAAAA2U6Ggm+SAgUKqECBAo54KgAAACBTpCv4du/eXdWqVbOP1+3evXu6d2Cz2TRnzhxr1QEAAAAOkq7gO3/+fF27ds0efOfPn5/uHRB8AQAAkB2kK/jOmjVLJUqUSLYMAAAAPE7SFXx79OjxwGUAAAAgu7M0nRkAAADwuCH4AgAAwCkQfAEAAOAUCL4AAABwCgRfAAAAOAWCLwAAAJyCpeBbrlw59erVy9G1AAAAAJnG8hnfrVu3OrIOAAAAIFNZCr7vvPOOIiIitHjxYkfXAwAAAGSKdN257a8aNGigdu3a6Z///Kd69uyppk2bqkCBAmn2b9y4seUCAQAAAEewFHyDgoJks9lkjNFXX32lr776Ks2+NptN8fHxlgsEAAAAHMFS8K1fv75sNpujawEAAAAyjaXgu2HDBgeXAQAAAGQuS8EXAIDs5OO1EVldQqr6NwvI6hIA3CdDwff48eP6/PPPtWXLFl26dEmenp4qW7asmjdvrhdeeEHe3t6OqhMAAADIEMvB9+uvv1bv3r0VGxsrY4y9/eDBg1qxYoXGjh2ruXPnqlmzZg4pFAAAAMgIS/P47t27V7169ZIxRm+99ZbCwsJ0+PBhhYeHa968eWrVqpUuXryotm3b6tChQ46uGQAAAHhkls74fvTRR4qPj9fy5cvVunXrZOtq1qyprl27asGCBXrhhRc0fvx4zZ492xG1AgAAAJZZOuO7YcMGBQYGpgi99+vatasqVKig9evXWy4OAAAAcBRLwffq1asqUaLEQ/v5+/vrzz//tLILAAAAwKEsBd/ChQvr+PHjD+136tQp5cmTx8ouAAAAAIeyFHybN2+uyMhIffbZZ2n2+fbbb3XkyBE9/fTTlosDAAAAHMXSxW3vvfee/vvf/+rNN9/U0qVL1aNHD1WoUEGenp46ceKEvv76a33//fdydXXVu+++6+iaAQAAgEdmKfiWLl1aK1euVMeOHbVu3TqFhYUlW2+Mkaenp/7zn//oqaeeckihAAAAQEZYvoFFSEiIjhw5olmzZunnn3/WiRMnFBsbK19fX4WEhKhPnz4qVaqUA0sFAAAArMvQLYvz5MmjN998U2+++aaj6gEAAAAyhaWL21xdXdW2bduH9mvTpo2KFy9uZRcAAACAQ6X7jO/p06ft/zbGKDo6OlnbX926dUsHDx7UlStXMlYhAAAA4ADpDr6lSpWSzWaTJNlsNoWFhal06dIP3MYYo8qVK2esQgAAAMAB0h18ixYtag++586dk4eHhwoUKJBmf3d3dwUEBOjDDz/MeJUAAABABqU7+J45c8b+bxcXFzVt2lTLli3LlKIAAAAAR7M0q8OsWbNUokQJR9cCAAAAZBpLszr06NFDtWrV0tixY1W3bl2dO3fOvu7777/X888/ryVLljisSAAAACCjLJ3xvXbtmmrXrq3jx49LkuLj45OtW7p0qX744Qf94x//0HfffWcfGwwAAABkFUtnfCdPnqxjx44pJCRE27dvV8mSJe3runXrpoULF6p48eL6/vvvNX36dIcVCwAAAFhlKfguWbJE+fPn14oVK1SzZs1k6zw8PNS+fXuFhYXJw8NDM2fOdEihAAAAQEZYCr4nT55UpUqVlCdPnjT7lC1bVtWrV9fvv/9uuTgAAADAUSwFX09PT12/fj19O3CxtAsAAADAoSyl0pCQEO3du1dr165Ns8/BgwcVHh6uKlWqWC4OAAAAcBRLwXfo0KFydXVVaGio3n77bW3dulVXrlxRdHS0jhw5ovHjx6thw4ZKSEhQv379HFwyAAAA8OgsTWdWu3ZtzZ49Wy+//LKmTp2qqVOnptpvxIgRat++fYYKBAAAABzB8gDcLl26aP/+/XrzzTcVFBSkXLlyydXVVUWLFlWnTp20efNmDR8+3JG1AgAAAJZZOuObpEyZMvr4448dVQsAAACQabL1lAsxMTEaPHiwihYtKi8vLwUHBz/wgrq0NGvWTDabTX379s2EKgEAAPA4SNcZ35IlS6pZs2aaMWOGfTm9bDabTp06Zam4nj17atGiRerXr5/Kly+v2bNnq3Xr1lq/fr1CQkLS9RyLFy/W1q1bLe0fAAAA/zvSFXzPnDmjS5cuJVtOL5vN9uhVSQoPD9e3336riRMnasCAAZKk7t27KygoSIMGDdKWLVse+hx3797VO++8o8GDBzPeGAAAwMmlK/ieOHFCOXPmTLac2RYtWiRXV1f16dPH3ubp6anevXtr6NCh+uOPP1SiRIkHPseECROUmJioAQMGEHwBAACcXLqCr7+//wOXM8Pu3bsVEBAgb2/vZO21a9eWJO3Zs+eBwff06dP66KOPNHPmTHl5eWVqrQAAAMj+MjSrQ2Y6f/68/Pz8UrQntZ07d+6B27/zzjuqVq2aOnfu/Ej7jYmJUUxMjH35xo0bj7Q9AAAAsqd0BV9XV1fLO7DZbIqPj3/k7e7cuSMPD48U7Z6envb1aVm/fr2+//57bd++/ZH3O27cOI0aNeqRtwMAAED2lq7gW6JEiRQXqd2+fVuXL1+WJPn4+Kh48eK6deuWzp49q9jYWNlsNtWuXdseVB+Vl5dXsjOvSe7evWtfn5r4+Hi9+eabeuGFF1SrVq1H3u+QIUP09ttv25dv3Ljx0LHEAAAAyP7SFXxPnjyZbPnixYuqV6+e8uXLpy+//FINGjSwr0tISNC3336r9957T8YYrVy50lJhfn5+Onv2bIr28+fPS5KKFi2a6nZz587VkSNHNH369BR137x5UydPnlThwoWTXax3Pw8Pj1TPNAMAAODxZukGFkOHDtXp06e1du3aZKFXujcsomvXrvr555+1Z88ey8MGqlatqoiIiBRjbJOGL1StWjXV7U6fPq24uDjVrVtXpUuXtj+ke6G4dOnSWrNmjaWaAAAA8PiyFHxXrlypOnXqPHB2h3LlyqlOnTpauHChpcLat2+vhIQEffHFF/a2mJgYzZo1S8HBwfbhB6dPn9bhw4ftfTp37qwlS5akeEhS69attWTJEgUHB1uqCQAAAI8vS7M6XL9+XbGxsQ/tl5CQoAsXLljZhYKDg9WhQwcNGTJEFy9eVLly5TRnzhydPHnSfgc56d5NLTZu3ChjjCQpMDBQgYGBqT5n6dKl9dxzz1mqBwAAAI83S8G3TJky2rlzp44ePary5cun2uf06dPasWOHSpUqZbm4uXPnatiwYZo3b56uXr2qypUra8WKFapfv77l5wQAAIBzsjTU4cUXX1RcXJxatmyp9evXp1i/fPlyNW/eXHFxcXrppZcsF+fp6amJEyfq/Pnzunv3rsLDw9WiRYtkfTZs2GA/2/sgxhhNmzbNci0AAAB4vFk649uvXz9t27ZNixYtUtOmTVWgQAGVLl1aMTExOnXqlG7cuCFjjJ555hn179/f0TUDAAAAj8zSGV8XFxctXLhQc+fOVZUqVXT58mXt2LFD+/bt0/Xr11W8eHFNnjxZS5cuzdDNLwAAAABHydAti7t166Zu3brpypUrioyMVEJCgvz8/B442wMAAACQFTIUfJPkz59fxhi5uLgof/78jnhKAAAAwKEsDXVIMnv2bD399NPy9PSUr6+vevXqJUlq3Lix/vOf/zikQAAAAMARLAffl156Sb1799a2bdvk7u4uY4x9doWjR4/qjTfeULdu3RxWKAAAAJARloLvDz/8oJkzZ+qJJ57Qxo0bU9xWeP369apSpYq++eYbff311w4pFAAAAMgIS8F32rRpypEjh1avXq169erJxSX505QrV07fffed3NzcNHPmTIcUCgAAAGSEpeC7c+dO1axZU8WKFUuzT/ny5fXkk0/qwIEDlosDAAAAHMVS8I2Pj09Xv1y5cun69etWdgEAAAA4lKXgW7FiRe3du1eXLl1Ks090dLQOHDigUqVKWa0NAAAAcBhLwbdXr166ffu2OnXqpD///DPF+ps3b6p37966ceOGOnfunOEiAQAAgIyydAOLPn366IcfftDq1atVrlw5ValSRZK0Z88etWjRQjt37tTVq1dVqVIlDRw40KEFAwAAAFZYOuPr4uKiZcuWacCAAUpMTNSWLVskSWfOnNHatWt19epVtWvXTmFhYcqZM6dDCwYAAACssHzLYnd3d02YMEFDhgzRhg0bFBkZqbi4OPn5+alevXoqU6aMI+sEAAAAMsRS8B09erTKli2rrl27ysfHR+3atXN0XQAAAIBDWRrqMHXqVP373/92dC0AAABAprEUfJ955hnt2bNH586dc3Q9AAAAQKawFHwnT54sf39/tWrVSlu3bnV0TQAAAIDDWRrj27p1a0nSgQMHFBISopw5c8rHxyfVvjabTadOnbJeIQAAAOAAloLvzp07ky3fvn1bt2/fTrWvzWazsgsAAADAoSwF3xMnTji6DgAAACBTWQq+/v7+jq4DAAAAyFSWb2CRZPfu3dqxY4eioqKUM2dOFS1aVCEhISpSpIgj6gMAAAAcwnLwPXTokHr06KFdu3alur5du3b6v//7PxUtWtRycQAAAICjWAq+p06dUoMGDXT58mUVKFBATZo0UYkSJWSM0fHjx/Xzzz9r8eLF+u2337Rr1640Z3wAAAAA/i6Wgu+wYcN0+fJl9ezZU9OmTVPOnDmTrb969aq6du2q1atX64MPPtCkSZMcUiwAAABglaUbWKxatUq+vr764osvUoReSfLx8dHChQvl4+Oj5cuXZ7hIAAAAIKMsBd/o6GgFBQXJzS3tE8a5c+dW9erVdebMGcvFAQAAAI5iKfg++eSTOnv27EP7nT9/XqVKlbKyCwAAAMChLAXfd955R4cPH9b8+fPT7LNs2TL9/vvveuONNywXBwAAADiKpYvbAgMD1aFDB/Xs2VNLlixRaGioypYtKy8vL50/f17Lly/X7NmzFRwcrAoVKigsLCzFczRu3DjDxQMAAADpZSn4Vq1aVTabTcYYLV26VEuXLk3Rxxij8PBwNW/ePMU6m82m+Ph4K7sGAGSCj9dGZHUJaerfLCCrSwDwP8JS8K1fv75sNpujawEAAAAyjaXgu2HDBgeXAQAAAGQuSxe3AQAAAI8bgi8AAACcAsEXAAAAToHgCwAAAKdA8AUAAIBTIPgCAADAKVgKvl999ZWuX7/u6FoAAACATGMp+Pbp00dFihRRu3bt9N133yk6OtrRdQEAAAAOZSn41qtXT/Hx8frhhx/UpUsX+fr6qkuXLlq2bJni4uIcXSMAAACQYZaC78aNG3X+/Hl99dVXatWqleLj4/Xtt9+qXbt28vX11csvv8zd3QAAAJCtWL64rWDBgnrxxRe1YsUKXbp0Sd999506duyoxMREzZgxQ02aNFGpUqU0YsQIRUZGOrJmAAAA4JE5ZFaH3Llzq0OHDvrmm2908eJFrVy5Uk8//bROnz6tsWPHKiAgQC1atNDy5csdsTsAAADgkbk58sl27typxYsXa8mSJYqIiJAk2Ww2lS9fXmvXrtXPP/+sypUr67vvvlNAQIAjdw0AWe7jtRFZXUKq+jfjeAsAUgaDb2JiojZu3KglS5Zo6dKlOnv2rIwxstlseuqpp9S5c2d16NBBvr6++v333zVp0iTNmTNHffr0YQwwAAAA/laWgu+yZcu0ZMkSrVixQlFRUTLGSJKqVaumzp07q1OnTipZsmSybZ588knNmjVLBw4c0Pbt2zNeOQAAAPAILAXf5557TjabTcYYBQYGqnPnzurcuXO6hi/cuXNHXl5eVnYLAAAAWGYp+Pr7+9vDbpUqVR5p2wMHDljZJQAAAJAhloLviRMn7P8+evSo/P39lSNHDknS5cuX5erqKh8fH8dUCAAAADiA5enMli9frvLly+uJJ57QhQsX7O0//PCDChcurLZt2zJ/LwAAALINS8F3165dev7553X8+HEFBgYqV65c9nUlS5ZU3rx5tXz5ctWtW1fnz593WLEAAACAVZaC77hx45SQkKApU6bowIEDKlCggH1ds2bNdPbsWfXs2VN//vmnxo4d67BiAQAAAKssBd+dO3cqICBA/fr1S3W9h4eHpk+fLj8/P61cuTIj9QEAAAAOYSn4/vnnnypRosQD+7i7u6tixYoMdQAAAEC2YCn4Fi9eXAcPHlRCQsID+506dYrZHQAAAJAtWAq+zz//vM6fP6/XXntNsbGxqfaZMGGCjh07pmbNmmWoQAAAAMARLM3jO3ToUC1evFgzZszQihUr9OyzzyogIEBeXl76448/9MMPP+jIkSPy8fHR6NGjHV0zAAAA8MgsBd+8efNq48aN6tmzp37++Wd9+eWXstlskiRjjCTpiSee0IIFC1S6dGnHVQsAAABYZCn4SlLRokW1Zs0a7du3T+vWrdOJEyd09+5d+fr6ql69emrWrJk9DAMAAABZzXLwTVK5cmVVrlzZEbUAAAAAmSZDwffu3bs6fvy4rl279sAZHurXr5+R3QAAAAAZZin4xsbG6q233tLcuXN19+7dB/a12WyKj4+3VBwAAADgKJaC7+jRozV9+nRJ9+b0LV68uFxdXR1aGAAAAOBIloLvggUL5ObmpkWLFik0NNTRNQEAAAAOZ+kGFufPn1edOnUIvQAAAHhsWAq+vr6+cnPL8IQQAAAAwN/GUvB97rnnFB4erosXLzq6HgAAACBTWAq+I0eOlJ+fn1q1aqXIyEhH1wQAAAA4nKXxCq+88oqKFCmiX3/9VRUqVFBAQIB8fHzk4pIyR9tsNm3cuDHDhQIAAAAZYSn4Llq0yP7vhIQEHTp0KM2+3LYYAAAA2YGl4Lt+/XpH1wEAAABkKkvBt0GDBo6uAwAAAMhUGZ6T7Pbt29q9e7cuXLigQoUKqUGDBrp06ZIKFSrkiPoAAAAAh7A0q4MkXb9+XT179lT+/PnVoEEDderUSVOmTJEk1axZU507d9aVK1ccVigAAACQEZaCb1xcnBo3bqy5c+fK09NTzZs3lzFGxhhJ925wsXDhQjVu3FgxMTEOLRgAAACwwlLw/eyzz7R792517NhRZ8+e1U8//ZRs/datW/XPf/5TBw4csJ8FBgAAALKSpeA7d+5c5cuXT3PmzFHu3LlTrHd1ddV//vMf5c6dO9nUZwAAAEBWsRR8jxw5ourVq8vDwyPNPnny5FGlSpW4sxsAAACyBUvB18vLS5cvX35ovzt37iguLs7KLgAAAACHshR8a9eurYMHD+q3335Ls8+pU6d08OBBVapUyXJxAAAAgKNYCr79+vVTfHy82rVrpxUrVig2NjbZ+s2bN6tt27aKjY3Va6+95pBCAQAAgIywdAOL5s2ba+TIkRo5cqTatm0rFxcX2Ww2rVu3Tjlz5lRMTIyMMeratau6d+/u6JoBAACAR2b5BhbDhw/X8uXLVatWLSUmJsoYozt37uju3bsqUaKEpk6dqnnz5jmyVgAAAMCyDN2yuE2bNmrTpo2ioqJ04sQJxcXFyc/PT/7+/o6qDwAAAHCIDAXfJPnz51f+/Pkd8VQAAABAprAUfGfOnPlI/V988UUruwEAAAAcxlLwfemll2Sz2R7azxgjm81G8AUAAECWsxR8u3fvnmrwvXnzps6cOaPffvtNCQkJ6tmzJ+N9AQAAkC1YCr6zZ89+4Prz58+rV69e+vHHH7V161YruwAAAAAcyvJ0Zg/i5+enhQsXKjo6WsOGDcuMXQAAAACPJFOCryR5e3urcuXKWr9+fWbtAgAAAEi3TAu+knT58mVdu3YtM3cBAAAApIulMb6JiYkPXH/p0iV9+umnioiIUJUqVSwVBgAAADiSpeDr7u6e7r79+vWzsgsAAADAoSwFX2PMA9fnzp1bgYGB+te//qUXXnjBUmEAAACAI2XKUAcAAAAgu8nUi9sAAACA7MLSGd/IyMgM77hMmTIZfg4AAAAgvSwF33LlyqV6y+L0stlsio+Pt7w9AAAA8KgsBd/atWvr+vXrOnLkiCSpYMGCKlasmOLi4nTmzBnduHHD3p4rVy7HVQsAAABYZCn4Ll26VHXr1tWTTz6p//znP6pbt659XWJiosLCwtS3b1/Fx8fr119/la+vr8MKBgAAAKywdHHbsGHDdO7cOa1evTpZ6JUkFxcXNW3aVKtXr9aZM2c0dOhQhxQKAAAAZISl4PvTTz+pVq1aKlq0aJp9/P39Vbt2bf3444+WiwMAAAAcxVLwvXr16kNvYpHk2rVrVnYBAAAAOJSl4PvEE09o+/bt2rt3b5p9Tp48qfDwcJUvX95ycQAAAICjWAq+/fv3V3x8vJo3b6558+bp1q1b9nV37tzR4sWL1bRpU8XFxemVV15xWLEAAACAVZaCb9euXTV06FBdvnxZPXv2VL58+eTr66vChQvL29tbHTp0UGRkpJ577jm98cYblouLiYnR4MGDVbRoUXl5eSk4OFhr16596HaLFy9Wp06dVKZMGeXMmVMVKlTQO++8w7ALAAAAJ2b5lsVjx47Vxo0b1bZtW+XOnVuXLl3S5cuXlZiYqKCgIH366adatGhRhorr2bOnpkyZoq5du2rq1KlydXVV69attXnz5gdu16dPHx06dEjdunXT//3f/6lly5aaNm2annrqKd25cydDNQEAAODxZGke3yQhISEKCQmRJF2+fFmxsbHKnz+/PD09M1xYeHi4vv32W02cOFEDBgyQJHXv3l1BQUEaNGiQtmzZkua2ixYtUsOGDZO11ahRQz169NCCBQv00ksvZbg+AI738dqIrC4hVf2bBWR1CQAAB7B8xvd+Z86c0cmTJ3Xjxg15enoqMTExw8+5aNEiubq6qk+fPvY2T09P9e7dW1u3btUff/yR5rZ/Db2S1K5dO0nSoUOHMlwbAAAAHj+Wg298fLxGjhypYsWKyd/fX8HBwRo8eLAk6cknn9S7776rmJgYy4Xt3r1bAQEB8vb2TtZeu3ZtSdKePXse6fkuXLgg6d5tlAEAAOB8LA91CA0N1erVq2Wz2RQQEKAjR47Y5/aNj4/XxIkTtWPHDv3888+y2WyP/Pznz5+Xn59fivaktnPnzj3S840fP16urq5q3779A/vFxMQkC+w3btx4pP0AAAAge7J0xnf27NlatWqV6tevr2PHjqUYPrBz5041btxYGzZs0L///W9Lhd25c0ceHh4p2pPGDz/KRWpff/21ZsyYoXfeeeeh8wqPGzdOefPmtT9KlCjxaIUDAAAgW7IUfL/88kvlypVLS5YsUalSpVKsz5s3r+bNmydPT08tWLDAUmFeXl6pDpW4e/eufX16bNq0Sb1791aLFi30wQcfPLT/kCFDdP36dfvjQWOJAQAA8PiwNNRh//79qlmzpvLly5dmnyJFiigoKEgREdau0vbz89PZs2dTtJ8/f16SVLRo0Yc+x969exUaGqqgoCAtWrRIbm4Pf7keHh6pnmkGAADA483SGV8XFxdFR0enq9/t27et7EJVq1ZVREREijG227dvt69/kOPHj6tly5YqXLiwfvzxR+XOndtSHQAAAPjfYCn4Vq1aVfv27VNkZGSafa5cuaIDBw4oIMDa/Jft27dXQkKCvvjiC3tbTEyMZs2apeDgYPvY29OnT+vw4cPJtr1w4YKaN28uFxcXrV69WoUKFbJUAwAAAP53WBrq8Nprr+mXX35Ru3bttGDBAgUFBSVbf/LkSfXu3VvR0dHq1auXpcKCg4PVoUMHDRkyRBcvXlS5cuU0Z84cnTx5UjNmzLD36969uzZu3GifUUKSWrZsqcjISA0aNEibN29Odqc3X19fNWvWzFJNAAAAeHxZCr6dOnXSmjVrNGvWLFWpUkV+fn6y2WzasmWLKlSooBMnTig+Pl6NGjVS3759LRc3d+5cDRs2TPPmzdPVq1dVuXJlrVixQvXr13/gdnv37pUkTZgwIcW6Bg0aEHwBAACckOV5fGfMmKEaNWrogw8+sM+pGxUVpaioKHl5eelf//qXPvzwQ7m6ulouztPTUxMnTtTEiRPT7LNhw4YUbfef/QUAAACkDARfSXr99df16quvau/evYqMjFRcXJz8/PxUq1Yt5cyZ01E1AgAAABlmKfj27t1bTz75pN5++225uLioWrVqqlatmqNrAwAAABzG0qwOK1eu1DfffOPoWgAAAIBMYyn4durUSfv379fBgwcdXQ8AAACQKSwF348++khPP/20WrZsqW+++UaXLl1SYmJimg8AAAAgq1ka4+vv76/ExERdvXpV3bp1e2Bfm82m+Ph4S8UBAAAAjmIp+F6+fDndfZlaDAAAANmBpeDL8AUAAAA8biyN8QUAAAAeN+kKvvnz51fXrl0zuxYAAAAg06Qr+F67dk03b95MdV2ZMmXUp08fhxYFAAAAOFqGhzqcPHlSFy5ccEQtAAAAQKZhjC8AAACcAsEXAAAAToHgCwAAAKdA8AUAAIBTIPgCAADAKRB8AQAA4BTSfcvilStXytXVNUW7zWZLc13S+vj4eOsVAgAAAA6Q7uBrjLG0A6vbAQAAAI6UruB74sSJzK4DAAAAyFTpCr7+/v6ZXQcAAACQqbi4DQAAAE6B4AsAAACnkO6L2wBkfx+vjcjqElLVv1lAVpcAAABnfAEAAOAcCL4AAABwCgRfAAAAOAWCLwAAAJwCwRcAAABOgeALAAAAp0DwBQAAgFMg+AIAAMApEHwBAADgFAi+AAAAcAoEXwAAADgFgi8AAACcAsEXAAAAToHgCwAAAKdA8AUAAIBTIPgCAADAKRB8AQAA4BQIvgAAAHAKBF8AAAA4BYIvAAAAnALBFwAAAE6B4AsAAACnQPAFAACAUyD4AgAAwCkQfAEAAOAUCL4AAABwCgRfAAAAOAWCLwAAAJwCwRcAAABOgeALAAAAp0DwBQAAgFMg+AIAAMApEHwBAADgFAi+AAAAcAoEXwAAADgFgi8AAACcAsEXAAAAToHgCwAAAKdA8AUAAIBTIPgCAADAKRB8AQAA4BQIvgAAAHAKBF8AAAA4BYIvAAAAnALBFwAAAE6B4AsAAACnQPAFAACAUyD4AgAAwCkQfAEAAOAUCL4AAABwCgRfAAAAOAWCLwAAAJwCwRcAAABOgeALAAAAp0DwBQAAgFMg+AIAAMApEHwBAADgFAi+AAAAcAoEXwAAADgFgi8AAACcAsEXAAAAToHgCwAAAKdA8AUAAIBTIPgCAADAKRB8AQAA4BQIvgAAAHAKBF8AAAA4BYIvAAAAnALBFwAAAE6B4AsAAACnQPAFAACAUyD4AgAAwCkQfAEAAOAUCL4AAABwCgRfAAAAOAWCLwAAAJwCwRcAAABOgeALAAAAp0DwBQAAgFMg+AIAAMApEHwBAADgFAi+AAAAcAoEXwAAADgFgi8AAACcAsEXAAAATiFbB9+YmBgNHjxYRYsWlZeXl4KDg7V27dp0bXv27Fl17NhR+fLlk7e3t9q2bavIyMhMrhgAAADZVbYOvj179tSUKVPUtWtXTZ06Va6urmrdurU2b978wO1u3bqlRo0aaePGjRo6dKhGjRql3bt3q0GDBrpy5crfVD0AAACyE7esLiAt4eHh+vbbbzVx4kQNGDBAktS9e3cFBQVp0KBB2rJlS5rbfv755zp69KjCw8NVq1YtSVKrVq0UFBSkyZMn68MPP/xbXgMAAACyj2x7xnfRokVydXVVnz597G2enp7q3bu3tm7dqj/++OOB29aqVcseeiUpMDBQTZo00cKFCzO1bgAAAGRP2Tb47t69WwEBAfL29k7WXrt2bUnSnj17Ut0uMTFR+/btU82aNVOsq127to4fP66bN286vF4AAABkb9l2qMP58+fl5+eXoj2p7dy5c6luFxUVpZiYmIduW6FChVS3j4mJUUxMjH35+vXrkqQbN2482gsAssDd27eyuoRUpffvh/ozR3rqz661S493/c7wuyM93vVn19qlx7v+vzs3Je3PGPPAftk2+N65c0ceHh4p2j09Pe3r09pOkqVtJWncuHEaNWpUivYSJUo8vGgAqRqa1QVkEPVnrce5/se5don6s9rjXH9W1X7z5k3lzZs3zfXZNvh6eXklO/Oa5O7du/b1aW0nydK2kjRkyBC9/fbb9uXExERFRUWpQIECstls6X8B2cCNGzdUokQJ/fHHHymGjDwOHuf6H+faJerPatSfdR7n2iXqz2qPc/2Pc+3SvTO9N2/eVNGiRR/YL9sGXz8/P509ezZF+/nz5yUpzReWP39+eXh42Ps9yrbSvTPFfz1bnC9fvvSWnS15e3s/lr/ESR7n+h/n2iXqz2rUn3Ue59ol6s9qj3P9j3PtDzrTmyTbXtxWtWpVRUREpBgjsn37dvv61Li4uKhSpUrauXNninXbt29XmTJllCdPHofXCwAAgOwt2wbf9u3bKyEhQV988YW9LSYmRrNmzVJwcLB9zO3p06d1+PDhFNvu2LEjWfg9cuSIwsLC1KFDh7/nBQAAACBbybZDHYKDg9WhQwcNGTJEFy9eVLly5TRnzhydPHlSM2bMsPfr3r27Nm7cmOwqvtdff11ffvml2rRpowEDBsjd3V1TpkyRr6+v3nnnnax4OVnCw8NDI0aMSPVCv8fB41z/41y7RP1ZjfqzzuNcu0T9We1xrv9xrv1R2MzD5n3IQnfv3tWwYcM0f/58Xb16VZUrV9aYMWPUokULe5+GDRumCL6SdObMGfXv319r1qxRYmKiGjZsqI8//ljlypX7u18GAAAAsoFsHXwBAAAAR8m2Y3wBAAAARyL4AgAAwCkQfLMJm80mV1dXXbp0KcW6gQMHymaz6f3337e3HT58WM8++6wKFSqk/Pnzq0mTJlq3bp19/ezZs2Wz2fTss8+meL7ExEQVKVJENptNx44d0/Dhw5UvX75k46QPHz4sm82mfv36pailUKFCD70lYHocP35cXbp0ka+vrzw8PFS6dGn17dtXFy9eTLX/yJEjFRISkuH9JnmU97xnz57q1q1bms/VsGFDzZ4922G1OUqpUqVks9nsj5w5c6pu3boKCwtL1/aOfs8dLSEhQR9//LGeeOIJ5cyZU2XLltW7775rv9V4w4YNk73++x+TJk3KsrptNpuCgoKUkJCQrH327NkqXry4ffmvP7/7H4sWLcrUGrt3767KlSsna1u1apVsNps++eSTZO0dOnRQjRo1MrWeR+HI4+ndu3fl4eGhKVOmJHuezp07y8XFRVFRUfa2mzdvytXVVZ9++mm2eg3So30mOEpkZKS6dOmiQoUKycPDQ4GBgZo0aZISExN18uTJZPuz2Wz6+eefH/qcGzZskM1mU3x8vMPqTK8HHW+y6nM0tWNc3rx51aZNG0VGRjrk+e//PftfQPDNZlasWJGibdmyZXJ1dbUvX7lyRQ0bNlSZMmX0008/acWKFapUqZKaN2+utWvX2vu5uLho3bp1io6OTvZ827dv1+XLl+3L9erV0/Xr13XkyBF72/r162Wz2bRhw4Zk24aHhyskJCTDd7H7/fffVaNGDV26dElz587V7t27NWnSJG3YsEG1atXSuXPndOzYMdlsNp08eTJD+3qY9LznEyZM0OTJkzO1jvSKj49P9WeTln/96186evSojh49qg0bNqhy5cpq0aKF1q9f/0j7/bt+Ho/io48+0qeffqoPP/xQ27Zt0/jx4/Xf//432Yf766+/bn/99z9eeumlLKz83t/A9OnTH9rvww8/TLX+Vq1aZWp99erV08GDB3X79m1724OOC/Xr17e8r8z63XLE8dTT01M1a9ZUeHh4sudJeg9++eUXe9vOnTuVmJiYofciM15DkvR+JjhCRESEgoODdfXqVX333XfasWOH+vfvrw8//FCDBw9O0f/o0aOqW7fuQ583ODhYR48elZvb3z8p1YOON1nxOZrk+eefT3Zs+PHHH3Xy5Em1b98+w8+9YMGCZHez/Z9gkC1IMnXr1jVt27ZN1n748GHj6elpatasad577z1jjDFfffWVqVChQorneOaZZ0y3bt2MMcbMmjXLFCtWzJQqVcosWbIkWb93333XhISEGEnm6NGj5ubNm8bV1dXMnTvX3qdjx47mueeeMzabzVy5csUYY0xCQoLJnTu3mTx5coZfb40aNUzLli1NQkJCsvaoqChTuHBh88orr5ijR48aSebEiRPGGGNGjBhh6tatm+F9J3mU9/xhGjRoYGbNmuWw2h4kLi7OSDLr169/aF9/f38zYsSIFO3t2rUzQUFBD93+/vf8rz+P7KB48eLmm2++Sda2c+dOI8kcO3bMNGjQIN0/w7+TJBMSEmIKFixorl27Zm9P+rtN4u/vb7788susKNEcOnTISDK//PKLva127drmueeeMz4+Pva/3T///NNIMt9//73lfTn6d8vRx9PBgwebMmXK2NcdPHjQuLq6mmeffda89dZb9vbx48ebvHnzpjiuZYfX8CifCY7QuHFj07BhQxMfH5+sfcmSJcZms5lffvnFofv7OzzoeLNnz56//XPUmHufPT169EjR/vXXXxtJ5tKlSw7Zz/8SzvhmI6GhoVq7dq3u3Lljb1u2bJkaN26sXLly2duuXbumGzdu6NatW8m2nzx5coqvVJ599ln98MMPydqWLVum0NBQ+3Lu3LlVtWrVZGc0NmzYoJdfflnFihXTxo0bJUkHDx7UrVu3VK9evQy9zp07d2rXrl0aM2aMXFyS/wr6+PhowIABmj17tsqXLy9JKl26dLL/MQ8dOlQ+Pj7Knz+/Ro8enaFa0vue/3Wow8SJE1WkSBHlyZNHffv2VWJioiRp9OjRye4q+Morr8jDw0MxMTGSpMWLF6tkyZKS7n1t9u6778rX11e5c+dW+/btdebMmWT78Pf3l7e3t+rVq6d9+/ZJktzd3SVJjRo1sjy84pVXXtGBAwd0+PBhXbx4UR07dlTu3Lnl6+urgQMH2utNcvLkyVR/HpMmTVKpUqXk5eWlJ554QrNmzbJUj1XXr19PcWvzatWq6aefflLBggX/1loe1cCBA+Xp6Znh3+HMEhgYqIIFC9qPCzdv3tSuXbv03nvv6fbt29q7d68k2deHhIQoOjpaffr0kY+Pj/Lly6eXXnpJ165dk3Tv6/SBAwfKz89PPj4+atWqlU6dOpXm71ZGOfJ4GhISosjISF25ckXSvTN51atXV9u2bZN9cxIeHq66deumOK5lh9eQJD2fCRl16tQphYWFaeDAgcnOTEv3XlNqx4n7hzqUKlVKU6dOVatWreTp6amAgABt3rxZUsqhDgcPHlSDBg3k5eWlMmXKJLvplaM96HhTqlSpv/Vz9GE8PT0l3fu8eNgxfvLkyfL19ZWPj4+GDh2abOjeX4c6jB8/XiVKlJC3t7eaNWumAwcO2Nc96OeWnRB8s5Hq1asrf/78ycY5LVu2LMWYrNatW+v69euqWLGi+vfvr+XLl+vatWsKCAhIMc4uNDRUK1eutAezyMhIHTt2LNlcyNK9rzWT/mAPHjyoqKgo1atXT40aNbJ/EIWHhytXrlyqVq1ahl7n9u3blTNnzjTHBAYHBysmJkb/+c9/JN07eAQHB9u3PXnypH7++WcNHz5cI0aM0P79+y3Xkt73/H7Lli3TiBEjNHr0aG3YsEFRUVH69ddfJUlNmjTRgQMH7B9AW7duVXx8vP0ugps2bVKTJk0kSWPGjNH69eu1cOFCrV69Wrdv31a7du0k3RtL+cEHH+jLL7/UL7/8oieeeEItWrRQfHy8/U6F8+fP1z/+8Q9LrzsoKEiSdOjQIXXs2FE5c+bUL7/8opkzZ2rx4sUpxnQVL17cPl4w6eexdu1ajR07VlOmTNGOHTvUqVMn9e7dW6dPn7ZUkxXt27fX4MGD1bp1a3366afav3+/bDabWrZsma57tmelnDlzavz48Zo2bZpDx1U6UkhIiP24sGnTJhUsWFA1a9ZUcHBwsuNChQoVVLhwYb3++us6c+aMVq1apSVLlmjPnj16+eWXJUlffPGFFi1apP/+979au3at3N3d1b59+1R/txzBkcfTunXrymaz2d+LDRs2qFGjRmrUqJH2799vH+cbHh7u0ECTlZ8JGbFnzx5JUu3atVOsc3FxUY8ePex3X03LiBEj1KFDB23ZskUlSpRQ3759U/SJjY1V69atVaFCBW3fvl1Dhw7VG2+8oR07djjkdfzVw443f+fn6IOcO3dO06ZNU4sWLZQ3b94HHuOXLl2qUaNG6dNPP9XatWt18ODBNMPql19+qQ8//FDjx4/X5s2b9eSTT6pRo0bJxrmn5+eW5bL6lDPukWTWrl1rXnvtNdO7d29jjDGXLl0ybm5u5syZMym+st25c6fp0qWLKViwoJFk3NzczLPPPmsuXLhgjPn/X2vFxsaavHnzmk2bNhljjJkyZYpp1qyZOXHiRLKvmb7//nvj4eFhYmNjzWeffWaCg4ONMcbMnDnTVK5c2RhjzKuvvmqaNm2a4dc6ZsyYZF/n/tXBgweNJLNx48YUQx3y5ctn7ty5Y+9boEABs2DBAkt1PMp73qNHD9O1a1djjDGNGjUyAwcOtD/PnTt3TIECBcysWbNMbGysyZ07t1m3bp25ceOG8fT0NM8884yZMGGCMebeEI958+aZO3fumFy5cpnff//d/jxRUVHGxcXFHDhwwHzyySemePHi5vr168YYY27cuGFmzZploqOjHTLUISYmxkgyo0ePNkWKFEn2deTSpUtNwYIFjTEPHurw66+/Jnvvr1y5YiSZDRs2PLQuR7l7966ZOHGiqVWrlnFxcTGSTLFixczMmTONMfe+BnR1dTUeHh4pHn/9CvbvlPS7Z4wxTz/9tP3r7NSGOri5uaWovWzZsn9LnZMnTzalS5c2xhgzcOBA06lTJ2OMMcOHDzehoaHGGGNatmxpXnrpJXPq1CmTI0cOc+PGDfv2e/bsMW5ububq1aumX79+pmbNmiYmJsYYY8y5c+fsXwtnxlAHRx5PjTGmUqVKZtSoUcYYYwoXLmx++uknY4wxJUuWNIsXLzYXLlwwkszmzZuz5Wt41M+EjJg/f76RZOLi4tLs89f93f834e/vb9544w173x9++MG4u7sbY4xZv369/bnnzp1rfH19k+2nf//+KYYjOMrDjjd/5+dokgYNGhgXFxf7sSFHjhxGksmTJ4+JjIw0mzZteuAxvl69embo0KH2ddevXze5c+e2D927//esTJkyZtKkScn2HxgYaKZMmWKMefDPLTvhjG82ExoaquXLlysxMVErV65UlSpVVKxYsRT9atSooQULFujixYvav3+/Ro0apc2bN6e4YMfd3V0tW7a0f7WV1ldaISEhiomJ0d69e7V+/Xo1atRIkuxnNK5cueKwsxne3t66dOmS/YzDXyV9leTn55diXZkyZexf4Uj3hmn89UKNR5Xe9zzJvn37VKdOHfuyp6ennnzySUn33u/69etr69at2r59u6pWrapmzZppy5YtunXrlvbu3avGjRvr+PHjun37tqpXry5PT095enrKz89PiYmJOn78uDp16iQfHx/5+/vrH//4hxYsWKDQ0FB5eXll6LUmuXnzpqR7P4s///xTuXLlstfRsWNHXb58WTdu3Hjgczz99NMqUqSIBg4cqH/84x96+umnJckhVyqnl4eHhwYMGKDw8HBFRUVp6dKlqly5sl566SX7WZ+XX35Ze/bsSfH461ewWeWTTz7RsmXL0rzYcMSIESlqX7169d9SW7169XTixAldvnw5xXHhl19+UUJCgnbs2KF69epp//79io2NVaFChey/S8HBwYqPj9fp06f1yiuv6OLFiypZsqS6du2qNWvWWP7GIr0ceTxNOpv3+++/Kyoqyj7bSaNGjbR+/XqFh4fL09NTtWrVyravQUr/Z0JGJH3bktqMFJJ09erVZMM3UlOpUiX7v729vRUXF5diJocDBw6odu3ayS50mzJlijp37my19Ad62PHm7/wcvV9oaKj92LB3716FhYXJ19dXAwYM0N69ex94jD906FCy31lvb28FBASk2Mft27cVGRmZ4sLNKlWq6OjRo/bl9PzcshrBN5tp1KiRoqOjtW3btjS/cn/77bftH3xJ0yINHTpUH3/8caofnqGhoVq2bJmuXr2qzZs3p/qchQsXVkBAgMLDw7Vx40b7H2ypUqXk7++vNWvWaP/+/Q75g61evbpiY2O1e/fuVNf//PPPKlSoUKrrHBX87pee9/x+cXFxKa7GvX9aqiZNmmjr1q3aunWrQkJCVK9ePfty+fLlVbRoUcXFxUm69/Xx/YHm0KFDaty4sYoUKaI9e/Zo2bJlevLJJ/X5558rMDBQ586dc8hr3rVrl1xcXBQbG6sKFSokq2Hv3r06dOiQcufO/cDnmDRpkjp27CgfHx/17NkzXVMROdKWLVvsX6NL9z5s27ZtqxUrVqhUqVL2rxYLFCigwMDAFI/solatWurevbv69++f6n8GixQpkqL2smXL/i21VatWTbly5dK6deu0e/du+3Hhqaee0t27d7VkyRJduXJF9erVU1xcnPLkyZMipB86dEgVKlRQYGCgjh49qjlz5qhYsWIaPXq0qlWrluH/uD6II4+nISEh2rFjh33mmaS/j6SvsXfs2KHatWsrR44c2fY1JEnPZ0JGJE2Dl9oxPjo6WkWKFNGqVase+Bzp+Y/p7du37dc8ZLb0HG/+zs/R++XNmzfZ8aFRo0Z6/fXX9dtvvykuLu6Bx/jr16+n671OGhP819/vO3fuKGfOnPbl7HJC4UEIvtmMh4eHWrRoof/+979as2ZNqv8TP3LkiBYsWJCi3d3dPdnZ0CStW7dWZGSkpkyZoooVK8rf3z/VfderV0+zZ8/WtWvXkk0r06hRI3388ceS5JDxd08//bTKlSunDz/8MMW6qKgozZgxQ6+++qrDpnp5mPS85/erUKGCtm3bZl++fft2sgH+TZo00bZt2/Trr7+qbt26qlKliu7cuaPZs2fbx/eWK1dOrq6uio6Oth+scuTIoV69eikmJkZTp07VnDlzVK9ePY0ePVq//fabYmNjHXahwLRp09SwYUNVqlRJZ86cUYkSJex1HDhwQCNHjnzoBTrz5s3T4MGDNXToUD377LMpLojLbO7u7poxY4aOHz+erN3FxUVubm6Z8p+kzDJu3DgdP35cM2fOzOpSknFzc1OdOnXsF78knQny8PDQU089pQkTJqhYsWIqXbq0AgMDdfPmTXl5edl/l65cuaLXX39dbm5ueu+997R27Vq1aNFCEyZM0Pbt2xUREZHsb8fRHHk8rVevni5evKg5c+bYA4107/h44MAB/fTTT5lywVJWfiZYVbJkSdWtWzfF3MeS9NVXXylnzpxq3LhxhvcTGBhoH0+cpEmTJvryyy8z/Nx/ld7jzd/1OfowPj4+iouLU2Bg4AOP8SVLlkx2nUxUVFSqf5P58+dXgQIFtH37dntbQkKCtm3bluws7+OA4JsNhYaG6vPPP1e+fPlSHQA/aNAgffPNN3r33Xe1a9cu7dy5U9OnT9c777yT7H+kSfLly6d69eppwoQJD/yffb169exnLe6/YrhRo0basWOHatSokex/dla5uLjoq6++0k8//aTOnTsrLCxMhw4dsl+tXL58eQ0ZMkQeHh6S7s0C8bCvxTLqYe/5/fr166dp06Zp1qxZ2rVrl3r16pXsq5zKlSvLZrMpLCzMfoX3008/rYULF9qDb+7cufXqq6+qb9++2rBhgzZv3qxu3bqpUKFCKlCggDw8PPTuu+9q0aJFOnDggKZNm6bo6GhVrVpVrq6ucnNz0969e+1DFh4kKipKx44d07Fjx7Rr1y717t1bP//8syZMmKBmzZqpTJkyevHFF7Vz504tXrxYb775ZqoXpfz151GsWDH9+OOP2rNnj1atWqXu3bvL3d1dERERj/LWW1arVi01adJEoaGhWrp0qQ4ePKhVq1apa9euunz5sv1r9KtXr9pf//0PR89bmhF+fn4aOnSo/SLJ+126dCnV+pNu0pHZko4L94c96f8fF5LCXmBgoNq0aaOePXtq69atWrNmjXr37q2goCC5uroqISFB/fr106pVq7R//35NmjTJ/rVqZv6tO+p4Wrx4cZUqVSrFe1GyZEmVLl1aO3fuzLQr9bPqMyEjPv/8c23fvl2dOnXSpk2bdODAAU2aNEmDBw/WlClTHHLxabdu3RQVFaV33nlHe/bssc+v26xZMwe8guTSe7z5uz5HH8Zmsyk2Nvahx/iuXbtqypQp+uGHH7Rjxw517do1zeFqb775poYNG6bvv/9eO3bs0Isvvig3Nzd16tQp01+PQ2X1IGPco/sG9l++fNm4urqa1157zb7+rxcybNu2zTRt2tQULFjQeHt7m+DgYDNz5kyTmJhojEl5kcwnn3xiJJnt27cbY1JeWGCMMcePHzeSUsx7+scffxhJyS7ocoS9e/ea559/3hQoUMDkyJHDlC9f3gwfPtxER0cbY4xJTEw0TZs2NTly5DBbtmxJdR7fjMxz+ijv+f0XtxljzNixY03+/PmNj4+Pee+998w//vGPZPP4duzY0QQEBNiXP/jgA+Pi4mKuXr1qb4uOjjavvPKK8fb2Nj4+PqZbt2729XFxcWbgwIGmePHixsvLywQFBZlFixbZt+3Vq5fJkSOH+fbbbx/4Gv39/Y0k+yNXrlymQYMG5tdff7X3OXHihGnRooXx8PAwxYsXN6NGjbLPQ3r/e/7Xn0dERIQJDg42np6eplatWuaXX34xPXv2NDlz5kzP2+8Q0dHRZtiwYaZChQrG09PTlCxZ0rz00kvm2LFjxph7P8P7X//9j/vnX/273f+7l+Tu3bumdOnSKS5uS6v+jz/++G+pdd26dUZSir+zTZs2GUnms88+s7ddvnzZdOzY0eTMmdMULlzYvPnmm+bu3bvGGGNu3rxpevfubYoUKWJy5sxpatWqZb8Q8q+/Wxnl6ONpkhdeeMHkyJHD3L59O1l77969jaura7IL+7Lba7DymZBR+/fvN88++6zJkyeP8fT0NMHBwWbx4sWp7u/+1/vX4/r9F7Td/29j7v0eVqpUyXh4eJgqVaqYVatWOaz+v3rY8caYv/9zNK15fH/44Qf7xcYPOsbHxsaad9991/j6+pq8efOaIUOGmCeeeML+2XL/71lsbKx5++23TYECBYynp6epX7++2bNnj32fD/q5ZSc2Y/7GK1EAAACQLezfv1/e3t724S5xcXHKnz+/1qxZo6eeeiqLq8scDHUAAABwQjNnzlSzZs20ceNGbd26Vd27d5evr2+qw93+V/z9N7sGAABAlhszZoyuXLmi559/Xnfv3tVTTz2llStXPhazM1jFUAcAAAA4BYY6AAAAwCkQfAEAAOAUCL4AAABwCgRfAAAAOAWCLwA40MmTJ2Wz2dL1yJcvX1aXCwBOhenMACCTtGnT5oHrc+fO/bfUER8fL3d3d0lK83akAOAMCL4AkElWrFiR1SUAAO7DUAcAAAA4BYIvAGQD165d05AhQ1ShQgV5enqqSJEi6tq1q/bs2ZNq/8uXL2vUqFGqVKmS8uTJIx8fH1WuXFnDhw/XhQsX7P1GjhxpH+YgSTabTaVKlZIkbdiwQTabTSEhIanuo1SpUrLZbDp27Ji9rWHDhrLZbDpw4ID+/e9/q1y5cipTpkyy7Xbs2KH27dvL19dXnp6eeuKJJzRq1CjdunUrxT5iYmI0ZcoUVatWTd7e3sqTJ49q1aqlzz77TImJiel9+wAgXQi+AJDFTp48qerVq+ujjz5SVFSUnnrqKRUuXFhff/21atWqpRkzZiTrf+XKFVWvXl0jR47UhQsXVKNGDVWsWFHHjh3TmDFjVKNGDV2+fFmSFBAQoNatW9u3bdOmjZo0aZLhmocPH67XX39dLi4uyYLzrFmz9NRTT+n777+Xj4+P6tatq6ioKI0cOVKVKlXSqVOn7H0TEhLUtGlTvfPOOzp37pxq166tChUq6Pfff1ffvn31+uuvZ7hOAEjGAAAc5sSJE0aSSe/hNTEx0dSuXdtIMn379jUxMTH2dRs3bjS5cuUyrq6u5siRI/b2CRMmGEnm+eefN9HR0fb2K1eumEqVKhlJ5vPPP7e3x8XFpVrT+vXrjSRTt27dVGvz9/c3kszRo0ftbQ0aNDCSjJubm1m4cGGy/nv27DHu7u4mT548ZtWqVfb2+Ph4069fPyPJ1KtXz96+aNEiI8k8/fTTyV73H3/8YSpWrGhsNluy1w0AGcUZXwDIJA+ayixpuMHq1asVHh6u6tWra+rUqcqRI4d9+/r162vgwIFKSEjQzJkz7e3x8fEKDg7WsGHD5OXlZW/Pnz+/QkNDJUkXL17M1NfWo0cPdejQIVnbuHHjFBcXpzFjxqhFixb2dldXV02ePFllypTRpk2bdPjwYUlSRESEpHtnpe9/3cWLF9ekSZP0+uuvKzo6OlNfBwDnwqwOAJBJHjSdma+vryTpxx9/lCS1aNFCLi4pz0W0aNFCI0eOVHh4uL1tyJAhGjJkSLJ+V65c0dGjR7Vq1SpJmT9tWbNmzZItJyYm2vfdqlWrFP1dXFzUrFkzTZ8+XeHh4QoMDFTNmjUlSXPmzFG+fPnUrVs3Va1aVa6urmrVqlWqzwMAGUHwBYBMkp7pzCIjIyXdO1s6bty4NPvdf8GaJO3cuVMzZ87Uli1bFBkZqZs3b0qSPD09M1Bx+hUoUCDZclRUlK5fvy5JqlChwgO3TXotzZo108cff6yRI0fqk08+0SeffKI8efKoXr16euaZZ9SlSxflzZs3c14AAKdE8AWALBQXFydJqly5skqUKJFmPz8/P/u///3vf6tv375yc3NTkyZN1KJFC5UpU0a1atXS4sWL9cEHHziktqQwnR5Jr0OSWrduLZvNlmZff39/+7/79eunl156SWvXrlVYWJg2b96sn376ST/++KNGjhypDRs26IknnrD2AgDgLwi+AJCFkgJtx44d9d577z20/61bt9S/f3+5urpqy5YtqlGjRrL133zzTbr3/aBweuvWLV27di3dz1WgQAG5u7srLi5OX3zxhYoVK/bQbRISEmSMUe7cudWuXTu1a9dOknTu3DkNGDBA33zzjSZMmKBZs2aluw4AeBAubgOALFS/fn1J0rp161JdP3/+fBUvXtw+pvfw4cOKiYlRYGBgitArSZs3b073vpNumXzp0qUU61atWvVI8+jmyJFDderUkZT2awkNDVXx4sX122+/SZIaNGggd3d37d27N1m/okWLatCgQZKk8+fPp7sGAHgYgi8AZKHOnTurWLFiWr9+vSZPnpxs3Zo1a/TWW2/pwoUL6ty5s6T/P7b26NGj2r9/v71vVFSU+vTpo23btkm6N/NDEhcXF/uFc/ffRKJs2bJyd3dXRESEVq9ebW+PiIjQgAEDHvm1JG3z3nvvJbvxRkxMjAYMGKDly5eraNGiql69uiSpbt26ku7NCXz79m17/7i4OP3nP/+RJNWqVeuR6wCANGX1fGoA8L/kUefxNcaYrVu3mnz58hlJpmjRoqZhw4amfPnyRpJxcXExn376abL+7dq1M5KMu7u7qVevnqlTp47JkSOHKVSokBk+fLiRZAoXLmz69+9v3yYgIMBIMoGBgaZnz5729l69etn3U7NmTVOjRg3j6upq6tata5566qk05/Fdu3Ztqq/l3Xfftc/zGxQUZOrXr2/y589vJJlixYqZiIgIe98LFy6YokWLGknG29vbNGjQwDRq1MgULFjQSDIBAQHm6tWr6X4fAeBhOOMLAFmsTp062r17t1588UUZY7RlyxbduXNH7du31y+//KK+ffsm6//1119rxIgR8vf3144dO3Tx4kX17dtXv//+u4YOHapnnnlG165d09mzZ+3bTJ06VWXLltXx48d16NAhe/vnn3+uIUOGqESJEtq3b5+uXr2qd955Rz/++GOyuXXTa9y4cfrhhx8UEhKikydPateuXSpSpIgGDRqkffv2qXz58va+vr6+2r59u15++WUVKFBAW7du1ZYtW5Q/f36988472rZtm/Lly/fobygApMFmTCZP9ggAAABkA5zxBQAAgFMg+AIAAMApEHwBAADgFAi+AAAAcAoEXwAAADgFgi8AAACcAsEXAAAAToHgCwAAAKdA8AUAAIBTIPgCAADAKRB8AQAA4BQIvgAAAHAKBF8AAAA4BYIvAAAAnML/A5+om9Nht86CAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 800x800 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "feature_names = ['MSM','MSMW', 'MSW', 'Oth','NE', 'SE', 'SW', 'West', 'Midwest','Region', 'Clinic', 'Delta']\n",
    "PI_dataframe = pd.DataFrame({\n",
    "'MSM':353,\n",
    "'MSMW': 0,\n",
    "'MSW': 229,\n",
    "'Other':0,\n",
    "'Midwest':156,\n",
    "'Northeast':103,\n",
    "'West': 455,\n",
    "'Southeast': 168,\n",
    "'Southwest':0,\n",
    "'Region':474,\n",
    "'Clinic':448, \n",
    "'Delta': 74},index=[0])\n",
    "\n",
    "PI_dataframe = pd.DataFrame({\n",
    "'Features': feature_names,\n",
    "'Importance': [353, 0, 229, 0, 156, 103, 455, 168, 0, 474, 448, 74]})\n",
    "\n",
    "PI_dataframe_sorted = PI_dataframe.sort_values('Importance')\n",
    "PI_dataframe_sorted[\"Importance\"]  = PI_dataframe_sorted[\"Importance\"]/500\n",
    "plt.rcParams['figure.figsize'] = [8, 8]\n",
    "y_pos = np.arange(len(feature_names))\n",
    "plt.bar('Features', 'Importance', data =  PI_dataframe_sorted, align='center', alpha=0.5)\n",
    "plt.xticks(y_pos, **hfont)\n",
    "plt.yticks(fontsize=12)\n",
    "plt.xlabel('Features', **hfont, fontsize=16)\n",
    "plt.ylabel('Frequency predictor identified as significant', **hfont,fontsize=16)\n",
    "plt.savefig('Features_by_importance.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 800x800 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "## permutation importance on test data \n",
    "model_nn = MLPClassifier(solver = 'lbfgs', activation = 'tanh', max_iter = 3000 ,hidden_layer_sizes= 12, alpha = 1.291549665014884, random_state=10, learning_rate = 'adaptive' )\n",
    "#train data: 2000 - 2009\n",
    "train_data = CIP_data_no_drop.loc[CIP_data_no_drop['YEAR'].isin([2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,2010])]\n",
    "X_train = train_data[['MSM','MSMW', 'MSW', 'Oth/Unk/Missing','Northeast', 'Southeast', 'Southwest', 'West', 'Midwest','PREV_REGION', 'PREV_CLINIC', 'DELTA_REGION']]\n",
    "y_train = 1 - train_data['Susceptible']\n",
    "\n",
    "oversample = RandomOverSampler(sampling_strategy = 0.5, random_state=42)\n",
    "X_train, y_train = oversample.fit_resample(X_train,y_train)\n",
    "model_fit = model_nn.fit(X_train, y_train)\n",
    "\n",
    "#test data: 2010 - 2019 \n",
    "test_data = CIP_data_no_drop.loc[CIP_data_no_drop['YEAR'].isin([2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019])]\n",
    "X_test = test_data[['MSM','MSMW', 'MSW', 'Oth/Unk/Missing','Northeast', 'Southeast', 'Southwest', 'West', 'Midwest','PREV_REGION', 'PREV_CLINIC', 'DELTA_REGION']]\n",
    "y_test = 1 - test_data['Susceptible']\n",
    "oversample = RandomOverSampler(sampling_strategy = 0.5, random_state=42)\n",
    "X_test, y_test = oversample.fit_resample(X_test,y_test)\n",
    "\n",
    "y_predict = model_nn.predict(X_test)\n",
    "\n",
    "ROC_AUC_neural_network_apparent = metrics.roc_auc_score(y_test, y_predict)\n",
    "\n",
    "perm = permutation_importance(model_fit, X_train, y_train, random_state=1)#.fit(X_test,y_test)\n",
    "#eli5.show_weights(perm, feature_names = X_test.columns.tolist())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x800 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "perm_sorted_idx = perm.importances_mean.argsort()\n",
    "feature_names = ['MSM','MSMW', 'MSW', 'Oth/Unk/Missing','Northeast', 'Southeast', 'Southwest', 'West', 'Midwest','PREV_REGION', 'PREV_CLINIC', 'DELTA_REGION']\n",
    "#tree_importance_sorted_idx = np.argsort(model_nn.feature_importances_)\n",
    "#tree_indices = np.arange(0, len(model_nn.feature_importances_)) + 0.5\n",
    "\n",
    "#fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 8))\n",
    "#ax1.barh(tree_indices, model_nn.feature_importances_[tree_importance_sorted_idx], height=0.7)\n",
    "#ax1.set_yticks(tree_indices)\n",
    "#ax1.set_yticklabels(CIP_data_no_drop.feature_names[tree_importance_sorted_idx])\n",
    "#ax1.set_ylim((0, len(model_nn.feature_importances_)))\n",
    "plt.boxplot(\n",
    "    perm.importances[perm_sorted_idx].T,\n",
    "    vert=False,\n",
    "    #labels=feature_names[perm_sorted_idx],\n",
    ")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n",
      "/var/folders/3f/vvt02dh16jddhc3q1tl6f3zh0000gn/T/ipykernel_85583/1347534679.py:15: FutureWarning: The behavior of `series[i:j]` with an integer-dtype index is deprecated. In a future version, this will be treated as *label-based* indexing, consistent with e.g. `series[i]` lookups. To retain the old behavior, use `series.iloc[i:j]`. To get the future behavior, use `series.loc[i:j]`.\n",
      "  selected_feature_names = (df['Features'][0: n_features_wanted]).tolist()\n"
     ]
    }
   ],
   "source": [
    "## What happens to feature importance if you only train on the 2011 data?\n",
    "\n",
    "n_iterations = 100\n",
    "PI_dataframe_2011 = pd.DataFrame({\n",
    "'MSM':0,\n",
    "'MSMW':0,\n",
    "'MSW':0,\n",
    "'Other':0,\n",
    "'Midwest':0,\n",
    "'Northeast':0,\n",
    "'West':0,\n",
    "'Southeast':0,\n",
    "'Southwest':0,\n",
    "'Region':0,\n",
    "'Clinic':0},index=[0])\n",
    "\n",
    "model_nn = MLPClassifier(solver = 'lbfgs', activation = 'tanh', max_iter = 3000 ,hidden_layer_sizes= 13, alpha = 1.291549665014884, random_state=10, learning_rate = 'constant' )\n",
    "feature_names = ['MSM','MSMW', 'MSW', 'Oth/Unk/Missing','Northeast', 'Southeast', 'Southwest', 'West', 'Midwest','PREV_REGION', 'PREV_CLINIC']\n",
    "\n",
    "for i in range(n_iterations):\n",
    "    #Generate new test and train data \n",
    "            # train\n",
    "    train_data = CIP_data_no_drop.loc[CIP_data_no_drop['YEAR'].isin([2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010])]\n",
    "    X_train = train_data[['MSM','MSMW', 'MSW', 'Oth/Unk/Missing','Northeast', 'Southeast', 'Southwest', 'West', 'Midwest','PREV_REGION', 'PREV_CLINIC']]\n",
    "    y_train = train_data['Susceptible']\n",
    "\n",
    "    oversample = RandomOverSampler(sampling_strategy = 0.5)\n",
    "    X_train, y_train = oversample.fit_resample(X_train,y_train)\n",
    "\n",
    "            # test\n",
    "    test_data = CIP_data_no_drop.loc[CIP_data_no_drop['YEAR'].isin([2011])]\n",
    "    X_test = test_data[['MSM','MSMW', 'MSW', 'Oth/Unk/Missing','Northeast', 'Southeast', 'Southwest', 'West', 'Midwest','PREV_REGION', 'PREV_CLINIC']]\n",
    "    y_test = test_data['Susceptible']\n",
    "    oversample = RandomOverSampler(sampling_strategy = 0.5)\n",
    "    X_test, y_test = oversample.fit_resample(X_test,y_test)\n",
    "\n",
    "    # Train model on training data - don't need to test on test data \n",
    "    model_fit_train = model_nn.fit(X_train, y_train)\n",
    "\n",
    "    # Permutation importance \n",
    "    PI = permutation_importance(model_fit_train, X_test, y_test, n_repeats = 10, random_state = 42)\n",
    "    important_features = get_features_based_on_importance_rank(feature_names, 'Importance', PI.importances_mean, 5)\n",
    "    for feature in important_features:\n",
    "        if feature == 'PREV_CLINIC':\n",
    "                PI_dataframe_2011[\"Clinic\"] += 1\n",
    "        elif feature == \"PREV_REGION\":\n",
    "                PI_dataframe_2011[\"Region\"] += 1\n",
    "        elif feature == \"MSM\":\n",
    "                PI_dataframe_2011[\"MSM\"] += 1\n",
    "        elif feature == \"MSMW\":\n",
    "                PI_dataframe_2011[\"MSMW\"] += 1\n",
    "        elif feature == \"MSW\":\n",
    "                PI_dataframe_2011[\"MSW\"] += 1\n",
    "        elif feature == \"Oth/Unk/Missing\":\n",
    "                PI_dataframe_2011[\"Other\"] += 1  \n",
    "        elif feature == \"Northeast\":\n",
    "                PI_dataframe_2011[\"Northeast\"] += 1 \n",
    "        elif feature == \"Southeast\":\n",
    "                PI_dataframe_2011[\"Southeast\"] += 1    \n",
    "        elif feature == \"Southewest\":\n",
    "                PI_dataframe_2011[\"Southwest\"] += 1   \n",
    "        elif feature == \"Midwest\":\n",
    "                PI_dataframe_2011[\"Midwest\"] += 1    \n",
    "        elif feature == \"West\":\n",
    "                PI_dataframe_2011[\"West\"] += 1   \n",
    "\n",
    "    #Save results. 1 = +ve, -1 = -ve "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   MSM  MSMW  MSW  Other  Midwest  Northeast  West  Southeast  Southwest  \\\n",
      "0    9     0    9      0        0          1     8          4          0   \n",
      "\n",
      "   Region  Clinic  \n",
      "0      10       9  \n"
     ]
    }
   ],
   "source": [
    "print(PI_dataframe)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "feature_names = ['MSM','MSMW', 'MSW', 'Oth','NE', 'SE', 'SW', 'West', 'Midwest','Region', 'Clinic']\n",
    "PI_dataframe_2011 = pd.DataFrame({\n",
    "'MSM':83,\n",
    "'MSMW': 40,\n",
    "'MSW': 90,\n",
    "'Other':8,\n",
    "'Midwest':24,\n",
    "'Northeast':34,\n",
    "'West': 40,\n",
    "'Southeast': 32,\n",
    "'Southwest':0,\n",
    "'Region':37,\n",
    "'Clinic':100},index=[0])\n",
    "\n",
    "PI_dataframe = pd.DataFrame({\n",
    "'Features': feature_names,\n",
    "'Importance': [83, 40, 90, 8, 24, 34, 40, 32, 0, 37, 100]})\n",
    "\n",
    "PI_dataframe_sorted = PI_dataframe.sort_values('Importance')\n",
    "PI_dataframe_sorted[\"Importance\"]  = PI_dataframe_sorted[\"Importance\"]/100\n",
    "plt.rcParams['figure.figsize'] = [8, 8]\n",
    "y_pos = np.arange(len(feature_names))\n",
    "plt.bar('Features', 'Importance', data =  PI_dataframe_sorted, align='center', alpha=0.5)\n",
    "plt.xticks(y_pos, **hfont)\n",
    "plt.yticks(fontsize=12)\n",
    "plt.xlabel('Features', **hfont, fontsize=16)\n",
    "plt.ylabel('Frequency predictor identified as significant', **hfont,fontsize=16)\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "GISP_init",
   "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.10.9 (main, Jan 11 2023, 09:18:18) [Clang 14.0.6 ]"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "37b4cc77837642ee25c4eb6578aebe03e17eb3bb59efdde49edbbc888dbc418f"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}