multilabel_classification.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Cooking ingredients recommendation  \n",
    "## Multi-label classification\n",
    "\n",
    "* This notebook builds a recommendation system for cooking ingredients using multi-label classification. \n",
    "* This notebook is organized as the following\n",
    "1. Load data  \n",
    "2. Create neural network for multi-label classification  \n",
    "3. Evaluate model \n",
    "4. Example recommendations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# for mac\n",
    "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",
    "# Third party imports \n",
    "import h5py\n",
    "import ijson\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import tensorflow as tf\n",
    "import tensorflow.keras.backend as K\n",
    "from matplotlib import style\n",
    "plt.style.use('ggplot')\n",
    "from tensorflow import keras\n",
    "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, Flatten\n",
    "from tensorflow.keras.models import load_model\n",
    "from tensorflow.keras.optimizers import Adam\n",
    "\n",
    "# custom functions \n",
    "import functions as fn"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. Load data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1(a) Load encoded training and CV data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# load the encoded data\n",
    "with open(\"data/ingredient_recommendation/train_encoded.csv\", \"rb\") as f:\n",
    "    train_encoded = pickle.load(f)\n",
    "with open(\"data/ingredient_recommendation/CV_encoded.csv\", \"rb\") as f:\n",
    "    CV_encoded = pickle.load(f)\n",
    "with open(\"data/ingredient_recommendation/test_encoded.csv\", \"rb\") as f:\n",
    "    test_encoded = pickle.load(f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1(b) Tokenizer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "number of words:  6712\n"
     ]
    }
   ],
   "source": [
    "# load tokenizer from preprocessing step\n",
    "with open('models/tokenizer.pickle', 'rb') as handle:\n",
    "    t = pickle.load(handle)\n",
    "\n",
    "# create 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": [
    "## 1(c) Prepare arrays X, y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "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 integers (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",
    "    n_words = len(t.word_index)\n",
    "    \n",
    "    for i in range(n_doc):\n",
    "        recipe = 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",
    "                # append\n",
    "                sample.append(recipe_sample)\n",
    "                target.append(recipe_target)\n",
    "                indices.append(i)\n",
    "            \n",
    "    # create array X\n",
    "    X = np.array(sample)\n",
    "    \n",
    "    # create array y\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": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create X, y for training \n",
    "X_train, y_train, sample_train, target_train, indices_train = create_Xy(train_encoded, 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_encoded, t, 5, 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. multi-label classification model using neural networks  \n",
    "* Will use keras to construct neural networks that perform multi-label classification"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2(a) Define custom metrics and callbacks"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b> Custom metrics </b> \n",
    "* keras doesn't have a built-in function for computing precision / recall / F1 scores, so I wrote my own metrics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "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": "markdown",
   "metadata": {},
   "source": [
    "<b> Custom callback</b>  \n",
    "* By default, when keras evaluates the model on batches of training and CV set, and then returns a batch-wide average.  \n",
    "* The custom callback evaluates the model on the entire CV set. \n",
    "* Furthermore, it performs early stopping while monitoring the CV set F1 score. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "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": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# function that evaluates the model on CV set \n",
    "# & visualizes the distribution of precision, recall, F1 scores\n",
    "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  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2(b) Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "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": 11,
   "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.0301 - precision_at_k: 0.0651 - recall_at_k: 0.0335 - F1_at_k: 0.0440 - val_loss: 0.0061 - val_precision_at_k: 0.0505 - val_recall_at_k: 0.0250 - val_F1_at_k: 0.0331\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.0817 - recall_at_k: 0.0447 - F1_at_k: 0.0575 - val_loss: 0.0056 - val_precision_at_k: 0.1124 - val_recall_at_k: 0.0699 - val_F1_at_k: 0.0866\n",
      "Epoch 3/20\n",
      " Validation precision: 0.1667, Validation recall: 0.1429, Validation F1: 0.1538\n",
      "4098/4098 - 30s - loss: 0.0054 - precision_at_k: 0.1423 - recall_at_k: 0.1009 - F1_at_k: 0.1193 - val_loss: 0.0052 - val_precision_at_k: 0.1629 - val_recall_at_k: 0.1332 - val_F1_at_k: 0.1494\n",
      "Epoch 4/20\n",
      " Validation precision: 0.1667, Validation recall: 0.1875, Validation F1: 0.2000\n",
      "4098/4098 - 30s - loss: 0.0050 - precision_at_k: 0.1706 - recall_at_k: 0.1563 - F1_at_k: 0.1708 - val_loss: 0.0049 - val_precision_at_k: 0.1771 - val_recall_at_k: 0.1814 - val_F1_at_k: 0.1892\n",
      "Epoch 5/20\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2000\n",
      "4098/4098 - 30s - loss: 0.0048 - precision_at_k: 0.1915 - recall_at_k: 0.1921 - F1_at_k: 0.2015 - val_loss: 0.0048 - val_precision_at_k: 0.1867 - val_recall_at_k: 0.2011 - val_F1_at_k: 0.2043\n",
      "Epoch 6/20\n",
      " Validation precision: 0.1667, Validation recall: 0.2000, Validation F1: 0.2222\n",
      "4098/4098 - 30s - loss: 0.0047 - precision_at_k: 0.2170 - recall_at_k: 0.2125 - F1_at_k: 0.2194 - val_loss: 0.0047 - val_precision_at_k: 0.1990 - val_recall_at_k: 0.2079 - val_F1_at_k: 0.2122\n",
      "Epoch 7/20\n",
      " Validation precision: 0.1667, Validation recall: 0.2143, Validation F1: 0.2222\n",
      "4098/4098 - 30s - loss: 0.0045 - precision_at_k: 0.2375 - recall_at_k: 0.2274 - F1_at_k: 0.2322 - val_loss: 0.0047 - val_precision_at_k: 0.2029 - val_recall_at_k: 0.2111 - val_F1_at_k: 0.2173\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.2539 - recall_at_k: 0.2391 - F1_at_k: 0.2418 - val_loss: 0.0047 - val_precision_at_k: 0.2076 - val_recall_at_k: 0.2166 - val_F1_at_k: 0.2197\n",
      "Epoch 9/20\n",
      " Validation precision: 0.1667, Validation recall: 0.2222, Validation F1: 0.2222\n",
      "4098/4098 - 32s - loss: 0.0044 - precision_at_k: 0.2665 - recall_at_k: 0.2486 - F1_at_k: 0.2500 - val_loss: 0.0047 - val_precision_at_k: 0.2124 - val_recall_at_k: 0.2184 - val_F1_at_k: 0.2219\n",
      "Epoch 10/20\n",
      " Validation precision: 0.1667, Validation recall: 0.2222, Validation F1: 0.2222\n",
      "4098/4098 - 32s - loss: 0.0043 - precision_at_k: 0.2788 - recall_at_k: 0.2571 - F1_at_k: 0.2579 - val_loss: 0.0047 - val_precision_at_k: 0.2124 - val_recall_at_k: 0.2157 - val_F1_at_k: 0.2223\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 - 32s - loss: 0.0042 - precision_at_k: 0.2880 - recall_at_k: 0.2645 - F1_at_k: 0.2639 - val_loss: 0.0046 - val_precision_at_k: 0.2162 - val_recall_at_k: 0.2195 - val_F1_at_k: 0.2228\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": 12,
   "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": 13,
   "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.24008574490889603\n",
      "Mean recall on CV set:  0.24520060612603412\n",
      "Mean F-score on CV set:  0.21977437167209368\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": [
    "## 2(c) models with varying architectures  \n",
    "* I played around with various architectures of the neural network.  \n",
    "* In particular, I played around with \n",
    "    * Embedding dimension\n",
    "    * Adding depth (layers) to the neural network \n",
    "    * Removing the layer that computes the mean of embedded vectors  \n",
    "* In the end, adding complexity to the neural network (by increasing dimension or adding hidden layers) did not improve the performance, as measured by F1 score on the CV set. So I decided to use the original architecture from 2(b) since it achieves a good performance without too much complexity (and less training time).\n",
    "    \n",
    "* This section shows only one architecture (with a higher embedding dimension and one additional hidden layer). However, one can play around with various architectures in a similar manner.  "
   ]
  },
  {
   "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": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "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": false
   },
   "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": [
    "* A more complex architecture did not lead to improvement in performance.  \n",
    "* Thus, we'll return to the simpler architecture from section 2(b)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2(c) Hyperparameter tuning"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "i. Tune learning rate alpha  \n",
    "ii. Tune batch size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b> (i) Learning rate </b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "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.0003 to 0.03\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": 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": "markdown",
   "metadata": {},
   "source": [
    "*  The above is showing us that the smaller learning rates will reach better Validation F1 performance\n",
    "* We'll thus choose the (largest) learning rate that whose validation loss doesn't increase too quickly\n",
    "* choose rate of alpha = 0.002"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b> (ii) Tune batch size </b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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": "markdown",
   "metadata": {},
   "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": [
    "# 3. Evaluation on CV 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(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": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "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": 9,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAl0AAADTCAYAAAC7p6aqAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/d3fzzAAAACXBIWXMAAAsTAAALEwEAmpwYAAAvb0lEQVR4nO3de1hU5b4H8O8wXlC5ODOACOKFi3pQBAtETcWUo+a2Dps87kwqUUpDdylmWhqSZFKKKIXpVo9urf107KToqUwPoaBhW8LwAgViXnKHIsyEkhcE3vMHjytHmIGBucL38zw8j/POWmt+a7Fe/M16bzIhhAARERERmZSdpQMgIiIiag+YdBERERGZAZMuIiIiIjNg0kVERERkBky6iIiIiMyASRcRERGRGdhM0jV27FjExMTo3SYhIQG+vr5miqjt+Oyzz+Dj4wO5XI6ZM2daOpwGduzYgQ4dOjR7+5kzZyI8PNyEEdkO1hvTsfZ683A9aG+/Z977pmPt9741s5mkqzlee+01fPfdd83e3tfXFwkJCaYLyAbU1tZi1qxZmDZtGi5fvowNGzZYOqQG/vKXv+Bf//pXs7ffsGEDPvvsMxNG1Law3hjOFuoNNY33vuGae+/PnDkTMpmswc+nn35q5oitS/MfH9gABwcHODg4WDqMRgkhUFNTg44dO1o6FC2lpaWoqqrC5MmT4enpadRjV1dXo1OnTq0+TpcuXdClS5dmb+/s7Nzqz2xPWG8M19J6Y6w6QcbBe99whtz7o0ePxu7du7XKunfvbsLoDGfuOmlzT7oSExPh7u4OpVKJmTNn4vfff5fee/hR8ZUrV/D000/DxcUFXbp0gbe3N9asWQOg/tHz+fPn8fbbb0sZ+MWLFwEA3333HcaMGYMuXbpAoVDg2WefRVlZmVYc69evR69evdC1a1dMnDgRu3btgkwmw5UrVwD80SR2+PBhDB06FJ07d8bBgwdx4cIFREZGwsPDA127dkVAQAB27dqldeyxY8di9uzZWL58Odzc3NC9e3csW7YMdXV1WLlyJXr06AFXV1csW7asyeul71x27NgBLy8vAMCYMWMgk8lw5MiRRo8zduxYzJo1C0uXLoWLiwucnJwQExOD27dvN4j7rbfeQs+ePaUKWVJSgqeffhrdu3eHQqHAhAkTcObMGa3j5+XlYdKkSXBycoKDgwOGDRuGf/7zn1rX8r4bN24gOjoa7u7u6Ny5M7y8vBAXFye9/3CzihACa9euhbe3Nzp16gQfHx+sX79e6/P79u2L+Ph4vPrqq1AqlejRowdee+011NbWNnmNbQHrjeXqjSnqRHOuR1P0/Z7bEt77lrn3AaBTp05wd3fX+rG3t9e5fVN/2wEgLS0N/v7+6Ny5M9zc3DB16lTpvZs3b2LOnDlwdXWFvb09goODcejQIen9ixcvQiaT4ZNPPsHkyZPRrVs3vPnmmwCATz/9FEFBQbC3t0ffvn0RFxenda8cO3YMjz32GBwdHeHo6IjAwEAcPHiwyevZgLARYWFhwtnZWSxYsED8+OOP4sCBA8LZ2VnEx8dL26xYsUL4+PhIr5988kkxfvx48cMPP4gLFy6IzMxM8Y9//EMIIURFRYXo27evWLRokSgtLRWlpaWipqZGlJaWCkdHRzF9+nRx+vRpcfToUREQECBGjRolHffzzz8XcrlcrF+/XhQXF4vt27eLnj17CgDil19+EUIIsX37diGTyURwcLD45ptvxPnz50VZWZk4ffq0+PDDD8WpU6dESUmJSE1NFXK5XGRmZmqdq5OTk3j99ddFUVGR2LZtmwAgnnjiCbF48WJRVFQkduzYIQCIr776Suc1a+pcbt26JU6cOCEAiH379onS0lJx9+5dndff0dFRxMTEiMLCQrF//37h6uoq/vrXv2pt4+DgIObMmSMKCgrE6dOnxdWrV0WPHj3E3LlzxenTp8VPP/0k5s+fL5RKpSgrKxNCCHH27FnRtWtX8cwzz4jc3FxRXFws/vGPf4icnBzpWsrlculz/vrXv4ohQ4aI7777Tly6dEl8++234m9/+5v0/gsvvCDGjx8vvf7www+Fvb292Lx5syguLhYfffSR6Ny5s9i6dau0TZ8+fUT37t3F6tWrRXFxsfj000+FXC4X//Vf/6Xz+toC1hvL1xtT1InmXI+H64Ehv+e2gPe+Ze/9h++/5mjqb3t8fLzo1q2b+OCDD0RRUZHIy8sTiYmJ0vtTp04Vffr0EV9//bUoLCwUr7zyiujYsaP48ccfhRBCXLhwQQAQnp6eYteuXeL8+fPi559/Ftu3bxfdu3cXO3fuFOfPnxdZWVkiICBAREVFCSGEqKmpEQqFQixcuFAUFxeL4uJisWfPHpGdnW3Q+QkhhE0lXQEBAVplc+bMEcOHD5deP1yBhgwZIlasWKHzmD4+Pg3eX758ufD09NS6kfLz8wUAkZWVJYQQYuTIkdIv474lS5Y0qEAAmvVLeeqpp0RMTIzWuQYGBmpt4+/vLwYPHqxVNmTIELFo0SKdx23Oudy/CY8ePao3xrCwMNGnTx9RU1MjlW3evFl06tRJVFVVSdv4+fmJ2tpaaZsVK1aI0NBQrWPV1dUJb29vkZKSIoQQIioqSgwZMkRrvwc9nHQ99dRT4oUXXtAZ68OVvVevXmLx4sVa2yxYsED069dPet2nTx/x5JNPam0zceJE8cwzz+j8HFvAemP5emOKOtGYh69HU0lXU79nW8d737L3/gsvvCDkcrno1q2b9OPt7d3keen6215VVSXs7e3FmjVrGn3/3LlzAoD48ssvtcqHDh0qoqOjtWJfuXKl1jZ9+vQRH330kVZZVlaWACDUarVQq9UCgDh8+LDe+JvDppoXg4KCtF57enri2rVrOrdfsGAB3n33XYSGhmLJkiXIzs5u8jMKCgowfPhwrTbewMBAODs7o6CgAABQWFiI4cOHa+03YsSIRo8XEhKi9frWrVtYunQpBg0aBKVSCQcHB3z11Ve4dOmS1naBgYFar93d3TFkyJAGZQ8/wjb0XAwxbNgwyOVy6fVjjz2G6upqnD9/Xip79NFHYWf3x22Vm5uLvLw8qe+Eg4MDHB0dcfHiRZw7dw5AfTPK+PHjtfbTJzY2Fv/zP/+DwYMH49VXX8WBAwdQV1fX6LY3btzAlStXMGbMGK3ysLAwXLx4Ebdu3ZLKDL2/bAXrjWXrjSnqRHOvhz4t+T3bGt77lr33Q0NDkZ+fL/188803AIDLly9r3f9z584FoP9ve0FBAe7cuYMJEyY0+lmFhYUA0OBv/ZgxYxrEPmzYMOnf169fx6VLlxAXF6cV0xNPPAGgviuAQqFATEwMJk6ciCeeeAJJSUkoKioy+HoANtaR/uHObjKZTOd/tgAQHR2NSZMm4euvv8bhw4fxxBNP4M9//jM+/vhjvZ8jk8maLNe1zYPkcnmD9uvFixdj3759SE5OxsCBA9GtWzcsWrQIlZWVWts93HlSJpM1Wqbv/Jt7Li0lhGhQ1q1bN63XdXV1GD9+PD788MMG2z7Y4d2QeCZOnIjLly/j4MGDOHLkCKKiohAQEIBvvvlGKyl80MPHbyx2Q+8vW8F6Y9l6Y4o60dzroU9Lf8+2hPe+Ze/9Ll26NDolh4eHB/Lz86XXTk5OAPT/bW9pHEKIBvs8WCfvX48NGzbg8ccfb7B/r169AABbtmzBq6++ikOHDuH//u//8NZbb+HDDz/EnDlzDIrHpp50tUTPnj0RHR2NnTt3Ytu2bfjkk09w48YNAPUV8uGO0oMGDcLx48dRXV0tlZ06dQqVlZUYNGgQAMDf3x/Hjx/X2q+5w46zs7MxY8YM/OUvf0FgYCC8vb1RXFzcmlPUqTnnYojc3Fyt63X8+HGpY7ouwcHBKCgogKenJ3x9fbV+XF1dAdQ/CcjIyDAowVEqlZg+fTo2b96ML7/8EllZWdI3nQc5OTmhV69eyMrK0irPzs5Gv3790LVr12Z/ZnvCemO8evMwY9QJY10Pfb/n9or3vunu/fs6dOigdd+7ublJ7+n62+7v7w97e3udndfvx/fw08mjR4/qjb1Hjx7w8vJCUVFRg/ro6+urlQQPHjwYcXFxOHDgAGbPno2//e1vBp97m0665s+fj6+++grnz59HQUEB9uzZAy8vLzg6OgIA+vXrh2+//RaXL19GeXk56urqMH/+fNy4cQMzZ87E2bNncezYMTz33HMYNWoURo8eDQBYtGgRPv30U3zwwQcoKSnBzp07sXPnTgBNZ+EDBgzAvn37cOLECRQWFuKll17Cr7/+arLzb+pcDFFRUYF58+bhxx9/xJdffom33noLL774YoNv8g/HUFtbi4iICBw9ehQXL17EsWPHsGzZMuTk5AAAXn/9dZw7dw4zZszA999/j/Pnz+Ozzz5r8EfqvmXLlmHPnj0oKirCuXPn8Mknn8DBwQG9e/dudPs33ngDH3zwAbZs2YJz585h8+bN+Oijj6RRK6SN9ca49aax47e2ThjjejT1e26PeO+b9t5vir6/7Q4ODli0aBESEhKQlpaG4uJinDp1CqtXrwYA+Pj44D//8z8RGxuLgwcP4qeffsKrr76Ks2fPYvHixXo/d9WqVUhNTcU777yDs2fPoqioCOnp6dJTrJKSEixZsgTHjh3DpUuXcPz4cRw9ehT+/v4Gn2ObTrqEEFiwYAEGDx6MMWPG4Pfff8eBAwekm/ztt99GZWUlBgwYAFdXV1y+fBk9evTAoUOHcOXKFYSEhGDKlCkYPHgwPv/8c+m4kZGReP/995GUlISAgAB88sknWLFiBQDoHQ4LACkpKejTpw8ef/xxjB8/Hp6enlpDXo2pOediiKlTp8LR0RGjRo3CM888g8mTJ+P9999vMobjx4/DxcUFkZGRGDBgAGbMmIFLly6hZ8+eAICAgAAcOXIE169fR1hYGIKCgrB27VqdTYX29vaIj4/Ho48+iuDgYJw+fRoHDhzQOT/Xyy+/jJUrV+Ldd9+Fv78/3nvvPSQlJWH27Nktug5tHeuNcetNY8dvbZ0wxvVo6vfcHvHeN+2935Sm/rYnJiZKCdLgwYMxYcIEnDx5Utp/69atmDhxIqKiohAYGIhvv/0WX3zxBQYOHKj3c5977jns3r0bX375JYYNG4aQkBAkJCRIU7x069YN586dwzPPPIP+/fvj6aefxsiRIxvtItAUmWiscwsZbOXKldiwYQMqKiosHYpJjB07Fr6+vti6daulQ6E2pK3XGyJdeO+3TzbVkd5a3Lt3D8nJydLkaocPH8aaNWswb948S4dGZLVYb6i94r1P9/FJVwvU1NRgypQpyMvLw82bN9GvXz88//zzWLx4sUELM9sSPumi1mqP9YYI4L1Pf2DSRURERGQGbbojPREREZG1YNJFREREZAZMuoiIiIjMwCZ68OmaCM7FxQXl5eVmjkY/a4wJsM64bDEmDw8PM0ajG+tE61ljXLYYE+uE4awxJsA647LFmPTViSaTrvLycqSlpeG3336DTCZDeHg4Jk+ejKqqKqSkpOD69etwdXXFwoUL4eDgAADYu3cvMjMzYWdnh+joaGnR0Z9//hlpaWmorq7G0KFDER0d3a4n4iMiIqL2o8nmRblcjueeew4pKSlYtWoVDh48iCtXriA9PR0BAQFITU1FQEAA0tPTAQBXrlxBTk4O1q1bh2XLlmHbtm3S+mFbtmzBnDlzkJqaiqtXr2oteElERETUljWZdCkUCnh7ewOoXzHc09MTarUaubm5CAsLAwCEhYUhNzcXQP2iyCNHjkTHjh3h5uYGd3d3lJSUQKPR4Pbt2+jfvz9kMhnGjBkj7UNERETU1hnUp6usrAwXLlyAr68vKisroVAoANQnZvdXYVer1fDz85P2USqVUKvVkMvlUKlUUrlKpYJarW70czIyMpCRkQEASEpKgouLS+PBd+ig8z1LscaYAOuMy1Zj2rhxI06ePAlnZ2ckJydrvbd//358/PHH2Lp1K5ycnACwuZ2IiOo1O+m6c+cOkpOTMXPmTHTt2lXndrrmWjVkDtbw8HCEh4dLr3V1WLPFDnaWYo1x2WJMHh4eGDt2LCZNmoS0tDSt98rLy3HmzBmtpO3B5naNRoPExERs2LABdnZ2UnO7n58fVq9ejfz8fAwdOtRk50ZERJbVrKSrpqYGycnJGD16NEJDQwEAzs7O0Gg0UCgU0Gg00rd6lUqltYCnWq2GUqlsUF5RUQGlUmnMczFI7YtPtXhf+Zb9RoyEbI2/vz/KysoalP/973/HjBkzsGbNGqlMV3O7q6ur1NwOQGput9WkS199utbEvqxP1BaxTlBjmuzTJYTApk2b4OnpiSlTpkjlwcHByMrKAgBkZWUhJCREKs/JycG9e/dQVlaG0tJS+Pr6QqFQoEuXLiguLoYQAtnZ2QgODjbRaRGZ1/fffw+lUom+fftqlavVaq1m9fvN7Q+X62tuJyKitqHJJ11FRUXIzs5G7969sXjxYgDA9OnTERERgZSUFGRmZsLFxQVxcXEAAC8vL4wYMQJxcXGws7PD7NmzYWdXn9vFxMRg48aNqK6uRlBQkM1+qyd60N27d7Fnzx4sX768wXvGaG4HrL+fY1Pf3PWxVL8+W+1TaG4t7ee4a9cu5OXloUOHDujRowdiY2PRrVs3AOznSO1Xk0nXwIEDsXv37kbfi4+Pb7Q8MjISkZGRDcp9fHwadDwmsnXXrl1DWVmZ9KWkoqICS5YswerVq43W3G7L/RybYql4rfFa2WJMuvo5DhkyBM8++yzkcjk+/vhj7N27F1FRUeznSO0alwEiaqXevXtj69atSEtLQ1paGlQqFd577z10796dze3ULvj7+0uTY98XGBgIuVwOAOjfv7/UfM5phag9s4llgIisyfr161FYWIibN29i7ty5mDZtGsaNG9fotuZubr/255Et3pedd8lUMjMzMXJk/b1pjGmFiGwVky4iAy1YsEDv+w9PJcHmdmrP9uzZA7lcjtGjRwNgP8fmYD/HP7S1mJh0ERGRSRw5cgR5eXmIj4+XOsSzn2PT2M/xD7YYk74Fr9mni4iIjC4/Px/79u3DkiVL0LlzZ6mc/RypPeOTLiIiapXG+jnu3bsXNTU1SExMBAD4+fnhpZdeYj9HateYdBERUas01s9R1+ASgP0cqf1i8yIRERGRGTDpIiIiIjIDJl1EREREZsCki4iIiMgMmHQRERERmQGTLiIiIiIzYNJFREREZAZMuoiIiIjMgEkXERERkRlwRnoiA23cuBEnT56Es7OzNHv2rl27kJeXhw4dOqBHjx6IjY1Ft27dAAB79+5FZmYm7OzsEB0djaCgIADAzz//jLS0NFRXV2Po0KGIjo6WFgUmIqK2h0+6iAw0duxYvPnmm1plQ4YMQXJyMtauXYuePXti7969AIArV64gJycH69atw7Jly7Bt2zbU1dUBALZs2YI5c+YgNTUVV69eRX5+vrlPhYiIzIhJF5GB/P394eDgoFUWGBgIuVwOAOjfvz/UajUAIDc3FyNHjkTHjh3h5uYGd3d3lJSUQKPR4Pbt2+jfvz9kMhnGjBmD3Nxcs58LERGZD5sXiYwsMzMTI0eOBACo1Wr4+flJ7ymVSqjVasjlcqhUKqlcpVJJiRoRtW+1Lz7V4n3lW/YbMRIyNiZdREa0Z88eyOVyjB49GgAghGh0O13lumRkZCAjIwMAkJSUBBcXl0a3u2bQUbXpOmZzWOpzW6NDhw4W+2xdGBNR28aki8hIjhw5gry8PMTHx0sd4lUqFSoqKqRt1Go1lEplg/KKigoolUqdxw4PD0d4eLj0ury83Ojxm+KY1vy5Li4uFvtsXWwxJg8PDzNGQ2Tb2KeLyAjy8/Oxb98+LFmyBJ07d5bKg4ODkZOTg3v37qGsrAylpaXw9fWFQqFAly5dUFxcDCEEsrOzERwcbMEzICIiU+OTLiIDrV+/HoWFhbh58ybmzp2LadOmYe/evaipqUFiYiIAwM/PDy+99BK8vLwwYsQIxMXFwc7ODrNnz4adXf13nZiYGGzcuBHV1dUICgrC0KFDLXlaRC3W2DQqVVVVSElJwfXr1+Hq6oqFCxdKA1A4jQq1V0y6iAy0YMGCBmXjxo3TuX1kZCQiIyMblPv4+Ej/QRHZsrFjx2LSpElIS0uTytLT0xEQEICIiAikp6cjPT0dUVFRWtOoaDQaJCYmYsOGDbCzs5OmUfHz88Pq1auRn5/PLyPUprB5kYiIWqWxaVRyc3MRFhYGAAgLC5OmROE0KtSeMekiIiKjq6yshEKhAAAoFArcuHEDQP1gkgenS7k/jcrD5ZxGhdoiNi8SEZHZcBoV02pNzNY4PUhbi4lJFxERGZ2zszM0Gg0UCgU0Gg2cnJwAcBoVU2tNzLY4ZYkltGYaFTYvEhGR0QUHByMrKwsAkJWVhZCQEKmc06hQe9Xkk67GhgLv3r0b33zzjfTNZfr06XjkkUcAcCgwEVF709g0KhEREUhJSUFmZiZcXFwQFxcHAJxGhdq1JpOuxoYCA8Cf/vQnPPWU9vpQHApMRNT+NDaNCgDEx8c3Ws5pVKi9arJ5sbGhwLpwKDARERFR41rckf7gwYPIzs6Gt7c3nn/+eTg4OECtVsPPz0/a5v5QYLlczqHARERE1K61KOmaMGECpk6dCgD47//+b+zcuROxsbFmHwrcmmGbphpGbI3DWwHrjIsxERFRe9KipKt79+7Sv8ePH4/33nsPgPmHAltqKKm+z7TG4a2AdcZlizHpGwpMRESkT4umjNBoNNK/T5w4AS8vLwAcCkxERESkS5NPuhobClxQUICLFy9CJpPB1dUVL730EgAOBSYiIiLSpcmkq7GhwOPGjdO5PYcC61f74lNNb6SDfMt+I0ZCLdXY3HVVVVVISUnB9evX4erqioULF0qjfm1l7rrW3JtERNQ0zkhPZKCxY8fizTff1CpLT09HQEAAUlNTERAQgPT0dADac9ctW7YM27ZtQ11dHQBIc9elpqbi6tWryM/PN/OZEBGROTHpIjJQY3PX5ebmIiwsDAAQFhYmzUPHueuIiOg+Jl1ERlBZWQmFQgEAUCgUuHHjBoD6EbwPzlF3f+66h8s5dx0RUdvX4slRiahp5p67rjXzz1mKpeZFs8Y52RgTUdvGpIvICJydnaHRaKBQKKDRaKTF4M09d50tstS52OI8cZbAueuIjIfNi0RGEBwcjKysLABAVlYWQkJCpHLOXUdERACfdBEZrLG56yIiIpCSkoLMzEy4uLggLi4OAOeuIyKiPzDpIjJQY3PXAUB8fHyj5Zy7joiIADYvEhEREZkFn3QREZHJfPHFF8jMzIRMJoOXlxdiY2NRXV1t8AoORG0Bn3QREZFJqNVqHDhwAElJSUhOTkZdXR1ycnJatIIDUVvApIuIiEymrq4O1dXVqK2tRXV1NRQKhcErOBC1FWxeJCIik1AqlXjyySfx8ssvo1OnTggMDERgYKDeFRz8/Py09udKDdSWMOkiIiKTqKqqQm5uLtLS0tC1a1esW7cO2dnZOrc3ZKUGc6zS0JqZ+C21OkRrYrbG1QfaWkxMuoiIyCTOnDkDNzc3aYWG0NBQFBcXG7yCQ2PMsUqDta0O0BytidkWV0SwhNas0sA+XUREZBIuLi44d+4c7t69CyEEzpw5A09PT4NXcCBqK/iki4iITMLPzw/Dhw/HkiVLIJfL0bdvX4SHh+POnTsGr+BA1BYw6SIiIpOZNm0apk2bplXWsWNHg1dwIGoL+BWCiIiIyAyYdBERERGZAZMuIiIiIjOw6T5d1/480tIhEGnhOnNERKQLn3QRGQnXmSMiIn2YdBEZEdeZIyIiXWy6eZHImnCdOSIi0odJF5GR2Po6c5ZiqXXV2tqabqZijTER2SomXURGYuvrzFmKpc7FFtd0s4TWrDNHRNrYp4vISLjOHBER6cMnXURGwnXmiNqW2hefsnQI1MYw6SIyIq4zR0REuvBrNREREZEZNPmka+PGjTh58iScnZ2RnJwMoH6UlqEzbP/8889IS0tDdXU1hg4diujoaMhkMtOdGREREZEVafJJ19ixY/Hmm29qlbVkhu0tW7Zgzpw5SE1NxdWrV5Gfn2/0kyEiIiKyVk0mXf7+/tJTrPsMnWFbo9Hg9u3b6N+/P2QyGcaMGSPtQ0RERNQetKgjvaEzbMvlcqhUKqlcpVLpnXnb2ieC1DdRYFMTCbYm5tZMUGiNExwyJqK27/fff8emTZvwyy+/QCaT4eWXX4aHhwcXgad2yaijF3XNsG3IzNuA9U8EqS8eU05u2Jrj2uKki5bAiSCJjGv79u0ICgrCokWLUFNTg7t372Lv3r0ICAhAREQE0tPTkZ6ejqioKK0uKhqNBomJidiwYQOnUqE2o0V38v0ZtgE0a4bth8srKip0zrxNRERtw61bt/Djjz9i3LhxAOqfJHfr1o2LwFO71aKky9AZthUKBbp06YLi4mIIIZCdnY3g4GDjnQUREVmdsrIyODk5YePGjXj99dexadMm3LlzR28XlQe7onAReGprmmxeXL9+PQoLC3Hz5k3MnTsX06ZNQ0REhMEzbMfExGDjxo2orq5GUFAQhg4datozIyIii6qtrcWFCxcwa9Ys+Pn5Yfv27dJo98ZwEfjWY99f02tNTE0mXQsWLGi03NAZtn18fKR5voiIqO1TqVRQqVTSAKvhw4cjPT2di8CbEPv+ml5r+v6ydyIREZlE9+7doVKp8OuvvwIAzpw5g169enEReGq3uPYiERGZzKxZs5Camoqamhq4ubkhNjYWQgguAk/tEpMuIiIymb59+yIpKalBOReBtz7X/jyyxfvKt+w3YiRtF5MuIiPiRJCGq33xqRbvyz/0RGRLmHQRGREngiQiIl34153ISDgRJBER6cMnXURG8uBEkJcuXYK3tzdmzpxp8FqlRETUNjHpIjISTgRpfpwI0vSsMSbSrTV9JMn0mHQRGQkngjQ/TgRpelwEnsh42KeLyEg4ESQREenDJ11ERsSJIImISBcmXe0EJ70zD04ESUREuvBrNREREZEZ8EkXEbVLfPpLRObGJ11EREREZsCki4iIiMgMmHQRERERmQGTLiIiIiIzYNJFREREZAYcvUhERCZVV1eHpUuXQqlUYunSpaiqqkJKSgquX78OV1dXLFy4EA4ODgCAvXv3IjMzE3Z2doiOjkZQUJBlgycyIj7pIiIik/rqq6/g6ekpvU5PT0dAQABSU1MREBAgLQx/5coV5OTkYN26dVi2bBm2bduGuro6C0VNZHxMuoiIyGQqKipw8uRJjB8/XirLzc1FWFgYACAsLAy5ublS+ciRI9GxY0e4ubnB3d0dJSUlFombyBSYdBERkcns2LEDUVFRkMlkUlllZSUUCgUAQKFQ4MaNGwAAtVoNlUolbadUKqFWq80bMJEJsU8XERGZRF5eHpydneHt7Y2CgoImtxdCNPvYGRkZyMjIAAAkJSXBxcWl0e2uNfuI1Bq6rn9rdejQwWTHbqnWxMSki4iITKKoqAjff/89fvjhB1RXV+P27dtITU2Fs7MzNBoNFAoFNBoNnJycAAAqlQoVFRXS/mq1GkqlstFjh4eHIzw8XHpdXl5u2pMhvUx1/V1cXKzud9tUTB4eHjrfY9JFZGQcqUVU79lnn8Wzzz4LACgoKMD//u//4pVXXsGuXbuQlZWFiIgIZGVlISQkBAAQHByM1NRUTJkyBRqNBqWlpfD19bXkKRAZFft0ERkZR2oR6RcREYHTp0/jlVdewenTpxEREQEA8PLywogRIxAXF4dVq1Zh9uzZsLPjf1PUdvBJF5ER3R+pFRkZiS+++AJA/YishIQEAPUjtRISEhAVFaVzpFb//v0teAZEpjFo0CAMGjQIAODo6Ij4+PhGt4uMjERkZKQ5QyMyG36FIDIijtQiIiJd+KSLyEg4Usv8WjOqqTXXiiO1iKglWpV0zZs3D/b29rCzs4NcLkdSUhI7DVO7xZFa5mep68CRWn/QN1KLiLS1+knXihUrpP9EgD86DUdERCA9PR3p6emIiorS6jSs0WiQmJiIDRs2sJMktRkcqUVERPoYPePh8g5E2jhSi4iIACM86Vq1ahUA4N///d8RHh6ut9Own5+ftJ++TsPW3n9FX/+Gpvo/WKofCfuvNI+xYuJILSIielirkq7ExEQolUpUVlbinXfe0du2b0inYWvvv6IvHlP2yWD/FdNj/xUiIjKVVrVl3O/06+zsjJCQEJSUlEidhgG0uNMwERERUVvT4qTrzp07uH37tvTv06dPo3fv3ggODkZWVhYANOg0nJOTg3v37qGsrIydhomIiKhdaXHzYmVlJdauXQsAqK2txahRoxAUFAQfHx+kpKQgMzMTLi4uiIuLA6DdadjOzo6dhomIiKhdaXHS1aNHD6xZs6ZBOTsNExERETXER01EREREZsCki4iIiMgMuPYiEdms2hefsnQIRETNxqSLiIiIWqWlX4DkW/YbORLrxuZFIiIiIjPgky4iIjKJ8vJypKWl4bfffoNMJkN4eDgmT56MqqoqpKSk4Pr163B1dcXChQvh4OAAANi7dy8yMzNhZ2eH6OhoBAUFWfYkiIyISRcREZmEXC7Hc889B29vb9y+fRtLly7FkCFDcOTIEQQEBCAiIgLp6elIT09HVFQUrly5gpycHKxbtw4ajQaJiYnYsGED53SkNoN3MhERmYRCoYC3tzcAoEuXLvD09IRarUZubi7CwsIAAGFhYcjNzQUA5ObmYuTIkejYsSPc3Nzg7u6OkpISi8VPZGx80kVkJGxKIdKtrKwMFy5cgK+vLyorK6FQKADUJ2Y3btwAUL8mr5+fn7SPUqmEWq22SLxEpsCki8hI2JRC1Lg7d+4gOTkZM2fORNeuXXVuJ4Ro9jEzMjKQkZEBAEhKSoKLi0uj210zLFQyM12/t/s6dOjQ5Dbm1pqYmHQRGYlCoZC+vT/clJKQkACgviklISEBUVFROptS+vfvb8GzIDKumpoaJCcnY/To0QgNDQUAODs7Q6PRQKFQQKPRwMnJCQCgUqlQUVEh7atWq6FUKhs9bnh4OMLDw6XX5eXlJjwLMpWmfm8uLi5W97ttKiYPDw+d7/ErNZEJNLcpRaVSSfuwKYXaGiEENm3aBE9PT0yZMkUqDw4ORlZWFgAgKysLISEhUnlOTg7u3buHsrIylJaWwtfX1yKxE5kCn3QRGRmbUto+UzV3tLWmlKKiImRnZ6N3795YvHgxAGD69OmIiIhASkoKMjMz4eLigri4OACAl5cXRowYgbi4ONjZ2WH27Nlsbqc2hUkXkRGxKaV9MNX1b2tNKQMHDsTu3bsbfS8+Pr7R8sjISERGRhoWJJGN4FcIIiNhUwoREenDJ11ERsKmFLJWrVoYfG+O8QIhaueYdBEZCZtSiIhIH36tJiIiIjIDPumiJrWmaUK+Zb8RIyEiIrJdfNJFREREZAZMuoiIiIjMgEkXERERkRmwTxcRkYHYz5GIWoJPuoiIiIjMgEkXERERkRmweZGIiIgsoqmm+mt63rPFpno+6SIiIiIyAyZdRERERGbApIuIiIjIDJh0EREREZmB2TvS5+fnY/v27airq8P48eMRERFh7hCIrArrRPuir+NwW+s03FKsE9RWmTXpqqurw7Zt27B8+XKoVCq88cYbCA4ORq9evcwZBtmIlk5AaUv/ObFOEGljnaDmssVJis3avFhSUgJ3d3f06NEDHTp0wMiRI5Gbm2vOEIisCusEkTbWCWrLzPqkS61WQ6VSSa9VKhXOnTtnzhCIrArrBDVXa77V2xLWCTKHVtWnvTkt3tWsSZcQokGZTCZrUJaRkYGMjAwAQFJSEjw8PBo/4JffGzU+Y9EZL2C5mHmtmk1vTEbWXuoE2TbWCSJtLa0TZm1eVKlUqKiokF5XVFRAoVA02C48PBxJSUlISkrSe7ylS5caPcbWssaYAOuMizGxTliSNcbFmFgnLMka42prMZk16fLx8UFpaSnKyspQU1ODnJwcBAcHmzMEIqvCOkGkjXWC2jKzNi/K5XLMmjULq1atQl1dHR5//HF4eXmZMwQiq8I6QaSNdYLaMrPP0/XII4/gkUceMcqxwsPDjXIcY7LGmADrjIsx1WOdsAxrjIsx1WOdsAxrjKutxSQTjfVaJCIiIiKj4jJARERERGZg9ubF5mpqGQghBLZv344ffvgBnTt3RmxsLLy9vZu1r6liOnr0KPbt2wcAsLe3R0xMDPr27QsAmDdvHuzt7WFnZwe5XN7kiBtjxVRQUID3338fbm5uAIDQ0FBMnTq1WfuaKqb9+/fj6NGjAOpnn75y5Qq2bdsGBwcHk12njRs34uTJk3B2dkZycnKD9y1xPxmKdcI4MbFO1GsLdeJBrakflopJX/2wVEz3lZSUYNmyZVi4cCGGDx9u0piaG1dBQQF27NiB2tpaODo64u2337ZoTLdu3UJqaioqKipQW1uLJ598Eo8//rj+gworVFtbK+bPny+uXr0q7t27J1577TXxyy+/aG2Tl5cnVq1aJerq6kRRUZF44403mr2vqWL66aefxM2bN4UQQpw8eVKKSQghYmNjRWVlZavjMDSms2fPitWrV7doX1PF9KDc3FyRkJAgvTbFdRJCiIKCAnH+/HkRFxfX6Pvmvp8MxTphvJhYJ+rZep14UGvqhyVj0lc/LBXT/e0SEhLEu+++K44fP27SmJobV1VVlViwYIG4fv26EEKI3377zeIxff7552LXrl1CCCEqKyvFzJkzxb179/Qe1yqbF5uzDMT333+PMWPGQCaToX///vj999+h0WhMtoREc447YMAAODg4AAD8/Py05poxhdacqyWv04O+/fZbPPbYY63+3Kb4+/tLv5vGmPt+MhTrhPFiMsW+xjwu64ThWlM/LBmTtdaPAwcOIDQ0FE5OTiaNx5C4jh07htDQULi4uAAAnJ2dLR6TTCbDnTt3IITAnTt34ODgADs7/WmVVSZdjS0DoVarG2xz/+I/uE1z9jVVTA/KzMzE0KFDtcpWrVqFJUuWSLMomyum4uJiLF68GO+++y5++eUXg/Y1VUwAcPfuXeTn5zd4dG3s69Qc5r6fWhIf64TxYmKdaJq114kHtaZ+WDKmBzVWPywRk1qtxokTJzBhwgSTxmJoXKWlpaiqqkJCQgKWLFmCrKwsi8c0adIk/Otf/8KcOXOwaNEiREdHN5l0WWWfLtGMZSB0bdOcfU0V031nz57F4cOHsXLlSqksMTERSqUSlZWVeOedd+Dh4QF/f3+Tx9SvXz9s3LgR9vb2OHnyJNasWYPU1FSruE55eXla3/QA01yn5jD3/WQo1gnjxcQ60TzWXice1Jr6YcmY7musflgqph07dmDGjBlNJg/G1Jy4amtrceHCBbz11luorq7G8uXL4efnZ7IlqpoT06lTp9CnTx/Ex8fj2rVrSExMxMCBA9G1a1edx7XKJ13NWQZCpVKhvLy8wTbNXULCFDEBwKVLl7B582YsXrwYjo6OUrlSqQRQ/0g0JCQEJSUlZompa9eusLe3B1A/901tbS1u3Lhh8esE1DejjBo1SqvMFNepOcx9P7UkPtYJ48TEOtE81l4nHtSa+mHJmADd9cNSMZ0/fx4bNmzAvHnz8N1332Hr1q04ceKExeNSqVQIDAyEvb09nJyc8G//9m+4dOmSRWM6fPgwQkNDIZPJ4O7uDjc3N/z66696j2uVSVdzloEIDg5GdnY2hBAoLi5G165doVAoTLaERHOOW15ejrVr12L+/Pla2fedO3dw+/Zt6d+nT59G7969zRLTb7/9JmXsJSUlqKurg6Ojo0WvE1A/6qOwsFDrPVNdp+Yw9/1kKNYJ48XEOtE81l4nHtSa+mHJmHTVD0vGlJaWJv0MHz4cMTExGDZsmMXjCg4Oxk8//YTa2lrcvXsXJSUl8PT0tGhMLi4uOHPmDID6vyu//vqrNCpaF6udHPXkyZP4+9//Li0DERkZiUOHDgEAJkyYACEEtm3bhlOnTqFTp06IjY2Fj4+Pzn3NEdOmTZvwz3/+U+o3cH9497Vr17B27VoA9Y9IR40aZbaYvv76axw6dAhyuRydOnXC888/jwEDBujc1xwxAcCRI0eQn5+PBQsWSPuZ8jqtX78ehYWFuHnzJpydnTFt2jTU1NRIMVnifjIU64RxYmKdqNcW6sSDWlM/LBWTrvphyZgelJaWhkcffdQsU0Y0J679+/fj8OHDsLOzw7hx4/CnP/3JojGp1Wps3LhRGpDxH//xHxgzZozeY1pt0kVERETUllhl8yIRERFRW8Oki4iIiMgMmHQRERERmQGTLiIiIiIzYNJFREREZAZMuoiIiIjMgEkXERERkRkw6SIiIiIyg/8HRSIgEtI+mKEAAAAASUVORK5CYII=\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.24300345361438608\n",
      "Mean recall on CV set:  0.24680057071114525\n",
      "Mean F-score on CV set:  0.22204943621825077\n"
     ]
    }
   ],
   "source": [
    "# load model with best performing validation_F1 score\n",
    "metrics = MetricsAtK(k = 6)\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": "markdown",
   "metadata": {},
   "source": [
    "# 4. Example recommendations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "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": 13,
   "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>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>chinese</th>\n",
       "      <td>0.333333</td>\n",
       "      <td>0.230769</td>\n",
       "      <td>0.266667</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>korean</th>\n",
       "      <td>0.250000</td>\n",
       "      <td>0.250000</td>\n",
       "      <td>0.250000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>greek</th>\n",
       "      <td>0.166667</td>\n",
       "      <td>0.222222</td>\n",
       "      <td>0.235294</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>indian</th>\n",
       "      <td>0.333333</td>\n",
       "      <td>0.200000</td>\n",
       "      <td>0.235294</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>russian</th>\n",
       "      <td>0.166667</td>\n",
       "      <td>0.250000</td>\n",
       "      <td>0.222222</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>irish</th>\n",
       "      <td>0.166667</td>\n",
       "      <td>0.250000</td>\n",
       "      <td>0.222222</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>moroccan</th>\n",
       "      <td>0.333333</td>\n",
       "      <td>0.200000</td>\n",
       "      <td>0.222222</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>french</th>\n",
       "      <td>0.166667</td>\n",
       "      <td>0.200000</td>\n",
       "      <td>0.210526</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>spanish</th>\n",
       "      <td>0.166667</td>\n",
       "      <td>0.200000</td>\n",
       "      <td>0.210526</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>brazilian</th>\n",
       "      <td>0.166667</td>\n",
       "      <td>0.200000</td>\n",
       "      <td>0.200000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>thai</th>\n",
       "      <td>0.166667</td>\n",
       "      <td>0.176471</td>\n",
       "      <td>0.200000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>jamaican</th>\n",
       "      <td>0.166667</td>\n",
       "      <td>0.200000</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>cajun_creole</th>\n",
       "      <td>0.333333</td>\n",
       "      <td>0.176471</td>\n",
       "      <td>0.200000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>vietnamese</th>\n",
       "      <td>0.166667</td>\n",
       "      <td>0.166667</td>\n",
       "      <td>0.200000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>japanese</th>\n",
       "      <td>0.166667</td>\n",
       "      <td>0.166667</td>\n",
       "      <td>0.181818</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "              precisions   recalls   Fscores\n",
       "cuisine                                     \n",
       "chinese         0.333333  0.230769  0.266667\n",
       "filipino        0.166667  0.250000  0.250000\n",
       "korean          0.250000  0.250000  0.250000\n",
       "greek           0.166667  0.222222  0.235294\n",
       "indian          0.333333  0.200000  0.235294\n",
       "russian         0.166667  0.250000  0.222222\n",
       "irish           0.166667  0.250000  0.222222\n",
       "italian         0.166667  0.250000  0.222222\n",
       "southern_us     0.166667  0.250000  0.222222\n",
       "moroccan        0.333333  0.200000  0.222222\n",
       "french          0.166667  0.200000  0.210526\n",
       "spanish         0.166667  0.200000  0.210526\n",
       "british         0.166667  0.200000  0.205263\n",
       "brazilian       0.166667  0.200000  0.200000\n",
       "thai            0.166667  0.176471  0.200000\n",
       "jamaican        0.166667  0.200000  0.200000\n",
       "mexican         0.166667  0.200000  0.200000\n",
       "cajun_creole    0.333333  0.176471  0.200000\n",
       "vietnamese      0.166667  0.166667  0.200000\n",
       "japanese        0.166667  0.166667  0.181818"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# are there any systematic underperformance for particular cuisine? \n",
    "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",
    "# compute median scores for each cuisine\n",
    "CV_scores = df_CV[[\"cuisine\", \"precisions\", \"recalls\", \"Fscores\"]].groupby(\"cuisine\").median().sort_values(by='Fscores', ascending = False)\n",
    "CV_scores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x360 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(ncols = 3, figsize = (15, 5))\n",
    "ax[0].boxplot(CV_scores[\"precisions\"])\n",
    "ax[0].set_title(\"precisions\")\n",
    "ax[1].boxplot(CV_scores[\"recalls\"])\n",
    "ax[1].set_title(\"recalls\")\n",
    "ax[2].boxplot(CV_scores[\"Fscores\"])\n",
    "ax[2].set_title(\"Fscores\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* It looks like the recommender has high F1 scores for baking related recipes.  \n",
    "* The boxplots look a bit different than the traditional boxplots because we don't have a lot of data.  \n",
    "* According to the boxplots, there isn't a particular cuisine for which the model performs terribly."
   ]
  }
 ],
 "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.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}