ingredients_recommendation.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Cooking ingredients recommendation\n",
    "This notebook builds a recommendation system for cooking ingredients using. The end goal is to build a recommendation system that takes as input a list of existing ingredients and outputs a collection of ingredients that would go well with the existing ingredients. \n",
    "\n",
    "<b> Notebook contents </b>\n",
    "0. load and clean data  \n",
    "1. Preliminary analysis\n",
    "2. Non-negative matrix factorizations\n",
    "3. Word-embeddings\n",
    "4. Association rule mining  \n",
    "5. Comparison of models\n",
    "6. Future directions / To Do \n",
    "\n",
    "***NOTE:*** *This is project is in progress.*\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "sys.path.append('/usr/local/lib/python3.7/site-packages')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# conda environment \"recipes\"\n",
    "# Python standard libraries\n",
    "import ast \n",
    "import csv\n",
    "import os\n",
    "import pickle\n",
    "import random\n",
    "import re\n",
    "import statistics\n",
    "import time\n",
    "from collections import Counter \n",
    "from itertools import combinations\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import functions as fn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "SBNyXAdi--WO",
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "# Third party imports \n",
    "import gensim\n",
    "import h5py\n",
    "import ijson\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from efficient_apriori import apriori\n",
    "from gensim.models import Word2Vec\n",
    "from gensim.models.nmf import Nmf\n",
    "from gensim.corpora import Dictionary\n",
    "from matplotlib import style\n",
    "plt.style.use('ggplot')\n",
    "from sklearn.decomposition import NMF, PCA\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow.keras.callbacks import ModelCheckpoint, EarlyStopping\n",
    "from tensorflow.keras.preprocessing.text import Tokenizer\n",
    "from tensorflow.keras.preprocessing.sequence import pad_sequences\n",
    "from tensorflow.keras import Sequential\n",
    "from tensorflow.keras.layers import Embedding, Lambda, Dense\n",
    "import tensorflow.keras.backend as K"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow import keras"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sample_ingredients(ing, n_samples):  \n",
    "    # For each recipe, sample \"n_samples\" number of ingredients randomly.\n",
    "    # (If a recipe involves fewer than \"n_samples\" ingredients, ignore that recipe)\n",
    "    # The sampled ingredients will function as the existing ingredients\n",
    "    # Goal of the model is to predict the remaining ingredients that\n",
    "    # have not been sampled\n",
    "    \n",
    "    \"\"\"\n",
    "    --- input ---\n",
    "    ing: (list of lists) Each item of ing is a list of ingredients \n",
    "           for a particular recipe\n",
    "    n_samples: (int) number of ingredients to be sampled\n",
    "   \n",
    "    --- output ---\n",
    "    existing_ing: (list of lists) Each item of sampled_ing is a list of \n",
    "            ingredients that have been sampled\n",
    "    missing_ing: (list of lists) Each item of remaining_ing is a list of ingredients\n",
    "            that have not been sampled\n",
    "    \"\"\"\n",
    "    \n",
    "    existing_ing = []\n",
    "    missing_ing = []\n",
    "    indices = []\n",
    "    for idx, recipe in enumerate(ing):\n",
    "        if len(recipe) > n_samples:\n",
    "            # randomly select 5 ingredients\n",
    "            sampled = random.sample(recipe, n_samples)\n",
    "            remain = list(set(recipe)-set(sampled))\n",
    "\n",
    "            existing_ing.append(sampled)\n",
    "            missing_ing.append(remain)\n",
    "            indices.append(idx)\n",
    "    return existing_ing, missing_ing, indices\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_scores(predicted_ing, true_ing):\n",
    "    \"\"\"\n",
    "    predicted_ing: (list) of predicted ingredients from the model\n",
    "    true_ing: (list) of true ingredients that needed to be predicted\n",
    "    \"\"\"\n",
    "    \n",
    "    predicted_ing = set(predicted_ing)\n",
    "    true_ing = set(true_ing)\n",
    "\n",
    "    TP = len(predicted_ing.intersection(true_ing))\n",
    "\n",
    "    if len(predicted_ing) != 0:\n",
    "        precision = TP / (len(predicted_ing))\n",
    "    else:\n",
    "        precision = 0 \n",
    "    recall = TP / len(true_ing)\n",
    "    \n",
    "    if recall != 0 and precision != 0:\n",
    "        F_score = (2 * recall * precision)/(precision + recall)\n",
    "    else:\n",
    "        F_score = 0\n",
    "    \n",
    "    return precision, recall, F_score\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "precision:  0.3333333333333333\n",
      "recall:  1.0\n",
      "F_score:  0.5\n"
     ]
    }
   ],
   "source": [
    "# example \n",
    "precision, recall, F_score = compute_scores(['onions', 'scallions', 'bread'],\n",
    "                                           ['scallions'])\n",
    "\n",
    "print('precision: ' , precision)\n",
    "print('recall: ', recall)\n",
    "print('F_score: ', F_score)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Multi-label classification via neural networks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# load data\n",
    "df = pd.read_csv('data/ingredient_recommendation/data.csv')\n",
    "cuisine = list(np.unique(df.cuisine))\n",
    "\n",
    "# Convert to correct format (list of lists)\n",
    "documents = [ast.literal_eval(df.document[idx]) for idx in range(df.shape[0])]\n",
    "\n",
    "# randomly shuffle the order of ingredients in each document\n",
    "for item in documents:\n",
    "    random.shuffle(item)\n",
    "    \n",
    "# load train, cv, test data index\n",
    "f = h5py.File('data/ingredient_recommendation/train_val_test.hdf5', 'r')\n",
    "train_idx = list(f.get(\"train_idx\"))\n",
    "cv_idx = list(f.get(\"cv_idx\"))\n",
    "test_idx = list(f.get(\"test_idx\"))\n",
    "f.close()\n",
    "\n",
    "train_doc = [documents[i] for i in train_idx]\n",
    "cv_doc = [documents[i] for i in cv_idx]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# tokenize\n",
    "#t=Tokenizer()  \n",
    "#t.fit_on_texts(documents)\n",
    "\n",
    "# save tokenizer\n",
    "#with open('models/multilabel_tokenizer.pickle', 'wb') as handle:\n",
    "#    pickle.dump(t, handle, protocol=pickle.HIGHEST_PROTOCOL)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "number of words:  6712\n"
     ]
    }
   ],
   "source": [
    "# load tokenizer\n",
    "with open('models/multilabel_tokenizer.pickle', 'rb') as handle:\n",
    "    t = pickle.load(handle)\n",
    "\n",
    "encoded_recipes=t.texts_to_sequences(documents)\n",
    "\n",
    "# create reverse dictionary from index to words \n",
    "index_to_words=dict(map(reversed,t.word_index.items())) \n",
    "\n",
    "# number of words\n",
    "n_words = len(t.word_index)\n",
    "print('number of words: ', n_words)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Prepare dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_Xy(doc, t, sample_size, n_repeat = 1):\n",
    "    # Given a list of documents, sample \"sample_size\" number of ingredients from each document. \n",
    "    # Create arrays X and y for neural network training and testing.\n",
    "    # If a document contains less than \"sample_size\" ingredients, then skip that document.\n",
    "    \n",
    "    \"\"\"\n",
    "    --- input ---\n",
    "    doc: (list of lists) Each doc[i] is a document given by a list of ingredients\n",
    "    t: (tokenizer)\n",
    "    sample_size: (int) number of ingredients to sample from each doc\n",
    "    n_repeat: (int) number of times to perform the sampling.\n",
    "    \n",
    "    --- output ---\n",
    "    X: (array) representing the ingredients sampled for each document\n",
    "        X[i][j] = 1 if sampled ingredients of doc[i] contains ingredient j (according to tokenizer t)\n",
    "    y: (array) representing the ingredients NOT sampled\n",
    "        y[i][j] = 1 if ingredient j is present in doc[i] but was not sampled\n",
    "    sample: (list of list) representing the ingredients sampled for each document.\n",
    "        sample[i] = [i_1, ... , i_k], where i_j is an ingredient sampled for doc[i]\n",
    "    target: (list of list) representing the ingredients in doc[i] that have not been sampled.\n",
    "        target[i] = [i_1, ... , i_m], where i_m is an ingredient that hasn't been sampled\n",
    "    \"\"\"\n",
    "    \n",
    "    sample = []\n",
    "    target = []\n",
    "    indices = []\n",
    "    n_doc = len(doc)\n",
    "    encoded_doc = t.texts_to_sequences(doc)\n",
    "    \n",
    "    for i in range(n_doc):\n",
    "        recipe = encoded_doc[i]\n",
    "        \n",
    "        # check that recipe contains more than \"sample_size\" ingredients\n",
    "        if len(recipe) > sample_size:\n",
    "            for j in range(n_repeat):\n",
    "                random.shuffle(recipe)\n",
    "\n",
    "                # split to sample & target\n",
    "                recipe_sample = recipe[:sample_size]\n",
    "                recipe_target = recipe[sample_size:]\n",
    "\n",
    "                # adjust index to start at 0. This is because tokenizer starts index at 0\n",
    "                recipe_sample = [item-1 for item in recipe_sample]\n",
    "                recipe_target = [item-1 for item in recipe_target]\n",
    "\n",
    "                # append\n",
    "                sample.append(recipe_sample)\n",
    "                target.append(recipe_target)\n",
    "                indices.append(i)\n",
    "            \n",
    "    # create array X, y\n",
    "    n_words = len(t.word_index)\n",
    "    \n",
    "    X = np.array(sample)\n",
    "    y = np.zeros((len(target), n_words))\n",
    "    \n",
    "    for data_idx, target_words in enumerate(target):\n",
    "        for word_idx in target_words:\n",
    "            y[data_idx, word_idx] = 1\n",
    "\n",
    "    return X, y, sample, target, indices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>id</th>\n",
       "      <th>cuisine</th>\n",
       "      <th>ingredients</th>\n",
       "      <th>document</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>25295</td>\n",
       "      <td>french</td>\n",
       "      <td>['eggs', 'semisweet_chocolate', 'white_sugar',...</td>\n",
       "      <td>['eggs', 'semisweet_chocolate', 'white_sugar',...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>4810</td>\n",
       "      <td>chinese</td>\n",
       "      <td>['spareribs', 'vegetable_oil', 'corn_starch', ...</td>\n",
       "      <td>['spareribs', 'vegetable_oil', 'corn_starch', ...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3128</td>\n",
       "      <td>korean</td>\n",
       "      <td>['soy_sauce', 'pork_loin', 'yellow_onion', 'mi...</td>\n",
       "      <td>['soy_sauce', 'pork_loin', 'yellow_onion', 'mi...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>19484</td>\n",
       "      <td>mexican</td>\n",
       "      <td>['turbinado', 'kosher_salt', 'cod_fillets', 's...</td>\n",
       "      <td>['turbinado', 'kosher_salt', 'cod_fillets', 's...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>49410</td>\n",
       "      <td>southern_us</td>\n",
       "      <td>['eggs', 'ground_black_pepper', 'paprika', 'sh...</td>\n",
       "      <td>['eggs', 'ground_black_pepper', 'paprika', 'sh...</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      id      cuisine                                        ingredients  \\\n",
       "0  25295       french  ['eggs', 'semisweet_chocolate', 'white_sugar',...   \n",
       "1   4810      chinese  ['spareribs', 'vegetable_oil', 'corn_starch', ...   \n",
       "2   3128       korean  ['soy_sauce', 'pork_loin', 'yellow_onion', 'mi...   \n",
       "3  19484      mexican  ['turbinado', 'kosher_salt', 'cod_fillets', 's...   \n",
       "4  49410  southern_us  ['eggs', 'ground_black_pepper', 'paprika', 'sh...   \n",
       "\n",
       "                                            document  \n",
       "0  ['eggs', 'semisweet_chocolate', 'white_sugar',...  \n",
       "1  ['spareribs', 'vegetable_oil', 'corn_starch', ...  \n",
       "2  ['soy_sauce', 'pork_loin', 'yellow_onion', 'mi...  \n",
       "3  ['turbinado', 'kosher_salt', 'cod_fillets', 's...  \n",
       "4  ['eggs', 'ground_black_pepper', 'paprika', 'sh...  "
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# load balanced training set \n",
    "df_train = pd.read_csv('data/ingredient_recommendation/balanced_training.csv')\n",
    "df_train.drop(\"Unnamed: 0\", axis = 1, inplace = True)\n",
    "df_train.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [],
   "source": [
    "# get training documents\n",
    "train_doc = [ast.literal_eval(df_train.document[idx]) for idx in range(df_train.shape[0])]\n",
    "\n",
    "# Create X, y for training \n",
    "X_train, y_train, sample_train, target_train, indices_train = create_Xy(train_doc, t, 5, 5)\n",
    "\n",
    "# Create X_cv, y_cv for evaluation on cross-validation set\n",
    "X_cv, y_cv, sampled_cv, target_cv, indices_cv = create_Xy(cv_doc, t, 5, 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MetricsAtK:\n",
    "    def __init__(self, k):\n",
    "        self.k = k\n",
    "\n",
    "    def _prediction_tensor(self, y_pred):\n",
    "        # Given tensor y_pred of floats (predicted probabilities), \n",
    "        # return a tensor of same shape with 1 in locations with \"k\" top probabilities. \n",
    "        y_pred = tf.convert_to_tensor(y_pred)\n",
    "        topk_indices = tf.nn.top_k(y_pred, k = self.k, sorted = True).indices\n",
    "        ii, _ = tf.meshgrid(tf.range(tf.shape(y_pred)[0]), tf.range(6), indexing='ij')\n",
    "        index_tensor = tf.reshape(tf.stack([ii, topk_indices], axis=-1), shape=(-1, 2))\n",
    "        index_tensor = tf.cast(index_tensor, tf.int64)\n",
    "        n_nzero = tf.shape(index_tensor)[0]\n",
    "\n",
    "        sparse = tf.SparseTensor(indices = index_tensor, values=tf.ones(n_nzero), dense_shape=tf.shape(y_pred, out_type=tf.dtypes.int64))\n",
    "        sparse = tf.sparse.reorder(sparse)\n",
    "        pred = tf.sparse.to_dense(sparse)\n",
    "        pred = tf.cast(pred, tf.float32)\n",
    "\n",
    "        return pred\n",
    "\n",
    "    def _TP_at_k(self, y_true, y_pred):\n",
    "        y_true = tf.convert_to_tensor(y_true, dtype = tf.float32)\n",
    "        # compute true positives for each sample\n",
    "        pred = self._prediction_tensor(y_pred)\n",
    "\n",
    "        TP = K.sum(tf.multiply(pred, y_true), axis = 1)\n",
    "        TP = tf.cast(TP, tf.float32)\n",
    "        \n",
    "        return TP\n",
    "    \n",
    "    def precision_at_k(self, y_true, y_pred):\n",
    "        TP = self._TP_at_k(y_true, y_pred)\n",
    "        precisions = TP / self.k\n",
    "        \n",
    "        # compute median\n",
    "        mid = tf.shape(precisions)[0]//2 + 1\n",
    "        precision_median = tf.nn.top_k(precisions, mid).values[-1]\n",
    "        return precision_median\n",
    "    \n",
    "    def recall_at_k(self, y_true, y_pred):\n",
    "        TP = self._TP_at_k(y_true, y_pred)\n",
    "        y_true = tf.convert_to_tensor(y_true, dtype = tf.float32)\n",
    "        recalls = TP / K.sum(y_true, axis = 1)\n",
    "        \n",
    "        # compute median\n",
    "        mid = tf.shape(recalls)[0]//2 + 1\n",
    "        recall_median = tf.nn.top_k(recalls, mid).values[-1]\n",
    "        return recall_median\n",
    "    \n",
    "    def F1_at_k(self, y_true, y_pred):\n",
    "        TP = self._TP_at_k(y_true, y_pred)\n",
    "        y_true = tf.convert_to_tensor(y_true, dtype = tf.float32)\n",
    "        precisions = TP / self.k\n",
    "        recalls = TP / K.sum(y_true, axis = 1)\n",
    "        f1 = (2 * precisions * recalls) / (precisions + recalls + K.epsilon())\n",
    "        \n",
    "        # compute median\n",
    "        mid = tf.shape(f1)[0]//2 + 1\n",
    "        f1_median = tf.nn.top_k(f1, mid).values[-1]\n",
    "        return f1_median\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# A custom callback that \n",
    "# (1) computes the precision, recall, F1 score on the entire CV set (not batch-wide average)\n",
    "# (2) performs early stopping while monitoring CV_F1 score \n",
    "\n",
    "class EarlyStoppingAtK(keras.callbacks.Callback):\n",
    "        \n",
    "    def __init__(self, X_val, y_val, metrics, patience = 0, verbose = 0):\n",
    "        super(keras.callbacks.Callback, self).__init__()\n",
    "        self.Xval = X_val\n",
    "        self.yval = y_val\n",
    "        self.metrics = metrics\n",
    "        self.precisions = []\n",
    "        self.recalls = []\n",
    "        self.F1scores = []\n",
    "        self.patience = patience\n",
    "        self.verbose = verbose\n",
    "        self.wait = 0 # number of epochs since the maximum F1 score\n",
    "        self.max = -np.Inf\n",
    "        self.best_weights = None\n",
    "        self.best_epoch = 0\n",
    "        \n",
    "    def on_epoch_end(self, epoch, logs={}):\n",
    "        X_val, y_val = self.Xval, self.yval\n",
    "        y_pred = np.asarray(self.model.predict(X_val))\n",
    "        \n",
    "        # evaluate CV set\n",
    "        p = self.metrics.precision_at_k(y_val, y_pred).numpy()\n",
    "        r = self.metrics.recall_at_k(y_val, y_pred).numpy()\n",
    "        fscore = self.metrics.F1_at_k(y_val, y_pred).numpy()\n",
    "        \n",
    "        self.precisions.append(p)\n",
    "        self.recalls.append(r)\n",
    "        self.F1scores.append(fscore)\n",
    "        print(\" Validation precision: %.4f, Validation recall: %.4f, Validation F1: %.4f\" %(p, r, fscore))\n",
    "        \n",
    "        # early stopping\n",
    "        # If current score is better than historic max\n",
    "        if fscore > self.max:\n",
    "            # update \n",
    "            self.max = fscore\n",
    "            self.wait = 0 \n",
    "            # Record the current weights\n",
    "            self.best_weights = self.model.get_weights()\n",
    "            self.best_epoch = epoch + 1\n",
    "        else:\n",
    "            self.wait += 1\n",
    "            if self.wait >= self.patience:\n",
    "                self.model.stop_training = True\n",
    "                print(\"\\n Early stopping at epoch \", epoch + 1)\n",
    "                \n",
    "                # restore weights from the best_weights\n",
    "                self.model.set_weights(self.best_weights)\n",
    "                print(\"\\n Restoring model weights to weights from epoch \", self.best_epoch)\n",
    "        return "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def show_histograms(model, X_cv, y_cv):\n",
    "    # get 6 most probable ingredients \n",
    "    y_pred = model.predict(X_cv)\n",
    "    n_dataset = y_pred.shape[0]\n",
    "    pred = []\n",
    "    for i in range(n_dataset):\n",
    "        pred_ing = y_pred[i,:].argsort()[::-1][:6].tolist()\n",
    "        pred.append(pred_ing)\n",
    "\n",
    "    # for each document in CV set, create a list of missing ingredients (true ingredients)\n",
    "    missing_ing = []\n",
    "    for i in range(n_dataset):\n",
    "        missing_ing.append(np.nonzero(y_cv[i,:])[0].tolist())\n",
    "\n",
    "    ## compute precision, recall, F-score on the CV set \n",
    "    scores = [fn.compute_scores(pred[i], missing_ing[i]) for i in range(len(pred))]\n",
    "\n",
    "    precisions = [item[0] for item in scores] \n",
    "    recalls = [item[1] for item in scores]\n",
    "    Fscores = [item[2] for item in scores]\n",
    "\n",
    "    fig, ax = plt.subplots(ncols = 3, figsize = (10,3))\n",
    "    ax[0].hist(precisions)\n",
    "    ax[0].set_title('histogram of precision')\n",
    "\n",
    "    ax[1].hist(recalls)\n",
    "    ax[1].set_title('histogram of recalls')\n",
    "\n",
    "    ax[2].hist(Fscores)\n",
    "    ax[2].set_title('histogram of F-scores')\n",
    "    plt.show()\n",
    "\n",
    "    print(\"Median precision on CV set: \", statistics.median(precisions) )\n",
    "    print(\"Median recall on CV set: \", statistics.median(recalls) )\n",
    "    print(\"Median F-score on CV set: \", statistics.median(Fscores) )\n",
    "\n",
    "    print(\"Mean precision on CV set: \", statistics.mean(precisions) )\n",
    "    print(\"Mean recall on CV set: \", statistics.mean(recalls) )\n",
    "    print(\"Mean F-score on CV set: \", statistics.mean(Fscores) )\n",
    "\n",
    "    return \n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Model 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"model1\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "Embedding (Embedding)        (None, 5, 100)            671200    \n",
      "_________________________________________________________________\n",
      "Mean (Lambda)                (None, 100)               0         \n",
      "_________________________________________________________________\n",
      "Dense (Dense)                (None, 6712)              677912    \n",
      "=================================================================\n",
      "Total params: 1,349,112\n",
      "Trainable params: 1,349,112\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "# define model structure\n",
    "context_size = 5\n",
    "embed_size = 100\n",
    "\n",
    "model = Sequential(name = \"model1\")\n",
    "\n",
    "# embedding\n",
    "model.add(Embedding(n_words, embed_size, input_length = context_size, name = \"Embedding\"))\n",
    "\n",
    "# take the mean of vectors\n",
    "model.add(Lambda(lambda x: K.mean(x, axis=1), output_shape = (embed_size,), name = \"Mean\"))\n",
    "\n",
    "# last layer\n",
    "model.add(Dense(n_words, activation = 'sigmoid', name = \"Dense\"))\n",
    "\n",
    "#metrics = MetricsAtK(6, X_cv, y_cv)\n",
    "\n",
    "metrics = MetricsAtK(k = 6)\n",
    "model.compile(loss =  'binary_crossentropy', optimizer = 'adam', metrics = [metrics.precision_at_k,\n",
    "                                                                           metrics.recall_at_k,\n",
    "                                                                           metrics.F1_at_k])\n",
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/20\n",
      " Validation precision: 0.0000, Validation recall: 0.0000, Validation F1: 0.0000\n",
      "4098/4098 - 31s - loss: 0.0302 - precision_at_k: 0.0639 - recall_at_k: 0.0334 - F1_at_k: 0.0435 - val_loss: 0.0060 - val_precision_at_k: 0.0486 - val_recall_at_k: 0.0277 - val_F1_at_k: 0.0350\n",
      "Epoch 2/20\n",
      " Validation precision: 0.1667, Validation recall: 0.0909, Validation F1: 0.1176\n",
      "4098/4098 - 30s - loss: 0.0058 - precision_at_k: 0.0783 - recall_at_k: 0.0432 - F1_at_k: 0.0553 - val_loss: 0.0056 - val_precision_at_k: 0.1124 - val_recall_at_k: 0.0699 - val_F1_at_k: 0.0858\n",
      "Epoch 3/20\n",
      " Validation precision: 0.1667, Validation recall: 0.1429, Validation F1: 0.1538\n",
      "4098/4098 - 31s - loss: 0.0054 - precision_at_k: 0.1420 - recall_at_k: 0.1001 - F1_at_k: 0.1186 - val_loss: 0.0052 - val_precision_at_k: 0.1590 - val_recall_at_k: 0.1318 - val_F1_at_k: 0.1477\n",
      "Epoch 4/20\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2000\n",
      "4098/4098 - 30s - loss: 0.0050 - precision_at_k: 0.1699 - recall_at_k: 0.1561 - F1_at_k: 0.1705 - val_loss: 0.0049 - val_precision_at_k: 0.1790 - val_recall_at_k: 0.1807 - val_F1_at_k: 0.1899\n",
      "Epoch 5/20\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2000\n",
      "4098/4098 - 31s - loss: 0.0048 - precision_at_k: 0.1938 - recall_at_k: 0.1928 - F1_at_k: 0.2021 - val_loss: 0.0048 - val_precision_at_k: 0.1857 - val_recall_at_k: 0.1998 - val_F1_at_k: 0.2045\n",
      "Epoch 6/20\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2222\n",
      "4098/4098 - 31s - loss: 0.0047 - precision_at_k: 0.2173 - recall_at_k: 0.2127 - F1_at_k: 0.2198 - val_loss: 0.0047 - val_precision_at_k: 0.2029 - val_recall_at_k: 0.2073 - val_F1_at_k: 0.2119\n",
      "Epoch 7/20\n",
      " Validation precision: 0.1667, Validation recall: 0.2222, Validation F1: 0.2222\n",
      "4098/4098 - 31s - loss: 0.0045 - precision_at_k: 0.2361 - recall_at_k: 0.2267 - F1_at_k: 0.2310 - val_loss: 0.0047 - val_precision_at_k: 0.2152 - val_recall_at_k: 0.2154 - val_F1_at_k: 0.2175\n",
      "Epoch 8/20\n",
      " Validation precision: 0.1667, Validation recall: 0.2222, Validation F1: 0.2222\n",
      "4098/4098 - 31s - loss: 0.0044 - precision_at_k: 0.2533 - recall_at_k: 0.2382 - F1_at_k: 0.2417 - val_loss: 0.0047 - val_precision_at_k: 0.2162 - val_recall_at_k: 0.2197 - val_F1_at_k: 0.2222\n",
      "Epoch 9/20\n",
      " Validation precision: 0.1667, Validation recall: 0.2222, Validation F1: 0.2222\n",
      "4098/4098 - 31s - loss: 0.0044 - precision_at_k: 0.2669 - recall_at_k: 0.2482 - F1_at_k: 0.2493 - val_loss: 0.0046 - val_precision_at_k: 0.2190 - val_recall_at_k: 0.2202 - val_F1_at_k: 0.2207\n",
      "Epoch 10/20\n",
      " Validation precision: 0.1667, Validation recall: 0.2222, Validation F1: 0.2222\n",
      "4098/4098 - 31s - loss: 0.0043 - precision_at_k: 0.2767 - recall_at_k: 0.2560 - F1_at_k: 0.2567 - val_loss: 0.0046 - val_precision_at_k: 0.2171 - val_recall_at_k: 0.2198 - val_F1_at_k: 0.2204\n",
      "Epoch 11/20\n",
      " Validation precision: 0.1667, Validation recall: 0.2222, Validation F1: 0.2222\n",
      "\n",
      " Early stopping at epoch  11\n",
      "\n",
      " Restoring model weights to weights from epoch  6\n",
      "4098/4098 - 31s - loss: 0.0042 - precision_at_k: 0.2861 - recall_at_k: 0.2645 - F1_at_k: 0.2623 - val_loss: 0.0046 - val_precision_at_k: 0.2124 - val_recall_at_k: 0.2208 - val_F1_at_k: 0.2214\n"
     ]
    }
   ],
   "source": [
    "# callbacks for early stopping and model saving\n",
    "# early stopping\n",
    "es = EarlyStoppingAtK(X_cv, y_cv, metrics, patience = 5)\n",
    "\n",
    "# save model\n",
    "mc = ModelCheckpoint('models/multilabel_NN/model1_{epoch:02d}.h5', save_freq = 'epoch', verbose = 0)\n",
    "\n",
    "# fit model\n",
    "history = model.fit(x = X_train, y = y_train, validation_data=(X_cv, y_cv), epochs = 20, verbose = 2, callbacks = [es, mc])\n",
    "\n",
    "model.save('models/multilabel_NN/model1.h5')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x360 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# number of epochs determined by the following\n",
    "# plot the training and validation loss to determine if overfitting / underfitting \n",
    "\n",
    "train_loss = history.history['loss']\n",
    "val_loss = history.history['val_loss']\n",
    "train_F1 = history.history['F1_at_k']\n",
    "batch_val_F1 = history.history['val_F1_at_k']\n",
    "val_F1 = es.F1scores\n",
    "n_epochs = len(train_loss)\n",
    "\n",
    "fig, ax = plt.subplots(ncols = 2, figsize = (15,5))\n",
    "ax[0].plot(list(range(n_epochs)), train_loss, label ='train loss')\n",
    "ax[0].plot(list(range(n_epochs)), val_loss, label ='val loss')\n",
    "ax[0].set_xlabel('training epochs')\n",
    "ax[0].set_ylabel('loss')\n",
    "ax[0].legend()\n",
    "ax[1].plot(list(range(n_epochs)), train_F1, label ='train F1')\n",
    "ax[1].plot(list(range(n_epochs)), batch_val_F1, label ='batch val F1')\n",
    "ax[1].plot(list(range(n_epochs)), val_F1, label ='val F1')\n",
    "ax[1].set_xlabel('training epochs')\n",
    "ax[1].set_ylabel('F1')\n",
    "ax[1].legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x216 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Median precision on CV set:  0.16666666666666666\n",
      "Median recall on CV set:  0.2\n",
      "Median F-score on CV set:  0.2222222222222222\n",
      "Mean precision on CV set:  0.24142550911039656\n",
      "Mean recall on CV set:  0.2479735083150312\n",
      "Mean F-score on CV set:  0.22138768610365644\n"
     ]
    }
   ],
   "source": [
    "# load model with best performing validation_F1 score\n",
    "model = keras.models.load_model('models/multilabel_NN/model1.h5', custom_objects= {'precision_at_k':metrics.precision_at_k,\n",
    "                                                                                  'recall_at_k':metrics.recall_at_k,\n",
    "                                                                                  'F1_at_k': metrics.F1_at_k})\n",
    "show_histograms(model, X_cv, y_cv)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Play around with different architectures"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### model 2: larger embedding size  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* The model performance on the validation set didn't improve. \n",
    "* We'll keep the structure of model 1, which has embedding dimension 100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"model2\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "Embedding (Embedding)        (None, 5, 300)            2013600   \n",
      "_________________________________________________________________\n",
      "Mean (Lambda)                (None, 300)               0         \n",
      "_________________________________________________________________\n",
      "Dense (Dense)                (None, 6712)              2020312   \n",
      "=================================================================\n",
      "Total params: 4,033,912\n",
      "Trainable params: 4,033,912\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "context_size = 5\n",
    "embed_size = 300\n",
    "\n",
    "model = Sequential(name = 'model2')\n",
    "\n",
    "# embedding\n",
    "model.add(Embedding(n_words, embed_size, input_length = context_size, name = \"Embedding\"))\n",
    "\n",
    "# Take the mean of vectors\n",
    "model.add(Lambda(lambda x: K.mean(x, axis=1), output_shape = (embed_size,), name = \"Mean\" ))\n",
    "# last layer\n",
    "model.add(Dense(n_words, activation = 'sigmoid', name = 'Dense'))\n",
    "\n",
    "metrics = MetricsAtK(k = 6)\n",
    "model.compile(loss = 'binary_crossentropy', optimizer = 'adam', metrics = [metrics.precision_at_k,\n",
    "                                                                           metrics.recall_at_k,\n",
    "                                                                           metrics.F1_at_k])\n",
    "\n",
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/20\n",
      " Validation precision: 0.0000, Validation recall: 0.0000, Validation F1: 0.0000\n",
      "4098/4098 - 73s - loss: 0.0224 - precision_at_k: 0.0663 - recall_at_k: 0.0347 - F1_at_k: 0.0452 - val_loss: 0.0058 - val_precision_at_k: 0.0619 - val_recall_at_k: 0.0347 - val_F1_at_k: 0.0441\n",
      "Epoch 2/20\n",
      " Validation precision: 0.1667, Validation recall: 0.1429, Validation F1: 0.1538\n",
      "4098/4098 - 72s - loss: 0.0055 - precision_at_k: 0.1288 - recall_at_k: 0.0874 - F1_at_k: 0.1048 - val_loss: 0.0052 - val_precision_at_k: 0.1571 - val_recall_at_k: 0.1337 - val_F1_at_k: 0.1472\n",
      "Epoch 3/20\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2000\n",
      "4098/4098 - 72s - loss: 0.0050 - precision_at_k: 0.1776 - recall_at_k: 0.1673 - F1_at_k: 0.1803 - val_loss: 0.0049 - val_precision_at_k: 0.1895 - val_recall_at_k: 0.1958 - val_F1_at_k: 0.2031\n",
      "Epoch 4/20\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2222\n",
      "4098/4098 - 72s - loss: 0.0047 - precision_at_k: 0.2171 - recall_at_k: 0.2124 - F1_at_k: 0.2193 - val_loss: 0.0047 - val_precision_at_k: 0.2076 - val_recall_at_k: 0.2077 - val_F1_at_k: 0.2136\n",
      "Epoch 5/20\n",
      " Validation precision: 0.1667, Validation recall: 0.2222, Validation F1: 0.2222\n",
      "4098/4098 - 72s - loss: 0.0045 - precision_at_k: 0.2491 - recall_at_k: 0.2347 - F1_at_k: 0.2386 - val_loss: 0.0047 - val_precision_at_k: 0.2171 - val_recall_at_k: 0.2166 - val_F1_at_k: 0.2204\n",
      "Epoch 6/20\n",
      " Validation precision: 0.1667, Validation recall: 0.2222, Validation F1: 0.2222\n",
      "4098/4098 - 72s - loss: 0.0044 - precision_at_k: 0.2711 - recall_at_k: 0.2506 - F1_at_k: 0.2524 - val_loss: 0.0046 - val_precision_at_k: 0.2229 - val_recall_at_k: 0.2220 - val_F1_at_k: 0.2227\n",
      "Epoch 7/20\n",
      " Validation precision: 0.1667, Validation recall: 0.2222, Validation F1: 0.2222\n",
      "4098/4098 - 72s - loss: 0.0042 - precision_at_k: 0.2849 - recall_at_k: 0.2642 - F1_at_k: 0.2632 - val_loss: 0.0046 - val_precision_at_k: 0.2162 - val_recall_at_k: 0.2251 - val_F1_at_k: 0.2244\n",
      "Epoch 8/20\n",
      " Validation precision: 0.1667, Validation recall: 0.2222, Validation F1: 0.2222\n",
      "4098/4098 - 72s - loss: 0.0041 - precision_at_k: 0.2973 - recall_at_k: 0.2761 - F1_at_k: 0.2730 - val_loss: 0.0046 - val_precision_at_k: 0.2143 - val_recall_at_k: 0.2231 - val_F1_at_k: 0.2234\n",
      "Epoch 9/20\n",
      " Validation precision: 0.1667, Validation recall: 0.2222, Validation F1: 0.2222\n",
      "\n",
      " Early stopping at epoch  9\n",
      "\n",
      " Restoring model weights to weights from epoch  4\n",
      "4098/4098 - 72s - loss: 0.0040 - precision_at_k: 0.3070 - recall_at_k: 0.2856 - F1_at_k: 0.2823 - val_loss: 0.0046 - val_precision_at_k: 0.2200 - val_recall_at_k: 0.2228 - val_F1_at_k: 0.2235\n"
     ]
    }
   ],
   "source": [
    "# Fit model with callbacks\n",
    "# early stopping\n",
    "es = EarlyStoppingAtK(X_cv, y_cv, metrics, patience = 5)\n",
    "\n",
    "# save model\n",
    "mc = ModelCheckpoint('models/multilabel_NN/model2_{epoch:02d}.h5', save_freq = 'epoch', verbose = 0)\n",
    "\n",
    "# fit model\n",
    "history = model.fit(x = X_train, y = y_train, validation_data=(X_cv, y_cv), epochs = 20, verbose = 2, callbacks = [es, mc])\n",
    "\n",
    "model.save('models/multilabel_NN/model2.h5')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA44AAAFACAYAAADziiJ5AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/d3fzzAAAACXBIWXMAAAsTAAALEwEAmpwYAACB3ElEQVR4nOzdeXxU9b3/8deZJRvZJ5AQkgBhU7AKGCqCgAhS15ZrrVWrdVcaLa3eWrW1ta3F0ou4YKHairTW/m5rtWq9tlYRt4oLCKiAQtgJJIQsZN9mzvf3x4QhIQECmclkkvfz8YgzZ/l+z2fCmDOf+W6WMcYgIiIiIiIicgSOcAcgIiIiIiIiPZsSRxERERERETkqJY4iIiIiIiJyVEocRURERERE5KiUOIqIiIiIiMhRKXEUERERERGRo1LiKCIiIiIiIkflCncAPcnevXu7XEdaWhqlpaVBiCb0FGtoRFKsEFnxKtbQ6IuxZmZmBiGavqWr98i++D7rLpEUr2INjUiKFSIr3r4W69Huj2pxFBERERERkaNS4igiIiIiIiJHpcRRREREREREjkpjHEVEeihjDA0NDdi2jWVZIbvOvn37aGxsDFn9wXQ8sRpjcDgcxMTEhPT311cd7/uzt77PwkHvbREJByWOIiI9VENDA263G5crtH+qXS4XTqczpNcIluON1ev10tDQQGxsbAij6puO9/3Zm99n4aD3toh0t25LHNetW8eyZcuwbZsZM2Ywe/bsNseNMSxbtoy1a9cSHR1Nfn4+ubm5lJaWsnjxYg4cOIBlWcycOZMLLrgAgD/96U98/PHHuFwu0tPTyc/Pp1+/fpSUlHD77bcHZgUaMWIEN998c3e9VBGRoLBtO+RJY2/ncrl6dMtRJNP7M7z03haR7tYtf/Ft22bp0qXce++9eDwe7rnnHvLy8sjKygqcs3btWoqLi1m0aBEFBQU8+eSTPPDAAzidTq6++mpyc3Opr6/n7rvv5tRTTyUrK4tTTz2VK6+8EqfTyTPPPMMLL7zAVVddBUBGRgYLFizojpcnIhIS6oIWHPo9hoZ+r+GnfwMR6U7dMjnOli1byMjIID09HZfLxaRJk1i1alWbc1avXs3UqVOxLIuRI0dSW1tLRUUFKSkp5ObmAhAbG8ugQYMoLy8H4LTTTgt0JRk5cmRgv4iIdF1lZSV/+MMfTqjs1VdfTWVlZafPX7hwIY8//vgJXUv6pu5+f55++umce+65nHvuuTzwwAMALFu2jMmTJ7f5bCIi0lt1S+JYXl6Ox+MJbHs8nnZ/YMvLy0lLSzvqOSUlJWzfvp3hw4e3u8aKFSsYO3Zsm3N/+MMfct999/H5558H6ZWIiPQdVVVVPP300x0e8/l8Ry37pz/9iaSkpFCEJQJ0//vzpptu4vXXX+f111/nRz/6EQATJkzgL3/5S5seVCIivVW3dFU1xrTbd3j3imOd09DQwMKFC7n22muJi4trc97f//53nE4nU6ZMASAlJYUlS5aQkJDAtm3bWLBgAQsXLmxXbvny5SxfvhyA+fPnt0lcj5ddU0XD+2/B2C+T1j/jhOvpTi6Xq0uvuTsp1tCJpHj7Wqz79u3rtjFkHV3nV7/6FTt37mTWrFlMmzaNmTNn8uCDD5Kens6GDRt49913ueaaa9i7dy+NjY3ceOONfPvb3wYgLy+Pf//739TW1nLllVfy5S9/mdWrV5ORkcEf//jHdhN6OBwOHA4HLpeL9evXc+edd1JfX8+QIUN45JFHSE5O5ve//z1PP/00TqeTkSNH8rvf/Y6VK1dy7733Av57xksvvUR8fHybuqOjoyPmfSOd98ADD7Bz507OPfdcpk6dyowZM3jooYcC78+33nqL66+/PvD+vOGGGwLDWc444wz+9a9/UVtby1VXXdXm/fnUU0+RkJDQqRhOOeWUUL5EEZFjMsZAWQns3k5DfDyMCN3fpW75ROLxeCgrKwtsl5WVkZKS0u6c0tLSDs/xer0sXLiQKVOmcMYZZ7Qp99Zbb/Hxxx/z05/+NJBout1u3G43ALm5uaSnp1NUVMSwYcPalJ05cyYzZ84MbLe+/vEyZSXYS+bDLT+gLm/qCdfTndLS0rr0mruTYg2dSIq3r8Xa2NjYLTM7ulwuvF5vu/333HMPX3zxBa+99hoAK1euZO3ataxYsYKcnBy8Xi8PPvggKSkp1NfXc+GFF3LeeeeRmpqKMQafz4fP52Pbtm385je/4X/+53+45ZZb+Mc//sHXv/71NteybRvbtvF6vdx2223cf//9nHnmmSxYsID/+Z//4Re/+AWPPfYYq1atwul0UllZidfrZfHixcybN48JEyZQW1vb4WtpbGxs929xcPI0iVw/+tGP2LRpE6+//jrgf3+uW7cu8P4EfxfT1u/PCy64gNTU1Db1bN++ncWLF7NgwQJuueUW/vnPf/LNb36z3fV+//vf8/zzzwPw4x//mLPPPju0L1BE5DDG64Xi3Zhd22H3Nsxu/yN1tQDUDhkOP34oZNfvlsRx2LBhFBUVUVJSQmpqKitXrmTu3LltzsnLy+PVV19l8uTJFBQUEBcXR0pKCsYYHn/8cQYNGsRFF13Upsy6det46aWX+PnPf050dHRgf1VVFfHx8TgcDvbt20dRURHp6emhfZGp/SEuHu+2zRAhiaOIRA77L7/33yCCyMoeiuPym46rzNixYwMfygGeeuop/vWvfwGwd+9etm/f3u6DeXZ2dqBl5tRTT2X37t1HrL+qqorKykrOPPNMAL7xjW9wyy23AHDyySeTn5/PrFmzOO+88wB/V8Gf//zn/Nd//Rfnn3++EsIw6cz707asDnsXHUlPe3/edNNNzJkz57jiERE5UaahDnbvwOzeBrtaksS9O+Hgl6PuKMgagpU3BbKHYmUPJfW00ymrqQ1ZTN2SODqdTq6//nrmzZuHbdtMnz6d7OzswLfYs2bNYty4caxZs4a5c+cSFRVFfn4+AJs2beKdd94hJyeHO++8E4ArrriC8ePHs3TpUrxeL/fffz9waNmNjRs38uyzz+J0OnE4HNx0003tui4Fm2VZkJNL8/aCkF5HRCScWnf5X7lyJe+++y4vv/wysbGxXHrppR0uD9D6iz2n00lDQ8MJXfvpp59m1apV/Otf/+KRRx7hzTff5LbbbmPGjBmsWLGCiy++mL/+9a8djoOXviGc708RkRNhjIHKCn8L4q5t/kRx93YoKTp0UnwCZOdizbjY/5iTCwMysQ7rlWTFxEKkJ44A48ePZ/z48W32zZo1K/DcsixuvPHGduVOOukknn322Q7rfOyxxzrcP3HiRCZOnNiFaE+MlZOL961/4vD52v1Dioh0xfG2vARDv379qKmpOeLx6upqkpKSiI2NZcuWLaxZs6bL10xMTCQpKYkPP/yQM844g+eff56JEydi2zZ79+7lrLPO4vTTT+fFF18MzL598sknc/LJJ/Pxxx+zZcsWJY5h0Jn355G6RJ+ocLw/RUS6wtg+KCnC7PInh/7HbVDdapbn/hn+FsQzz8HKzoWcXEhO7RHL72jl3mDKHgpNTVBcCIMGhzsaEZEuSU1NZcKECZxzzjlMnz6dGTNmtDl+9tln86c//YmZM2eSm5vb7svBE/XII49w991309DQQE5ODg899BA+n4/vfve7VFdXY4zhpptuIikpiQULFrBy5UocDgcjR45k+vTpQYlBer5wvT9bW7p0KUuWLGH//v3MnDmTc845hwcffDDo1xGRyGOaGmHPLszurYeSxMId0NTS88HpgsxsrC/lQU4uVvZQyBqKFdcvrHEfjWWOZ8BBL7d3794ulTd7dmH/7Das62/HcWbP//DS1yYa6S6RFCtEVrx9Lda6urp2s0GHQrBbgkLpRGLt6PeosZDH7/B75PG+P3v7+ywcDv4b9LW/jd1FsYZOJMXbmVhNTdWhcYgtXU4p3gPG9p8QG9cyDjHX39U0e6g/aXS5uz3WYzna/VEtjsGUMQiiomDXNoiAxFFERERERDrHGAOl+wIzmprd2/2f+ytaJWspaf4k8fRJ/gQxOxfS0ntEV9OuUuIYRJbTiWvwcLy7t4U7FBEREREROUHG64Wi3dR/+iH2xk9bWhO3Q33L5DOWAzIGYY0Yc6iraXYuVkJieAMPISWOQeYeOhLvf17HGNMrvlkQEREREenNjLfZPx5x11bYuQWzc6t/PKK3mSqAqGj/0hdnTD3U5XTQYKyo6GPU3LsocQwy19AR8NqLUFYCaSFeO1JERERERDrNNDfDnh3+5HDnFv94xD07Dq2PGNvP34J4zoWQM4zU006nIioWy6EVE5Q4Bpk7d6T/ya5tShxFRERERMLENDVCYUuSuGsrZucW2LsLfD7/CXHxMHgY1oyvwuDhWINzIS0Dy+EI1OFKS8OKkIl8Qk2JY5C5Bg8Dy4HZvQ1r/JnhDkdEREREpNczjY0tM5puhZ0tSWLRbrBbZjaNT4Cc4VizTscaPAxyhvWaSWu6ixLHILOiYyBjkH8ArYhIHzNixAgKCgo6vV/kRO3evZtrrrmGFStWdLrMX//6V6ZNm0ZGRsZRz1m/fj33339/MMIMuPTSS/nJT37Caaed1m7/vn37iImJAeB73/seF110EXfccQfLly8nLS3tuF6jSF9gGur9ayPu3OJPEndthaLCQ8tfJCT5WxDHnoGVMwwGD4fUNCWJXaTEMQSsnFzM5g3hDkNERERa+dvf/sZJJ5101MQxHH7zm9+0Sygvu+wyrrvuOr73ve+FKSqRnsHU1/nXSNy5paW76VbYtwcOLkWflOrvbjp+kr8lcfBwSE5VkhgCShxDITsXPnwbU13Vq6fkFZHebd68eQwaNIhrr70WgIULF9KvXz+uvvpqrrvuOiorK/F6vfzwhz/kK1/5SqfqNMbwy1/+kjfffBPLspg7dy5f+9rX2LdvH9/5zneorq7G5/Pxq1/9iry8PP77v/+bTz/9FMuy+OY3v0l+fn4IX7FEGq/Xy/e+9z02bNjA0KFDWbRoEbGxsTz88MO8/vrrNDQ0kJeXx69//WteeeUVPvnkE2677TZiYmL4xz/+waZNm/jpT39KXV0d0dHR/PWvfwWguLiYb33rW+zYsYPzzz+fe++9t811V6xYwV//+leeeOIJAFauXMkTTzzBH//4R+6++24++eQTGhoauPDCC/nBD35wQq9t4sSJ7N69u2u/IJEIY+pqWloQtx2a3bRk76ETUtL8SeKXpwa6m1rJqeELuI9R4hgCVk4uBmD3Vhg9LtzhiIickK997Wvcd999gcTx5Zdf5s9//jPR0dEsXbqUhIQEysvLufjii5k1a1anvt395z//yYYNG3j99dcpLy/nggsuYOLEibzwwgtMmzaN733ve/h8Purr69mwYQPFxcWBbnqVlZWhfLkSgbZu3crChQuZMGECd9xxB3/84x+ZM2cO1157LbfffjsA3/3ud3n99de56KKL+MMf/hDoLtrU1MR3vvMdfvvb3zJ27Fiqq6sD3UXXr1/Pv//9b6Kiopg6dSrXXXcdgwYNClx36tSp3HXXXdTV1REXF8c//vEPvvrVrwJw1113kZKSgs/n45vf/CYbN25k9OjRR30dB5NZ8HeVTU3VB2Hp/UxtdctYxIOzm26F/cWHTvAM8M9uOumcQ0liYnLY4hUljqGRkwuA2bUNS4mjiATBk6v3sb2iIah1Dk2J4ca8I8/+fMopp1BaWkpxcTFlZWUkJSUxaNAgmpubmT9/Ph9++CGWZVFcXMz+/fsZMGDAMa/50UcfMXv2bJxOJ/3792fixIl88sknjB07lv/+7//G6/Xyla98hVNOOYWcnBx27drFvffey4wZM5g2bVowX74EUWfen5ZlYQ52LeuEY70/ATIzM5kwYQIAl1xyCU899RRz5sxh5cqV/Pa3v6W+vp4DBw4watQoZs2a1abs1q1bGTBgAGPHjgUgISEhcGzKlCkkJvp7DI0cOZI9e/a0SRxdLhfTp0/n9ddf58ILL+SNN94ItEoe/ILF5/Oxb98+CgoKjpk4dtRVVaQ3MY2N/m6m277AbNvM/sLt2CVFh05IS/e3JE6Z5R+TmDNMvfZ6ICWOIWD1S4DU/qAJckQkwl144YW88sorlJSU8LWvfQ2Av//975SVlfGvf/0Lt9vNGWecQWNjY6fqO1LiMHHiRJ5//nneeOMNvve97zFnzhy+8Y1v8Prrr/PWW2/xhz/8gZdffplFixYF7bVJ5Du8lduyLBoaGvjRj37EP//5TwYNGsTChQs7fH8aY47YSh4dfWhRb4fDgffg+m6tXHzxxfzxj38kOTmZsWPHEh8fz65du3jiiSd45ZVXSE5O5vvf/z4NDcH9wkekpzPGwP4izLZNsG0TZttmKNx+aAmM/hm4R42hacosrMHD/Uliv/jwBi2dosQxVHJy/f2zRUSC4FgtL6Hyta99jTvvvJPy8nKef/55AKqrq0lLS8PtdvPee+9RWFjY6fomTpzIM888wze+8Q0OHDjAhx9+yE9+8hMKCwvJyMjgW9/6FnV1dXz22WfMmDEDt9vNhRdeyODBgwNdD6Xn6cz70+VydZiAdcWePXtYvXo1eXl5vPTSS0yYMCGQJKamplJbW8srr7zChRdeCEC/fv2oqakBYPjw4ezbt49169YxduxYampqAt1FO2PSpEn84Ac/4M9//jMXX3wx4P9/IzY2lsTERPbv38+bb77JmWdqaS7p3UxdLewowGzb5E8Wt2+Cmmr/wZhYGDoS6ytfx8odBbkjsRKSSE5Lo1RrI0YcJY4hYmUPxXzyEaaxwb9Eh4hIBBo1ahS1tbVkZGSQnu5PDi655BKuueYazj//fMaMGcPw4cM7Xd/555/Pxx9/zLnnnotlWfz4xz9mwIABPPvsszz++OO4XC769evHo48+SlFREXfccQd2yxpc99xzT0heo0SuESNG8Le//Y27776boUOHcs011xAbG8uVV17JzJkzycrKatMF9LLLLuPuu+8OTI7z29/+lnvvvZeGhgZiYmICk+N0htPpZObMmTz77LM8+uijAIwZM4ZTTjmF6dOnk5OTE+hGeyLy8/N5//33KS8v5/TTT+cHP/gBV1xxxQnXJxIMxvZBUWGr1sRN/rUSjQHLgoHZWGMnQu4of6I4MAvL4Qx32BIkljmeAQe93N69e4990jGktXyDYtZ9gL34ARx3/w/WsJOCEF3wpUXQtz2KNXQiKd6+FuvBiTdCLRQtQaFyIrF29HvMzMwMZlh9wuH3yON9f/b291k4HPw36Gt/G7uLYgVTXQnbNvtbE7dvgu2boaHef7BfQkuCONKfJA4ZiRXXL6zxhkJfi/Vo90e1OIZK9jCgZYKcHpo4ioiIiIgAGK8X9uw41Jq49YtDs5w6HJA1FGvi9EOtiQMGaq3EPkaJY6ikpvm/idmtcY4iIiIi0rOYirJAd1OzbRPs3ALNTf6DSakwbBTWtPOwho6CwcOxWk0aJX2TEscQsSxLE+SIiIiISNiZpoPLYbQkids2Q0VLl0aXy58YTjv/UGtiappaE6UdJY4hZGUPxax4BeP1Yrn0qxaR46Mh6MGh36OI9CXGGCjd5+9qejBRbL0cRlo61ojRh5LErKFYbnd4g5aIoGwmlLJzwdsMxYWQNSTc0YhIhDm4fpxLXzydMK/Xi8PhCHcYQbdu3TqWLVuGbdvMmDGD2bNntzn+7rvv8tJLLwEQExPDjTfeyJAhQwC49dZbiYmJweFw4HQ6mT9/fjdHLyLBZJoaafp0NfbajzDbN8O2TVBd6T8YHQNDRmDN+q9Dy2EkpoQ3YIlY+jQSQlZOLoaWCXKUOIrIcYqJiaGhoYHGxsaQdhmKjo7ucIH0nuh4YjXG4HA4jmttvkhg2zZLly7l3nvvxePxcM8995CXl0dWVlbgnAEDBvCzn/2M+Ph41q5dy+9+9zseeOCBwPH77ruPxMTEcIQvIl1kjIG9uzEb1mA2rIXN66nwNvsPZmRhfSnvUGtiZg6WU8thSHAocQyljEEQFQW7t4c7EhGJQJZlERsbG/Lr9LWpxiPdli1b2qyrOWnSJFatWtUmcRw1alTg+YgRIygrK+v2OHuiESNGUFBQ0G5/dnY2J510aAb0P/7xj8TExHDzzTfzySefcNlllzFv3rzuDFWkDVNbA5+vw2xY608WD45PHJiNdfb5JE2cSlVaJla/+LDGKb2bEscQshxOGDQEo5lVRUQkSMrLy/F4PIFtj8fTYTJ00IoVKxg3blybfQeToHPPPZeZM2eGJtAIEhMTw+uvvx7YdrlcVFVV8cMf/pAvvviCTZs2hTE66YuM7YMdWzDr12A2rvVPZmNsiO0HJ5+GddE3scaMx/L0ByA6LQ2rj3+pJqHXbYnjscZjGGNYtmwZa9euJTo6mvz8fHJzcyktLWXx4sUcOHAAy7KYOXMmF1xwAQA1NTU8/PDD7N+/n/79+3P77bcTH+//puWFF15gxYoVOBwOrrvuOsaOHdtdL7UNKzsXs/pdjDGanUpERLqso8l+jnR/Wb9+PW+++Sa/+MUvAvvuv/9+UlNTqays5Je//CWZmZmMHj26Xdnly5ezfPlyAObPn09aWlqb4/v27Tvu8bfBHK97//33k5WVxXXXXQfAggULiI+P59vf/jbf/va3qayspLm5mbvvvpvzzz//mDEcvj8xMZFJkyaxa9cuHA5HjxxrHB0dTVpaGi6Xq92/T0+lWI/MV76fprUf0rj2Q5o+WYWpqQLLwjXsJKIvvYaocWfgHjkay9n+vRhJv1eIrHgVa6v6Q1ZzK50Zj7F27VqKi4tZtGgRBQUFPPnkkzzwwAM4nU6uvvpqcnNzqa+v5+677+bUU08lKyuLF198kS996UvMnj2bF198kRdffJGrrrqKwsJCVq5cyUMPPURFRQX3338/jz76aHgmSMjJhXdehdJ90D+j+68vIiK9isfjadP1tKysjJSU9pNd7Ny5kyeeeIJ77rmHhISEwP7U1FQAkpKSmDBhAlu2bOkwcZw5c2ab1sjDuwg3NjbiPI6xUy6XC6/X2+nzj+Xiiy/mvvvu4+qrrwbgpZde4s9//jNOp5Mnn3yShIQEysvLufjii5k5c2Ygue4ohoaGBqZPnw5ATk4Of/zjHwPn+Xw+bNsOauzB0tjYSGlpaUR14Vash5jmZijY0NL9dA3s2ek/kJSC9aU8rFPGY508FpOQSAPQAFBxICyxBlskxdvXYs3MzDzisW5JHDszHmP16tVMnToVy7IYOXIktbW1VFRUkJKSErghxsbGMmjQIMrLy8nKymLVqlX87Gc/A2DatGn87Gc/46qrrmLVqlVMmjQJt9vNgAEDyMjIYMuWLYwcObI7Xm4bByfIYfc2JY4iItJlw4YNo6ioiJKSElJTU1m5ciVz585tc05paSkPPvggt912W5sPAQ0NDRhjiI2NpaGhgU8//ZRLL720yzGtX1NH1QHfUc+xLOu4lkZJTHZyyvi4Ix4/5ZRTKC0tpbi4mLKyMpKSkhg0aBDNzc3Mnz+fDz/8EMuyKC4uZv/+/QwYMOCIdR3eVVUkFIwxsG/voUltNn0GTY3+dRSHj8b6+jVYp4yHQUPUS016pG5JHDszHqO8vLxN06rH46G8vLzNt6glJSVs376d4cOHA1BZWRk4npKSQlVVVaCuESNGBMqlpqZSXl4e/BfWGYMGg+XA7N6ONX5SeGIQEZFew+l0cv311zNv3jxs22b69OlkZ2fz2muvATBr1iyee+45ampqePLJJwNl5s+fT2VlJQ8++CDgb0k766yzwjaUIxguvPBCXnnlFUpKSvja174GwN///nfKysr417/+hdvt5owzzoiYWYOl9zH1dfD5J4daFctK/AcGZGJNnok1ZjyMOgUrJvQToYl0Vbckjp0Zj3GscxoaGli4cCHXXnstcXFH/gbySHV15FjjN05ER32LS7MG4ywuJKWH9Y9Wn+3QiKRYIbLiVayhoVgjz/jx4xk/fnybfbNmzQo8nzNnDnPmzGlXLj09nQULFgQ9nqO1DB4U7K6qAF/72te48847KS8v5/nnnwegurqatLQ03G437733HoWFhUG9psjRGNuG3dv8k9psWONfU9Hng+hYOPlUrPMu8U9qo15oEoG6JXHszHgMj8fTpk9u63O8Xi8LFy5kypQpnHHGGYFzkpKSAt1ZKyoqAmtSHX698vLywJiO1o41fuNEdNS32M7MwbdpfY/rH93X+mx3l0iKFSIrXsUaGn0x1qON4ZDIMWrUKGpra9sMh7nkkku45pprOP/88xkzZkygl9KJOOOMM6ipqaGpqYlXX32V//3f/w3LsBfp2UxVBWbDOtiwBrNxHVRX+g/k5GLN+i9/q+KwUVgudzjDFOmybkkcOzMeIy8vj1dffZXJkydTUFBAXFwcKSkpGGN4/PHHGTRoEBdddFG7Mm+//TazZ8/m7bffZsKECYH9ixYt4qKLLqKiooKioqIu3Ti6LCcXPnwbU12JlZAUvjhERER6mTfeeKPNdmpqKi+//HKH5x5p2ZIj7f/www+7Fpz0SsbbDFu/ODRWcVfLsmsJSVijx8Ip47FGj8VKbD9plUgk65bEsTPjMcaNG8eaNWuYO3cuUVFR5OfnA7Bp0ybeeecdcnJyuPPOOwG44oorGD9+PLNnz+bhhx9mxYoVpKWlcccddwD+hXzPPPNM7rjjDhwOBzfccEN4ZlRtYWW3TJCzaxuMGXes00VERESkBzH7iw91P/3iM2isB6cThp2ENfsqrFNOh+yhWGH8vCkSat22KNGxxmNYlsWNN97YrtxJJ53Es88+22GdCQkJ/PSnP+3w2CWXXMIll1zShYiDKCcXALN7G5YSRxEREZEezTQ20rjqPez33/IniyVF/gOeAVgTp/m7n550Klbsscf3ivQWPW81217I6pcAqf0PdWUQERERkR7H7NyK+c9rmA/f5kB9HURFw6gvYZ1zsf/L//RMLZUhfZYSx+6Sk4vZrcRRRER6h+NZk1FCQ/8GwWHqajEfvY1593XYtRXcUVinTybpK1+jKj0by61JbURAiWO3sbJzMZ98hGmo11o9IiIS8RwOB16vF5dLHyXCwev1hnX+hkhnjIEtn2PefQ3z8X+gqQmyhmJdeQvWl6dh9YsnOi0NK0JmnBbpDvpr302snFz/H6nCHTD85HCHIyIi0iUxMTE0NDTQ2NjYqa570dHRNDY2dkNkXdfTYzXG4HA4iImJCXcoEcdUV2LeX+FvXSwuhJhYrInnYE05FwYPVzdUkaNQ4thdAhPkbMdS4igiIhHOsixiYzvfg6YvrhcqPYOxbfj8E3/r4roPwef1z4Z67Vys0yerJ5hIJylx7C4padAvATTOUURERCTkTHkpZuVyzH+WQ1kJxCdgTb8Q66xzsQblhDs8kYijxLGbWJblnyBHM6uKiIiIhITxeuGz1djvvgbr14Cx4eTTsL5+DdbYiZroRqQLlDh2Iys7F7PiZYzXi6XJBERERESCwpTsxfzndczKFVBZAcmpWOdfinXWTKz+GeEOT6RXUPbSnXJywev1D8bOGhLuaEREREQilmluwqx5H/Pua7DpM3A44Et5OKbMglNOx3I6wx2iSK+ixLEbWTm5GMDs2oalxFFERETkuJnCHf7WxfffhLoaSEvHmn0V1uQZWMmecIcn0mspcexO6ZkQFdUyQc454Y5GREREJCKYhjrMqv/4Wxe3bwaXC2vcmVhTZsGoL2FpTUuRkFPi2I0shxMGDdEEOSIiIiLHYIyB7Zv9rYsfvQuN9TAwG+ubN2CdMR0rITHcIYr0KUocu5mVk4v56F2MMVpkVkREROQwprYa88Fb/tbFPTshKhprwhR/62LuKH1+CgOfbWj02TT7DE0+//Mmr6HZNjR6bZp8hibfwceW517Tbv/BOuJiyvA2N+J0WLgdFk6Hhcth4bRov88BTsvC7bRwWgf3H3Zey36ng8Pq62Bfy3X0Pjp+Shy7W04uvP0qlO4DzfIlIiIigrFt2Lwe8+7rmDUrwdsMQ0ZgXZ2PNWEqVmxcuEPsUXy2ocFrt/wYyu0a9pXV+RM0b/skrtFnaG7Z1+gzNHkPS/IOT/wOO+4zJx6rywFRTgdRTosopwO308KymmnyevHa/tfibfnxGYPXDt7v6VhxOa1DyaSrVULaen+Uu5DmZi/+X0HLf83BZ7TdbtlpMP55TVqd1Ha7E8dbXeNg3W23TbvjJ2fs456z0k/0V3JMShy7mZU9zP+Pu3ubEkcRERHp9YwxlO33sqOgieamerxe76GDPi9UV2GqK/3JouMcrGmzISEJoqKhEfiPD6ju9rhdrsNiPUG28ScBtvE/t/E/N8Yc2tdmu+U5h8qYVufZ5mDa0dqBTsViYeG2LKItBxb+VjcHYLW0wFmAw/JvO1wWlqvlGFZgv4XlP25xqI5Wzy2LdnUezuVyHfV360+i2iZph5Knw5KqwHETSLzaljmUpLWpo/W+g8+NwXhbx+B/DcYc/vtu+X0eo9GyM22a1hE32u5od63Dti0LYppCu06pEsfuNigHHA7/zKrjJ4U7GhEREZGQsG3D3t3NbNvUSGWFj6hoi/7psViNXqipgopSqK70fzrvlwDp/SEpGazwT3TT5DM0W4ZGYwcSNt/B5M02h54b8BmDbfu3O9p/PBwWOFq6UjpaEjKnw8LhAJflaL+/ZTvK7cL2+Vq2WxI9BzhaJXyOHtQ1MyrKidXkO8ZZPSPeqKgompqawh1Gp/RP7xfS+pU4djMrKhoysjRBjoiIiPRKzU2GXdsa2VbQSEOdoV+Cg1PzYhmUUEX8uhXUvv4POFAGCUlYk2ZgnXUuVsag7o3RZyipbaa4uomimiaKq5sprmmiqLqZfTXNNNtH75vpcljEuixiXA5i3A7/Y8tPrMtBjNtqsy/G5SDW7SDGZXWwz/8T7bJOOLlLS0ujtLT0hMqGQyTFq1gPUeIYBlZOLuaLT8MdhoiIiEjQ1NXabN/cyK5tjXi94Onv5NTTYxgw0IVZ/R7m4UXUNjXCmPE4rrgJTp2A5Qpd17r6ZpvilqSwqLqJ4prmQJJYWtdM69ww2mkxMCGKrKQo8gbFMzDBzZD0VJrra1olg4eSPJejZ7SGiXQnJY7hkJ0LH7yFqTqAlZgc7mhERERETtiBci/bNjWyd3czAJnZbnJHRZOc6sL4fJjnlmFeexGGnUTanb+kwhkVlOsaY6hu9FFU0yoxrD7UenigoW1XyIRoJxnxbk7qH0tGfCIDE6IYGO8mIyGK5Bhnu1k209I8lJZ2YVYYkV5GiWMYWNlDWybI2Q5jxoU7HBEREZHjYoxh314v2zY1ULbfh8sFQ0dGM3RENHH9/GMUTdUB7N8tgE2fYU2/AOuyG3CmD4Tj6EpnG0NZnTfQjbS4dYJY00xdc9tBhJ44FwPj3f5Ww/goMhLcDEyIIiPeTb8oZ1B/ByJ9jRLHcMjJBfBPkKPEUURERCKEz2vYvaOJbZsbqa22iYmzGH1aDDm50bijDrXYme2bsX87H2qqsK77Ho5JM45YZ+vxhoeSwo7HGzotSI93kxEfxUn9YwNJYUZCFOn93ES7wj+xjkhvpcQxDKx+CeAZ4F+SQ0RERKSHa2yw2bGlkR1bmmhqNCSlOBk/MY6B2W4ch433s9/5N+Z/n4CkVBx3/xorZxi2MRRWNbH+QCmb95b5xx0eZbxhRqvxhhnx/lbDgQlu0uLcODW+UCQslDiGS3auZlYVERGRHq26yse2TY0U7mjCtiE900XuqBg8/duPCTTNzZj/fQLz7muUnjKJredfR0GZRcHmXWwpa6C+1crugfGGabFkJCQGWg4HHmG8oYiEnxLHMLFycjGffIhpqMeKiQ13OCIiIiKAf/xiWYmXrZsaKSny4nBC1pAockdFk5DYfpxgbZOPgh372Pzacgq8GWyZ/kvKTRSsqsDlgCHJMZw9NJERnhhOG5JBjK+WeI03FIk4ShzDxMoeijEGCnfA8JPDHY6IiIj0cbZt2Lu7mW2bGqms8BEVbTFyTAxDhkcRHeMfO9jss9lxoJHNpQ0UlNVTUNZAYVXL4ugpXyYzysepmSmMSIthhCeWoSnRRDkPjTtMS4untLQhHC9PRLqo2xLHdevWsWzZMmzbZsaMGcyePbvNcWMMy5YtY+3atURHR5Ofn09urn8SmSVLlrBmzRqSkpJYuHBhoMzDDz/M3r17AairqyMuLo4FCxZQUlLC7bffTmZmJgAjRozg5ptv7p4X2lkHJ8jZvQ1LiaOIiIiESXOTYde2RrZtbqSh3tAvwcGpebFk5rgpqffyflE1m8sa2Fxaz/aKRrwtAxKTYpyMtA8wZfv7jHDWMeJb3yIxJzvMr0ZEQqVbEkfbtlm6dCn33nsvHo+He+65h7y8PLKysgLnrF27luLiYhYtWkRBQQFPPvkkDzzwAABnn3025513HosXL25T7+233x54/vTTTxMXFxfYzsjIYMGCBSF+ZV2QkgbxCaBxjiIiIhIGdbU22zc3smtbI14vJHmcRA8x7PI18vaOAxSsaaC2yT8uMcZlMTw1hotHtbQmxlt4/vZbWP0fGD8Jx3VzsWLijnFFEYlk3ZI4btmyhYyMDNLT0wGYNGkSq1atapM4rl69mqlTp2JZFiNHjqS2tpaKigpSUlIYPXo0JSUlR6zfGMP777/PT3/605C/lmCxLEsT5IiIiEi3O1DuZfPnDewr9GIwVMb4WEs1W/c1wj5wWDA4OZqzchIZ2dLlNCsxKjCbqSneg/3or6CoEOvr12B95RJNZiPSB3RL4lheXo7H4wlsezweCgoK2p2TlpbW5pzy8nJSUlKOWf/nn39OUlISAwcODOwrKSnhhz/8IbGxsVx++eWcfHL77qDLly9n+fLlAMyfP7/N9U+Uy+XqdD3Vo06h7v+exZOcjOXq/uGmxxNruCnW0ImkeBVraChWkd7Naxt2VjSwaVsDtXtsYhqdNBmbL0w9G+xaEnAyIj2GaZ4kRnpiyE2NOeJ6iGbdh9hPPQxOJ47v/wxr9NjufTEiEjbdkq0YY9rtazeFcyfOOZL33nuPyZMnB7ZTUlJYsmQJCQkJbNu2jQULFrBw4cI2XVkBZs6cycyZMwPbpaWlnbre0aSlpXW6HjstA7zNlK5fi5U1tMvXPl7HE2u4KdbQiaR4FWto9MVYD46BF+ltjDHsq2n2j0ksq2fr/gYcByxOIo5ky4UPKIxvICXTxXkDkviuJ53EmGN/HDS2D/PyXzD/91cYPBzHd+7G8gwI/QsSkR6jWxJHj8dDWVlZYLusrKxdS6LH42nzYaCjczri8/n46KOPmD9/fmCf2+3G7XYDkJubS3p6OkVFRQwbNqyrLyWorJxcDGB2bQtL4igiIiKRrarRx+bt5Xy8fT8FZQ1sLmugutFHLA5OccYxwZGA23Lg7AdDRkYxalgMTmfHrYlHYmqrsZ98CNZ/jDV5Bta3voPljgrRKxKRnqpbEsdhw4ZRVFRESUkJqamprFy5krlz57Y5Jy8vj1dffZXJkydTUFBAXFxcpxLHzz77jMzMzDZdYauqqoiPj8fhcLBv3z6KiooC4yt7lPRMiIr2T5AzaUa4oxERkQhxrJnK3333XV566SUAYmJiuPHGGxkyZEinykrk+LS4lvvfKqTJZ3BYkJ0UzVnpCWQ3xmAqwNiQPtDFsFExpPZ3ntA4RLN7O/aSB6CiDOuqfKypX9F4RpE+qlsSR6fTyfXXX8+8efOwbZvp06eTnZ3Na6+9BsCsWbMYN24ca9asYe7cuURFRZGfnx8o/8gjj7Bx40aqq6uZM2cOl112Geeccw7QvpsqwMaNG3n22WdxOp04HA5uuukm4uPju+OlHhfLv6IuZrcmyBERkc7pzEzlAwYM4Gc/+xnx8fGsXbuW3/3udzzwwAOdKiuRYUdFA796Zw8Z8W7unDESZ3kdhVubKNnrBSfkDI0id2Q08YnOE76G/cGbmD8thrh4HHc+gDXspCC+AhGJNN02I8v48eMZP358m32zZs0KPLcsixtvvLHDst///vePWO+tt97abt/EiROZOHHiiQXazaycXMyHb2OM0Td4IiJyTJ2ZqXzUqFGB5yNGjAgMF+lMWen5Suua+cVbhcQ4HeSPHMjuldWUlzYSFW0x6pQYBg+LIjrm+Lqjtma8XsxzyzBvvAwjx+C45YdYicfuBSYivVv3T+UpbWUPhbf+BaX7oH9GuKMREZEerjMzlbe2YsUKxo0bd9xlgz3zeCTNiNuTY61p9PLAq59S32z4wfDBbFlbR3JKFJPO7s+wUQm4jjAbamf5KsqofPjnNG/8hLiLv0n8t28N6szvPfl3ezjFGjqRFK9ibVV/yGqWTrGyh2HAP85RiaOIiBzD8cxCvn79et58801+8YtfHHfZYM883hdn7w22Zp/hF2/uZmd5HbdmDmRvQR1DR0Qx7dxsysrKOHCgvEv1my2fYz/+a6ivxbrxv2k8YxqNBw4EJ/gWPfV32xHFGjqRFG9fi/Vos4537Wsp6bqsweBwYHZpnKOIiBxbZ2YqB9i5cydPPPEEd955JwkJCcdVVnoeYwyPfVDEhn113ODJoHafYdQpMYwZF9vloS7GGOw3/4n94I8hKgrHPf+D44xpQYpcRHoLJY5hZrmjYGC2JsgREZFOaT1TudfrZeXKleTl5bU5p7S0lAcffJDbbrutzbfHnSkrPdMzn5Ty3o5qrklKx3cAxoyLZeSYmK4njU2NmGWPYv7f4zB6LI4fP6QlwkSkQ+qq2gNY2bmYLz4JdxgiIhIBOjNT+XPPPUdNTQ1PPvlkoMz8+fOPWFZ6tn9truDlDeVc0a8/zjqL074cR/bQrq+jaEr3Yf/2V7BrG9bFV2Bd9E0sh9oURKRjShx7guyh8MGbmKoDWInJ4Y5GRER6uGPNVD5nzhzmzJnT6bLSc31YWM2fVu/n0pg0YpsdjJ8Ux8CsICSNG9Zi//5BsG0ct/0E67QJQYhWRHozJY49gJWTe2iCnFN0MxcRERHYVFrP4/8pZrbbQ7xxMmFqP/qnu7tUpzEG86/nMC8+A5k5OPLvwRpw5MkwREQOUuLYE2TnAmB2b8NS4igiItLnFVU3sejNIi6wPMQ7HUycFk+Kp2sf20x9HfayR2DtB1gTpmBd812s6JjgBCwivZ4Sxx7A6hcPngH+FkcRERHp0yobvDy8fC/T7WTio51MOjuexGRnl+o0RbuxlzwAJUVY37wBa8ZXuzyxjoj0LUoce4qcXMzu7eGOQkRERMKo0Wvz2PJiJjYmEhfrYMqMePrFdzFp/Hgl9rJH/Utt3PFLrFGnBClaEelLlDj2EFZ2Lmbdh5iGeqyY2HCHIyIiIt3MZxueWL6PMTX9iI6zOPvcRGJiT3yWU2P7MC88g3n1eRg6Esecu7FS04IYsYj0JUocewgrJxdjDBRuh+Gjwx2OiIiIdCNjDM+8tZ/BB2Jw9IOZsxKJiu5C0lhdhf37BfD5J1hTz8O6/CYsd9cm1hGRvk2JY09xcIKcXduwlDiKiIj0KS+8W0Hq/iia42wuPC8Fl/vExx+anVuwl/wKqg5gXfNdHGedG8RIRaSvUuLYU6R4ID5RE+SIiIj0IcYYXnuvEneRg5oYL5dekIrLdeJJo/3eG5hnlkBiMo675mMNGRHEaEWkL1Pi2ENYlgXZQzVBjoiISB9hjOHtldU07YH9UU186wIPbteJdU813mbMX5/EvPUvOPk0HDf9ACshKcgRi0hfpsSxB7FycjFvvIzxerFc+qcRERHprYxteG9lDdV7bHa5Gvj2BWlEu09s9lRf2X7sBT+CbZuwvnIJ1n9djeXs2kysIiKHU3bSk2TngtcLRbshe2i4oxEREZEQ8PkMH7xXQ0WRjy8cdVzzlTQSok/sI5nZvJ7y3y2AhgYcc+7COn1ykKMVEfE78em6JOisnGGAf4IcERER6X28XsP779RQXuTjY6r5xsxUBsRHnVBdZucW7Id+gtUvAcePFihpFJGQUuLYk6QPhKho2K3EUUREpLdpbrJ5/60ayku8/Meu5JJpqQxJiTmhuoy3GfsPiyA+idT5v8PKzAlytCIibSlx7EEshxOyhmCUOIqIiPQqjQ02K9+soaLMyxu+A5w/MZlTM/qdcH3mX89D4Q4cV30HR0JiECMVEemYEscexsrJhd3bMbYd7lBEREQkCOpqbd57o4bKSh+v+iqYcloiZw898RlPzZ6dmFeexfryVKyxZwQxUhGRI1Pi2NNk50J9HZTuC3ckIiIi0kXVVT7ee6Oa2nofLzeXc+rwOL4+OvWE6zM+n7+Lamwc1uU3BTFSEZGjU+LYw1g5uf4n6q4qIiIS0Q6Ue1m5ooZGr+HvjWUMyYrmprx0/9rNJ8gs/wfsKMC64mat0ygi3UqJY08zaDA4HJpZVUREJIKVlXh5/60abMvw96ZS0jwufjA5E6ejC0njvr2Yl/4MY8/AmjAliNGKiBxbt63juG7dOpYtW4Zt28yYMYPZs2e3OW6MYdmyZaxdu5bo6Gjy8/PJzfW3vi1ZsoQ1a9aQlJTEwoULA2WeffZZ3njjDRIT/YPCr7jiCsaPHw/ACy+8wIoVK3A4HFx33XWMHTu2W15nV1nuKBiYjdm9PdyhiIiIyAnYt7eZ1StrccdY/K2+lKg4i3vPziLadeLf1xvbxv7jInC5cXxrTpdaLUVETkS3JI62bbN06VLuvfdePB4P99xzD3l5eWRlZQXOWbt2LcXFxSxatIiCggKefPJJHnjgAQDOPvtszjvvPBYvXtyu7gsvvJCvfvWrbfYVFhaycuVKHnroISoqKrj//vt59NFHcTgio4HVys7FfP5JuMMQERGR47RnVxNrP6ijX6KDvzeU0mDZ/M/0wSTFdO0jl3n7VSjYiHXtXKxkT5CiFRHpvG7JpLZs2UJGRgbp6em4XC4mTZrEqlWr2pyzevVqpk6dimVZjBw5ktraWioqKgAYPXo08fHxnb7eqlWrmDRpEm63mwEDBpCRkcGWLVuC+ppCKicXKssxVRXhjkREREQ6aceWRta8X0eSx8mrppzihmbuPTuLgQlRXarXlJVgnv8jjB6HNWlGkKIVETk+3ZI4lpeX4/Ec+nbM4/FQXl7e7py0tLSjntORf//73/zgBz9gyZIl1NTUdHi91NTUTtXVUwQmyNE4RxERkYhQ8HkDn31cT/+BLt5xHGBzRQM/OCuTUWmxXarXGIP99GLA4Lg6X11URSRsuqWrqjGm3b7D//B15pzDzZo1i0svvRSAv/71rzz99NPk5+d3WFdHli9fzvLlywGYP39+m8T1RLlcri7XY8fmsR+IK9tHvyDEdCTBiLW7KNbQiaR4FWtoKFaRE2eM4YtPG9jyRSOZOW4+tKr5aGstcyakc0ZWQtfrX7kCNq7FuvIWrLT0IEQsInJiuiVx9Hg8lJWVBbbLyspISUlpd05paelRzzlccnJy4PmMGTP49a9/3eH1ysvLSU1tv2bSzJkzmTlzZmC79fVPVFpaWlDqwTOA2i/WUx+Muo4gaLF2A8UaOpEUr2INjb4Ya2ZmZhCikb7O2IbP1tSzc2sTg4dFsTm6nn9/eoBLx3g4f+TRP8N0qv4D5Zhnn4QRo7GmnR+EiEVETly3dFUdNmwYRUVFlJSU4PV6WblyJXl5eW3OycvL45133sEYw+bNm4mLiztm4nhwDCTARx99RHZ2dqCulStX0tzcTElJCUVFRQwfPjz4LyyUcnK1JIeIiEgPZfsMaz6oY+fWJoafHE1pShN/+nQ/Zw9J5KrTut4qbozB/vPj0NyM49vfxYqQCf5EpPfqlhZHp9PJ9ddfz7x587Btm+nTp5Odnc1rr70G+Lucjhs3jjVr1jB37lyioqLIz88PlH/kkUfYuHEj1dXVzJkzh8suu4xzzjmHZ555hh07dmBZFv379+fmm28GIDs7mzPPPJM77rgDh8PBDTfcEDEzqh5k5eRi1n6AaajDiokLdzgiIiLSwus1fLyylpIiLyefFkNNko/fvFnMqRlx3DZxYFDGIZrV78G6D7AuvRYrY1AQohYR6ZpuW8dx/PjxgTUWD5o1a1bguWVZ3HjjjR2W/f73v9/h/u9+97tHvN4ll1zCJZdccvyB9hBW9jAMwO4dMGJ0mKMRERERgOYmw0f/qaF8v49T82KxUw3zX9tDVlI0d08ZhNsZhKSxugrzv0/A4OFYM78WhKhFRLousprh+pKWmVXVXVVERKRnaGywWflmDRVlPk4/M464DAe/eLOQuCgHP52eRb8oZ1CuY/7ye6irxXHtXCxncOoUEemqbmtxlOOUnArxibBbiaOIiEi41dfZvP9WDfV1Nl8+qx9xHgf3vLaTRq/Nr2YNJi3OHZTrmE8+wnz0NtbFV2BlDQlKnSIiwaAWxx7Ksiz/BDlKHEVERMKqptrHe29U09hgM3FaPCkDnPzqnT3srW7i7qmDGJwcHZTrmLoa7GeWwKDBWBdcGpQ6RUSCRYljD2Zl58KeXRhvc7hDERER6ZMqK7y890YNPh9Mmh5PSpqTR98vYv2+OuZOHMipGf2Cdi3z3B+g8oC/i6orOC2YIiLBosSxJ8vJBZ8X9u4OdyQiIiJ9Tvl+LyvfrMHhhMnnxJOU4uJP6/bz7s5qrhnbn2lDk4J2LbNxHebd17BmzcYaMiJo9YqIBIsSxx7MOjhBjrqrioiIdKuSombef7uG6BgHk89JID7RySubKvj7xnIuGJnMf41ODdq1TEM99tO/gfRBWF+9Imj1iogEkxLHnmzAQIiKht3bwx2JiIhIn7F9Sw0f/aeW+AQnk8+JJ66fg/d3V/P71fs4IyueG09PD8pajQeZF/4E5ftxXPNdrKjgjJcUEQk2zarag1kOJ2QPxezaGu5QRESkB1m3bh3Lli3Dtm1mzJjB7Nmz2xzfs2cPS5YsYfv27Vx++eV89atfDRy79dZbiYmJweFw4HQ6mT9/fjdH37OVlXh5/61iUjxOvjwlHneUxRf763novb2M8MTw35MzcTqCmDRu2Yh58xWs6Rdiad1mEenBlDj2cFZ2LuaDNzG2jeVQA7GISF9n2zZLly7l3nvvxePxcM8995CXl0dWVlbgnPj4eK677jpWrVrVYR333XcfiYmJ3RVyRNm9owm328EZ0+JxuSz2VDXxy7cL8cS5uPfsLKJdwbsXm6ZG7D88Bqn9sf7r6qDVKyISCspEerqcXGioh9LicEciIiI9wJYtW8jIyCA9PR2Xy8WkSZPaJYhJSUkMHz4cpxaPPy62bSje00z2kH64XBYH6r38/M3dOID7pmeTFBPc79vNy3+BfXtwfPs2rJjYoNYtIhJsanHs4azsoRjwj3MckBnucEREJMzKy8vxeDyBbY/HQ0FBwXHVMW/ePADOPfdcZs6cGdT4Iln5fi/NTYbBw/rR4K3j/rcKqaj3Mm9mDgMTooJ6LbOjAPPaC1hnnYs1emxQ6xYRCYVOJ47r169nwIABDBgwgIqKCv785z/jcDi48sorSU5ODmGIfdygweBwYHZtwzp9crijERGRMDPGtNt3PBO13H///aSmplJZWckvf/lLMjMzGT26/di65cuXs3z5cgDmz59PWlraiQcNuFyuLtcRagUb9+N0WQwaHM89/7eTbRUN/Oqik5mU6zl24eNgmpspf2YJJKfimfMDHP0SulRfJPxuD1KsoRFJsUJkxatYW9Xf2ROXLl3Kj3/8YwCefvppAJxOJ0888QR33XVXaKITLHcUDMzG7NKSHCIi4m9hLCsrC2yXlZWRkpLS6fKpqf5lJJKSkpgwYQJbtmzpMHGcOXNmm9bI0tLSLkQNaWlpXa4jlIwxbC+oon+6k4VvFbByRwXf+XI6JyWaoMdtv/wXzM6tOG79MeX1jVDf2KX6evrvtjXFGhqRFCtEVrx9LdbMzCP3cOz0GMfy8nLS0tLw+Xx88skn3HLLLdx0001s3ry5S8HJsVk5uaC1HEVEBBg2bBhFRUWUlJTg9XpZuXIleXl5nSrb0NBAfX194Pmnn35KTk5OKMONGBVlPhobDAeivfxj/T4uHePhvBGdT8g7y+zZiXnlWawvT8Uae0bQ6xcRCZVOtzjGxsZy4MABdu/eTVZWFjExMXi9XrxebyjjE/BPkPP+m5jKCqyk4N/EREQkcjidTq6//nrmzZuHbdtMnz6d7OxsXnvtNQBmzZrFgQMHuPvuu6mvr8eyLP75z3/y0EMPUV1dzYMPPgiAz+fjrLPOYuzYsWF8NT1HcWEzlgP+r6iC4Wn9uOq04Hf3Mj4f9h8WQVw/rMtvDnr9IiKh1OnE8bzzzuOee+7B6/Vy7bXXAvDFF18waNCgUMUmLazs3JYJcrZB0unhDkdERELEGMPnn3/eYdfR1saPH8/48ePb7Js1a1bgeXJyMo8//ni7cnFxcSxYsCA4wfYixhiKCptxJcKO0kZ+cdaQ4xo32unrLP8H7CjAuvlOrAQthyIikaXTiePs2bP58pe/jMPhICMjA/CPk5gzZ07IgpMW2UMB/BPknKLEUUSkt/J6vfz85z/nr3/9a7hD6VOqDtjU1dp8Hl1LZkIUZw9Po6K87NgFj4Mp3oN56c8w9gysvLOCWreISHc4ruU4Wg+WXL9+PQ6H45jfikrXWXHxkJYOmiBHRCTivf3220c8puEf4VFU2ATAx7U13DQxHacjuK2Nxraxn34M3G4c35oTktZMEZFQ63TieN9993HFFVdw0kkn8eKLL/LKK6/gcDj4yle+wiWXXBLKGAUgJxejCXJERCLekiVLyM3Nxe12tzvW0VIbEnrFhc1UurwkRDk5e2hS0Os3b78KBRuxrp2LlRzcpT1ERLpLpxPH3bt3M3LkSADeeOMN7rvvPmJiYvjJT36ixLEbWNm5mDXvY+rrsGLjwh2OiIicoIEDB/Ktb32LU045pd2xpqYmrr766jBE1XfVVPmorrLZ4Kvjv0734Ap2a2NZCeb5P8LocViTZgS1bhGR7tTp5TgOfgtaXFwMQFZWFmlpadTW1oYmMmnDys71PyncEdY4RESka0aPHs3evXs7PKYhIN2vaE8zABVRzcwcFtzWRmMM9tOLAXB8+1Z1URWRiNbpFsdRo0bx1FNPUVFRwYQJEwB/EpmQkBCy4KSVHH/iaHZtwxqhDxUiIpHqsssuIzk5ucNjLpeL++67r3sD6uN27GikxDQx6+Rkol2d/j69U8zKN2DjWqwrb8HyDAhq3SIi3a3TfyFvvfVW4uLiGDx4MJdddhkAe/fu5YILLghZcNJKciokJMHureGOREREuuB73/tem+2D6ypK96urtWmoMux1NHHeyOSg1m0OlGOeXQojRmNNOz+odYuIhEOnWxwTEhK48sor2+w7fA0pCR3LsiA7F6OZVUVEItrhE+Bs2LAhTJHI51vqARiRG02c2xm0eo0x2H/+LTQ347hmLpYjuC2ZIiLh0OnE0ev18ve//5133nmHiooKUlJSmDp1Kpdccgku13Gt6iEnyMrJxbz+EsbbjOVqPxufiIj0fBrn1nNs2dZAIzazv5Qa1HrN6v/Aug+xLr0OKz3z2AVERCJApzO+Z555hq1bt3LTTTfRv39/9u/fz/PPP09dXR3XXnvtMcuvW7eOZcuWYds2M2bMYPbs2W2OG2NYtmwZa9euJTo6mvz8fHJz/eP6lixZwpo1a0hKSmLhwoWBMn/605/4+OOPcblcpKenk5+fT79+/SgpKeH2228PrDs5YsQIbr755s6+1J4reyj4vLB3d2DMo4iIRBafz8f69esD27Ztt9kGOpxxVYJrV2kjsY0O8EBidBBbG6srMf/7OxgyAmvmV4NWr4hIuHU6cfzggw9YsGBBYDKczMxMhg4dyp133nnMxNG2bZYuXcq9996Lx+PhnnvuIS8vj6ysrMA5a9eupbi4mEWLFlFQUMCTTz7JAw88AMDZZ5/Neeedx+LFi9vUe+qpp3LllVfidDp55plneOGFF7jqqqsAyMjIYMGCBZ19eRHBysnFAGb3NiwljiIiESkpKYnf/va3ge34+Pg225Zl8Zvf/CYcofUpK9ZV4rGimPSl+KDWa/7ye6irxfHfc7GcwUtIRUTCrdOJY1cWJd6yZQsZGRmkp6cDMGnSJFatWtUmcVy9ejVTp07FsixGjhxJbW1toEvs6NGjKSkpaVfvaaedFng+cuRIPvjggxOOMSIMyIToGNi1DSaHOxgRETkRh38JKt2vrK6ZhlKD122TlR4VtHrNJx9hPnoH66tXYg0aHLR6RUR6gk4njmeeeSa//vWvufTSS0lLS6O0tJTnn3+eiRMnHrNseXk5Ho8nsO3xeCgoKGh3TlpaWptzysvLSUlJ6VR8K1asYNKkSYHtkpISfvjDHxIbG8vll1/OySef3Kl6ejLL4YCsIZogR0REpAteXF/OQKLIzHEHbcypqavBfmYJDBqMdf7Xg1KniEhP0unE8aqrruL5559n6dKlVFRUkJqayqRJk7j00kuPWbaj1srD/1B35pwj+fvf/47T6WTKlCkApKSksGTJEhISEti2bRsLFixg4cKFxMXFtSm3fPlyli9fDsD8+fPbJK4nyuVyBaWeI6kaOYaGN/+FJzW1y7O0hTrWYFKsoRNJ8SrW0FCs0pdUNnjZtK2BAVY0w3Njglav+dsyqDqA47Z7NYGdiPRKR00cDx+sP2bMGMaMGYMxJpDUffHFF8ccxO/xeCgrKwtsl5WVtWtJ9Hg8lJaWHvWcjrz11lt8/PHH/PSnPw3E5Ha7cbv9f7Rzc3NJT0+nqKiIYcOGtSk7c+ZMZs6cGdhuff0TdbA1NlTs/gMxDXWUfrEea0DXZmoLdazBpFhDJ5LiVayh0RdjPTh5mvQ9L39RQbaJxh0DyanBGYNoNq7F/Od1rPO+jjV4eFDqFBHpaY6aOLYerN/awQTtYAJ5rEH8w4YNo6ioiJKSElJTU1m5ciVz585tc05eXh6vvvoqkydPpqCggLi4uGMmjuvWreOll17i5z//OdHR0YH9VVVVxMfH43A42LdvH0VFRYHxlZHu4AQ57NrmH/MoIiIinVLb5OPfmyq41NmfQdlRQemmahrqsZ9eDBmDsC6+PAhRioj0TEdNHIM1gN/pdHL99dczb948bNtm+vTpZGdn89prrwEwa9Ysxo0bx5o1a5g7dy5RUVHk5+cHyj/yyCNs3LiR6upq5syZw2WXXcY555zD0qVL8Xq93H///cChZTc2btzIs88+i9PpxOFwcNNNNxEfH9xZ08ImczA4nZhd27Dyzgp3NCIiIhHjn5srSPW5cTgtBmYFpzupeeFPUL4fxw9/hRUVfewCIiIRqtNjHLtq/PjxjB8/vs2+WbNmBZ5blsWNN97YYdnvf//7He5/7LHHOtw/ceLETk3aE4kstxsGZmN2a4IcERGRzmrw2vzjiwpmxiXjNhap/bv+EcgUbMS8+QrW9Auxho8OQpQiIj1X12ZXkbCwsof6u6qKiIhIp7y+5QA1jT7SvG4GDnLjcHStm6ppasT+42OQ2h/rv64OUpQiIj2XEsdIlJMLVQcwlRXhjkRERKTHa/bZvLCxnEnJCdg+yAhCN1Xz8l9g3x4c374NKyY2CFGKiPRsShwjkJXdMjusWh1FRESO6c3tVZTVezk9Ph6XC9LSu9ZN1ewowPz7Bawps7BGjw1OkCIiPZwSx0iUPRQAs2trmAMRERHp2Xy24fkNZYxIiaG5AtIz3TidJ95N1Xibsf+wCJKSsS69LoiRioj0bEocI5AV1w/6Z2iCHBERkWP4z84qimua+WpOKk2NpsvdVM2/noc9O3Fcle+/H4uI9BFKHCOVJsgRERE5KtsYnttQRk5SFCmNLhxOGDDwxBNHs2cn5pVnsb48Deu0LwcxUhGRnk+JY4SysnNhfzGmvi7coYiIiPRIqwpr2FXZxNdHp1K8p5kBGW5crhPrpmp8Pn8X1bh+WJffFORIRUR6PiWOEcrKyfU/2b09vIGIiIj0QMYY/rahjIx4N19K7EdDfde6qZrlL8GOAqwrbsFKSAxipCIikUGJY6RqSRw1zlFERKS9T4rrKChr4OtjPOzb48WyID3zxGZTNcV7MC/9Pxg7EStvcpAjFRGJDEocI1VSKiQkaZyjiIhIB/62vhRPrIuzhyRQXNhMWrqLqKjj/9hjbBv76cfA7cbxrTlY1onPyCoiEsmUOEYoy7IgOxejxFFERKSNz0vqWF9Sz+zRqTTUQG2NzcAT7KZq3v4XFGzEuuxGrOTUIEcqIhI5lDhGMCsnF4p2Y7zN4Q5FRESkx/jbhjISo53MGp5MUaH/Hpkx6PgTR1O6D/P8H2HMOKxJ5wQ7TBGRiKLEMZLl5ILPC3t3hTsSERGRHmFbeQMf763lqyelEONyUFTYRGp/J9Exx/eRxxiD/afFgIXj6lvVRVVE+jwljhHMym6ZIEfdVUVERAB4bkMZcW4H549MoabaR3WlzcATaW1c+QZsXIf19WuwPANCEKmISGRR4hjJBgyE6BhNkCMiIgIUVjayclc1F4xMIT7KSfHBbqpZUcdVj698P+bZpTByDNa080IRqohIxFHiGMEshwOyhmhJDhEREeD5jWVEOS2+elIKAEWFzSSlOInr1/mPO8YYqp94EJqbcXz7u/57rYiIKHGMdFZOLuzegbHtcIciIiISNvtqmnhrexWzRiSTFOOivs7mQLnvuGdTNe8tp/Gjd7G+9i2s9MwQRSsiEnlObCVc6Tmyc6Hxn7C/GHSDExHpE9atW8eyZcuwbZsZM2Ywe/bsNsf37NnDkiVL2L59O5dffjlf/epXO102Ur2wsRyHBbNP9i+ZcbCb6vEkjmbLRswzvyXq1Dy8M7967AIiIn2IWhwjnJUzDNAEOSIifYVt2yxdupQf/ehHPPzww7z33nsUFha2OSc+Pp7rrruOiy+++LjLRqLyei/Lt1ZyTm4SaXH+RLFoTzPxiQ7iE52dqsOUlWAv+RV4BpB05y+xnJ0rJyLSVyhxjHSZOeB0wu6t4Y5ERES6wZYtW8jIyCA9PR2Xy8WkSZNYtWpVm3OSkpIYPnw4zsOSn86UjUQvfV6OzxguGe0BoLHBpmy/t9OtjaahHvs3vwSvF8d378URnxjKcEVEIpISxwhnud0wMFstjiIifUR5eTkejyew7fF4KC8vD3nZnqq60cerBRWcNTiRgQn+2VP37W0G07luqsa2sZc+DHt24bjlh1gZWaEOWUQkImmMYy9gZediNqwJdxgiItINjDHt9nV2cfrjKbt8+XKWL18OwPz580lLSzuOKNtzuVxdrqMjL32wkwav4abJw0hL6wfA2g/2Ep/oInd4+jF/NzXPPE7tug9IuOH7xE07N6SxhkokxatYQyOSYoXIilextqo/ZDVL98nJhfdXYA6UYyWnhjsaEREJIY/HQ1lZWWC7rKyMlJSUoJedOXMmM2fODGyXlpaeYMR+aWlpXa7jcHXNPp5du4czsuJJpJ7S0nqamwx7dtcxdER0m9faEfvDtzHPP401ZRa1Z0ynriW+UMQaSpEUr2INjUiKFSIr3r4Wa2bmkSfbVFfVXsDKyfU/0XqOIiK93rBhwygqKqKkpASv18vKlSvJy8sLedme6NWCA9Q02XzjlEPdb/cVNWPsY3dTNds3Y/6wCEaegnXlLZ1utRUR6avU4tgbZA0F/DOrWl+K3A8AIiJybE6nk+uvv5558+Zh2zbTp08nOzub1157DYBZs2Zx4MAB7r77burr67Esi3/+85889NBDxMXFdVg2EjV6bV76vJyxGXGM8MQG9hcXNhMdY5HiOfKsqKa8FHvxPEhOxTHnbizX8a31KCLSF3Vb4nisdaOMMSxbtoy1a9cSHR1Nfn4+ubn+lrQlS5awZs0akpKSWLhwYaBMTU0NDz/8MPv376d///7cfvvtxMfHA/DCCy+wYsUKHA4H1113HWPHju2ul9rtrLh+0D9DE+SIiPQR48ePZ/z48W32zZo1K/A8OTmZxx9/vNNlI9HyrZUcaPDxjVMOjefxeg0lRc1kD406YguiaWzEXvIANDTguP1+rATNoCoi0hnd0lW1M+tGrV27luLiYhYtWsTNN9/Mk08+GTh29tln86Mf/ahdvS+++CJf+tKXWLRoEV/60pd48cUXASgsLGTlypU89NBD/PjHP2bp0qXYth3S1xh22bnqqioiIn2C1za8sLGMk/vHMmbAodbG/cXN+HyQcYRuqsYYzLJHYNdWHDf9AGtQTjdFLCIS+bolcezMulGrV69m6tSpWJbFyJEjqa2tpaKiAoDRo0cHWhJbW7VqFdOmTQNg2rRpgTpXrVrFpEmTcLvdDBgwgIyMDLZs2RLiVxleVk4u7C/G1NWGOxQREZGQent7JfvrvFw6xtOmZbGosBl3lIWnf8cdqsz//RXz8XtYX78G67QJ3RWuiEiv0C1dVTtaN6qgoKDdOa2njz24ttTRZoqrrKwMHE9JSaGqqipQ14gRIwLnpaamdrhOVbCnGofwTdnbeMpYDrz4DEnV5UTlDO5UGU0vHBqRFCtEVryKNTQUq0QSn214bkM5uSnRnJ7ZL7Df9hn27W1m4KAoHI723VTNx+9h/vH/sM6cjjXrv7ozZBGRXqFbEsfOrBvVlXWpOnO9jgR7qnEI35S9JsmfmB/4bC2O9M5NdNDXphfuLpEUK0RWvIo1NPpirEebblx6tvd3V7O3uokfTsls8zmhtMSLt7njbqpm11bspx6GYSdhXX2bZlAVETkB3dJVtTPrRnk8njYfBjqzLlVSUlKgO2tFRQWJiYkdXq+8vJzU1F6+vmFSKiQkgSbIERGRXsoYw3MbyhiUGMXErIQ2x4oKm3G6oH9G2+/EzYFy7N/Mg/hEHPn3YLk1g6qIyInolsSxM+tG5eXl8c4772CMYfPmzcTFxR0zcczLy+Ptt98G4O2332bChAmB/StXrqS5uZmSkhKKiooYPnx4aF5cD2FZFuTkYnZvD3coIiIiIfHx3lq2VzRy6RgPzlbdUY1tKN7TTPpAN05nq/3NTf4ZVGurcdx6L1bi0T9XiIjIkXVLV9XOrDk1btw41qxZw9y5c4mKiiI/Pz9Q/pFHHmHjxo1UV1czZ84cLrvsMs455xxmz57Nww8/zIoVK0hLS+OOO+4AIDs7mzPPPJM77rgDh8PBDTfcgMPRLTlyWFk5uZjXXsQ0N+sbVRER6VWMMTy7vowB/VxMHdJ2CY3yUh9NjYaBrbqpGmMwT/8Gtm/G8Z27/ZPIiYjICeu2dRyPteaUZVnceOONHZb9/ve/3+H+hIQEfvrTn3Z47JJLLuGSSy45sWAjVfYw8Plg7y4YPCzc0YiIiATNZ/vq2FRazy0T0nEdNvlNUWETDgcMGNgqcXz175gP3sL62rewxk/q7nBFRHqd3t8M14dY2UMB/yQAIiIivclzG8pIiXEyc1hSm/3GGIr2NNM/w4XL7U8ozboPMS88jTVhCtaFl4UjXBGRXkeJY28yYCBEx8JuTZAjIiK9x+bSej4pruNrJ6cS5Wz70aWywkdDnWFgVhQApnAH9pMPQc4wrGvnagZVEZEgUeLYi1gOB2QP0QQ5IiLSq/xtQxnxUQ7OG9F+cpuiwmYsC9IzXZjqSuzf/BJiY3Hc9mOsqOgwRCsi0jspcexlrOxc2L0DY9vhDkVERKTLdlQ08FFhDRePSiXW3fZjizGGosJmPANcuJ0+7CW/gqoDOPJ/jJXsCVPEIiK9kxLH3iYnFxrroaQo3JGIiIh02fMbyolxObhwVPvWxpoqm9pqm4xBLswzv4UtG/3dU4eOCEOkIiK9mxLHXsbK9k83bjTOUUREIlxRdRP/2VXFBSOTSYh2tj9e2AxA+vY3Me8tx7romzi+PLW7wxQR6ROUOPY2mTngdGqCHBERiXjPbSjDaVl89aTUDo8XFTaTEldP9HNPwPgzsS6+opsjFBHpO5Q49jKW2w0DczC7lDiKiEjk2l/bzFvbKzl3eBIpse2Xna6t8VF1wEf6hv+DQYNxXH+7f5I4EREJCf2F7YWsnFzYtQ1jTLhDEREROSEvfl6OMXDJ6I4nuSnaWgNARuUGHLfdixUd053hiYj0OUoce6OcXKiuhMrycEciIiJy3A40eHltywHOHppE/37udseN10vRJ4UkVu8k/sY5WJ7+YYhSRKRvUeLYC1nZQ/1P1F1VREQi0MtfVNDsM1wypuOxjfV/fYYD0YPIGOTGGnZSN0cnItI3KXHsjQIzq24PcyAiIiLHp6bJxz83VzApJ4GsxOh2x+03/0nxlkoAMieP6u7wRET6LCWOvZAVGwf9MzRBjoiIRJx/bqqgrtnmG6e0H9toPv8E85ffUZx7DvEJDhIS2y/RISIioaHEsbfKydWSHCIiElEavDb/2FRBXmY/hqa0nezG7NuL/fivaRo0kvLobDKy2o99FBGR0FHi2EtZ2bmwvxhTVxvuUERERDrl3wUHqG708Y1T0trsN3U12L+5HxwW+792J8bAQCWOIiLdSoljL2Xl+Mc5onGOIiISAZp9Ni9+Xs6X0uM4qX9sYL/x+bB/twD2F+P4zj0UV8USG2eRlKJuqiIi3UmJY28VmCBH3VVFRKTne2NbJeX1Xi4d03Zso3nuD7BhLda3voNv6Bj2F3sZmBWFZVnhCVREpI9S4thLWcmpkJisJTlERKTH89mGv28sZ4QnhtMy4gL77Xdfwyx/CWvGxTimzGJfUTO2jcY3ioiEgRLH3iwnVy2OIiLS4727s4p9Nc184xRPoCXRbF6P+fPjMHoc1jeuB6CosJnoGItUj7qpioh0NyWOvZiVnQtFuzHNzeEORUREpEO2MTy3oYzBydFMGBQPgNlfjP3b+dA/Hcctd2I5nfi8hpKiZjIGubEc6qYqItLdlDj2Ztm54PPB3p3hjkRERKRDHxbWsLuyiUvHeHBYFqahDnvxPLBtHLf9BCvOn0zu3+fF51U3VRGRcFHi2IsdnFnVaJyjiIj0QMYY/ra+jIEJbibnJGBsH/aTD0HRbhy3/BArPTNwblFhE263RdoAVxgjFhHpu5Q49mb9MyAmFjTOUUREeqC1RbVsLW/g66M9OB0W5sVn4JOPsC6/CWv02MB5tm3Yt9dL+iAXDnVTFREJCyWOvZjlcEDWULU4iohIj/S39WV44lycPTQJ+/03Mf96HmvaeVhnX9DmvLISL81NhoFZUeEJVERE6Lb+HuvWrWPZsmXYts2MGTOYPXt2m+PGGJYtW8batWuJjo4mPz+f3Nzco5Z9+OGH2bt3LwB1dXXExcWxYMECSkpKuP3228nM9HdxGTFiBDfffHN3vdQexcoeiln5Bsb2YTk0C52IiPQMG0rq2Li/nhtPH4Brxybspx+DUV/Cuvzmdms0FhU243RC/3R1UxURCZdu+Qts2zZLly7l3nvvxePxcM8995CXl0dWVlbgnLVr11JcXMyiRYsoKCjgySef5IEHHjhq2dtvvz1Q/umnnyYu7tDaTxkZGSxYsKA7Xl7PlpMLb74CJUWQkXXs80VERLrBc+vLSIp2cq7Hiz3/AUhJwzHnLixX248mxjYU72lmwEA3Tpe6qYqIhEu3dFXdsmULGRkZpKen43K5mDRpEqtWrWpzzurVq5k6dSqWZTFy5Ehqa2upqKjoVFljDO+//z6TJ0/ujpcTUQIT5OzeHuZIRERE/LaUNbCmqJaLRyTgfvwBaG7C8d2fYMUntju3osxHY4NhYLZmUxURCaduaXEsLy/H4/EEtj0eDwUFBe3OSUtLa3NOeXl5p8p+/vnnJCUlMXDgwMC+kpISfvjDHxIbG8vll1/OySefHOyXFRkyc8Dpgl3bYMKUcEcjIiJB0JXhH7feeisxMTE4HA6cTifz58/v9vif21BGnNvBV1Y+A7t3+JPGgdkdnltU2IzDAQMGKnEUEQmnbkkcjTHt9h0+fuFI53Sm7HvvvdemtTElJYUlS5aQkJDAtm3bWLBgAQsXLmzTlRVg+fLlLF++HID58+e3SVxPlMvlCko9wVSWMxRH8W5SDourJ8Z6JIo1dCIpXsUaGoo1snRl+MdB9913H4mJ7Vv3usPuykY+2F3Npe4i+q15B+sb12N96fQOzzXGUFTYRFq6C7db3VRFRMKpWxJHj8dDWVlZYLusrIyUlJR255SWlrY7x+v1HrWsz+fjo48+avONqdvtxu32fzOZm5tLeno6RUVFDBs2rM01Z86cycyZMwPbra9/otLS0oJSTzDZA3Pwfraa/fv3t0m6e2KsR6JYQyeS4lWsodEXYz04eVokaj2EAwgM4WidOB5p+Mfh995weG5DGVGW4cK3nsCaPAPr3K8d8dzKCh/1dYaRY9TaKCISbt0yxnHYsGEUFRVRUlKC1+tl5cqV5OXltTknLy+Pd955B2MMmzdvJi4ujpSUlGOW/eyzz8jMzGzTnbWqqgrbtgHYt28fRUVFgRtsn5STC9WVcKA83JGIiEgXdTSEo7y8vN05HQ3/OGjevHncddddgV433WVfTRPvbK9iVuFKEgcPwfpWfrteRK0V72nGsiB9kBJHEZFw65YWR6fTyfXXX8+8efOwbZvp06eTnZ3Na6+9BsCsWbMYN24ca9asYe7cuURFRZGfn3/Usgcd3k0VYOPGjTz77LM4nU4cDgc33XQT8fHx3fFSeyQrOxcDsHsbpHiOdbqIiPRgXRn+AXD//feTmppKZWUlv/zlL8nMzGT06NHtzg/2cA6Xy8Urn5fhsL38V816+j/wKI7k1KOWKSnaSUZmLIMGDejStY9XpHWJjqR4FWtoRFKsEFnxKtZW9Yes5sOMHz+e8ePHt9k3a9aswHPLsrjxxhs7XfagW2+9td2+iRMnMnHixC5E28tkDwXA7NqGdeqEMAcjIiJd0ZXhHwCpqf5kLSkpiQkTJrBly5YOE8dgD+cwjmhe2VTOOSVrSb15LuVeG45SZ3WVj8qKZrKHurq9K3Ukdd+GyIpXsYZGJMUKkRVvX4v1aEM5uqWrqoSXFRsHAwZidm8LdygiItJFXRn+0dDQQH19PQANDQ18+umn5OTkhDxmYwx/fPof2MAlU0ZhZQ09ZpmiwmYAMtRNVUSkR+i2FkcJs+yhsHNruKMQEZEu6srwj8rKSh588EHAP7ncWWedxdixY0Mec+X//Z1/2iOYElvFwC+f2akyxYXNpHicxMbpO24RkZ5AiWMfYWXnYj5eiamrwYrru+M9RUR6gxMd/pGens6CBQtCHt/h/s81lEZnFJeeO7JT59fV+qis8HHyaTEhjkxERDpLX+P1EVZOy1Iku3eENQ4REel7ho0ZwZWnDyInuXOJ4MFuqgOz1E1VRKSnUOLYV+TkAmB2q7uqiIh0rzNzErj1rGOPazyoqLCZxGQH/eKdIYxKRESOhxLHPsJKSoGkFNilCXJERKTnaqi3qSj1MTArKtyhiIhIK0oc+5LsoRgljiIi0oMV79FsqiIiPZESxz7Eys6Fot2Y5qZwhyIiItKhosJm+sU7SEjSRxQRkZ5Ef5X7ECsnF2wb9u4KdygiIiLtNDXalJV4GZjtxrKscIcjIiKtKHHsSw5OkKPuqiIi0gPt2+vFGBiobqoiIj2OEse+JC0DYmI1QY6IiPRIRYVNxMRaJKVqNlURkZ5GiWMfYjkckDUUs1uJo4iI9CzeZsP+Yi8Ds9RNVUSkJ1Li2MdYObmwezvG9oU7FBERkYCS4mZsGzK0DIeISI+kxLGvycmFpkYoKQp3JCIiIgFFu5uJirbwpKmbqohIT6TEsY+xsjVBjoiI9Cw+n2FfUTMZg9xYDnVTFRHpiZQ49jWZ2eB0aYIcERHpMUr3efF5YWCWZlMVEempXOEOoLdo9No89kERX8puICPax7CUGOKje153G8vlhsxsTZAjIiI9RlFhMy43pA3QxxIRkZ5Kf6GDpLTOy6bSet7duSOwLz3eTW5KDMNSoxmWGkNuagzJMeH/lVs5uZhPVmGMCXcoIiLSx9m2oXhPM+mZbhxOdVMVEempwp/F9BKDEqP4/ezhuPslsWrLXraVN7C1ooFt5Q28v7s6cJ4n1kVuqj+Z9D/G4Il1de/U49nD4L03sMtLAd2kRUQkfMr2e2luMuqmKiLSwylxDLKkWDdjB/Zj7MB+gX21TT62VzSytbwhkFB+vLcGu6XBLynGybCUmEBCOSw1hgH9QreOlZWTiwG82zbD0FEhuYaIiEhnFBc243BC/wwljiIiPZkSx27QL8rJKelxnJIeF9jX4LXZcTCZrGhga3kDL2wsw2cOlnG0SiZjyE2NJjMhCkcwksmsIQDUv/4SJm8KZObAgAwsR88bkykiIr2XMYaiwmYGDHTjcqkHjIhIT6bEMUxiXA5O6h/LSf1jA/uafDY7DzSyrfxQQvnKpgqaW5omY1wOclMOjZcclhpDVmIUzuOcutyKjYNTJ9C46j+w6j/+nS43ZGRhZeZAZnbLYw70T1dCKSIiIVFR5qOxwTBwkFobRUR6OiWOPUiU08EITywjPIeSSa9tKKz0J5L+n0Ze23KAxpamySinxZDktslkTlIUbufRV1pxfvcnpPaLo2z9J5i9u2DvLkzRbszWz+GjtwlMm3N4QjmoJaFMU0IpIiJdU1zYjOWA9Ex9HBER6en0l7qHczkshqTEMCQlhhnD/Pt8tmFvdVOrMZONvL2jin8VHGgpA4OTo1tmdPUnlEOSo4l2tU0mHbFxWENHYA0d0Wa/aaiDosKWhHI3Zu8uzJaNbRNKdxRkDAq0TB5MLJVQiohIZxzspto/3YU7SstKi4j0dEocI5DTYZGdFE12UjRnD00CwDaGfTXNgZbJbeUNfFBYw+tbKwFwWJCdGE1uq6VBvhTbhG1Mu3GTVkwcDB2JNXRkm/2moc6fSBbt9rdQ7t2FKdgAH7ZKKKOiWrVQ5mANzG7VQqkPBiIi4ld1wEddrc3wk6PDHYqIiHRCtyWO69atY9myZdi2zYwZM5g9e3ab48YYli1bxtq1a4mOjiY/P5/c3Nyjln322Wd54403SExMBOCKK65g/PjxALzwwgusWLECh8PBddddx9ixY7vrpYaFw7IYmBDFwIQozhrs/30YYyit87ZJJtcV1fLm9qqWUrtwOSA11k1anAtPnAtPXPvnyTEunA7Ln1DmjsLKbTsTq6mvg6Ldh7q87t2F2bQePnjrsIQyu/0YSs8AJZQiIn1QUWEzWJCh8Y0iIhGhWxJH27ZZunQp9957Lx6Ph3vuuYe8vDyysrIC56xdu5bi4mIWLVpEQUEBTz75JA888MAxy1544YV89atfbXO9wsJCVq5cyUMPPURFRQX3338/jz76KI4+lqBYlkX/fm7693MzMTshsL+83su28gZqiGJnyQHK6ryU1TVTUNbAh4U1NPlMm3ocFqTEuloSSrc/qYxtm2SmDh6Ju6OEsiWRDHR5/eJT+ODNVgllNAzMDrRMBrq8KqEUEenVigub8aQ5iY7R33oRkUjQLYnjli1byMjIID09HYBJkyaxatWqNonj6tWrmTp1KpZlMXLkSGpra6moqGD//v3HLHu4VatWMWnSJNxuNwMGDCAjI4MtW7YwcuTII5bpS1JjXaQOiictLY3S0qg2x4wxVDfZlNU1U1bnpTTw6E8udx1oZM3eGhq8pl29yTHODlosB+IZmU3aWDepsS6iXQ5MXW37FsojJZSZ/oSyYfhJGMsJSSmQlILljmp3fRERiQw1VT6qq2zGjIs99skiItIjdEviWF5ejsfjCWx7PB4KCgranZOWltbmnPLy8mOW/fe//80777xDbm4u3/72t4mPj6e8vJwRIw5N+JKamkp5eXkoXlqvY1kWidFOEqOdDE3p+BxjDHXNdpvEsqzOS1m9/3lxTTMbSuqoabLblU2Idra0VvYjLe5UPKPH48lzkRbnJtVqIq2ymJh9rRLKzz+B99+k8vCK4vpBUiokJmMlpUJSsn87qWU7MQWSUyAuHisYa1+KiEjQFBU2AzAwS91URUQiRbckjsa0b506/MP8kc45WtlZs2Zx6aWXAvDXv/6Vp59+mvz8/A7LdGT58uUsX74cgPnz57dJXE+Uy+UKSj3doauxDj7G8fpmH/trmthf00hJTSMl1Qef+x+37qnlQH3zYaUs+kXl0j/pZAYMimJAfDRp0YZkXwPu+mqi6muIqqskurYSd3U50VXlRO3dh2vDZ0Q31BDta8ZBq39/lxtHSiqOZA/OFA+OZA+O1JbHFA/Og9tJqVju4HyAiaT3AERWvIo1NBSrdLeiwmaSU53ExqmbqohIpOiWxNHj8VBWVhbYLisrIyUlpd05paWl7c7xer1HLJucnBzYP2PGDH796193eL3y8nJSU1PbxTVz5kxmzpwZ2G59/RPl7/7Z9Xq6Q3fEGgcMjoXBsU7oHwu07ZbU7LMprz/YFbZ1C2YzpbUNbNlfQ0W9t1Uq2K/lJxOigLSWn1aiHIZoDDH4iDbNRPuaifY2ENPcQHRxLdG7qon2lRHjaybabiLa10SMr4kot5OYmGiiY6KI6RdHdL84YhLiiUmIJzo5mZjkZKJSUnDE9TtqK2YkvQcgsuJVrKHRF2PNzMwMQjRyIupqbSorfJx8aky4QxERkePQLYnjsGHDKCoqoqSkhNTUVFauXMncuXPbnJOXl8err77K5MmTKSgoIC4ujpSUFBITE49YtqKiIpBEfvTRR2RnZwfqWrRoERdddBEVFRUUFRUxfPjw7nipcpzcTgfp8VGkxx95zKLXNkTHJ7O3ZD+NPkOj16bBa9PoPfS8wWto9Nkt2/79jb5Wz702VV7TUs6msdlHg8/QQW/aQ5qB8pafnQC1QC1RviZijJdofERbhhgnRDsdRLudxES5SEjoh88YXG4XrqgoXC4nLoeFy+FfSsVlWbicFk7Lwu20cFr+/W6H5T/e6sfpoNXzlnMs//7Dz3dY7VvyRUR6muI9/p4mGeqmKiISUbolcXQ6nVx//fXMmzcP27aZPn062dnZvPbaa4C/y+m4ceNYs2YNc+fOJSoqivz8/KOWBXjmmWfYsWOHf/bQ/v25+eabAcjOzubMM8/kjjvuwOFwcMMNN/S5GVV7E5fDIiXOje8oyeWJso2hydcqoWxJLg9uN9TV01hdQ2NtLQ11DTTUN9DY0ExjUzMNzV4avC3lcVLpjKLE4aaxpBqf5cRrOfE6/I8+hxOf5Qx6/Ic7mKC6DksqndbBxLRtIupyWMRE78Pb3IRltSSf+B/9PxZW6+f4Hw8et1qOOwPHCNTT5jkHE9tD5a1WdTodHZVv2ec4VD6xyqK6qjqw9qiFvx6r5VwObgcerUPbLQXalW19Tsujv54OyracS0us/t0t5x1etraJA/Xe4P8jh+C7AWedP9aDLfuGtsMH/NuHzjcGTKt+AAePmQ62DSZwwLQ65+Duo16ng+vt91bTz/iIc4f+/ycJjaLCJhKSHMQn6N9QRCSSWKazAwL7gL1793a5jr7Y5as79PRYTXMzVFVAZQUJ2FTtK4b6Wqiva3msx9TX0lzfgK+hHm9DI97GRnwNDXibm/FZTppbkktfq4TzYNLpdUbhjY7FFx2LNzoWb1QMXncMvqgYfO5ovO4ovC7/j88Zhc/pxut04XW48Dqc+CwXXix8xuC1/a24PtvQbBucThfN3mZsQ8uPwbQ82i0f7m3bYOM/bg7uNy37bP+H+sPL6w+LhMqvzs1h9IC4LtWhrqrHr6v3yLS0NPYUlvDaS1WMHBPNqFN67oyqPf2ec7hIilexhkYkxQqRFW9fi/Vo98duaXEU6e0stxs8A8AzgJi0NGqO8D9tR9+vG9sHDfWHksy6Oqivw7RJPA89mvoSqD78WN2xg3Q6ITYOYvu1eYxJTKIRC6Jj2v1Y0TEQ1X5/4LjzyC0GpnXi2ZJM+g4mlQcTU9omo4eSVrA5mKAeSmKTkpKpOFABLeX81/EnroFktdU1WzYDxw5+T3aksgfPaVvPodfTui5aX8O0vo6/vvj4eGpqao7973IcQpWM9+vXj9ra2jaNmQdbYw8+B9q06rbdPlTSanX80HbHxw+25AbqadmwaHs8UA6LpKREBkYdPqmWRIqD3VQHZmlJJRGRSKPEUSTMLIcT4uL9P633H0cdxrbbJp8tj6aDxJO6Vknp/mKai3b719ZsaoTGhrb1HuvCLveRk8pWP47oGIiKxh0T61+jMzoGKzoWoqPh8MeYWHC5OhyvmZYWT6mzoYNAep6+9g1ld0lLS42YWKW9osJm4uIdJCRp+IiISKRR4ijSC1gOh39ty7h+QP9D+ztRtnXSYGwbmpv8CWQHP+YI+wPHmhqgoQEOlGEaG6GxHg4+2m1nIjpqUupwtE8oo2OoiE/Ah4Xljvbvi4qGqChwH3zesh0VjXVw2x3V7tjB/ZpMSKT7NDb6KN3nJXdUtP7fExGJQEocRSTAcjgOtRp2dPwE6zXGgNfbNpFs9Wga69snowdbQFslrHZNNdTVYpoaoanJf05zo7/uw6/ZmcDaJJKHJZaB5PPwxLTteVbrxDT6UKLqczn8Lb5uNzg7bkEV6UsKd9RhDAwcpNlURUQikRJHEQk5y7L8CZTbDfEdHO9kPZ4jdKk0Pp8/gTyYTAZ+Dm2b5qYO9/vL+feZ1mVrqjouc/i1jxBrmygtR0sC6vYnoW73oZbQg8/dUS1JaFRgO/Bz2L5On3eUMagS2datW8eyZcuwbZsZM2Ywe/bsNseNMSxbtoy1a9cSHR1Nfn4+ubm5nSobKju21hATa5Hs0ftSRCQSKXEUkYhnOZ3gjIOYI8+0GYz2PmOMvytvc5O/xbSp0f+8VcJpmpqgqYH46ChqyssPnX/wp8n/aAL7mqGuFpor/LPzHkyADz632y822ulJcpzO9snl4QlmVBSV8QnYPrtln7vto+vQc6v1MVfUEc53q5U1xGzbZunSpdx77714PB7uuece8vLyyMrKCpyzdu1aiouLWbRoEQUFBTz55JM88MADnSobCl6vYc+uOrKHuvW+EBGJUEocRUQ6ybKsQ91S+yV0fE7LY1xaGnVBmMSlTWtqm8Sy7Y/pYF+b85qawNvsb1U9uK+6EpqbaPZ5/WNSvQev0dS1hBX8U6ceM8H0b1tHSFRpl6i6aUj1YNKzsOITu/y7jVRbtmwhIyOD9PR0ACZNmsSqVavaJH+rV69m6tSpWJbFyJEjqa2tpaKigv379x+zbCiUFDXj8xkGZqmbqohIpFLiKCLSg3WmNRW61qLa0ayqxucDb/OhVtGDj96mdvsCracdnd9qvzl8X01Vy/7mtklrczP42o9bBagEHHfNh+Gju/CKI1t5eTkejyew7fF4KCgoaHdOWlpam3PKy8s7Vfag5cuXs3z5cgDmz5/fpr7jtXHtPqJjnIw8OQOHo+e3OLpcri693u4WSfEq1tCIpFghsuJVrK3qD1nNIiISsfwJq/OIEyW1OTcE1ze2D5q97RLV5H79OBB99CS6tzu4Hmlrh3f/PNI5nSl70MyZM5k5c2ZguyvLoIw4xcHJpw6kvLzshOvoTpG0RA1EVryKNTQiKVaIrHj7WqyZmZlHPKbEUUREehzL4YRop3+m2lbcaWlYEXIDDxWPx0NZ2aEErKysjJSUlHbntP7wcPAcr9d7zLKh4HZbpKXFUFpaE/JriYhIaGgFXhERkQgybNgwioqKKCkpwev1snLlSvLy8tqck5eXxzvvvIMxhs2bNxMXF0dKSkqnyoqIiHRELY4iIiIRxOl0cv311zNv3jxs22b69OlkZ2fz2muvATBr1izGjRvHmjVrmDt3LlFRUeTn5x+1rIiIyLEocRQREYkw48ePZ/z48W32zZo1K/DcsixuvPHGTpcVERE5FnVVFRERERERkaNS4igiIiIiIiJHpcRRREREREREjkqJo4iIiIiIiByVEkcRERERERE5KiWOIiIiIiIiclRKHEVEREREROSoLGOMCXcQIiIiIiIi0nOpxTHI7r777nCH0GmKNTQiKVaIrHgVa2goVukOkfRvF0mxQmTFq1hDI5JihciKV7EeosRRREREREREjkqJo4iIiIiIiByVEscgmzlzZrhD6DTFGhqRFCtEVryKNTQUq3SHSPq3i6RYIbLiVayhEUmxQmTFq1gP0eQ4IiIiIiIiclRqcRQREREREZGjcoU7gN5i3bp1LFu2DNu2mTFjBrNnzw53SEe0ZMkS1qxZQ1JSEgsXLgx3OEdVWlrK4sWLOXDgAJZlMXPmTC644IJwh9WhpqYm7rvvPrxeLz6fj4kTJ3LZZZeFO6yjsm2bu+++m9TU1B49a9itt95KTEwMDocDp9PJ/Pnzwx3SUdXW1vL444+ze/duLMviO9/5DiNHjgx3WO3s3buXhx9+OLBdUlLCZZddxoUXXhjGqI7s//7v/1ixYgWWZZGdnU1+fj5RUVHhDks6IVLukbo/hobuj6EVSfdI3R9Do9vuj0a6zOfzmdtuu80UFxeb5uZm84Mf/MDs3r073GEd0YYNG8zWrVvNHXfcEe5Qjqm8vNxs3brVGGNMXV2dmTt3bo/93dq2berr640xxjQ3N5t77rnHbNq0KcxRHd3LL79sHnnkEfOrX/0q3KEcVX5+vqmsrAx3GJ322GOPmeXLlxtj/O+FmpqaMEd0bD6fz9x4442mpKQk3KF0qKyszOTn55vGxkZjjDELFy40b775ZniDkk6JpHuk7o+hoftjaEXSPVL3x+DrzvujuqoGwZYtW8jIyCA9PR2Xy8WkSZNYtWpVuMM6otGjRxMfHx/uMDolJSWF3NxcAGJjYxk0aBDl5eVhjqpjlmURExMDgM/nw+fzYVlWmKM6srKyMtasWcOMGTPCHUqvUldXx+eff84555wDgMvlol+/fmGO6tg+++wzMjIy6N+/f7hDOSLbtmlqasLn89HU1ERKSkq4Q5JOiKR7pO6PoaH7o4Duj6HUXfdHdVUNgvLycjweT2Db4/FQUFAQxoh6p5KSErZv387w4cPDHcoR2bbNXXfdRXFxMV/5ylcYMWJEuEM6oj/84Q9cddVV1NfXhzuUTpk3bx4A5557bo+e4aykpITExESWLFnCzp07yc3N5dprrw18aOqp3nvvPSZPnhzuMI4oNTWViy++mO985ztERUVx2mmncdppp4U7LOkE3SNDT/fH4Iq0+yNExj1S98fQ6M77o1ocg8B0MDFtT/4mLRI1NDSwcOFCrr32WuLi4sIdzhE5HA4WLFjA448/ztatW9m1a1e4Q+rQxx9/TFJSUuDb6p7u/vvv59e//jU/+tGP+Pe//83GjRvDHdIR+Xw+tm/fzqxZs/if//kfoqOjefHFF8Md1lF5vV4+/vhjJk6cGO5QjqimpoZVq1axePFinnjiCRoaGnjnnXfCHZZ0gu6RoaX7Y3BF2v0RIuceqftjaHTn/VGJYxB4PB7KysoC22VlZepCFURer5eFCxcyZcoUzjjjjHCH0yn9+vVj9OjRrFu3LtyhdGjTpk2sXr2aW2+9lUceeYT169ezaNGicId1RKmpqQAkJSUxYcIEtmzZEuaIjszj8eDxeALfpk+cOJHt27eHOaqjW7t2LUOHDiU5OTncoRzRZ599xoABA0hMTMTlcnHGGWewefPmcIclnaB7ZOjo/hh8kXZ/hMi5R+r+GBrdeX9U4hgEw4YNo6ioiJKSErxeLytXriQvLy/cYfUKxhgef/xxBg0axEUXXRTucI6qqqqK2tpawD+D3GeffcagQYPCHFXHrrzySh5//HEWL17M97//fU455RTmzp0b7rA61NDQEOgu1NDQwKeffkpOTk6Yozqy5ORkPB4Pe/fuBfx/0LOyssIc1dH19G44AGlpaRQUFNDY2Igxpkf//yVt6R4ZGro/hkYk3R8hsu6Ruj+GRnfeHzXGMQicTifXX3898+bNw7Ztpk+fTnZ2drjDOqJHHnmEjRs3Ul1dzZw5c7jssssCA5V7mk2bNvHOO++Qk5PDnXfeCcAVV1zB+PHjwxxZexUVFSxevBjbtjHGcOaZZ3L66aeHO6yIV1lZyYMPPgj4u7mcddZZjB07NrxBHcP111/PokWL8Hq9DBgwgPz8/HCHdESNjY18+umn3HzzzeEO5ahGjBjBxIkTueuuu3A6nQwZMqTHjuORtiLpHqn7Y2jo/hg6kXaP1P0x+Lrz/miZjgYfiIiIiIiIiLRQV1URERERERE5KiWOIiIiIiIiclRKHEVEREREROSolDiKiIiIiIjIUSlxFBERERERkaNS4ijSg/zud7/jueeeC/q5Pd1bb73FT37yk3CHISIiPZTujyLhp3UcRYLk1ltv5ZZbbuHUU0894TqOZ62gnr6ukIiICOj+KNJbqMVRpJv4fL5whyAiItLj6P4oEhksY4wJdxAike6xxx7jP//5Dy6XC4fDwaWXXsqZZ57Jbbfdxpw5c/jb3/7GgAED+PnPf85DDz3E559/TlNTE0OGDOHGG28kOzsbgMWLF+PxeLj88svZsGEDjz32GBdeeCEvvfQSDoeDK664gunTpx/3udXV1SxevJjPP/+czMxMTjvtNDZs2MD999/f4evZvHkzTz/9NIWFhfTv359rr72WMWPGAPCzn/2MkSNH8tlnn7F3717GjBlDfn4+8fHxAKxevZr/9//+H+Xl5YHXl5WVBUBpaSl/+MMf+PzzzzHGMHnyZG644Qbeeust3njjDUaMGMGbb75JXFwcN954I+PGjQP8XXWee+45qqqqSEhI4PLLL2fKlCmh+wcVEZGg0P1R90fpPdRVVSQIvvvd7/LFF1+06YpTUlICwMaNG3n44YdxOPwN/GPHjuU73/kOLpeLP//5zyxatIgFCxZ0WO+BAweoq6vj8ccf59NPP+Whhx5iwoQJgZtQZ89dunQpMTEx/O53v2P//v3MmzePtLS0Dq9ZXl7O/Pnzue222xg7dizr169n4cKFPPLIIyQmJgLw9ttv8+Mf/5gBAwbwm9/8hqeeeoq5c+eyd+9eHn30Ue68805Gjx7NK6+8wq9//evA6//1r3/NmDFjWLx4MQ6Hg23btgWuu2XLFqZNm8bSpUtZvnw5jz/+OI8//jiNjY0sW7aMX/3qV2RmZlJRUUFNTc2J/2OJiEi30f1R90fpPdRVVSTEvvGNbxATE0NUVBQA55xzDrGxsbjdbr7xjW+wc+dO6urqOizrdDq59NJLcblcjB8/npiYGPbu3Xtc59q2zYcffshll11GdHQ0WVlZTJs27YjxvvPOO4wbN47x48fjcDg49dRTGTZsGGvWrAmcM3XqVHJycoiJieHyyy/n/fffx7ZtVq5cybhx4zj11FNxuVxcfPHFNDU1sWnTJrZs2UJ5eTlXX3114Pdx0kknBepMS0tj5syZOBwOpk2bRkVFBZWVlQBYlsWuXbtoamoiJSUl8A20iIhELt0fdX+UyKIWR5EQ83g8gee2bfO///u/fPDBB1RVVWFZFgBVVVXExcW1K5uQkIDT6QxsR0dH09DQ0OF1jnRuVVUVPp+vTRytnx+utLSUDz74gI8//jiwz+fzBbriHF4+LS0Nn89HVVUVFRUV9O/fP3DM4XCQlpZGeXk5TqeT/v37t4mxteTk5DaxAzQ0NJCcnMz3v/99Xn75ZR5//HFGjRrFt7/9bQYNGnTE1yAiIj2f7o+6P0pkUeIoEmIHb34A//nPf1i9ejU/+clP6N+/P3V1dVx33XUhvX5iYiJOp5OysjIyMzMBKCsrO+L5Ho+HKVOmMGfOnCOe07p8aWkpTqeTxMREUlJS2LVrV+CYMYbS0lJSU1Nxu92Ulpbi8/mOeHM8krFjxzJ27Fiampr4y1/+whNPPMEvfvGL46pDRER6Ft0fdX+UyKKuqiJBkpycHBi3cST19fW4XC7i4+NpbGzkf//3f0Mel8Ph4Mtf/jJ/+9vfaGxsZM+ePbz99ttHPH/KlCl8/PHHrFu3Dtu2aWpqYsOGDW1uhu+++y6FhYU0Njby7LPPMnHiRBwOB5MmTWLt2rV89tlneL1eXn75ZdxuN6NGjWL48OGkpKTw5z//mYaGBpqamvjiiy+OGf+BAwdYvXo1DQ0NuFwuYmJiAuNhRESk59P9UfdH6R3U4igSJLNnz+app57imWee4ZJLLmHixIntzpk2bRqffPIJc+bMIT4+nm9+85u89tprIY/thhtuYPHixdx8881kZmYyefLkNgPvW0tLS+OHP/whzzzzDI8++igOh4Phw4dz0003Bc6ZOnUqixcvZu/evZx88snk5+cDkJmZyXe/+12eeuqpwKxxd911Fy6X/0/NXXfdxVNPPUV+fj6WZTF58uQ24zg6Yozh5Zdf5rHHHsOyrMBMdCIiEhl0f9T9UXoHLcch0gc988wzHDhwgNtuu+24y/7sZz9jypQpzJgxIwSRiYiIhI/ujyJHpvZskT5gz5497Ny5E2MMW7Zs4c033+TLX/5yuMMSEREJK90fRTpPXVVF+oD6+noeffRRKioqSEpK4qKLLmLChAnhDktERCSsdH8U6Tx1VRUREREREZGjUldVEREREREROSoljiIiIiIiInJUShxFRP5/+3UgAAAAACDI33qDCcoiAACWOAIAALDEEQAAgCWOAAAArAAzyGWij8Ws3wAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 1080x360 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# number of epochs determined by the following\n",
    "# plot the training and validation loss to determine if overfitting / underfitting \n",
    "\n",
    "train_loss = history.history['loss']\n",
    "val_loss = history.history['val_loss']\n",
    "train_F1 = history.history['F1_at_k']\n",
    "batch_val_F1 = history.history['val_F1_at_k']\n",
    "val_F1 = es.F1scores\n",
    "n_epochs = len(train_loss)\n",
    "\n",
    "fig, ax = plt.subplots(ncols = 2, figsize = (15,5))\n",
    "ax[0].plot(list(range(n_epochs)), train_loss, label ='train loss')\n",
    "ax[0].plot(list(range(n_epochs)), val_loss, label ='val loss')\n",
    "ax[0].set_xlabel('training epochs')\n",
    "ax[0].set_ylabel('loss')\n",
    "ax[0].legend()\n",
    "ax[1].plot(list(range(n_epochs)), train_F1, label ='train F1')\n",
    "ax[1].plot(list(range(n_epochs)), batch_val_F1, label ='batch val F1')\n",
    "ax[1].plot(list(range(n_epochs)), val_F1, label ='val F1')\n",
    "ax[1].set_xlabel('training epochs')\n",
    "ax[1].set_ylabel('F1')\n",
    "ax[1].legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation set precision:  0.16666667\n",
      "Validation set recall:  0.2\n",
      "Validation set F1:  0.22222218\n"
     ]
    }
   ],
   "source": [
    "# evaluate \n",
    "y_pred = model.predict(X_cv)\n",
    "print(\"Validation set precision: \", metrics.precision_at_k(y_cv, y_pred).numpy())\n",
    "print(\"Validation set recall: \", metrics.recall_at_k(y_cv, y_pred).numpy())\n",
    "print(\"Validation set F1: \", metrics.F1_at_k(y_cv, y_pred).numpy())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### model 3: Add hidden layer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"model3\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "Embedding (Embedding)        (None, 5, 500)            3356000   \n",
      "_________________________________________________________________\n",
      "Mean (Lambda)                (None, 500)               0         \n",
      "_________________________________________________________________\n",
      "Dense (Dense)                (None, 500)               250500    \n",
      "_________________________________________________________________\n",
      "dense_3 (Dense)              (None, 6712)              3362712   \n",
      "=================================================================\n",
      "Total params: 6,969,212\n",
      "Trainable params: 6,969,212\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "# define model architecture\n",
    "context_size = 5\n",
    "embed_size = 500\n",
    "model = Sequential(name = 'model3')\n",
    "\n",
    "model.add(Embedding(n_words, embed_size, input_length = context_size, name = \"Embedding\"))\n",
    "model.add(Lambda(lambda x: K.mean(x, axis=1), output_shape = (embed_size,), name = \"Mean\" ))\n",
    "model.add(Dense(500, activation = 'sigmoid', name = \"Dense\"))\n",
    "model.add(Dense(n_words, activation = 'sigmoid'))\n",
    "\n",
    "metrics = MetricsAtK(k = 6)\n",
    "model.compile(loss = 'binary_crossentropy', optimizer = 'adam', metrics = [metrics.precision_at_k,\n",
    "                                                                           metrics.recall_at_k,\n",
    "                                                                           metrics.F1_at_k])\n",
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/50\n",
      " Validation precision: 0.1667, Validation recall: 0.0833, Validation F1: 0.1111\n",
      "4098/4098 - 117s - loss: 0.0069 - precision_at_k: 0.0574 - recall_at_k: 0.0307 - F1_at_k: 0.0397 - val_loss: 0.0055 - val_precision_at_k: 0.1000 - val_recall_at_k: 0.0613 - val_F1_at_k: 0.0758\n",
      "Epoch 2/50\n",
      " Validation precision: 0.1667, Validation recall: 0.1429, Validation F1: 0.1667\n",
      "4098/4098 - 117s - loss: 0.0053 - precision_at_k: 0.1391 - recall_at_k: 0.0988 - F1_at_k: 0.1164 - val_loss: 0.0050 - val_precision_at_k: 0.1629 - val_recall_at_k: 0.1443 - val_F1_at_k: 0.1581\n",
      "Epoch 3/50\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2000\n",
      "4098/4098 - 117s - loss: 0.0049 - precision_at_k: 0.1735 - recall_at_k: 0.1648 - F1_at_k: 0.1778 - val_loss: 0.0048 - val_precision_at_k: 0.1714 - val_recall_at_k: 0.1845 - val_F1_at_k: 0.1919\n",
      "Epoch 4/50\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2000\n",
      "4098/4098 - 117s - loss: 0.0047 - precision_at_k: 0.1941 - recall_at_k: 0.1961 - F1_at_k: 0.2043 - val_loss: 0.0047 - val_precision_at_k: 0.1838 - val_recall_at_k: 0.1967 - val_F1_at_k: 0.2009\n",
      "Epoch 5/50\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2222\n",
      "4098/4098 - 117s - loss: 0.0045 - precision_at_k: 0.2175 - recall_at_k: 0.2150 - F1_at_k: 0.2212 - val_loss: 0.0047 - val_precision_at_k: 0.2000 - val_recall_at_k: 0.2059 - val_F1_at_k: 0.2106\n",
      "Epoch 6/50\n",
      " Validation precision: 0.1667, Validation recall: 0.2143, Validation F1: 0.2222\n",
      "4098/4098 - 117s - loss: 0.0044 - precision_at_k: 0.2395 - recall_at_k: 0.2311 - F1_at_k: 0.2343 - val_loss: 0.0046 - val_precision_at_k: 0.2048 - val_recall_at_k: 0.2127 - val_F1_at_k: 0.2142\n",
      "Epoch 7/50\n",
      " Validation precision: 0.1667, Validation recall: 0.2222, Validation F1: 0.2222\n",
      "4098/4098 - 116s - loss: 0.0043 - precision_at_k: 0.2571 - recall_at_k: 0.2436 - F1_at_k: 0.2450 - val_loss: 0.0046 - val_precision_at_k: 0.2029 - val_recall_at_k: 0.2201 - val_F1_at_k: 0.2204\n",
      "Epoch 8/50\n",
      " Validation precision: 0.1667, Validation recall: 0.2222, Validation F1: 0.2222\n",
      "4098/4098 - 117s - loss: 0.0042 - precision_at_k: 0.2730 - recall_at_k: 0.2543 - F1_at_k: 0.2546 - val_loss: 0.0046 - val_precision_at_k: 0.2114 - val_recall_at_k: 0.2195 - val_F1_at_k: 0.2207\n",
      "Epoch 9/50\n",
      " Validation precision: 0.1667, Validation recall: 0.2222, Validation F1: 0.2222\n",
      "4098/4098 - 117s - loss: 0.0041 - precision_at_k: 0.2876 - recall_at_k: 0.2640 - F1_at_k: 0.2640 - val_loss: 0.0046 - val_precision_at_k: 0.2067 - val_recall_at_k: 0.2183 - val_F1_at_k: 0.2211\n",
      "Epoch 10/50\n",
      " Validation precision: 0.1667, Validation recall: 0.2222, Validation F1: 0.2222\n",
      "\n",
      " Early stopping at epoch  10\n",
      "\n",
      " Restoring model weights to weights from epoch  5\n",
      "4098/4098 - 117s - loss: 0.0040 - precision_at_k: 0.2955 - recall_at_k: 0.2747 - F1_at_k: 0.2721 - val_loss: 0.0047 - val_precision_at_k: 0.2105 - val_recall_at_k: 0.2181 - val_F1_at_k: 0.2207\n"
     ]
    }
   ],
   "source": [
    "# Fit model with callbacks\n",
    "# early stopping\n",
    "es = EarlyStoppingAtK(X_cv, y_cv, metrics, patience = 5)\n",
    "\n",
    "# save model\n",
    "mc = ModelCheckpoint('models/multilabel_NN/model3_{epoch:02d}.h5', save_freq = 'epoch', verbose = 0)\n",
    "\n",
    "# fit model\n",
    "history = model.fit(x = X_train, y = y_train, validation_data=(X_cv, y_cv), epochs = 50, verbose = 2, callbacks = [es, mc])\n",
    "\n",
    "model.save('models/multilabel_NN/model3.h5')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x360 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# number of epochs determined by the following\n",
    "# plot the training and validation loss to determine if overfitting / underfitting \n",
    "\n",
    "train_loss = history.history['loss']\n",
    "val_loss = history.history['val_loss']\n",
    "train_F1 = history.history['F1_at_k']\n",
    "batch_val_F1 = history.history['val_F1_at_k']\n",
    "val_F1 = es.F1scores\n",
    "n_epochs = len(train_loss)\n",
    "\n",
    "fig, ax = plt.subplots(ncols = 2, figsize = (15,5))\n",
    "ax[0].plot(list(range(n_epochs)), train_loss, label ='train loss')\n",
    "ax[0].plot(list(range(n_epochs)), val_loss, label ='val loss')\n",
    "ax[0].set_xlabel('training epochs')\n",
    "ax[0].set_ylabel('loss')\n",
    "ax[0].legend()\n",
    "ax[1].plot(list(range(n_epochs)), train_F1, label ='train F1')\n",
    "ax[1].plot(list(range(n_epochs)), batch_val_F1, label ='batch val F1')\n",
    "ax[1].plot(list(range(n_epochs)), val_F1, label ='val F1')\n",
    "ax[1].set_xlabel('training epochs')\n",
    "ax[1].set_ylabel('F1')\n",
    "ax[1].legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation set precision:  0.16666667\n",
      "Validation set recall:  0.2\n",
      "Validation set F1:  0.22222218\n"
     ]
    }
   ],
   "source": [
    "# evaluate \n",
    "y_pred = model.predict(X_cv)\n",
    "print(\"Validation set precision: \", metrics.precision_at_k(y_cv, y_pred).numpy())\n",
    "print(\"Validation set recall: \", metrics.recall_at_k(y_cv, y_pred).numpy())\n",
    "print(\"Validation set F1: \", metrics.F1_at_k(y_cv, y_pred).numpy())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# adding hidden layer & increasing embedding dimension doesn't improve the validation performance\n",
    "# so we'll return to the original model (model 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## architecture without mean"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow.keras.layers import Flatten"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"model4\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "Embedding (Embedding)        (None, 5, 100)            671200    \n",
      "_________________________________________________________________\n",
      "Flatten (Flatten)            (None, 500)               0         \n",
      "_________________________________________________________________\n",
      "Dense (Dense)                (None, 6712)              3362712   \n",
      "=================================================================\n",
      "Total params: 4,033,912\n",
      "Trainable params: 4,033,912\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "# define model architecture\n",
    "context_size = 5\n",
    "embed_size = 500\n",
    "model = Sequential(name = 'model4')\n",
    "\n",
    "model.add(Embedding(n_words, embed_size, input_length = context_size, name = \"Embedding\"))\n",
    "model.add(Flatten(name = \"Flatten\"))\n",
    "model.add(Dense(n_words, activation = 'sigmoid', name = \"Dense\"))\n",
    "\n",
    "metrics = MetricsAtK(k = 6)\n",
    "model.compile(loss = 'binary_crossentropy', optimizer = 'adam', metrics = [metrics.precision_at_k,\n",
    "                                                                           metrics.recall_at_k,\n",
    "                                                                           metrics.F1_at_k])\n",
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/20\n",
      " Validation precision: 0.1667, Validation recall: 0.0909, Validation F1: 0.1176\n",
      "4098/4098 - 31s - loss: 0.0201 - precision_at_k: 0.0713 - recall_at_k: 0.0384 - F1_at_k: 0.0496 - val_loss: 0.0057 - val_precision_at_k: 0.1095 - val_recall_at_k: 0.0664 - val_F1_at_k: 0.0820\n",
      "Epoch 2/20\n",
      " Validation precision: 0.1667, Validation recall: 0.1667, Validation F1: 0.1818\n",
      "4098/4098 - 30s - loss: 0.0053 - precision_at_k: 0.1530 - recall_at_k: 0.1182 - F1_at_k: 0.1362 - val_loss: 0.0050 - val_precision_at_k: 0.1695 - val_recall_at_k: 0.1656 - val_F1_at_k: 0.1765\n",
      "Epoch 3/20\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2222\n",
      "4098/4098 - 30s - loss: 0.0048 - precision_at_k: 0.1983 - recall_at_k: 0.1958 - F1_at_k: 0.2049 - val_loss: 0.0048 - val_precision_at_k: 0.2000 - val_recall_at_k: 0.2059 - val_F1_at_k: 0.2105\n",
      "Epoch 4/20\n",
      " Validation precision: 0.1667, Validation recall: 0.2222, Validation F1: 0.2222\n",
      "4098/4098 - 30s - loss: 0.0045 - precision_at_k: 0.2443 - recall_at_k: 0.2335 - F1_at_k: 0.2369 - val_loss: 0.0047 - val_precision_at_k: 0.2124 - val_recall_at_k: 0.2141 - val_F1_at_k: 0.2169\n",
      "Epoch 5/20\n",
      " Validation precision: 0.1667, Validation recall: 0.2222, Validation F1: 0.2222\n",
      "4098/4098 - 30s - loss: 0.0043 - precision_at_k: 0.2738 - recall_at_k: 0.2540 - F1_at_k: 0.2550 - val_loss: 0.0047 - val_precision_at_k: 0.2086 - val_recall_at_k: 0.2137 - val_F1_at_k: 0.2142\n",
      "Epoch 6/20\n",
      " Validation precision: 0.1667, Validation recall: 0.2143, Validation F1: 0.2222\n",
      "4098/4098 - 30s - loss: 0.0041 - precision_at_k: 0.2947 - recall_at_k: 0.2710 - F1_at_k: 0.2694 - val_loss: 0.0048 - val_precision_at_k: 0.2124 - val_recall_at_k: 0.2117 - val_F1_at_k: 0.2149\n",
      "Epoch 7/20\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2222\n",
      "4098/4098 - 30s - loss: 0.0039 - precision_at_k: 0.3065 - recall_at_k: 0.2854 - F1_at_k: 0.2812 - val_loss: 0.0048 - val_precision_at_k: 0.2057 - val_recall_at_k: 0.2103 - val_F1_at_k: 0.2147\n",
      "Epoch 8/20\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2222\n",
      "\n",
      " Early stopping at epoch  8\n",
      "\n",
      " Restoring model weights to weights from epoch  3\n",
      "4098/4098 - 30s - loss: 0.0038 - precision_at_k: 0.3175 - recall_at_k: 0.2990 - F1_at_k: 0.2940 - val_loss: 0.0049 - val_precision_at_k: 0.1981 - val_recall_at_k: 0.2083 - val_F1_at_k: 0.2118\n"
     ]
    }
   ],
   "source": [
    "# Fit model with callbacks\n",
    "# early stopping\n",
    "es = EarlyStoppingAtK(X_cv, y_cv, metrics, patience = 5)\n",
    "\n",
    "# save model\n",
    "mc = ModelCheckpoint('models/multilabel_NN/model4_{epoch:02d}.h5', save_freq = 'epoch', verbose = 0)\n",
    "\n",
    "# fit model\n",
    "history = model.fit(x = X_train, y = y_train, validation_data=(X_cv, y_cv), epochs = 20, verbose = 2, callbacks = [es, mc])\n",
    "\n",
    "model.save('models/multilabel_NN/model4.h5')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x360 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# number of epochs determined by the following\n",
    "# plot the training and validation loss to determine if overfitting / underfitting \n",
    "\n",
    "train_loss = history.history['loss']\n",
    "val_loss = history.history['val_loss']\n",
    "train_F1 = history.history['F1_at_k']\n",
    "batch_val_F1 = history.history['val_F1_at_k']\n",
    "val_F1 = es.F1scores\n",
    "n_epochs = len(train_loss)\n",
    "\n",
    "fig, ax = plt.subplots(ncols = 2, figsize = (15,5))\n",
    "ax[0].plot(list(range(n_epochs)), train_loss, label ='train loss')\n",
    "ax[0].plot(list(range(n_epochs)), val_loss, label ='val loss')\n",
    "ax[0].set_xlabel('training epochs')\n",
    "ax[0].set_ylabel('loss')\n",
    "ax[0].legend()\n",
    "ax[1].plot(list(range(n_epochs)), train_F1, label ='train F1')\n",
    "ax[1].plot(list(range(n_epochs)), batch_val_F1, label ='batch val F1')\n",
    "ax[1].plot(list(range(n_epochs)), val_F1, label ='val F1')\n",
    "ax[1].set_xlabel('training epochs')\n",
    "ax[1].set_ylabel('F1')\n",
    "ax[1].legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation set precision:  0.16666667\n",
      "Validation set recall:  0.2\n",
      "Validation set F1:  0.22222218\n"
     ]
    }
   ],
   "source": [
    "# evaluate \n",
    "y_pred = model.predict(X_cv)\n",
    "print(\"Validation set precision: \", metrics.precision_at_k(y_cv, y_pred).numpy())\n",
    "print(\"Validation set recall: \", metrics.recall_at_k(y_cv, y_pred).numpy())\n",
    "print(\"Validation set F1: \", metrics.F1_at_k(y_cv, y_pred).numpy())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b> Going back to architecture 0 </b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow.keras.models import load_model\n",
    "from tensorflow.keras.optimizers import Adam"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's do hyperparameter tuning  \n",
    "1. Tune learning rate alpha\n",
    "2. Tune batch size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Validation precision: 0.0000, Validation recall: 0.0000, Validation F1: 0.0000\n",
      " Validation precision: 0.1667, Validation recall: 0.1000, Validation F1: 0.1250\n",
      " Validation precision: 0.1667, Validation recall: 0.1429, Validation F1: 0.1538\n",
      " Validation precision: 0.1667, Validation recall: 0.1818, Validation F1: 0.1905\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2000\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2222\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2222\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2222\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2222\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2222\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2105\n",
      "\n",
      " Early stopping at epoch  11\n",
      "\n",
      " Restoring model weights to weights from epoch  6\n",
      " Validation precision: 0.0000, Validation recall: 0.0000, Validation F1: 0.0000\n",
      " Validation precision: 0.0000, Validation recall: 0.0000, Validation F1: 0.0000\n",
      " Validation precision: 0.1667, Validation recall: 0.0909, Validation F1: 0.1176\n",
      " Validation precision: 0.1667, Validation recall: 0.1176, Validation F1: 0.1429\n",
      " Validation precision: 0.1667, Validation recall: 0.1667, Validation F1: 0.1667\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2000\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2000\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2222\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2222\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2222\n",
      " Validation precision: 0.1667, Validation recall: 0.2143, Validation F1: 0.2222\n",
      " Validation precision: 0.1667, Validation recall: 0.2222, Validation F1: 0.2222\n",
      " Validation precision: 0.1667, Validation recall: 0.2222, Validation F1: 0.2222\n",
      "\n",
      " Early stopping at epoch  13\n",
      "\n",
      " Restoring model weights to weights from epoch  8\n",
      " Validation precision: 0.1667, Validation recall: 0.1333, Validation F1: 0.1538\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2000\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2000\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2000\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2000\n",
      " Validation precision: 0.1667, Validation recall: 0.1667, Validation F1: 0.1818\n",
      " Validation precision: 0.1667, Validation recall: 0.1818, Validation F1: 0.1818\n",
      "\n",
      " Early stopping at epoch  7\n",
      "\n",
      " Restoring model weights to weights from epoch  2\n",
      " Validation precision: 0.1667, Validation recall: 0.1429, Validation F1: 0.1538\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2000\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2000\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2000\n",
      " Validation precision: 0.1667, Validation recall: 0.1818, Validation F1: 0.1905\n",
      " Validation precision: 0.1667, Validation recall: 0.1765, Validation F1: 0.1818\n",
      " Validation precision: 0.1667, Validation recall: 0.1667, Validation F1: 0.1818\n",
      "\n",
      " Early stopping at epoch  7\n",
      "\n",
      " Restoring model weights to weights from epoch  2\n",
      " Validation precision: 0.0000, Validation recall: 0.0000, Validation F1: 0.0000\n",
      " Validation precision: 0.0000, Validation recall: 0.0000, Validation F1: 0.0000\n",
      " Validation precision: 0.0000, Validation recall: 0.0000, Validation F1: 0.0000\n",
      " Validation precision: 0.1667, Validation recall: 0.0909, Validation F1: 0.1176\n",
      " Validation precision: 0.1667, Validation recall: 0.1250, Validation F1: 0.1429\n",
      " Validation precision: 0.1667, Validation recall: 0.1429, Validation F1: 0.1667\n",
      " Validation precision: 0.1667, Validation recall: 0.1667, Validation F1: 0.1818\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2000\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2000\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2105\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2222\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2222\n",
      " Validation precision: 0.1667, Validation recall: 0.2143, Validation F1: 0.2222\n",
      " Validation precision: 0.1667, Validation recall: 0.2143, Validation F1: 0.2222\n",
      " Validation precision: 0.1667, Validation recall: 0.2143, Validation F1: 0.2222\n",
      " Validation precision: 0.1667, Validation recall: 0.2143, Validation F1: 0.2222\n",
      "\n",
      " Early stopping at epoch  16\n",
      "\n",
      " Restoring model weights to weights from epoch  11\n",
      " Validation precision: 0.0000, Validation recall: 0.0000, Validation F1: 0.0000\n",
      " Validation precision: 0.0000, Validation recall: 0.0000, Validation F1: 0.0000\n",
      " Validation precision: 0.1667, Validation recall: 0.0769, Validation F1: 0.1053\n",
      " Validation precision: 0.1667, Validation recall: 0.1111, Validation F1: 0.1429\n",
      " Validation precision: 0.1667, Validation recall: 0.1429, Validation F1: 0.1667\n",
      " Validation precision: 0.1667, Validation recall: 0.1818, Validation F1: 0.1818\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2000\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2105\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2222\n",
      " Validation precision: 0.1667, Validation recall: 0.2105, Validation F1: 0.2222\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2222\n",
      " Validation precision: 0.1667, Validation recall: 0.2222, Validation F1: 0.2222\n",
      " Validation precision: 0.1667, Validation recall: 0.2143, Validation F1: 0.2222\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2222\n",
      "\n",
      " Early stopping at epoch  14\n",
      "\n",
      " Restoring model weights to weights from epoch  9\n",
      " Validation precision: 0.1667, Validation recall: 0.1429, Validation F1: 0.1538\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2000\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2000\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2000\n",
      " Validation precision: 0.1667, Validation recall: 0.1818, Validation F1: 0.1905\n",
      " Validation precision: 0.1667, Validation recall: 0.1667, Validation F1: 0.1818\n",
      " Validation precision: 0.1667, Validation recall: 0.1765, Validation F1: 0.1818\n",
      "\n",
      " Early stopping at epoch  7\n",
      "\n",
      " Restoring model weights to weights from epoch  2\n",
      " Validation precision: 0.1667, Validation recall: 0.1429, Validation F1: 0.1667\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2000\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2000\n",
      " Validation precision: 0.1667, Validation recall: 0.1818, Validation F1: 0.2000\n",
      " Validation precision: 0.1667, Validation recall: 0.1765, Validation F1: 0.1818\n",
      " Validation precision: 0.1667, Validation recall: 0.1667, Validation F1: 0.1818\n",
      " Validation precision: 0.1667, Validation recall: 0.1667, Validation F1: 0.1818\n",
      "\n",
      " Early stopping at epoch  7\n",
      "\n",
      " Restoring model weights to weights from epoch  2\n",
      " Validation precision: 0.1667, Validation recall: 0.0909, Validation F1: 0.1176\n",
      " Validation precision: 0.1667, Validation recall: 0.1667, Validation F1: 0.1818\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2000\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2000\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2000\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2000\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2000\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2000\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2000\n",
      "\n",
      " Early stopping at epoch  9\n",
      "\n",
      " Restoring model weights to weights from epoch  4\n",
      " Validation precision: 0.0000, Validation recall: 0.0000, Validation F1: 0.0000\n",
      " Validation precision: 0.0000, Validation recall: 0.0000, Validation F1: 0.0000\n",
      " Validation precision: 0.0000, Validation recall: 0.0000, Validation F1: 0.0000\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Validation precision: 0.0000, Validation recall: 0.0000, Validation F1: 0.0000\n",
      " Validation precision: 0.1667, Validation recall: 0.0500, Validation F1: 0.0769\n",
      " Validation precision: 0.1667, Validation recall: 0.0909, Validation F1: 0.1176\n",
      " Validation precision: 0.1667, Validation recall: 0.1111, Validation F1: 0.1333\n",
      " Validation precision: 0.1667, Validation recall: 0.1250, Validation F1: 0.1538\n",
      " Validation precision: 0.1667, Validation recall: 0.1429, Validation F1: 0.1667\n",
      " Validation precision: 0.1667, Validation recall: 0.1667, Validation F1: 0.1818\n",
      " Validation precision: 0.1667, Validation recall: 0.1765, Validation F1: 0.1818\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2000\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2000\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2000\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2000\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2000\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2105\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2222\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2222\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2222\n"
     ]
    }
   ],
   "source": [
    "# 1. tune learning rate alpha \n",
    "# train on a subset of X_train, y_train \n",
    "idx = random.sample(range(X_train.shape[0]),50000)\n",
    "X_sample = X_train[idx,:]\n",
    "y_sample = y_train[idx,:]\n",
    "alpha_history = []\n",
    "alpha_values = []\n",
    "val_precision = {}\n",
    "val_recall = {}\n",
    "val_f1 = {}\n",
    "\n",
    "for i in range(10):\n",
    "    # Sample parameter values from log scale, between 0.00001 to 0.1\n",
    "    alpha_log = np.random.uniform(np.log10(0.0003), np.log10(0.03), 1)[0]\n",
    "    alpha = round(10**alpha_log,6)\n",
    "\n",
    "    # Define model structure\n",
    "    context_size = 5\n",
    "    embed_size = 100\n",
    "    model = Sequential(name = \"model1\")\n",
    "    model.add(Embedding(n_words, embed_size, input_length = context_size, name = \"Embedding\"))\n",
    "    model.add(Lambda(lambda x: K.mean(x, axis=1), output_shape = (embed_size,), name = \"Mean\"))\n",
    "    model.add(Dense(n_words, activation = 'sigmoid', name = \"Dense\"))\n",
    "    opt = Adam(learning_rate = alpha )\n",
    "    metrics = MetricsAtK(k = 6)\n",
    "    model.compile(loss =  'binary_crossentropy', optimizer = opt, metrics = [metrics.precision_at_k,\n",
    "                                                                               metrics.recall_at_k,\n",
    "                                                                               metrics.F1_at_k])\n",
    "\n",
    "    # train \n",
    "    es = EarlyStoppingAtK(X_cv, y_cv, metrics, patience = 5)\n",
    "    history = model.fit(x = X_sample, y = y_sample, validation_data=(X_cv, y_cv), epochs = 20, verbose = 0, callbacks = [es])\n",
    "    alpha_history.append(history)\n",
    "    alpha_values.append(alpha)\n",
    "    \n",
    "    val_precision[i] = es.precisions\n",
    "    val_recall[i] = es.recalls\n",
    "    val_f1[i] = es.F1scores\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x360 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plot loss curves\n",
    "fig, ax = plt.subplots(ncols = 3, figsize = (15, 5))\n",
    "alpha_sort = np.argsort(alpha_values)\n",
    "\n",
    "for i in range(10):\n",
    "    train_loss = alpha_history[alpha_sort[i]].history['loss']\n",
    "    ax[0].plot(train_loss, label=alpha_values[alpha_sort[i]])\n",
    "ax[0].set_ylabel('loss')\n",
    "ax[0].set_xlabel('epoch')\n",
    "ax[0].legend(loc = 'upper right')\n",
    "ax[0].set_title('training loss')\n",
    "\n",
    "for i in range(10):\n",
    "    cv_loss = alpha_history[alpha_sort[i]].history['val_loss']\n",
    "    ax[1].plot(cv_loss, label=alpha_values[alpha_sort[i]])\n",
    "ax[1].set_ylabel('loss')\n",
    "ax[1].set_xlabel('epoch')\n",
    "ax[1].legend(loc = 'upper right')\n",
    "ax[1].set_title('validation loss')\n",
    "\n",
    "for i in range(10):\n",
    "    f1 = val_f1[alpha_sort[i]]\n",
    "    ax[2].plot(f1, label=alpha_values[alpha_sort[i]])\n",
    "ax[2].set_ylabel('validation F1')\n",
    "ax[2].set_xlabel('epoch')\n",
    "ax[2].legend(loc = 'lower right')\n",
    "ax[2].set_title('validation F1')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# why are the training loss increasing towards the end?\n",
    "# It's because I performed early stopping with some patience"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plot alpha values and val F1 score at the end of training\n",
    "\n",
    "alpha_sort = np.argsort(alpha_values)\n",
    "for i in range(10):\n",
    "    plt.scatter(alpha_values[alpha_sort[i]], val_f1[alpha_sort[i]][-1],\n",
    "               label = alpha_values[alpha_sort[i]])\n",
    "plt.xlim(0,0.025)\n",
    "plt.ylim(0,0.3)\n",
    "plt.xlabel('learning rate')\n",
    "plt.ylabel('validation F1')\n",
    "plt.legend(loc = 'upper right', bbox_to_anchor=(1.3, 1))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The above is showing us that the smaller learning rates will reach better Validation F1 performance\n",
    "\n",
    "# We'll thus choose the (largest) learning rate that whose validation loss doesn't increase too quickly\n",
    "# choose rate of 0.002"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "hyperparameter tuning  -- tune batch size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Validation precision: 0.0000, Validation recall: 0.0000, Validation F1: 0.0000\n",
      " Validation precision: 0.1667, Validation recall: 0.1250, Validation F1: 0.1538\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2000\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2105\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2222\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2222\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2222\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2222\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2222\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2105\n",
      "\n",
      " Early stopping at epoch  10\n",
      "\n",
      " Restoring model weights to weights from epoch  5\n",
      " Validation precision: 0.0000, Validation recall: 0.0000, Validation F1: 0.0000\n",
      " Validation precision: 0.1667, Validation recall: 0.0667, Validation F1: 0.0952\n",
      " Validation precision: 0.1667, Validation recall: 0.1111, Validation F1: 0.1429\n",
      " Validation precision: 0.1667, Validation recall: 0.1667, Validation F1: 0.1818\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2000\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2105\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2222\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2222\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2222\n",
      " Validation precision: 0.1667, Validation recall: 0.2143, Validation F1: 0.2222\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2222\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2222\n",
      "\n",
      " Early stopping at epoch  12\n",
      "\n",
      " Restoring model weights to weights from epoch  7\n",
      " Validation precision: 0.0000, Validation recall: 0.0000, Validation F1: 0.0000\n",
      " Validation precision: 0.0000, Validation recall: 0.0000, Validation F1: 0.0000\n",
      " Validation precision: 0.0000, Validation recall: 0.0000, Validation F1: 0.0000\n",
      " Validation precision: 0.1667, Validation recall: 0.0909, Validation F1: 0.1176\n",
      " Validation precision: 0.1667, Validation recall: 0.1111, Validation F1: 0.1333\n",
      " Validation precision: 0.1667, Validation recall: 0.1429, Validation F1: 0.1538\n",
      " Validation precision: 0.1667, Validation recall: 0.1667, Validation F1: 0.1818\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2000\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2000\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2069\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2105\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2222\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2222\n",
      " Validation precision: 0.1667, Validation recall: 0.2143, Validation F1: 0.2222\n",
      " Validation precision: 0.1667, Validation recall: 0.2143, Validation F1: 0.2222\n",
      " Validation precision: 0.1667, Validation recall: 0.2143, Validation F1: 0.2222\n",
      " Validation precision: 0.1667, Validation recall: 0.2143, Validation F1: 0.2222\n",
      "\n",
      " Early stopping at epoch  17\n",
      "\n",
      " Restoring model weights to weights from epoch  12\n",
      " Validation precision: 0.0000, Validation recall: 0.0000, Validation F1: 0.0000\n",
      " Validation precision: 0.0000, Validation recall: 0.0000, Validation F1: 0.0000\n",
      " Validation precision: 0.0000, Validation recall: 0.0000, Validation F1: 0.0000\n",
      " Validation precision: 0.0000, Validation recall: 0.0000, Validation F1: 0.0000\n",
      " Validation precision: 0.1667, Validation recall: 0.0769, Validation F1: 0.1053\n",
      " Validation precision: 0.1667, Validation recall: 0.1000, Validation F1: 0.1250\n",
      " Validation precision: 0.1667, Validation recall: 0.1111, Validation F1: 0.1333\n",
      " Validation precision: 0.1667, Validation recall: 0.1333, Validation F1: 0.1538\n",
      " Validation precision: 0.1667, Validation recall: 0.1429, Validation F1: 0.1667\n",
      " Validation precision: 0.1667, Validation recall: 0.1667, Validation F1: 0.1818\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2000\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2000\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2000\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2000\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2105\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2222\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2222\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2222\n",
      " Validation precision: 0.1667, Validation recall: 0.2143, Validation F1: 0.2222\n",
      " Validation precision: 0.1667, Validation recall: 0.2105, Validation F1: 0.2222\n",
      " Validation precision: 0.1667, Validation recall: 0.2143, Validation F1: 0.2222\n",
      "\n",
      " Early stopping at epoch  21\n",
      "\n",
      " Restoring model weights to weights from epoch  16\n",
      " Validation precision: 0.0000, Validation recall: 0.0000, Validation F1: 0.0000\n",
      " Validation precision: 0.0000, Validation recall: 0.0000, Validation F1: 0.0000\n",
      " Validation precision: 0.0000, Validation recall: 0.0000, Validation F1: 0.0000\n",
      " Validation precision: 0.0000, Validation recall: 0.0000, Validation F1: 0.0000\n",
      " Validation precision: 0.0000, Validation recall: 0.0000, Validation F1: 0.0000\n",
      " Validation precision: 0.1667, Validation recall: 0.0714, Validation F1: 0.1000\n",
      " Validation precision: 0.1667, Validation recall: 0.0909, Validation F1: 0.1176\n",
      " Validation precision: 0.1667, Validation recall: 0.1000, Validation F1: 0.1250\n",
      " Validation precision: 0.1667, Validation recall: 0.1176, Validation F1: 0.1429\n",
      " Validation precision: 0.1667, Validation recall: 0.1250, Validation F1: 0.1538\n",
      " Validation precision: 0.1667, Validation recall: 0.1429, Validation F1: 0.1667\n",
      " Validation precision: 0.1667, Validation recall: 0.1667, Validation F1: 0.1667\n",
      " Validation precision: 0.1667, Validation recall: 0.1667, Validation F1: 0.1818\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2000\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2000\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2000\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2105\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2105\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2222\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2222\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2222\n",
      " Validation precision: 0.1667, Validation recall: 0.2105, Validation F1: 0.2222\n",
      " Validation precision: 0.1667, Validation recall: 0.2143, Validation F1: 0.2222\n",
      " Validation precision: 0.1667, Validation recall: 0.2222, Validation F1: 0.2222\n",
      "\n",
      " Early stopping at epoch  24\n",
      "\n",
      " Restoring model weights to weights from epoch  19\n",
      " Validation precision: 0.0000, Validation recall: 0.0000, Validation F1: 0.0000\n",
      " Validation precision: 0.0000, Validation recall: 0.0000, Validation F1: 0.0000\n",
      " Validation precision: 0.0000, Validation recall: 0.0000, Validation F1: 0.0000\n",
      " Validation precision: 0.0000, Validation recall: 0.0000, Validation F1: 0.0000\n",
      " Validation precision: 0.0000, Validation recall: 0.0000, Validation F1: 0.0000\n",
      " Validation precision: 0.0000, Validation recall: 0.0000, Validation F1: 0.0000\n",
      "\n",
      " Early stopping at epoch  6\n",
      "\n",
      " Restoring model weights to weights from epoch  1\n"
     ]
    }
   ],
   "source": [
    "batch_size = [10, 20, 40, 60, 80, 100]\n",
    "\n",
    "# train on a subset of X_train, y_train\n",
    "idx = random.sample(range(X_train.shape[0]),50000)\n",
    "X_sample = X_train[idx,:]\n",
    "y_sample = y_train[idx,:]\n",
    "\n",
    "val_precision = {}\n",
    "val_recall = {}\n",
    "val_f1 = {}\n",
    "\n",
    "metrics = MetricsAtK(k = 6)\n",
    "\n",
    "for batch in batch_size:\n",
    "\n",
    "    # Define model structure\n",
    "    context_size = 5\n",
    "    embed_size = 100\n",
    "    model = Sequential(name = \"model1\")\n",
    "    model.add(Embedding(n_words, embed_size, input_length = context_size, name = \"Embedding\"))\n",
    "    model.add(Lambda(lambda x: K.mean(x, axis=1), output_shape = (embed_size,), name = \"Mean\"))\n",
    "    model.add(Dense(n_words, activation = 'sigmoid', name = \"Dense\"))\n",
    "    opt = Adam(learning_rate = 0.002)\n",
    "    model.compile(loss =  'binary_crossentropy', optimizer = opt, metrics = [metrics.precision_at_k,\n",
    "                                                                               metrics.recall_at_k,\n",
    "                                                                               metrics.F1_at_k])\n",
    "\n",
    "    # train \n",
    "    es = EarlyStoppingAtK(X_cv, y_cv, metrics, patience = 5)\n",
    "    history = model.fit(x = X_sample, y = y_sample, validation_data=(X_cv, y_cv), \n",
    "                        batch_size = batch,epochs = 50, verbose = 0, callbacks = [es])\n",
    "\n",
    "    val_precision[batch] = es.precisions\n",
    "    val_recall[batch] = es.recalls\n",
    "    val_f1[batch] = es.F1scores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 185,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "for i in batch_size:\n",
    "    f1 = val_f1[i]\n",
    "    plt.plot(f1, label=i)\n",
    "plt.legend()\n",
    "plt.xlabel(\"epoch\")\n",
    "plt.ylabel(\"validation F1\")\n",
    "plt.title(\"validation F1\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The above graph shows us that a wide range of batch sizes less than 100 would be appropriate. \n",
    "# we'll choose the default batch size of 32 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# model performance on test set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 186,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"model\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "Embedding (Embedding)        (None, 5, 100)            671200    \n",
      "_________________________________________________________________\n",
      "Mean (Lambda)                (None, 100)               0         \n",
      "_________________________________________________________________\n",
      "Dense (Dense)                (None, 6712)              677912    \n",
      "=================================================================\n",
      "Total params: 1,349,112\n",
      "Trainable params: 1,349,112\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "# define model structure\n",
    "context_size = 5\n",
    "embed_size = 100\n",
    "\n",
    "model = Sequential(name = \"model\")\n",
    "\n",
    "# embedding\n",
    "model.add(Embedding(n_words, embed_size, input_length = context_size, name = \"Embedding\"))\n",
    "\n",
    "# take the mean of vectors\n",
    "model.add(Lambda(lambda x: K.mean(x, axis=1), output_shape = (embed_size,), name = \"Mean\"))\n",
    "\n",
    "# last layer\n",
    "model.add(Dense(n_words, activation = 'sigmoid', name = \"Dense\"))\n",
    "\n",
    "#metrics = MetricsAtK(6, X_cv, y_cv)\n",
    "\n",
    "metrics = MetricsAtK(k = 6)\n",
    "opt = Adam(learning_rate = 0.002 )\n",
    "model.compile(loss =  'binary_crossentropy', optimizer = opt, metrics = [metrics.precision_at_k,\n",
    "                                                                           metrics.recall_at_k,\n",
    "                                                                           metrics.F1_at_k])\n",
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 187,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/20\n",
      " Validation precision: 0.1667, Validation recall: 0.0588, Validation F1: 0.0870\n",
      "4098/4098 - 31s - loss: 0.0194 - precision_at_k: 0.0634 - recall_at_k: 0.0336 - F1_at_k: 0.0436 - val_loss: 0.0058 - val_precision_at_k: 0.0790 - val_recall_at_k: 0.0421 - val_F1_at_k: 0.0542\n",
      "Epoch 2/20\n",
      " Validation precision: 0.1667, Validation recall: 0.1429, Validation F1: 0.1667\n",
      "4098/4098 - 31s - loss: 0.0055 - precision_at_k: 0.1323 - recall_at_k: 0.0907 - F1_at_k: 0.1082 - val_loss: 0.0051 - val_precision_at_k: 0.1610 - val_recall_at_k: 0.1337 - val_F1_at_k: 0.1499\n",
      "Epoch 3/20\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2000\n",
      "4098/4098 - 31s - loss: 0.0049 - precision_at_k: 0.1816 - recall_at_k: 0.1746 - F1_at_k: 0.1865 - val_loss: 0.0048 - val_precision_at_k: 0.1857 - val_recall_at_k: 0.1985 - val_F1_at_k: 0.2042\n",
      "Epoch 4/20\n",
      " Validation precision: 0.1667, Validation recall: 0.2222, Validation F1: 0.2222\n",
      "4098/4098 - 31s - loss: 0.0046 - precision_at_k: 0.2238 - recall_at_k: 0.2179 - F1_at_k: 0.2240 - val_loss: 0.0047 - val_precision_at_k: 0.2048 - val_recall_at_k: 0.2143 - val_F1_at_k: 0.2177\n",
      "Epoch 5/20\n",
      " Validation precision: 0.1667, Validation recall: 0.2222, Validation F1: 0.2222\n",
      "4098/4098 - 31s - loss: 0.0044 - precision_at_k: 0.2550 - recall_at_k: 0.2407 - F1_at_k: 0.2431 - val_loss: 0.0047 - val_precision_at_k: 0.2086 - val_recall_at_k: 0.2178 - val_F1_at_k: 0.2195\n",
      "Epoch 6/20\n",
      " Validation precision: 0.1667, Validation recall: 0.2222, Validation F1: 0.2222\n",
      "4098/4098 - 31s - loss: 0.0043 - precision_at_k: 0.2768 - recall_at_k: 0.2573 - F1_at_k: 0.2568 - val_loss: 0.0046 - val_precision_at_k: 0.2181 - val_recall_at_k: 0.2211 - val_F1_at_k: 0.2207\n",
      "Epoch 7/20\n",
      " Validation precision: 0.1667, Validation recall: 0.2222, Validation F1: 0.2222\n",
      "4098/4098 - 31s - loss: 0.0042 - precision_at_k: 0.2916 - recall_at_k: 0.2700 - F1_at_k: 0.2681 - val_loss: 0.0046 - val_precision_at_k: 0.2095 - val_recall_at_k: 0.2220 - val_F1_at_k: 0.2210\n",
      "Epoch 8/20\n",
      " Validation precision: 0.1667, Validation recall: 0.2222, Validation F1: 0.2222\n",
      "4098/4098 - 31s - loss: 0.0041 - precision_at_k: 0.3032 - recall_at_k: 0.2811 - F1_at_k: 0.2774 - val_loss: 0.0047 - val_precision_at_k: 0.2200 - val_recall_at_k: 0.2210 - val_F1_at_k: 0.2229\n",
      "Epoch 9/20\n",
      " Validation precision: 0.1667, Validation recall: 0.2222, Validation F1: 0.2222\n",
      "\n",
      " Early stopping at epoch  9\n",
      "\n",
      " Restoring model weights to weights from epoch  4\n",
      "4098/4098 - 31s - loss: 0.0040 - precision_at_k: 0.3103 - recall_at_k: 0.2901 - F1_at_k: 0.2849 - val_loss: 0.0047 - val_precision_at_k: 0.2133 - val_recall_at_k: 0.2204 - val_F1_at_k: 0.2215\n"
     ]
    }
   ],
   "source": [
    "# callbacks for early stopping and model saving\n",
    "# early stopping\n",
    "es = EarlyStoppingAtK(X_cv, y_cv, metrics, patience = 5)\n",
    "\n",
    "# save model\n",
    "mc = ModelCheckpoint('models/multilabel_NN/model_{epoch:02d}.h5', save_freq = 'epoch', verbose = 0)\n",
    "\n",
    "# fit model\n",
    "history = model.fit(x = X_train, y = y_train, validation_data=(X_cv, y_cv), \n",
    "                    batch_size = 32, epochs = 20, verbose = 2, callbacks = [es, mc])\n",
    "\n",
    "model.save('models/multilabel_NN/model.h5')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 188,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x360 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# number of epochs determined by the following\n",
    "# plot the training and validation loss to determine if overfitting / underfitting \n",
    "\n",
    "train_loss = history.history['loss']\n",
    "val_loss = history.history['val_loss']\n",
    "train_F1 = history.history['F1_at_k']\n",
    "batch_val_F1 = history.history['val_F1_at_k']\n",
    "val_F1 = es.F1scores\n",
    "n_epochs = len(train_loss)\n",
    "\n",
    "fig, ax = plt.subplots(ncols = 2, figsize = (15,5))\n",
    "ax[0].plot(list(range(n_epochs)), train_loss, label ='train loss')\n",
    "ax[0].plot(list(range(n_epochs)), val_loss, label ='val loss')\n",
    "ax[0].set_xlabel('training epochs')\n",
    "ax[0].set_ylabel('loss')\n",
    "ax[0].legend()\n",
    "ax[1].plot(list(range(n_epochs)), train_F1, label ='train F1')\n",
    "ax[1].plot(list(range(n_epochs)), batch_val_F1, label ='batch val F1')\n",
    "ax[1].plot(list(range(n_epochs)), val_F1, label ='val F1')\n",
    "ax[1].set_xlabel('training epochs')\n",
    "ax[1].set_ylabel('F1')\n",
    "ax[1].legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 189,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x216 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Median precision on CV set:  0.16666666666666666\n",
      "Median recall on CV set:  0.2222222222222222\n",
      "Median F-score on CV set:  0.2222222222222222\n",
      "Mean precision on CV set:  0.2466654757651542\n",
      "Mean recall on CV set:  0.2541429914747929\n",
      "Mean F-score on CV set:  0.22661873785672978\n"
     ]
    }
   ],
   "source": [
    "# load model with best performing validation_F1 score\n",
    "model = keras.models.load_model('models/multilabel_NN/model.h5', custom_objects= {'precision_at_k':metrics.precision_at_k,\n",
    "                                                                                  'recall_at_k':metrics.recall_at_k,\n",
    "                                                                                  'F1_at_k': metrics.F1_at_k})\n",
    "show_histograms(model, X_cv, y_cv)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 190,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred = model.predict(X_cv)\n",
    "n_dataset = y_pred.shape[0]\n",
    "pred = []\n",
    "for i in range(n_dataset):\n",
    "    pred_ing = y_pred[i,:].argsort()[::-1][:6].tolist()\n",
    "    pred.append(pred_ing)\n",
    "\n",
    "# for each document in CV set, create a list of missing ingredients (true ingredients)\n",
    "missing_ing = []\n",
    "for i in range(n_dataset):\n",
    "    missing_ing.append(np.nonzero(y_cv[i,:])[0].tolist())\n",
    "\n",
    "## compute precision, recall, F-score on the CV set \n",
    "scores = [fn.compute_scores(pred[i], missing_ing[i]) for i in range(len(pred))]\n",
    "\n",
    "precisions = [item[0] for item in scores] \n",
    "recalls = [item[1] for item in scores]\n",
    "Fscores = [item[2] for item in scores]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 191,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " ********** Example recommendations with high F scores **********\n",
      "==================== Example with F-score: 0.83 ====================\n",
      "---------- Existing ingredients ---------- \n",
      " ['baking_soda', 'kosher_salt', 'sugar', 'whole_milk', 'buttermilk']\n",
      "---------- Missing ingredients ---------- \n",
      " ['all-purpose_flour', 'cornmeal', 'large_eggs', 'southern_us', 'baking_powder', 'unsalted_butter']\n",
      "---------- Recommended ingredients ---------- \n",
      " ['all-purpose_flour', 'southern_us', 'unsalted_butter', 'large_eggs', 'baking_powder', 'irish'] \n",
      "\n",
      "==================== Example with F-score: 0.80 ====================\n",
      "---------- Existing ingredients ---------- \n",
      " ['baking_soda', 'quick-cooking_oats', 'unsalted_butter', 'british', 'baking_powder']\n",
      "---------- Missing ingredients ---------- \n",
      " ['sugar', 'large_eggs', 'all-purpose_flour', 'buttermilk']\n",
      "---------- Recommended ingredients ---------- \n",
      " ['all-purpose_flour', 'sugar', 'large_eggs', 'buttermilk', 'eggs', 'baking_soda'] \n",
      "\n",
      "==================== Example with F-score: 0.77 ====================\n",
      "---------- Existing ingredients ---------- \n",
      " ['powdered_sugar', 'cooking_spray', 'sugar', 'dried_cranberries', 'irish']\n",
      "---------- Missing ingredients ---------- \n",
      " ['all-purpose_flour', 'low-fat_buttermilk', 'baking_powder', 'butter', 'baking_soda', 'large_eggs', 'grated_orange']\n",
      "---------- Recommended ingredients ---------- \n",
      " ['all-purpose_flour', 'baking_powder', 'butter', 'baking_soda', 'large_egg_whites', 'large_eggs'] \n",
      "\n",
      "==================== Example with F-score: 0.75 ====================\n",
      "---------- Existing ingredients ---------- \n",
      " ['quail_eggs', 'garlic', 'tomato_sauce', 'potatoes', 'raisins']\n",
      "---------- Missing ingredients ---------- \n",
      " ['ground_pork', 'water', 'filipino', 'fish_sauce', 'carrots', 'oil', 'frozen_sweet_peas', 'ketchup', 'pepper', 'onions']\n",
      "---------- Recommended ingredients ---------- \n",
      " ['onions', 'carrots', 'pepper', 'filipino', 'water', 'oil'] \n",
      "\n",
      "==================== Example with F-score: 0.73 ====================\n",
      "---------- Existing ingredients ---------- \n",
      " ['irish', 'unsalted_butter', 'buttermilk', 'baking_powder', 'caraway_seeds']\n",
      "---------- Missing ingredients ---------- \n",
      " ['baking_soda', 'raisins', 'sugar', 'all-purpose_flour', 'large_eggs']\n",
      "---------- Recommended ingredients ---------- \n",
      " ['all-purpose_flour', 'baking_soda', 'sugar', 'large_eggs', 'whole_wheat_flour', 'all_purpose_unbleached_flour'] \n",
      "\n",
      "==================== Example with F-score: 0.73 ====================\n",
      "---------- Existing ingredients ---------- \n",
      " ['vegetable_oil_spray', 'lemon-lime_soda', 'sugar', 'grate_lime_peel', 'powdered_sugar']\n",
      "---------- Missing ingredients ---------- \n",
      " ['large_eggs', 'all-purpose_flour', 'southern_us', 'grated_lemon_peel', 'unsalted_butter']\n",
      "---------- Recommended ingredients ---------- \n",
      " ['french', 'unsalted_butter', 'southern_us', 'all-purpose_flour', 'large_eggs', 'fresh_lemon_juice'] \n",
      "\n",
      "==================== Example with F-score: 0.73 ====================\n",
      "---------- Existing ingredients ---------- \n",
      " ['italian', 'white_sugar', 'milk', 'ricotta_cheese', 'confectioners_sugar']\n",
      "---------- Missing ingredients ---------- \n",
      " ['butter', 'baking_soda', 'eggs', 'all-purpose_flour', 'vanilla_extract']\n",
      "---------- Recommended ingredients ---------- \n",
      " ['all-purpose_flour', 'eggs', 'butter', 'vanilla_extract', 'active_dry_yeast', 'bread_flour'] \n",
      "\n",
      "==================== Example with F-score: 0.73 ====================\n",
      "---------- Existing ingredients ---------- \n",
      " ['pepper', 'italian', 'heavy_cream', 'spaghetti', 'dried_parsley']\n",
      "---------- Missing ingredients ---------- \n",
      " ['garlic', 'butter', 'chicken_broth', 'olive_oil', 'grated_parmesan_cheese']\n",
      "---------- Recommended ingredients ---------- \n",
      " ['garlic', 'grated_parmesan_cheese', 'olive_oil', 'butter', 'garlic_cloves', 'onions'] \n",
      "\n",
      "==================== Example with F-score: 0.73 ====================\n",
      "---------- Existing ingredients ---------- \n",
      " ['southern_us', 'cranberries', 'vanilla_extract', 'sugar', 'butter']\n",
      "---------- Missing ingredients ---------- \n",
      " ['milk', 'baking_powder', 'all-purpose_flour', 'fresh_ginger', 'large_eggs']\n",
      "---------- Recommended ingredients ---------- \n",
      " ['all-purpose_flour', 'milk', 'large_eggs', 'eggs', 'chopped_pecans', 'baking_powder'] \n",
      "\n",
      "==================== Example with F-score: 0.73 ====================\n",
      "---------- Existing ingredients ---------- \n",
      " ['long_grain_white_rice', 'cumin', 'mexican', 'chicken_stock', 'butter']\n",
      "---------- Missing ingredients ---------- \n",
      " ['tomato_paste', 'garlic', 'pepper', 'chili_powder', 'onions']\n",
      "---------- Recommended ingredients ---------- \n",
      " ['onions', 'pepper', 'garlic', 'olive_oil', 'chicken_broth', 'chili_powder'] \n",
      "\n"
     ]
    }
   ],
   "source": [
    "# print examples with high F scores \n",
    "highF = np.argsort(Fscores)[::-1][:10]\n",
    "print(\" ********** Example recommendations with high F scores **********\")\n",
    "for i in highF:\n",
    "    print(\"==================== Example with F-score: %0.2f ====================\"  %Fscores[i])\n",
    "    print(\"---------- Existing ingredients ---------- \\n\", [index_to_words[item+1] for item in sampled_cv[i]])\n",
    "    print(\"---------- Missing ingredients ---------- \\n\", [index_to_words[item+1] for item in target_cv[i]])\n",
    "    print(\"---------- Recommended ingredients ---------- \\n\", [index_to_words[item+1] for item in pred[i]] ,\"\\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 192,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " ********** Example recommendations with low F scores **********\n",
      "==================== Example with F-score: 0.00 ====================\n",
      "---------- Existing ingredients ---------- \n",
      " ['italian', 'olive_oil', 'potatoes', 'red_pepper_flakes', 'bacon']\n",
      "---------- Missing ingredients ---------- \n",
      " ['feta_cheese_crumbles', 'salt_and_ground_black_pepper', 'eggs', 'sweet_pepper']\n",
      "---------- Recommended ingredients ---------- \n",
      " ['onions', 'garlic', 'pepper', 'ground_black_pepper', 'water', 'garlic_cloves'] \n",
      "\n",
      "==================== Example with F-score: 0.00 ====================\n",
      "---------- Existing ingredients ---------- \n",
      " ['basil', 'puff_pastry', 'italian', 'part-skim_mozzarella_cheese', 'fresh_basil']\n",
      "---------- Missing ingredients ---------- \n",
      " ['cooking_spray']\n",
      "---------- Recommended ingredients ---------- \n",
      " ['olive_oil', 'grated_parmesan_cheese', 'garlic', 'fresh_basil', 'garlic_cloves', 'eggs'] \n",
      "\n",
      "==================== Example with F-score: 0.00 ====================\n",
      "---------- Existing ingredients ---------- \n",
      " ['sour_cream', 'jell-o_gelatin', 'frozen_whipped_topping', 'mini_marshmallows', 'southern_us']\n",
      "---------- Missing ingredients ---------- \n",
      " ['chopped_pecans', 'crushed_pineapples_in_juice']\n",
      "---------- Recommended ingredients ---------- \n",
      " ['eggs', 'large_eggs', 'butter', 'all-purpose_flour', 'sugar', 'unsalted_butter'] \n",
      "\n",
      "==================== Example with F-score: 0.00 ====================\n",
      "---------- Existing ingredients ---------- \n",
      " ['arrow_root', 'plain_yogurt', 'brazilian', 'water', 'parmesan_cheese']\n",
      "---------- Missing ingredients ---------- \n",
      " ['sunflower_oil', 'eggs']\n",
      "---------- Recommended ingredients ---------- \n",
      " ['garlic', 'onions', 'garlic_cloves', 'pepper', 'olive_oil', 'tomatoes'] \n",
      "\n",
      "==================== Example with F-score: 0.00 ====================\n",
      "---------- Existing ingredients ---------- \n",
      " ['triple_sec', 'tequila', 'lime', 'mexican', 'lime_juice']\n",
      "---------- Missing ingredients ---------- \n",
      " ['ice_cubes', 'fresh_lime_juice']\n",
      "---------- Recommended ingredients ---------- \n",
      " ['avocado', 'jalapeno_chilies', 'lime', 'cilantro', 'garlic', 'chopped_cilantro_fresh'] \n",
      "\n",
      "==================== Example with F-score: 0.00 ====================\n",
      "---------- Existing ingredients ---------- \n",
      " ['kosher_salt', 'chinese', 'chili_flakes', 'rice_vinegar', 'peanut_oil']\n",
      "---------- Missing ingredients ---------- \n",
      " ['chinese_five-spice_powder', 'garlic_cloves', 'hoisin_sauce', 'celery', 'chicken_wings']\n",
      "---------- Recommended ingredients ---------- \n",
      " ['soy_sauce', 'sesame_oil', 'corn_starch', 'garlic', 'scallions', 'sugar'] \n",
      "\n",
      "==================== Example with F-score: 0.00 ====================\n",
      "---------- Existing ingredients ---------- \n",
      " ['korean', 'red_pepper', 'garlic', 'napa_cabbage', 'sugar']\n",
      "---------- Missing ingredients ---------- \n",
      " ['spring_onions', 'fresh_ginger', 'kosher_salt', 'fish_sauce', 'daikon']\n",
      "---------- Recommended ingredients ---------- \n",
      " ['sesame_oil', 'soy_sauce', 'scallions', 'green_onions', 'ginger', 'onions'] \n",
      "\n",
      "==================== Example with F-score: 0.00 ====================\n",
      "---------- Existing ingredients ---------- \n",
      " ['red_preserved_bean_curd', 'honey', 'pork_neck', 'red_food_coloring', 'chinese']\n",
      "---------- Missing ingredients ---------- \n",
      " ['white_pepper', 'chinese_five-spice_powder', 'hoisin_sauce', 'light_soy_sauce']\n",
      "---------- Recommended ingredients ---------- \n",
      " ['soy_sauce', 'sesame_oil', 'water', 'corn_starch', 'sugar', 'ginger'] \n",
      "\n",
      "==================== Example with F-score: 0.00 ====================\n",
      "---------- Existing ingredients ---------- \n",
      " ['biscuits', 'white_chocolate', 'sugar', 'fresh_raspberries', 'heavy_whipping_cream']\n",
      "---------- Missing ingredients ---------- \n",
      " ['water', 'almond_extract', 'british', 'raspberry_jam', 'raspberries', 'sliced_almonds']\n",
      "---------- Recommended ingredients ---------- \n",
      " ['french', 'whipping_cream', 'southern_us', 'italian', 'vanilla_extract', 'semisweet_chocolate'] \n",
      "\n",
      "==================== Example with F-score: 0.00 ====================\n",
      "---------- Existing ingredients ---------- \n",
      " ['sugarcane_juice', 'rice', 'indian', 'cashew_nuts', 'ghee']\n",
      "---------- Missing ingredients ---------- \n",
      " ['moong_dal', 'dates', 'ground_cardamom']\n",
      "---------- Recommended ingredients ---------- \n",
      " ['onions', 'garam_masala', 'oil', 'green_chilies', 'cumin_seed', 'garlic'] \n",
      "\n"
     ]
    }
   ],
   "source": [
    "# print examples with low F scores \n",
    "lowF = np.argsort(Fscores)[:10]\n",
    "print(\" ********** Example recommendations with low F scores **********\")\n",
    "for i in lowF:\n",
    "    print(\"==================== Example with F-score: %0.2f ====================\"  %Fscores[i])\n",
    "    print(\"---------- Existing ingredients ---------- \\n\", [index_to_words[item+1] for item in sampled_cv[i]])\n",
    "    print(\"---------- Missing ingredients ---------- \\n\", [index_to_words[item+1] for item in target_cv[i]])\n",
    "    print(\"---------- Recommended ingredients ---------- \\n\", [index_to_words[item+1] for item in pred[i]] ,\"\\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# are there any systematic underperformance for particular cuisine? "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 194,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>level_0</th>\n",
       "      <th>index</th>\n",
       "      <th>Unnamed: 0</th>\n",
       "      <th>id</th>\n",
       "      <th>cuisine</th>\n",
       "      <th>ingredients</th>\n",
       "      <th>document</th>\n",
       "      <th>precisions</th>\n",
       "      <th>recalls</th>\n",
       "      <th>Fscores</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>25693</td>\n",
       "      <td>southern_us</td>\n",
       "      <td>['plain_flour', 'ground_pepper', 'tomatoes', '...</td>\n",
       "      <td>['plain_flour', 'ground_pepper', 'tomatoes', '...</td>\n",
       "      <td>0.333333</td>\n",
       "      <td>0.333333</td>\n",
       "      <td>0.333333</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>7</td>\n",
       "      <td>7</td>\n",
       "      <td>3735</td>\n",
       "      <td>italian</td>\n",
       "      <td>['sugar', 'pistachio_nuts', 'white_almond_bark...</td>\n",
       "      <td>['sugar', 'pistachio_nuts', 'white_almond_bark...</td>\n",
       "      <td>0.166667</td>\n",
       "      <td>0.166667</td>\n",
       "      <td>0.166667</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2</td>\n",
       "      <td>15</td>\n",
       "      <td>15</td>\n",
       "      <td>24717</td>\n",
       "      <td>indian</td>\n",
       "      <td>['tumeric', 'vegetable_stock', 'tomatoes', 'ga...</td>\n",
       "      <td>['tumeric', 'vegetable_stock', 'tomatoes', 'ga...</td>\n",
       "      <td>0.333333</td>\n",
       "      <td>0.333333</td>\n",
       "      <td>0.333333</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>3</td>\n",
       "      <td>24</td>\n",
       "      <td>24</td>\n",
       "      <td>49136</td>\n",
       "      <td>italian</td>\n",
       "      <td>['marinara_sauce', 'flat_leaf_parsley', 'olive...</td>\n",
       "      <td>['marinara_sauce', 'flat_leaf_parsley', 'olive...</td>\n",
       "      <td>0.166667</td>\n",
       "      <td>0.200000</td>\n",
       "      <td>0.181818</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>4</td>\n",
       "      <td>38</td>\n",
       "      <td>38</td>\n",
       "      <td>17610</td>\n",
       "      <td>southern_us</td>\n",
       "      <td>['green_onions', 'cream_cheese', 'shredded_che...</td>\n",
       "      <td>['green_onions', 'cream_cheese', 'shredded_che...</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   level_0  index  Unnamed: 0     id      cuisine  \\\n",
       "0        0      1           1  25693  southern_us   \n",
       "1        1      7           7   3735      italian   \n",
       "2        2     15          15  24717       indian   \n",
       "3        3     24          24  49136      italian   \n",
       "4        4     38          38  17610  southern_us   \n",
       "\n",
       "                                         ingredients  \\\n",
       "0  ['plain_flour', 'ground_pepper', 'tomatoes', '...   \n",
       "1  ['sugar', 'pistachio_nuts', 'white_almond_bark...   \n",
       "2  ['tumeric', 'vegetable_stock', 'tomatoes', 'ga...   \n",
       "3  ['marinara_sauce', 'flat_leaf_parsley', 'olive...   \n",
       "4  ['green_onions', 'cream_cheese', 'shredded_che...   \n",
       "\n",
       "                                            document  precisions   recalls  \\\n",
       "0  ['plain_flour', 'ground_pepper', 'tomatoes', '...    0.333333  0.333333   \n",
       "1  ['sugar', 'pistachio_nuts', 'white_almond_bark...    0.166667  0.166667   \n",
       "2  ['tumeric', 'vegetable_stock', 'tomatoes', 'ga...    0.333333  0.333333   \n",
       "3  ['marinara_sauce', 'flat_leaf_parsley', 'olive...    0.166667  0.200000   \n",
       "4  ['green_onions', 'cream_cheese', 'shredded_che...    0.000000  0.000000   \n",
       "\n",
       "    Fscores  \n",
       "0  0.333333  \n",
       "1  0.166667  \n",
       "2  0.333333  \n",
       "3  0.181818  \n",
       "4  0.000000  "
      ]
     },
     "execution_count": 194,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_CV = df.loc[cv_idx]\n",
    "df_CV.reset_index(inplace = True)\n",
    "\n",
    "df_CV = df_CV.loc[indices_cv]\n",
    "df_CV.reset_index(inplace = True)\n",
    "\n",
    "df_CV[\"precisions\"] = precisions\n",
    "df_CV[\"recalls\"] = recalls\n",
    "df_CV[\"Fscores\"] = Fscores\n",
    "\n",
    "df_CV.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 195,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>precisions</th>\n",
       "      <th>recalls</th>\n",
       "      <th>Fscores</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>cuisine</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>korean</th>\n",
       "      <td>0.333333</td>\n",
       "      <td>0.272727</td>\n",
       "      <td>0.285714</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>moroccan</th>\n",
       "      <td>0.333333</td>\n",
       "      <td>0.200000</td>\n",
       "      <td>0.250000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>chinese</th>\n",
       "      <td>0.333333</td>\n",
       "      <td>0.222222</td>\n",
       "      <td>0.250000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>filipino</th>\n",
       "      <td>0.166667</td>\n",
       "      <td>0.250000</td>\n",
       "      <td>0.250000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>russian</th>\n",
       "      <td>0.333333</td>\n",
       "      <td>0.250000</td>\n",
       "      <td>0.250000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>indian</th>\n",
       "      <td>0.333333</td>\n",
       "      <td>0.200000</td>\n",
       "      <td>0.245000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>spanish</th>\n",
       "      <td>0.166667</td>\n",
       "      <td>0.250000</td>\n",
       "      <td>0.235294</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>irish</th>\n",
       "      <td>0.166667</td>\n",
       "      <td>0.250000</td>\n",
       "      <td>0.235294</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>italian</th>\n",
       "      <td>0.166667</td>\n",
       "      <td>0.250000</td>\n",
       "      <td>0.222222</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>southern_us</th>\n",
       "      <td>0.166667</td>\n",
       "      <td>0.250000</td>\n",
       "      <td>0.222222</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>cajun_creole</th>\n",
       "      <td>0.166667</td>\n",
       "      <td>0.179144</td>\n",
       "      <td>0.210526</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>vietnamese</th>\n",
       "      <td>0.166667</td>\n",
       "      <td>0.179144</td>\n",
       "      <td>0.205263</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>british</th>\n",
       "      <td>0.166667</td>\n",
       "      <td>0.200000</td>\n",
       "      <td>0.205263</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>thai</th>\n",
       "      <td>0.166667</td>\n",
       "      <td>0.200000</td>\n",
       "      <td>0.200000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>jamaican</th>\n",
       "      <td>0.166667</td>\n",
       "      <td>0.214286</td>\n",
       "      <td>0.200000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>mexican</th>\n",
       "      <td>0.166667</td>\n",
       "      <td>0.200000</td>\n",
       "      <td>0.200000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>japanese</th>\n",
       "      <td>0.166667</td>\n",
       "      <td>0.200000</td>\n",
       "      <td>0.200000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>greek</th>\n",
       "      <td>0.166667</td>\n",
       "      <td>0.235294</td>\n",
       "      <td>0.200000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>french</th>\n",
       "      <td>0.166667</td>\n",
       "      <td>0.200000</td>\n",
       "      <td>0.200000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>brazilian</th>\n",
       "      <td>0.166667</td>\n",
       "      <td>0.142857</td>\n",
       "      <td>0.166667</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "              precisions   recalls   Fscores\n",
       "cuisine                                     \n",
       "korean          0.333333  0.272727  0.285714\n",
       "moroccan        0.333333  0.200000  0.250000\n",
       "chinese         0.333333  0.222222  0.250000\n",
       "filipino        0.166667  0.250000  0.250000\n",
       "russian         0.333333  0.250000  0.250000\n",
       "indian          0.333333  0.200000  0.245000\n",
       "spanish         0.166667  0.250000  0.235294\n",
       "irish           0.166667  0.250000  0.235294\n",
       "italian         0.166667  0.250000  0.222222\n",
       "southern_us     0.166667  0.250000  0.222222\n",
       "cajun_creole    0.166667  0.179144  0.210526\n",
       "vietnamese      0.166667  0.179144  0.205263\n",
       "british         0.166667  0.200000  0.205263\n",
       "thai            0.166667  0.200000  0.200000\n",
       "jamaican        0.166667  0.214286  0.200000\n",
       "mexican         0.166667  0.200000  0.200000\n",
       "japanese        0.166667  0.200000  0.200000\n",
       "greek           0.166667  0.235294  0.200000\n",
       "french          0.166667  0.200000  0.200000\n",
       "brazilian       0.166667  0.142857  0.166667"
      ]
     },
     "execution_count": 195,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# compute median scores for each cuisine\n",
    "df_CV[[\"cuisine\", \"precisions\", \"recalls\", \"Fscores\"]].groupby(\"cuisine\").median().sort_values(by='Fscores', ascending = False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "# 5. Comparison of the models "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "* Compare the performance of various models on the cross-validation set"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "* Based on the performance of the recommenders on the cross-validation set, the recommender based on association rule mining performs the best.   \n",
    "* Note, however, that extracting the rules according to the apriori algorithm takes a long time. This may not be that big of an issue for the recommender once it learns all the rules from the training set.  \n",
    "* The recommender based on association rule mining takes longer to recommend ingredients than the other two recommenders. Again, this may not be that big of an issue for the application itself when users make a single query. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "# So far, the models we looked at are the following\n",
    "# NMF-based recommender\n",
    "# word-embedding based recommender\n",
    "# association-rule mining based recommender\n",
    "\n",
    "# Let's compare the performance of these models using k-fold cross-validation\n",
    "# report the performance on the test set "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "# define the models to compare"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "# define the set to perform k-fold cross-validation on \n",
    "# For this step, combine the training and cv set\n",
    "\n",
    "# load train, cv, test data index\n",
    "f = h5py.File('data/ingredient_recommendation/train_val_test.hdf5', 'r')\n",
    "train_idx = list(f.get(\"train_idx\"))\n",
    "cv_idx = list(f.get(\"cv_idx\"))\n",
    "test_idx = list(f.get(\"test_idx\"))\n",
    "f.close()\n",
    "\n",
    "# define the data used for kfold cross-validation \n",
    "kfold_idx = train_idx + cv_idx\n",
    "kfold_doc = [documents[i] for i in kfold_idx]\n",
    "\n",
    "# perform 10 fold CV \n",
    "\n",
    "# get existing ingredients and the remaining ingredients to be predicted\n",
    "existing_ing, missing_ing = sample_ingredients(kfold_doc, 5)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "# compare models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "# report performance on the test set "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "# 6. Future directions / To Do"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "* Revisit the metric for evaluating the models. \n",
    "* Deal with bias in dataset by grabbing more data. \n",
    "* Consider combining multiple models.\n",
    "* Serendipity / diversity / novelty of the system?\n",
    "* Build app."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "@webio": {
   "lastCommId": null,
   "lastKernelId": null
  },
  "accelerator": "GPU",
  "colab": {
   "collapsed_sections": [
    "8NbtLorVuwFi",
    "o3wTw-y6na8V",
    "_xJ1A1wubRsd",
    "NTJd4owFmJZ5",
    "jvYgfw6U--WS",
    "HZOxcKsk--Wg",
    "Cl0Nvd9EUYxs",
    "dio9K1a3YbJq",
    "9Uj03rp3--Xg",
    "U7KdNrk9--Xw",
    "SMFKl67x--YC",
    "xX8lM00e--Yu",
    "UbmCt1Wk--ZH",
    "VZAUNw9t4TNj",
    "TYOQ09iDqcQd",
    "FEoONi2ap1oc",
    "ra7XFlL0E_vz",
    "xM1SmBMykWcY"
   ],
   "machine_shape": "hm",
   "name": "recipes.ipynb",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}