response_classification.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Document Classification with LDA and MLPs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from source_scraping import load_all, load_province\n",
    "from topic_modelling import *\n",
    "\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import accuracy_score, precision_score, recall_score\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.metrics import confusion_matrix\n",
    "from sklearn.metrics import roc_auc_score\n",
    "from sklearn.utils import shuffle\n",
    "from sklearn.svm import LinearSVC, SVC\n",
    "\n",
    "from xgboost import XGBClassifier\n",
    "from matplotlib import pyplot as plt\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "import tensorflow as tf\n",
    "from tensorflow import keras\n",
    "from tensorflow.keras.models import Sequential\n",
    "from tensorflow.keras.layers import Dense, Dropout, Activation, ActivityRegularization\n",
    "from tensorflow.keras.optimizers import SGD, Nadam, Adam, Adamax\n",
    "from tensorflow.keras.regularizers import l1, l2, l1_l2\n",
    "from tensorflow.keras.metrics import Precision, Recall, BinaryAccuracy, AUC\n",
    "\n",
    "import os\n",
    "import joblib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.read_csv('SCHEMA UPDATE - Collecting NPIs Effects - FULL.csv')\n",
    "pos_df = df.dropna(subset=['oxford_government_response_category', 'source_full_text'])\n",
    "categories = pd.unique([string[0] for string in pos_df['oxford_government_response_category']])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Convert Document into Topic Vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def lda_preprocess(texts, lda_model, lda_dict, stop_words=stopwords.words('english'), allowed_postags=['NOUN', 'ADJ', 'VERB']):\n",
    "    partially_processed = custom_preprocess(texts, stop_words=stop_words, allowed_postags=allowed_postags)\n",
    "    corpus = form_corpus(partially_processed, lda_dict)\n",
    "    texts_by_topic = [lda_model.get_document_topics(doc) for doc in corpus]\n",
    "    processed_texts = []\n",
    "    for topic_list in texts_by_topic:\n",
    "        feature_list = np.zeros(len(lda_model.get_topics()))\n",
    "        for index, value in topic_list:\n",
    "            feature_list[index] = value\n",
    "        processed_texts.append(feature_list)\n",
    "    return np.array(processed_texts)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Geographical Words to Consider Removing\n",
    "\n",
    "Could be improved; derivatives of words on list might not correctly be removed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def geo_stop_words(df):\n",
    "    flatten = lambda l: [item for sublist in l for item in sublist] # flatten code from stackoverflow...\n",
    "    region_stop_words = set(flatten([reg.lower().split() for reg in df['region'].dropna()]))\n",
    "    sub_region_stop_words = set(flatten([reg.lower().split() for reg in df['subregion'].dropna()]))\n",
    "    geo_stop_words = region_stop_words.union(sub_region_stop_words)\n",
    "    return geo_stop_words"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def text_to_cats(df):\n",
    "    text_to_cats = { }\n",
    "\n",
    "    for index, row in df.dropna(subset=['oxford_government_response_category', 'source_full_text']).iterrows():\n",
    "        ox_cat = row['oxford_government_response_category']\n",
    "        if ox_cat:\n",
    "            text = row['source_full_text']\n",
    "            if text in text_to_cats:\n",
    "                text_to_cats[text].append(ox_cat)\n",
    "            else:\n",
    "                text_to_cats[text] = [ox_cat]\n",
    "                \n",
    "    return text_to_cats\n",
    "\n",
    "def vector_to_cats(v):\n",
    "    return categories[np.nonzero(v)]\n",
    "\n",
    "def process_cats(cats):\n",
    "    vector_cats = lambda cat : (categories == cat[0]).astype(np.float32)\n",
    "    vector_arr_cats = lambda a : sum([vector_cats(cat) for cat in a])\n",
    "    vectorized = lambda y : [vector_arr_cats(arr) for arr in y]\n",
    "    cap = lambda arr : [el if el < 1 else 1 for el in arr]\n",
    "    \n",
    "    return np.array([cap(el) for el in vectorized(cats)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model accuracy on instances that fall into multiple categories"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def multi_class_accuracy(y_true, y_pred):\n",
    "    num_correct = 0\n",
    "    num_present = 0\n",
    "    for i in range(0, y_true.shape[0]):\n",
    "        v = y_true[i]\n",
    "        if np.count_nonzero(v) > 1:\n",
    "            num_present += 1\n",
    "            if (y_pred[i] == y_true[i]).all():\n",
    "                num_correct += 1\n",
    "                \n",
    "    return num_correct / num_present"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Split DataFrame into Train and Test Sets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Splits data with interventions (i.e. for multilabel classification)\n",
    "\n",
    "def split_npi_data(df, oot=True, multilabel=True):\n",
    "    df = df[df['region'] != 'Quebec']\n",
    "    subsets = ['source_full_text', 'start_date']\n",
    "    if multilabel:\n",
    "        subsets.append('oxford_government_response_category')\n",
    "    df['start_date'] = pd.to_datetime(df['start_date'], errors='coerce')\n",
    "    df = df.dropna(subset=subsets)\n",
    "    if oot:\n",
    "        df = df.sort_values(['start_date'])\n",
    "    else:\n",
    "        df = df.sample(frac=1)\n",
    "    \n",
    "    if multilabel:\n",
    "        x_raw = list(text_to_cats(df).keys())\n",
    "        y = list(text_to_cats(df).values())\n",
    "        y = process_cats(y)\n",
    "    else:\n",
    "        x_raw = df['source_full_text']\n",
    "        y = np.array(df['oxford_government_response_category'].notna().astype(np.float))\n",
    "    \n",
    "    return train_test_split(x_raw, y, shuffle=(not oot))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Keywords"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "keywords = ['hospital', 'healthcare', 'vaccine', 'trial', 'clinic', # H\n",
    "            'econom', 'reopen', '$', 'financ', 'financial crisis', 'economic crisis', # E\n",
    "            'social distanc', 'mask', 'isolation', 'quarantine'] # C\n",
    "\n",
    "def apply_keywords(texts, keywords):\n",
    "    transformed_features = []\n",
    "    for word in keywords:\n",
    "        lamb = lambda texts: np.array([[word in document.lower()] for document in texts])\n",
    "        transformed_features.append(lamb(texts))\n",
    "    return transformed_features"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Convert Texts to Input Matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def text_to_topics(texts_list, lda_info=None, n_topics=200, stopword_ext=[], keywords=[]):\n",
    "    if lda_info is None:\n",
    "        x_train_raw = texts_list[0]\n",
    "        lda_info = lda_from_list(x_train_raw, n_topic_range=range(n_topics, n_topics + 1), stopword_extensions=stopword_ext, use_coherence=False, plot=False)\n",
    "    \n",
    "    lda_model = lda_info['best_model']\n",
    "    id2word = lda_info['id2word']\n",
    "    \n",
    "    topic_features = []\n",
    "    keyword_features = []\n",
    "    total_features = []\n",
    "        \n",
    "    # texts_list is a list of lists of documents (list of list of strings)\n",
    "    for texts in texts_list:\n",
    "        topic_vals = lda_preprocess(texts, lda_model, id2word)\n",
    "        topic_features.append(topic_vals)\n",
    "        \n",
    "        if keywords:\n",
    "            keyword_vals = np.concatenate(apply_keywords(texts, keywords), axis=1).astype(np.float)\n",
    "            keyword_features.append(keyword_vals)\n",
    "\n",
    "            total_vals = np.concatenate((topic_vals, keyword_vals), axis=1)\n",
    "            total_features.append(total_vals)\n",
    "   \n",
    "    if not keywords:\n",
    "        total_features = topic_features\n",
    "    total_features.append(lda_info) # For later use\n",
    "    \n",
    "    return total_features"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Make Prediction on Unseen Texts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def predict(model, new_texts, lda_info, keywords_lambdas=[], stopword_ext=[]):\n",
    "    new_texts_processed, lda_info = text_to_topics([new_texts], lda_info, stopword_ext=stopword_ext, keyword_lambdas=keywords_lambdas)\n",
    "    return model.predict(new_texts_processed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model Fitting\n",
    "\n",
    "Essentially a wrapper for Keras' <code>model.fit()</code>, this function streamlines some of the setup, like TensorBoard and early stopping callbacks (pieces of code called at the end of each epoch)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fit_model(model, x_train, y_train, epochs=200, validation_split=None, validation_data=None, log=False, verbose=2, name=''):\n",
    "    import time\n",
    "\n",
    "    root_logdir = os.path.join(os.curdir, \"tb_logs\")\n",
    "    run_id = time.strftime(\"run_%Y_%m_%d-%H_%M_%S\")\n",
    "    run_logdir = os.path.join(root_logdir, run_id + name)\n",
    "    \n",
    "    tensobroad_cb = keras.callbacks.TensorBoard(run_logdir)\n",
    "    early_stop = keras.callbacks.EarlyStopping(patience=20, restore_best_weights=True)\n",
    "    callbacks = [early_stop, tensobroad_cb] if log else [early_stop]\n",
    "    \n",
    "    return model.fit(x_train, y_train, epochs=epochs, validation_split=validation_split, callbacks=callbacks, verbose=verbose, validation_data=validation_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "ann = Sequential([\n",
    "        Dense(200, name='dense_200', activation='relu'),\n",
    "        Dropout(0.5, name='first_dropout_0.5'),\n",
    "        Dense(80, name='dense_80', activation='relu'),\n",
    "        Dropout(0.5, name='second_dropout_0.5'),\n",
    "        Dense(10, name='dense_10', activation='relu'),\n",
    "        Dense(3, name='output_3', activation='sigmoid')\n",
    "    ])\n",
    "\n",
    "ann.compile(optimizer=Nadam(), loss='binary_crossentropy', metrics=[AUC(curve='roc'), BinaryAccuracy(), Precision(), Recall()])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "x_train_raw, x_test_raw, y_train, y_test = split_npi_data(df, oot=True)\n",
    "x_train, x_test, lda_info = text_to_topics((x_train_raw, x_test_raw), n_topics=150, keywords=[])\n",
    "x_train, x_train_raw, y_train = shuffle(x_train, x_train_raw, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "fit_model(ann, x_train, y_train, epochs=200, validation_split=0.2, log=False, name='_updated_final')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8/8 [==============================] - 0s 2ms/step - loss: 0.3545 - auc: 0.9130 - binary_accuracy: 0.8487 - precision: 0.7695 - recall: 0.7849\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[0.354482501745224,\n",
       " 0.9130213260650635,\n",
       " 0.8487282395362854,\n",
       " 0.76953125,\n",
       " 0.7848605513572693]"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ann.evaluate(x_test, y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.7429718875502008, 0.16363636363636364)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "threshold = 0.5\n",
    "y_pred = (ann.predict(x_test) > threshold).astype(np.float32)\n",
    "x, y = np.concatenate((x_train, x_test), axis=0), np.concatenate((y_train, y_test), axis=0)\n",
    "\n",
    "accuracy_score(y_test, y_pred), multi_class_accuracy(y, (ann.predict(x) > 0.5).astype(np.float32)) # :("
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Hyperparameter Tuning"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "from numpy.random import choice, random_sample\n",
    "\n",
    "def create_model(**kwargs):\n",
    "    \n",
    "    hidden_layers = kwargs['hidden_layers']\n",
    "    neurons = kwargs['neurons']\n",
    "    activation = kwargs['activation']\n",
    "    \n",
    "    optimizer = kwargs['optimizer']\n",
    "    optimizer.learning_rate = kwargs['learning_rate']\n",
    "    \n",
    "    dropout = kwargs['dropout']\n",
    "    \n",
    "    model = Sequential()\n",
    "    \n",
    "    for _ in range(hidden_layers):\n",
    "        model.add(Dense(neurons, activation=activation))\n",
    "        model.add(Dropout(dropout))\n",
    "    \n",
    "    # Output layer\n",
    "    model.add(Dense(3, activation='sigmoid'))\n",
    "    \n",
    "    model.compile(loss='binary_crossentropy', \n",
    "                  optimizer=optimizer, \n",
    "                  metrics=[BinaryAccuracy(), Precision(), Recall()])\n",
    "    \n",
    "    return model\n",
    "\n",
    "def random_param_search(x_train, x_val, y_train, y_val, iterations=10, top_n=10, **kwargs):\n",
    "    min_losses = np.repeat(np.inf, repeats=top_n)\n",
    "    best_models = []# Fill array with something\n",
    "    best_params = []\n",
    "    \n",
    "    for _ in range(iterations):\n",
    "        params = {}\n",
    "        for key, value in kwargs.items():\n",
    "            params[key] = random_sample() if value == 'uniform' else choice(value)\n",
    "        \n",
    "        model = create_model(**params)\n",
    "        \n",
    "        es = keras.callbacks.EarlyStopping(patience=10, restore_best_weights=True)\n",
    "        try:\n",
    "            # This occasionally produces a bizarre error: https://github.com/keras-team/keras/issues/2967\n",
    "            # NaNs slip into predictions when there are missing values (should not be the case here) or as a result of\n",
    "            # gradient explosion. \n",
    "            model.fit(x_train, y_train, validation_data=(x_val, y_val), epochs=200, callbacks=[es], verbose=0)\n",
    "            loss = model.evaluate(x_val, y_val, return_dict=True, verbose=False)['loss']\n",
    "        except:\n",
    "            print(\"Error caused by parameters\", params)\n",
    "            continue\n",
    "            \n",
    "        if loss < np.max(min_losses):\n",
    "            \n",
    "            ind = np.argmax(min_losses)\n",
    "            min_losses[ind] = loss\n",
    "            \n",
    "            if len(best_models) < top_n:\n",
    "                best_models.append(model)\n",
    "                best_params.append(params)\n",
    "            else:\n",
    "                best_models[ind] = model\n",
    "                best_params[ind] = params\n",
    "        \n",
    "    return best_models, best_params, min_losses"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "fit_model(rnd_search, x_train, y_train, validation_split=0.2, verbose=0)\n",
    "# y_pred = (rnd_search.predict_proba(x_test) > 0.5).astype(np.int)\n",
    "rnd_search.best_params_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# %%time\n",
    "# df_2019 = load_all(start_date=datetime(2019, 10, 1), end_date=datetime(2019, 11, 1), verbose=True)\n",
    "# df_2019.to_csv('2019_oct_releases.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_2019 = pd.read_csv('2019_oct_releases.csv')\n",
    "df_2019['start_date'] = pd.to_datetime(df_2019['start_date'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_2019 = df_2019[df_2019['start_date'] <= datetime(2020, 1, 1)]\n",
    "df_2019 = df_2019[df_2019['region'] != 'Quebec']\n",
    "full_df = df_2019.append(pos_df).sample(frac=1)\n",
    "x_train_raw, x_test_raw, y_train, y_test = split_npi_data(full_df, multilabel=False, oot=False)\n",
    "x_train, x_test, lda_info = text_to_topics((x_train_raw, x_test_raw), lda_info=lda_info, n_topics=150)\n",
    "x_train, y_train = shuffle(x_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RND_CLF\n",
      "Accuracy 0.8859060402684564\n",
      "Precision 0.9188405797101449\n",
      "Recall 0.8879551820728291\n",
      "\n",
      "\n",
      "LIN_SVC_CLF\n",
      "Accuracy 0.7869127516778524\n",
      "Precision 0.8362573099415205\n",
      "Recall 0.8011204481792717\n",
      "\n",
      "\n",
      "RBF_SVC_CLF\n",
      "Accuracy 0.8758389261744967\n",
      "Precision 0.9077809798270894\n",
      "Recall 0.8823529411764706\n",
      "\n",
      "\n",
      "KNN_CLF\n",
      "Accuracy 0.8154362416107382\n",
      "Precision 0.8559077809798271\n",
      "Recall 0.8319327731092437\n",
      "\n",
      "\n",
      "LOG_CLF\n",
      "Accuracy 0.7399328859060402\n",
      "Precision 0.7563451776649747\n",
      "Recall 0.834733893557423\n",
      "\n",
      "\n",
      "XGB_CLF\n",
      "Accuracy 0.87248322147651\n",
      "Precision 0.9048991354466859\n",
      "Recall 0.8795518207282913\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "models = {\n",
    "    'rnd_clf' : RandomForestClassifier(n_estimators=400, max_depth=80, warm_start=True),\n",
    "    'lin_svc_clf' : LinearSVC(),\n",
    "    'rbf_svc_clf' : SVC(kernel='rbf'),\n",
    "    'knn_clf' : KNeighborsClassifier(),\n",
    "    'log_clf' : LogisticRegression(),\n",
    "    'xgb_clf' : XGBClassifier()\n",
    "}\n",
    "\n",
    "metrics = {\n",
    "    'Accuracy' : accuracy_score,\n",
    "    'Precision' : precision_score,\n",
    "    'Recall' : recall_score\n",
    "#     'ROC AUC' : roc_auc_score\n",
    "}\n",
    "\n",
    "for name, model in models.items():\n",
    "    model.fit(x_train, y_train)\n",
    "    print(name.upper())\n",
    "    for metric, metric_func in metrics.items():\n",
    "        print(metric, metric_func(y_test, model.predict(x_test)))\n",
    "    print('\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYgAAAEWCAYAAAB8LwAVAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAgAElEQVR4nO3deZQV1bn+8e8TBFFBZWizcplVEBEUtQWVBImI4gSiN4rECMYhGoesmHijuYkKYjRxzg0JcJVoEgNOV0VFEUWiMSpDBCNtVESUJvwiCgiooMD7++MU7aG76D4M1aehn89aZ3XVrr3rvNXDeXvXrqqtiMDMzKyyrxQ7ADMzq5ucIMzMLJUThJmZpXKCMDOzVE4QZmaWygnCzMxSOUGYmVkqJwgzM0vlBGH1mqQFko7JWx8saZmkoySFpEmV6v9J0rXJcp+kzm8r1fmrpGEFvPfXJN0labGklZL+KWm4pN2S7SFp35R2wyStk7Qq7/WbLfsOmG2aE4RZQtJQYBRwIvBeUtxT0pHVNPsE+I6k9pv5Xs2Bl4BdgCMioinQD9gT2KeAXbwUEU3yXpdszvubFcIJwgyQ9D3gFuC4iPhb3qZfAddX03Q5cDdwzWa+5eXASuCsiFgAEBELI+IHEfHaZu7LLBNOEGZwETAC6BsRMytt+y3QKf80VIrrgdMk7bcZ73kM8H8RsX7zQjWrPU4QZrlTOy8D/0jZ9hm5BDByU40j4v8Bo8klmUK1ABZvRv3KDpe0PO91+FbsyyyVE4RZrgfRCbhTklK23wl8VdLJ1ezjl8Bxkg4q8D0/Ar62eWFu5OWI2DPv9fJW7MsslROEGfwb6At8g9wppY1ExOfAcOA6IC2BEBEfAbcndQrxDDBIkv8Grc7yL6cZEBH/Ipck+ku6LaXKH4HGQP9qdnMrcCSwfwFveSuwO3CPpHYAklpJulXSgXn1GklqnPdqUMjxmG0LThBmiYh4Hzga+E/ghkrb1gFXA82rab+C3FVPm6yTV3cpuWTyBfCKpJXAs8DHwLy8qnPJjYNseJ1T+BGZbR15RjkzM0vjHoSZmaVygjDLiKTRlR6HseE1utixmRXCp5jMzCzVTsUOYFtp2bJltG/fvthhmJltV2bNmvVhRJSkbdthEkT79u2ZObPyUxLMzKw6kt7b1DaPQZiZWSonCDMzS+UEYWZmqZwgzMwslROEmZmlyixBSBon6QNJr29iuyT9WtI8Sa9JOiRv21BJbyevoVnFaGZmm5ZlD+Juqn/y5fFAx+R1AfA7qJir9xqgJ9ADuEZSswzjNDOzFJkliIh4HlhaTZWBwB8i52VgT0lfA44DpkTE0ohYBkyh+kSz1YY/Npfhj83N8i3MzLY7xbxRrhWwMG+9PCnbVHkVki4g1/ugbdu2WxxI2b9WbHFbM7Md1XY9SB0RYyOiNCJKS0pS7xQ3M7MtVMwEsQhok7feOinbVLmZmdWiYiaIicDZydVMhwMfR8RiYDJwrKRmyeD0sUmZmZnVoszGICSNB/oALSWVk7syqSFARIwGJgEnkJte8VOSqRQjYqmk64AZya5GJNMzmplZLcosQUTEmTVsD+DiTWwbB4zLIi4zMyvMdj1IbWZm2XGCMDOzVE4QZmaWygnCzMxSOUGYmVkqJwgzM0vlBGFmZqmcIMzMLJUThJmZpXKCMDOzVE4QZmaWygnCzMxSOUGYmVkqJwgzM0vlBGFmZqmcIMzMLFWmCUJSf0lvSpon6cqU7e0kPSvpNUnTJLXO27ZO0uzkNTHLOM3MrKospxxtAIwC+gHlwAxJEyOiLK/azcAfIuIeSUcDNwDfSbZ9FhHds4rPzMyql2UPogcwLyLmR8TnwARgYKU6XYCpyfJzKdvNzKxIskwQrYCFeevlSVm+OcCpyfIgoKmkFsl6Y0kzJb0s6ZS0N5B0QVJn5pIlS7Zl7GZm9V6xB6l/DBwl6VXgKGARsC7Z1i4iSoEhwO2S9qncOCLGRkRpRJSWlJTUWtBmZvVBZmMQ5D7s2+Stt07KKkTEv0h6EJKaAKdFxPJk26Lk63xJ04CDgXeyCrZs8QrOGPNSVrs3SzWweyuG9Gxb7DDMUmXZg5gBdJTUQVIjYDCw0dVIklpK2hDDVcC4pLyZpJ031AF6AfmD29vUwO6t6PK13bPavVmqssUreHT2opormhVJZj2IiFgr6RJgMtAAGBcRcyWNAGZGxESgD3CDpACeBy5Omu8PjJG0nlwSu7HS1U/b1JCebf1fnNU691itrsvyFBMRMQmYVKns6rzlB4EHU9r9DeiWZWxmZla9Yg9Sm5lZHeUEYWZmqZwgzMwslROEmZmlcoIwM7NUThBmZpYq08tczax69e0Oft85vn1xgjArkoHdKz+7csdWtngFgBPEdsQJwqxI6tsd/PWpp7Sj8BiEmZmlcoIwM7NUThBmZpbKCcLMzFI5QZiZWSonCDMzS5VpgpDUX9KbkuZJujJleztJz0p6TdI0Sa3ztg2V9HbyGpplnGZmVlVmCUJSA2AUcDzQBThTUpdK1W4G/hARBwIjgBuSts2Ba4CeQA/gGknNsorVzMyqyrIH0QOYFxHzI+JzYAIwsFKdLsDUZPm5vO3HAVMiYmlELAOmAP0zjNXMzCrJMkG0AhbmrZcnZfnmAKcmy4OAppJaFNjWzMwyVOxB6h8DR0l6FTgKWASsK7SxpAskzZQ0c8mSJVnFaGZWL2WZIBYBbfLWWydlFSLiXxFxakQcDPx3Ura8kLZJ3bERURoRpSUlJds6fjOzei3LBDED6Cipg6RGwGBgYn4FSS0lbYjhKmBcsjwZOFZSs2Rw+tikzMzMaklmCSIi1gKXkPtgfwO4PyLmShohaUBSrQ/wpqS3gK8C1ydtlwLXkUsyM4ARSZmZmdWSTB/3HRGTgEmVyq7OW34QeHATbcfxZY/CzMxqWbEHqc3MrI5ygjAzs1ROEGZmlsoJwszMUjlBmJlZKicIMzNL5QRhZmapnCDMzCyVE4SZmaVygjAzs1ROEGZmlsoJwszMUjlBmJlZKicIMzNL5QRhZmapMp0PwswsX9niFZwx5qVihwHAwO6tGNKzbbHDqNMy7UFI6i/pTUnzJF2Zsr2tpOckvSrpNUknJOXtJX0maXbyGp1lnGaWvYHdW9Hla7sXOwwgl6genV1lmnurJLMehKQGwCigH1AOzJA0MSLK8qr9jNxUpL+T1IXc7HPtk23vRET3rOIzs9o1pGfbOvMfe13pxdR1WfYgegDzImJ+RHwOTAAGVqoTwIZ/KfYA/pVhPGZmthmyTBCtgIV56+VJWb5rgbMklZPrPVyat61DcurpL5K+kfYGki6QNFPSzCVLlmzD0M3MrNhXMZ0J3B0RrYETgD9K+gqwGGgbEQcDlwN/llTl5GVEjI2I0ogoLSkpqdXAzcx2dFkmiEVAm7z11klZvnOB+wEi4iWgMdAyItZExEdJ+SzgHaBThrGamVklWSaIGUBHSR0kNQIGAxMr1Xkf6AsgaX9yCWKJpJJkkBtJewMdgfkZxmpmZpVkdhVTRKyVdAkwGWgAjIuIuZJGADMjYiLwI+B/Jf2Q3ID1sIgISb2BEZK+ANYDF0bE0qxiNTOzqjK9US4iJpEbfM4vuzpvuQzoldLuIeChLGMzM7PqFZQgJPUid8VRu6SNgIiIvbMLzczMiqnQHsRdwA+BWcC67MIxM7O6otAE8XFEPJlpJGZmVqcUmiCek3QT8H/Amg2FEfH3TKIyM7OiKzRB9Ey+luaVBXD0tg3HzMzqioISRER8M+tAzMysbinoRjlJe0i6dcNzjyTdImmPrIMzM7PiKfRO6nHASuD05LUC+H1WQZmZWfEVOgaxT0Sclrc+XNLsLAIyM7O6odAexGeSvr5hJblx7rNsQjIzs7qg0B7ERcA9ybiDgKXAsKyCMjOz4iv0KqbZwEEb5mSIiBWZRmVmZkVXbYKQdFZE/EnS5ZXKAYiIWzOMzczMiqimHsRuydemWQdiZmZ1S7UJIiLGJF+H1044ZmZWVxR6o9yvJO0uqaGkZyUtkXRW1sGZmVnxFHqZ67HJwPRJwAJgX+CKmhpJ6i/pTUnzJF2Zsr2tpOckvSrpNUkn5G27Kmn3pqTjCozTzMy2kUITxIZTUScCD0TExzU1SOaUHgUcD3QBzpTUpVK1nwH3R8TB5Oas/m3StkuyfgDQH/jthjmqzcysdhSaIB6X9E/gUOBZSSXA6hra9ADmRcT8iPgcmAAMrFQngN2T5T2AfyXLA4EJEbEmIt4F5iX7MzOzWlJQgoiIK4EjgdKI+AL4hKof9pW1AhbmrZcnZfmuBc6SVE5u7upLN6Mtki7Y8ADBJUuWFHIoZmZWoJrugzg6IqZKOjWvLL/K/23l+58J3B0Rt0g6AvijpK6FNo6IscBYgNLS0tjKWMysHilbvIIzxrxU7DA2MrB7K4b0bFvsMCrUdB/EUcBU4OSUbUH1CWIR0CZvvXVSlu9ccmMMRMRLkhoDLQtsa2a2RQZ2r3JCoujKFuceULHdJIiIuCb5es4W7HsG0FFSB3If7oOBIZXqvA/0Be6WtD/QGFgCTAT+LOlW4D+AjsD0LYjBzKyKIT3b1qkPYqDO9Wag8PsgfiFpz7z1ZpJGVtcmItYClwCTgTfIXa00V9IISQOSaj8Czpc0BxgPDIucucD9QBnwFHBxRKzb3IMzM7MtV+jTXI+PiJ9uWImIZck9Cz+rrlFETCI3+JxfdnXechnQaxNtrweuLzA+MzPbxgq9zLWBpJ03rEjaBdi5mvpmZradK7QHcS+5+x82TDN6DnBPNiGZmVldUOh8EL9MxgmOSYqui4jJ2YVlZmbFVmgPAnIDzWsj4hlJu0pqGhErswrMzMyKq9CrmM4HHgTGJEWtgEeyCsrMzIqv0EHqi8ldbbQCICLeBvbKKigzMyu+QhPEmuSBewBI2oncndRmZraDKjRB/EXST4FdJPUDHgAeyy4sMzMrtkITxE/IPQLjH8D3yN38Vu1NcmZmtn2r8SqmZKKeuRHRGfjf7EMyM7O6oMYeRPIMpDcl1a0nW5mZWaYKvQ+iGTBX0nRykwUBEBEDNt3EzMy2Z4UmiJ9nGoWZmdU5Nc0o1xi4ENiX3AD1XcljvM3MbAdX0xjEPUApueRwPHBL5hGZmVmdUNMppi4R0Q1A0l1s5qxukvoDdwANgDsj4sZK228Dvpms7grsFRF7JtvWkUtMAO97vMPMrHbVlCC+2LAQEWslFbzj5PLYUUA/oByYIWliMknQhn3+MK/+pcDBebv4LCK6F/yGZma2TdWUIA6StCJZFrk7qVckyxERu1fTtgcwLyLmA0iaAAwkN41omjOBawqO3MzMMlXtGERENIiI3ZNX04jYKW+5uuQAuSe+LsxbL0/KqpDUDugATM0rbixppqSXJZ2yiXYXJHVmLlmypIZwzMxscxT6qI2sDQYeTG7K26BdRJQCQ4DbJe1TuVFEjI2I0ogoLSkpqa1YzczqhSwTxCKgTd5666QszWBgfH5BRCxKvs4HprHx+ISZmWUsywQxA+goqYOkRuSSwMTKlSR1Jnen9kt5Zc0k7ZwstyQ3F8Wmxi7MzCwDmzPl6GZJrnq6BJhM7jLXcRExV9IIYGZEbEgWg4EJEZE/v8T+wBhJ68klsRvzr34yM7PsZZYgACJiErlHg+eXXV1p/dqUdn8DumUZm5mZVa+uDFKbmVkd4wRhZmapnCDMzCyVE4SZmaVygjAzs1ROEGZmlsoJwszMUjlBmJlZKicIMzNL5QRhZmapnCDMzCyVE4SZmaVygjAzs1ROEGZmlsoJwszMUmU6H4SZmRWubPEKzhjzUs0VgYHdWzGkZ9tM48m0ByGpv6Q3Jc2TdGXK9tskzU5eb0lanrdtqKS3k9fQLOM0Myu2gd1b0eVruxdUt2zxCh6dvSjjiDLsQUhqAIwC+gHlwAxJE/OnDo2IH+bVvxQ4OFluDlwDlAIBzEraLssqXjOzYhrSs23BPYJCexlbK8seRA9gXkTMj4jPgQnAwGrqnwmMT5aPA6ZExNIkKUwB+mcYq5mZVZJlgmgFLMxbL0/KqpDUDugATN2ctpIukDRT0swlS5Zsk6DNzCynrlzFNBh4MCLWbU6jiBgbEaURUVpSUpJRaGZm9VOWCWIR0CZvvXVSlmYwX55e2ty2ZmaWgSwTxAygo6QOkhqRSwITK1eS1BloBuSPukwGjpXUTFIz4NikzMzMaklmVzFFxFpJl5D7YG8AjIuIuZJGADMjYkOyGAxMiIjIa7tU0nXkkgzAiIhYmlWsZmZWVaY3ykXEJGBSpbKrK61fu4m244BxmQVnZmbVqiuD1GZmVsc4QZiZWSonCDMzS+UEYWZmqZwgzMwslROEmZmlcoIwM7NUThBmZpbKCcLMzFI5QZiZWSonCDMzS+UEYWZmqZwgzMwslROEmZmlcoIwM7NUThBmZpYq0wQhqb+kNyXNk3TlJuqcLqlM0lxJf84rXydpdvKqMlWpmZllK7MZ5SQ1AEYB/YByYIakiRFRllenI3AV0CsilknaK28Xn0VE96ziMzOz6mXZg+gBzIuI+RHxOTABGFipzvnAqIhYBhARH2QYj5mZbYYsE0QrYGHeenlSlq8T0EnSi5JeltQ/b1tjSTOT8lPS3kDSBUmdmUuWLNm20ZuZ1XOZnWLajPfvCPQBWgPPS+oWEcuBdhGxSNLewFRJ/4iId/IbR8RYYCxAaWlp1G7oZmY7tix7EIuANnnrrZOyfOXAxIj4IiLeBd4ilzCIiEXJ1/nANODgDGM1M7NKskwQM4COkjpIagQMBipfjfQIud4DklqSO+U0X1IzSTvnlfcCyjAzs1qT2SmmiFgr6RJgMtAAGBcRcyWNAGZGxMRk27GSyoB1wBUR8ZGkI4ExktaTS2I35l/9ZGZm2ct0DCIiJgGTKpVdnbccwOXJK7/O34BuWcZmZmbV853UZmaWygnCzMxSOUGYmVkqJwgzM0vlBGFmZqmcIMzMLFWxH7WRqS+++ILy8nJWr15d7FDM6pTGjRvTunVrGjZsWOxQrA7boRNEeXk5TZs2pX379kgqdjhmdUJE8NFHH1FeXk6HDh2KHY7VYTv0KabVq1fTokULJwezPJJo0aKFe9ZWox06QQBODmYp/HdhhdjhE4SZmW0ZJ4iMNWnSpGJ50qRJdOrUiffee49rr72WXXfdlQ8++CC17qaccMIJLF++vNo6ffr0YebMmVXK7777bi655JLNiL5wN998M507d6Z79+4cdthh/OEPf6g2li0xc+ZMLrvsMgDWrFnDMcccQ/fu3bnvvvs477zzKCvbuuc53n777RVxA6xdu5aSkhKuvHLj6dT79OnDfvvtx0EHHUSvXr148803t+p9Ae655x46duxIx44dueeee1LrzJkzhyOOOIJu3bpx8skns2LFioptN9xwA/vuuy/77bcfkydPBuDzzz+nd+/erF27dqvjs/rJCaKWPPvss1x22WU8+eSTtGvXDoCWLVtyyy23bNZ+Jk2axJ577plFiNWKCNavX5+6bfTo0UyZMoXp06cze/Zsnn32WXLPYdy2SktL+fWvfw3Aq6++CsDs2bM544wzuPPOO+nSpUvB+1q3bt1G62vXrmXcuHEMGTKkomzKlCl06tSJBx54oMrx3HvvvcyZM4ehQ4dyxRVXbOkhAbB06VKGDx/OK6+8wvTp0xk+fDjLli2rUu+8887jxhtv5B//+AeDBg3ipptuAqCsrIwJEyYwd+5cnnrqKb7//e+zbt06GjVqRN++fbnvvvu2Kj6rv+pNghj+2FzOGPPSNn0Nf2xuQe/9/PPPc/755/P444+zzz77VJR/97vf5b777mPp0qVV2vzpT3+iR48edO/ene9973sVH2jt27fnww8/BOC6665jv/324+tf/zpnnnkmN998c0X7Bx54gB49etCpUydeeOGFivKFCxfSp08fOnbsyPDhwyvKb731Vrp27UrXrl25/fbbAViwYAH77bcfZ599Nl27dmXhwoUMGzaMrl270q1bN2677TYAfvGLX/C73/2O3XffHYDdd9+doUOHVjmmiy66iNLSUg444ACuueaaivIrr7ySLl26cOCBB/LjH/+4Iv6uXbty0EEH0bt3bwCmTZvGSSedxAcffMBZZ53FjBkz6N69O++8885GPZWnn36aI444gkMOOYRvfetbrFq1quJ795Of/IRDDjmEBx54YKPYpk6dyiGHHMJOO315Yd/48eP5wQ9+QNu2bXnppZfSfrT07t2befPmpW4r1OTJk+nXrx/NmzenWbNm9OvXj6eeeqpKvbfeeqvie9GvXz8eeughAB599FEGDx7MzjvvTIcOHdh3332ZPn06AKeccgr33nvvVsVn9dcOfZlrXbBmzRpOOeUUpk2bRufOnTfa1qRJE7773e9yxx13bPRh/cYbb3Dffffx4osv0rBhQ77//e9z7733cvbZZ1fUmTFjBg899BBz5szhiy++4JBDDuHQQw+t2L527VqmT5/OpEmTGD58OM888wwA06dP5/XXX2fXXXflsMMO48QTT0QSv//973nllVeICHr27MlRRx1Fs2bNePvtt7nnnns4/PDDmTVrFosWLeL1118HYPny5axYsYKVK1ey99571/i9uP7662nevDnr1q2jb9++vPbaa7Rq1YqHH36Yf/7zn0iqOH02YsQIJk+eTKtWraqcUttrr7248847ufnmm3n88cc32vbhhx8ycuRInnnmGXbbbTd++ctfcuutt3L11bmnzLdo0YK///3vVWJ78cUXN/r+rV69mmeeeYYxY8awfPlyxo8fz5FHHlml3WOPPUa3blWfTH/TTTelfjD37t27ohe0waJFi2jT5svJF1u3bs2iRZUnX4QDDjiARx99lFNOOYUHHniAhQsXVrQ//PDDU9t37dqVGTNmVNmXWSEyTRCS+gN3kJsw6M6IuDGlzunAtUAAcyJiSFI+FPhZUm1kRKSfmC3QNScfsDXNt1jDhg058sgjueuuu7jjjjuqbL/sssvo3r17xX/OkDsdNWvWLA477DAAPvvsM/baa6+N2r344osMHDiQxo0b07hxY04++eSNtp966qkAHHrooSxYsKCivF+/frRo0aKizl//+lckMWjQIHbbbbeK8hdeeIEBAwbQrl27ig+fvffem/nz53PppZdy4okncuyxx1b8d16I+++/n7Fjx7J27VoWL15MWVkZXbp0oXHjxpx77rmcdNJJnHTSSQD06tWLYcOGcfrpp1ccSyFefvllysrK6NWrF5A7D3/EEUdUbD/jjDNS2y1evJj999+/Yv3xxx/nm9/8JrvssgunnXYa1113HbfffjsNGjQA4Nvf/ja77LIL7du353/+53+q7O+KK67Y6lNPlY0bN47LLruM6667jgEDBtCoUaMa2zRo0IBGjRqxcuVKmjZtuk3jsR1fZglCUgNgFNCP3NzTMyRNzJ8ZTlJH4CqgV0Qsk7RXUt4cuAYoJZc4ZiVtq56YreO+8pWvcP/999O3b19+8Ytf8NOf/nSj7XvuuSdDhgxh1KhRFWURwdChQ7nhhhu2+H133nlnIPcBkT9IWfnyxpoud9yQNACaNWvGnDlzmDx5MqNHj+b+++9n3LhxNGnShPnz51fbi3j33Xe5+eabmTFjBs2aNWPYsGGsXr2anXbaienTp/Pss8/y4IMP8pvf/IapU6cyevRoXnnlFZ544gkOPfRQZs2aVdBxRwT9+vVj/PjxNR5Pvl122WWj+wLGjx/PX//6V9q3bw/ARx99xNSpU+nXrx+QG4MoLS3dZByb04No1aoV06ZNq1gvLy+nT58+Vdp27tyZp59+GsidbnriiScq2m/oTWxo36pVq4r1NWvW0Lhx403GarYpWY5B9ADmRcT8iPgcmAAMrFTnfGDUhg/+iNhwSc9xwJSIWJpsmwL0zzDWTO2666488cQT3Hvvvdx1111Vtl9++eWMGTOm4oO8b9++PPjggxVXOC1dupT33ntvoza9evXiscceY/Xq1axatarKqZZNmTJlCkuXLuWzzz7jkUceoVevXnzjG9/gkUce4dNPP+WTTz7h4Ycf5hvf+EaVth9++CHr16/ntNNOY+TIkRWnaq666iouvvjiiqtqVq1atdHVQAArVqxgt912Y4899uDf//43Tz75ZEXdjz/+mBNOOIHbbruNOXPmAPDOO+/Qs2dPRowYQUlJyUYfgNU5/PDDefHFFyvGBT755BPeeuutGtvtv//+FW1WrFjBCy+8wPvvv8+CBQtYsGABo0aN2mTSSXPFFVcwe/bsKq/KyQHguOOO4+mnn2bZsmUsW7aMp59+muOOO65KvQ2/D+vXr2fkyJFceOGFAAwYMIAJEyawZs0a3n33Xd5++2169OgB5BJby5Yt/UgN2yJZnmJqBeT/VZcDPSvV6QQg6UVyp6GujYinNtG2VaW2SLoAuACgbdu22yzwLDRv3pynnnqK3r17U1JSstG2li1bMmjQoIpB3y5dujBy5EiOPfZY1q9fT8OGDRk1alTF1U8Ahx12GAMGDODAAw/kq1/9Kt26dWOPPfaoMY4ePXpw2mmnUV5ezllnnVXxX/CwYcMqPlTOO+88Dj744I1OTUHuXPc555xTcTXThh7ORRddxKpVqzjssMNo2LAhDRs25Ec/+tFGbQ866CAOPvhgOnfuTJs2bSpOAa1cuZKBAweyevVqIoJbb70VyH3Avv3220QEffv25aCDDuIvf/lLjcdXUlLC3XffzZlnnsmaNWsAGDlyJJ06daq23fHHH893vvMdAB5++GGOPvroil4YwMCBA/mv//qvin1uS82bN+fnP/95xSnFq6++mubNmwO5n8WFF15IaWkp48ePr+hpnnrqqZxzzjlAbmzi9NNPp0uXLuy0006MGjWq4lTYc889x4knnrjNY7biK1u8gjPG5C6e6PIfu2dyGl1ZXI4IIOk/gf4RcV6y/h2gZ0RcklfnceAL4HSgNfA8ubmozwMaR8TIpN7Pgc8i4mY2obS0NCpfb//GG29sdF55R7Nq1SqaNGnCp59+Su/evRk7diyHHHJIscPabg0aNIhf/epXdOzYsdihbDOnnnoqN954Y2qC3AK81icAAAacSURBVNH/PnZkf37lfR6d/eWFDFuTICTNiojU86VZ9iAWAW3y1lsnZfnKgVci4gvgXUlvAR2Ten0qtZ2WWaTbqQsuuICysjJWr17N0KFDnRy20o033sjixYt3mATx+eefc8opp9TYe7Ltz5CebRnSM/uzJln2IHYC3gL6kvvAnwEMiYi5eXX6A2dGxFBJLYFXge4kA9PAhk+8vwOHRkTVGwYS9bEHYbY1/PdhUKQeRESslXQJMJnc+MK4iJgraQQwMyImJtuOlVQGrAOuiIiPkqCvI5dUAEZUlxxqiMMPJjOrJKt/DG3HklkPoral9SDeffddmjZt6kd+m+XZMB/EypUrPR+EFW0Mouhat25NeXk5S5YsKXYoZnXKhhnlzKqzQyeIhg0b+j8kM7MtVG8e1mdmZpvHCcLMzFI5QZiZWaod5iomSUuA92qsuGktgQ+3UTjbi/p2zPXteMHHXF9szTG3i4iStA07TILYWpJmbupSrx1VfTvm+na84GOuL7I6Zp9iMjOzVE4QZmaWygniS2OLHUAR1Ldjrm/HCz7m+iKTY/YYhJmZpXIPwszMUjlBmJlZqnqVICT1l/SmpHmSrkzZvrOk+5Ltr0hqX/tRblsFHPPlksokvSbpWUnt0vazPanpmPPqnSYpJG33l0QWcsySTk9+1nMl/bm2Y9zWCvjdbivpOUmvJr/fJxQjzm1F0jhJH0h6fRPbJenXyffjNUlbP4NYRNSLF7k5Kd4B9gYaAXOALpXqfB8YnSwPBu4rdty1cMzfBHZNli+qD8ec1GtKborbl4HSYsddCz/njuQm5GqWrO9V7Lhr4ZjHAhcly12ABcWOeyuPuTe5SdRe38T2E4AnAQGHk5utc6vesz71IHoA8yJifkR8DkwABlaqMxC4J1l+EOir7XsiiRqPOSKei4hPk9WXyU3vuj0r5OcMcB3wS2B1bQaXkUKO+XxgVEQsA4iID2o5xm2tkGMOYPdkeQ/gX7UY3zYXEc8D1U2cNhD4Q+S8DOwp6Wtb8571KUG0AhbmrZcnZal1ImIt8DHQolaiy0Yhx5zvXHL/gWzPajzmpOvdJiKeqM3AMlTIz7kT0EnSi5JeTqb73Z4VcszXAmdJKgcmAZfWTmhFs7l/7zXaoeeDsMJJOgsoBY4qdixZkvQV4FZgWJFDqW07kTvN1IdcL/F5Sd0iYnlRo8rWmcDdEXGLpCOAP0rqGhHrix3Y9qI+9SAWAW3y1lsnZal1JO1Erlv6Ua1El41CjhlJxwD/DQyIiDW1FFtWajrmpkBXYJqkBeTO1U7czgeqC/k5lwMTI+KLiHgXeItcwtheFXLM5wL3A0TES0Bjcg+121EV9Pe+OepTgpgBdJTUQVIjcoPQEyvVmQgMTZb/E5gayejPdqrGY5Z0MDCGXHLY3s9LQw3HHBEfR0TLiGgfEe3JjbsMiIiZ6bvbLhTyu/0Iud4DklqSO+U0vzaD3MYKOeb3gb4AkvYnlyB25PmHJwJnJ1czHQ58HBGLt2aH9eYUU0SslXQJMJncFRDjImKupBHAzIiYCNxFrhs6j9xg0ODiRbz1Cjzmm4AmwAPJePz7ETGgaEFvpQKPeYdS4DFPBo6VVAasA66IiO22d1zgMf8I+F9JPyQ3YD1se/6HT9J4ckm+ZTKucg3QECAiRpMbZzkBmAd8Cpyz1e+5HX+/zMwsQ/XpFJOZmW0GJwgzM0vlBGFmZqmcIMzMLJUThJmZpXKCMNsMktZJmi3pdUmPSdpzG+9/QXKfApJWbct9m20uJwizzfNZRHSPiK7k7pW5uNgBmWXFCcJsy71E8jA0SftIekrSLEkvSOqclH9V0sOS5iSvI5PyR5K6cyVdUMRjMNukenMntdm2JKkBucc43JUUjQUujIi3JfUEfgscDfwa+EtEDEraNEnqfzcilkraBZgh6aHt+c5m2zE5QZhtnl0kzSbXc3gDmCKpCXAkXz6uBGDn5OvRwNkAEbGO3CPkAS6TNChZbkPuwXlOEFanOEGYbZ7PIqK7pF3JPQfoYuBuYHlEdC9kB5L6AMcAR0TEp5KmkXuQnFmd4jEIsy2QzMJ3GbkHwn0KvCvpW1AxN/BBSdVnyU3liqQGkvYg9xj5ZUly6EzukeNmdY4ThNkWiohXgdfITUzzbeBcSXOAuXw5/eUPgG9K+gcwi9zcyE8BO0l6A7iR3CPHzeocP83VzMxSuQdhZmapnCDMzCyVE4SZmaVygjAzs1ROEGZmlsoJwszMUjlBmJlZqv8PPj7zdME/+toAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.metrics import plot_precision_recall_curve\n",
    "\n",
    "for name, model in models.items():\n",
    "    disp = plot_precision_recall_curve(model, x_test, y_test)\n",
    "    disp.ax_.set_title(name.upper())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['models/binary_rnd_clf']"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rnd_clf = models['rnd_clf']\n",
    "lda = lda_info['best_model']\n",
    "\n",
    "joblib.dump(rnd_clf, 'models/binary_rnd_clf')\n",
    "\n",
    "ann.save('models/multilabel_ann')\n",
    "lda.save('models/lda')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.8.2 64-bit",
   "language": "python",
   "name": "python38264bitb7deb3926a5743b595e3b44ad861ac00"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}