user-movie-genres-model/3.train-model-pandas-ray.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Recommendation systems: Deep Model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This model is made up of feature layers that have users, movies and movie genres embedings followed by a neural network with dense layers and finally one output that is the rating prediction that input user(id) could assign to input movie(id)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Inputs**\n",
    "* **User id**: Really this is traducet as a sequence because embedding layers only can manage sequenced identifiers.\n",
    "* **Movie id**: Idem to User id.\n",
    "* **Movie genres**: One column by genre.\n",
    "\n",
    "**Output**\n",
    "*  **Rating prediction** that user could assign to movie."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Links**\n",
    "* [Deep Learning With Keras: Recommender Systems](https://www.johnwittenauer.net/deep-learning-with-keras-recommender-systems/)\n",
    "* [Collaborative Filtering for Movie Recommendations](https://keras.io/examples/structured_data/collaborative_filtering_movielens/)\n",
    "* [Movie lens datasets](https://grouplens.org/datasets/movielens/)\n",
    "* [Recommendation Systems Benchmarks](https://paperswithcode.com/task/recommendation-systems)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Required libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "sys.path.append('../src')\n",
    "\n",
    "import os\n",
    "from util import create_path, remove_dir\n",
    "\n",
    "def show_env_var(varname):\n",
    "    if varname in os.environ:\n",
    "        print(f'{varname}: {os.environ[varname]}')\n",
    "    else:\n",
    "        print(f'{varname} undefined')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "user_ray = False\n",
    "\n",
    "if user_ray:    \n",
    "    show_env_var('MODIN_OUT_OF_CORE')\n",
    "    show_env_var('MODIN_MEMORY')\n",
    "    show_env_var('MODIN_ON_RAY_PLASMA_DIR')\n",
    "\n",
    "    create_path(os.environ['MODIN_ON_RAY_PLASMA_DIR'])\n",
    "\n",
    "    import ray\n",
    "    import modin\n",
    "    import modin.pandas as pd\n",
    "    \n",
    "    modin.__version__\n",
    "\n",
    "    # ray.shutdown()\n",
    "    if not ray.is_initialized():\n",
    "        ray.init(num_cpus=24, num_gpus=1, dashboard_host=\"0.0.0.0\", dashboard_port=8080)\n",
    "    else:\n",
    "        print('Ray is already active!')\n",
    "else:\n",
    "    import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "\n",
    "import random\n",
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "from tensorflow.keras.callbacks import ModelCheckpoint, EarlyStopping\n",
    "\n",
    "import keras_tuner as kt\n",
    "from util import tf_detected_devices, tf_version, plot_model, Config, LoggerFactory, create_path\n",
    "\n",
    "from callback import MetricsPlotter\n",
    "from data import InMemoryXyDataGenerator\n",
    "from recommendation import UserMovieGenderEmbeddingDenseModelFactory\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import logging\n",
    "import warnings\n",
    "\n",
    "from data import MovieLensDataSource"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Helpers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "GENDER_COLUMNS = [\n",
    "    'gen_film_noir', \n",
    "    'gen_none', \n",
    "    'gen_imax', \n",
    "    'gen_documentary',\n",
    "    'gen_romance', \n",
    "    'gen_drama', \n",
    "    'gen_adventure', \n",
    "    'gen_western',\n",
    "    'gen_animation',\n",
    "    'gen_mystery', \n",
    "    'gen_fantasy',\n",
    "    'gen_action', \n",
    "    'gen_comedy', \n",
    "    'gen_sci_fi', \n",
    "    'gen_musical',\n",
    "    'gen_war', \n",
    "    'gen_crime', \n",
    "    'gen_children', \n",
    "    'gen_horror', \n",
    "    'gen_thriller'\n",
    "]\n",
    "X_COLUMNS = ['user_seq', 'movie_seq'] + GENDER_COLUMNS\n",
    "Y_COLUMNS = ['rating']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def log_counts(train_set, val_set, test_set):\n",
    "    logging.info(f'Train set count = {train_set.shape[0]} observations.')\n",
    "    logging.info(f'Validation set count = {val_set.shape[0]} observations.')\n",
    "    logging.info(f'Test set count = {test_set.shape[0]} observations.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def evaluate(model, samples, batch_size):\n",
    "    X, y = samples[X_COLUMNS].values, samples[Y_COLUMNS].values\n",
    "    \n",
    "    generator = InMemoryXyDataGenerator(\n",
    "        X,\n",
    "        y, \n",
    "        batch_size,\n",
    "        shuffle=True, \n",
    "        to_input=to_input\n",
    "    )\n",
    "    X_batch, y_batch = generator[0]\n",
    "    \n",
    "    return model.evaluate(X_batch, y_batch, batch_size=batch_size, verbose=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_best_hyperparameters(tuner):\n",
    "    return tuner.get_best_hyperparameters(num_trials=1)[0]\n",
    "\n",
    "def create_best_model_from(tuner):\n",
    "    return tuner.hypermodel.build(get_best_hyperparameters(tuner))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def lowest_loss_epoch(val_loss_per_epoch):\n",
    "    return val_loss_per_epoch.index(min(val_loss_per_epoch)) + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_loss(losses, xlabel='Epoch', ylabel='Loss', title='Loss by epoch'):\n",
    "    plt.plot(list(range(1, len(losses)+1)), losses)\n",
    "    plt.xlabel(xlabel)\n",
    "    plt.ylabel(ylabel)\n",
    "    plt.title(title)\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "\n",
    "class Dataset:\n",
    "    def __init__(self, observations):\n",
    "        self.observations = observations\n",
    " \n",
    "    def search_by_seqs(self, user_seq, movie_seq): \n",
    "        return self.observations[(self.observations.user_seq == user_seq) & (self.observations.movie_seq == movie_seq)]\n",
    "\n",
    "    def random_observation(self,  has_rating=True):\n",
    "        \"\"\"\n",
    "        Get a random observation.\n",
    "        \"\"\"\n",
    "        finish = True\n",
    "        while finish:\n",
    "            user_seq  = random.choice(self.observations['user_seq'])\n",
    "            movie_seq = random.choice(self.observations['movie_seq'])\n",
    "        \n",
    "            sample = self.search_by_seqs(user_seq, movie_seq)\n",
    "    \n",
    "            finish = sample.empty if has_rating else not sample.empty\n",
    "\n",
    "        return sample.head(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def predict(model, samples, batch_size):\n",
    "    X = samples[X_COLUMNS].values\n",
    "    y = samples[Y_COLUMNS].values\n",
    " \n",
    "    generator = InMemoryXyDataGenerator(\n",
    "        X,\n",
    "        y, \n",
    "        batch_size,\n",
    "        shuffle=True, \n",
    "        to_input=to_input\n",
    "    )\n",
    "    X_batch, y_batch = generator[0]\n",
    "\n",
    "    y_predicted = model.predict(X_batch, batch_size=batch_size, verbose=0)\n",
    "\n",
    "    result = samples.copy()\n",
    "    result.insert(0, 'pred_rating', y_predicted) \n",
    "    return result \n",
    "\n",
    "def to_percent(value): return round(value * 100, 2)\n",
    "\n",
    "def get_metrics(\n",
    "    dataset,\n",
    "    max_error   = 1, \n",
    "    sample_size = 1000,\n",
    "    loss_fn     = lambda y_pred, y_true : abs(y_pred - y_true)\n",
    "):\n",
    "    true_positives = false_positives = 0\n",
    "    error_dits     = []\n",
    "\n",
    "    for index in range(0, sample_size):\n",
    "        observation = dataset.random_observation()\n",
    "\n",
    "        prediction = predict(model, observation, batch_size=observation.shape[0])\n",
    "\n",
    "        y_pred = prediction['pred_rating'].item()\n",
    "        y_true = prediction['rating'].item()\n",
    "\n",
    "        error = loss_fn(y_pred, y_true)\n",
    "        error_dits.append(error)\n",
    "\n",
    "        if  error <= max_error:\n",
    "            true_positives  +=1\n",
    "        else:\n",
    "            false_positives +=1\n",
    "\n",
    "    return {\n",
    "        'true_positives':  f'{to_percent(true_positives / sample_size)}%',\n",
    "        'false_positives': f'{to_percent(false_positives / sample_size)}%',\n",
    "        'error_dist':      error_dits\n",
    "    }"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Logger config"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "tf.get_logger().setLevel(logging.ERROR)\n",
    "warnings.filterwarnings(\"ignore\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<RootLogger root (INFO)>"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "config = Config(path='../config/config.yaml')\n",
    "LoggerFactory(config['logger']).create()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Check environment"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Step 1**: Make sure that nvidia driver is installed runing next command:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NVIDIA GeForce RTX 3080, 10240 MiB\n"
     ]
    }
   ],
   "source": [
    "!nvidia-smi --query-gpu=gpu_name,memory.total --format=csv | sed -n 2p"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note:** If this shows a GPU model and memory size, that's all right, otherwise make suze that has the nvidia driver installed."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Step 2**: Let's check tensorflow version:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Tensorflow version: 2.8.0'"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tf_version()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Step 3**: Let's check devices that tensorflow detect:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "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>Name</th>\n",
       "      <th>Device Type</th>\n",
       "      <th>Memory</th>\n",
       "      <th>Description</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>/device:CPU:0</td>\n",
       "      <td>CPU</td>\n",
       "      <td>256M</td>\n",
       "      <td></td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>/device:GPU:0</td>\n",
       "      <td>GPU</td>\n",
       "      <td>6G</td>\n",
       "      <td>device: 0, name: NVIDIA GeForce RTX 3080, pci ...</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            Name Device Type Memory  \\\n",
       "0  /device:CPU:0         CPU   256M   \n",
       "1  /device:GPU:0         GPU     6G   \n",
       "\n",
       "                                         Description  \n",
       "0                                                     \n",
       "1  device: 0, name: NVIDIA GeForce RTX 3080, pci ...  "
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tf_detected_devices()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "tf.debugging.set_log_device_placement(False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Step 4**: Make sure that tensorflow detect cuda libs and GPU devices."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tf.test.is_built_with_cuda()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[PhysicalDevice(name='/physical_device:GPU:0', device_type='GPU')]"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tf.config.list_physical_devices('GPU')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Prepare model input data\n",
    "\n",
    "**Step 1**: Load train, val and test sets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "TEMP_PATH = './temp'\n",
    "TRAIN_PATH = f'{TEMP_PATH}/train'\n",
    "VAL_PATH = f'{TEMP_PATH}/val'\n",
    "TEST_PATH = f'{TEMP_PATH}/test'\n",
    "\n",
    "train  = True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "import glob\n",
    "\n",
    "def read_csv(path):\n",
    "    all_files = glob.glob(path)\n",
    "    li = [pd.read_csv(filename, index_col=None, header=0) for filename in all_files]\n",
    "    return pd.concat(li, axis=0, ignore_index=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2022-02-28 18:25:58 INFO Train set count = 70691 observations.\n",
      "2022-02-28 18:25:58 INFO Validation set count = 20130 observations.\n",
      "2022-02-28 18:25:58 INFO Test set count = 8623 observations.\n"
     ]
    }
   ],
   "source": [
    "train_set = read_csv(f'{TRAIN_PATH}/*.csv')\n",
    "val_set   = read_csv(f'{VAL_PATH}/*.csv')\n",
    "test_set  = read_csv(f'{TEST_PATH}/*.csv')\n",
    "\n",
    "log_counts(train_set, val_set, test_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Step 2:** Let's see min and max value of rating column."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2022-02-28 18:25:58 INFO Rattings:\n",
      " - min = 0.5\n",
      " - max = 5.0\n"
     ]
    }
   ],
   "source": [
    "min_rating, max_rating = train_set['rating'].min(), train_set['rating'].max()\n",
    "\n",
    "logging.info(f'Rattings:\\n - min = {min_rating}\\n - max = {max_rating}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Step 3:** Calculate train and val batch size and plot interval."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2022-02-28 18:25:58 INFO Steps: 100, Epochs: 80.\n",
      "2022-02-28 18:25:58 INFO Batch Size = (Train:706, Val:201).\n",
      "2022-02-28 18:25:58 INFO Interval = (Plot:50, Evaluate:51).\n"
     ]
    }
   ],
   "source": [
    "steps             = 100\n",
    "epochs            = 80\n",
    "plot_interval     = math.floor(steps / 2)\n",
    "\n",
    "train_batch_size  = math.floor(train_set.shape[0] / steps)\n",
    "val_batch_size    = math.floor(val_set.shape[0] / steps)\n",
    "evaluate_interval = plot_interval + 1\n",
    "\n",
    "logging.info(f'Steps: {steps}, Epochs: {epochs}.')\n",
    "logging.info(f'Batch Size = (Train:{train_batch_size}, Val:{val_batch_size}).')\n",
    "logging.info(f'Interval = (Plot:{plot_interval}, Evaluate:{evaluate_interval}).')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "train_set**Step 4:** build tran, validation and test matrix, excluding ids for inputs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train = train_set[X_COLUMNS].values\n",
    "y_train = train_set[Y_COLUMNS].values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_val = val_set[X_COLUMNS].values\n",
    "y_val = val_set[Y_COLUMNS].values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_test = test_set[X_COLUMNS].values\n",
    "y_test = test_set[Y_COLUMNS].values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Step 5:** Define data generator. A data generator is used to provide next observations batch to model under training process both to forward pass and also to get a validation batch."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "def to_input(X, y): return [X[:, 0],  X[:, 1], X[:, 2:22]], y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_generator = InMemoryXyDataGenerator(\n",
    "    X_train, \n",
    "    y_train,\n",
    "    train_batch_size,\n",
    "    shuffle  = True,\n",
    "    to_input = to_input\n",
    ")\n",
    "\n",
    "val_generator = InMemoryXyDataGenerator(\n",
    "    X_val, \n",
    "    y_val, \n",
    "    val_batch_size, \n",
    "    shuffle  = True,\n",
    "    to_input = to_input\n",
    ")\n",
    "\n",
    "test_generator = InMemoryXyDataGenerator(\n",
    "    X_test, \n",
    "    y_test, \n",
    "    train_batch_size, \n",
    "    shuffle  = True,\n",
    "    to_input = to_input\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Check train batch shape:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2022-02-28 18:25:58 INFO Train Batch columns: Users: (706,), Movies: (706,), genders:(706, 20)\n"
     ]
    }
   ],
   "source": [
    "batch = train_generator[0]\n",
    "\n",
    "logging.info(f'Train Batch columns: Users: {batch[0][0].shape}, Movies: {batch[0][1].shape}, genders:{batch[0][2].shape}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2022-02-28 18:25:58 INFO user_seq: 37\n",
      "2022-02-28 18:25:58 INFO movie_seq: 74\n",
      "2022-02-28 18:25:58 INFO genders: [0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0]\n"
     ]
    }
   ],
   "source": [
    "logging.info(f'user_seq: {batch[0][0][0]}')\n",
    "logging.info(f'movie_seq: {batch[0][1][0]}')\n",
    "logging.info(f'genders: {batch[0][2][0]}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Check users/movies sequence count:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "610"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "user_ids = set(np.concatenate((\n",
    "    train_set['user_id'].values,\n",
    "    val_set['user_id'].values,\n",
    "    test_set['user_id'].values\n",
    "), axis=0))\n",
    "\n",
    "n_users = len(user_ids)\n",
    "n_users"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8530"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "movie_ids = set(np.concatenate((\n",
    "    train_set['movie_id'].values, \n",
    "    val_set['movie_id'].values,\n",
    "    test_set['movie_id'].values\n",
    "), axis=0))\n",
    "\n",
    "n_movies = len(movie_ids)\n",
    "n_movies"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Model definition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_metrics_callback():\n",
    "    return MetricsPlotter(\n",
    "        validation_generator = val_generator, \n",
    "        metrics_names        = ['loss'],\n",
    "        plot_interval        = plot_interval,\n",
    "        evaluate_interval    = evaluate_interval,\n",
    "        batch_size           = train_batch_size,\n",
    "        val_batch_size       = val_batch_size\n",
    "    )\n",
    "\n",
    "def create_checkpoints_callback():\n",
    "    checkpoint_file = \\\n",
    "        create_path('./checkpoints') + \\\n",
    "        '/weights.epoch_{epoch:02d}-loss_{loss:.3f}-val_loss_{val_loss:.3f}.hdf5'\n",
    "\n",
    "    return ModelCheckpoint(\n",
    "        filepath          = checkpoint_file,\n",
    "        save_weights_only = True,\n",
    "        monitor           = 'val_loss',\n",
    "        mode              = 'max',\n",
    "        save_best_only    = True\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "def model_builder(hp):  \n",
    "    # Hyperparameters\n",
    "    lr       = hp.Choice('lr', values=[0.01, 0.001, 0.001])\n",
    "\n",
    "    units1   = hp.Int('units1', min_value=10, max_value=300, step=10)  \n",
    "    dropout1 = hp.Float('dropout1', min_value=0.1, max_value=0.9, step=0.1)\n",
    "\n",
    "    units2   = hp.Int('units2', min_value=10, max_value=300, step=10)\n",
    "    dropout2 = hp.Float('dropout2', min_value=0.1, max_value=0.9, step=0.1)\n",
    "      \n",
    "    units3   = hp.Int('units3', min_value=10, max_value=300, step=10)\n",
    "    dropout3 = hp.Float('dropout3', min_value=0.1, max_value=0.9, step=0.1)\n",
    "\n",
    "    user_embeding_vector_size  = hp.Int(\n",
    "      'usersfactor', min_value=50, max_value=500, step=50\n",
    "    )\n",
    "    movie_embeding_vector_size = hp.Int(\n",
    "      'moviesfactor', min_value=50, max_value=500, step=50\n",
    "    )\n",
    "\n",
    "    return UserMovieGenderEmbeddingDenseModelFactory.create(\n",
    "        n_users, \n",
    "        n_movies,\n",
    "        n_genders           = len(GENDER_COLUMNS),\n",
    "        min_rating          = min_rating,\n",
    "        max_rating          = max_rating,\n",
    "        user_n_min_factors  = user_embeding_vector_size,\n",
    "        movie_n_min_factors = movie_embeding_vector_size,\n",
    "        lr                  = lr,\n",
    "        units               = [units1,   units2,   units3],\n",
    "        dropout             = [dropout1, dropout2, dropout3]\n",
    "    )\n",
    "\n",
    "    return model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Search best model hyper parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "SEED = 42\n",
    "\n",
    "random.seed(SEED)\n",
    "np.random.seed(SEED)\n",
    "tf.random.set_seed(SEED)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Step 1**: Create an optimizer to search bestmodel hyper aprams give a set of optimmmmmizer hyperparams."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Search space summary\n",
      "Default search space size: 9\n",
      "lr (Choice)\n",
      "{'default': 0.01, 'conditions': [], 'values': [0.01, 0.001, 0.001], 'ordered': True}\n",
      "units1 (Int)\n",
      "{'default': None, 'conditions': [], 'min_value': 10, 'max_value': 300, 'step': 10, 'sampling': None}\n",
      "dropout1 (Float)\n",
      "{'default': 0.1, 'conditions': [], 'min_value': 0.1, 'max_value': 0.9, 'step': 0.1, 'sampling': None}\n",
      "units2 (Int)\n",
      "{'default': None, 'conditions': [], 'min_value': 10, 'max_value': 300, 'step': 10, 'sampling': None}\n",
      "dropout2 (Float)\n",
      "{'default': 0.1, 'conditions': [], 'min_value': 0.1, 'max_value': 0.9, 'step': 0.1, 'sampling': None}\n",
      "units3 (Int)\n",
      "{'default': None, 'conditions': [], 'min_value': 10, 'max_value': 300, 'step': 10, 'sampling': None}\n",
      "dropout3 (Float)\n",
      "{'default': 0.1, 'conditions': [], 'min_value': 0.1, 'max_value': 0.9, 'step': 0.1, 'sampling': None}\n",
      "usersfactor (Int)\n",
      "{'default': None, 'conditions': [], 'min_value': 50, 'max_value': 500, 'step': 50, 'sampling': None}\n",
      "moviesfactor (Int)\n",
      "{'default': None, 'conditions': [], 'min_value': 50, 'max_value': 500, 'step': 50, 'sampling': None}\n"
     ]
    }
   ],
   "source": [
    "path = create_path('./tunes')\n",
    "\n",
    "tuner = kt.Hyperband(\n",
    "    model_builder,\n",
    "    objective    = 'val_loss',\n",
    "    max_epochs   = 30,\n",
    "    factor       = 3,\n",
    "    seed         = SEED,\n",
    "    directory    = path,\n",
    "    project_name = 'recommendations'\n",
    ")\n",
    "\n",
    "tuner.search_space_summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Trial 91 Complete [00h 00m 25s]\n",
      "val_loss: 0.7562389969825745\n",
      "\n",
      "Best val_loss So Far: 0.7313058376312256\n",
      "Total elapsed time: 00h 01m 42s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Process Keras_worker_ForkPoolWorker-21:\n",
      "Process Keras_worker_ForkPoolWorker-45:\n",
      "Process Keras_worker_ForkPoolWorker-84:\n",
      "Process Keras_worker_ForkPoolWorker-69:\n",
      "Process Keras_worker_ForkPoolWorker-198:\n",
      "Process Keras_worker_ForkPoolWorker-129:\n",
      "Process Keras_worker_ForkPoolWorker-150:\n",
      "Process Keras_worker_ForkPoolWorker-111:\n",
      "Traceback (most recent call last):\n",
      "Traceback (most recent call last):\n",
      "Traceback (most recent call last):\n",
      "Traceback (most recent call last):\n",
      "Traceback (most recent call last):\n",
      "Traceback (most recent call last):\n",
      "Traceback (most recent call last):\n",
      "Traceback (most recent call last):\n",
      "  File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/multiprocessing/process.py\", line 315, in _bootstrap\n",
      "    self.run()\n",
      "  File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/multiprocessing/process.py\", line 315, in _bootstrap\n",
      "    self.run()\n",
      "  File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/multiprocessing/process.py\", line 315, in _bootstrap\n",
      "    self.run()\n",
      "  File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/multiprocessing/process.py\", line 315, in _bootstrap\n",
      "    self.run()\n",
      "  File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/multiprocessing/process.py\", line 315, in _bootstrap\n",
      "    self.run()\n",
      "  File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/multiprocessing/process.py\", line 315, in _bootstrap\n",
      "    self.run()\n",
      "  File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/multiprocessing/process.py\", line 315, in _bootstrap\n",
      "    self.run()\n",
      "  File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/multiprocessing/process.py\", line 315, in _bootstrap\n",
      "    self.run()\n",
      "  File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/multiprocessing/process.py\", line 108, in run\n",
      "    self._target(*self._args, **self._kwargs)\n",
      "  File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/multiprocessing/process.py\", line 108, in run\n",
      "    self._target(*self._args, **self._kwargs)\n",
      "  File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/multiprocessing/process.py\", line 108, in run\n",
      "    self._target(*self._args, **self._kwargs)\n",
      "  File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/multiprocessing/process.py\", line 108, in run\n",
      "    self._target(*self._args, **self._kwargs)\n",
      "  File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/multiprocessing/process.py\", line 108, in run\n",
      "    self._target(*self._args, **self._kwargs)\n",
      "  File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/multiprocessing/process.py\", line 108, in run\n",
      "    self._target(*self._args, **self._kwargs)\n",
      "  File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/multiprocessing/pool.py\", line 114, in worker\n",
      "    task = get()\n",
      "  File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/multiprocessing/process.py\", line 108, in run\n",
      "    self._target(*self._args, **self._kwargs)\n",
      "  File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/multiprocessing/process.py\", line 108, in run\n",
      "    self._target(*self._args, **self._kwargs)\n",
      "  File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/multiprocessing/pool.py\", line 114, in worker\n",
      "    task = get()\n",
      "  File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/multiprocessing/pool.py\", line 114, in worker\n",
      "    task = get()\n",
      "  File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/multiprocessing/pool.py\", line 114, in worker\n",
      "    task = get()\n",
      "  File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/multiprocessing/pool.py\", line 114, in worker\n",
      "    task = get()\n",
      "  File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/multiprocessing/pool.py\", line 114, in worker\n",
      "    task = get()\n",
      "  File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/multiprocessing/queues.py\", line 356, in get\n",
      "    res = self._reader.recv_bytes()\n",
      "  File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/multiprocessing/pool.py\", line 114, in worker\n",
      "    task = get()\n",
      "  File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/multiprocessing/queues.py\", line 356, in get\n",
      "    res = self._reader.recv_bytes()\n",
      "  File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/multiprocessing/queues.py\", line 356, in get\n",
      "    res = self._reader.recv_bytes()\n",
      "  File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/multiprocessing/queues.py\", line 356, in get\n",
      "    res = self._reader.recv_bytes()\n",
      "  File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/multiprocessing/pool.py\", line 114, in worker\n",
      "    task = get()\n",
      "  File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/multiprocessing/connection.py\", line 216, in recv_bytes\n",
      "    buf = self._recv_bytes(maxlength)\n",
      "  File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/multiprocessing/queues.py\", line 356, in get\n",
      "    res = self._reader.recv_bytes()\n",
      "  File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/multiprocessing/queues.py\", line 356, in get\n",
      "    res = self._reader.recv_bytes()\n",
      "  File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/multiprocessing/queues.py\", line 356, in get\n",
      "    res = self._reader.recv_bytes()\n",
      "  File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/multiprocessing/connection.py\", line 216, in recv_bytes\n",
      "    buf = self._recv_bytes(maxlength)\n",
      "  File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/multiprocessing/connection.py\", line 216, in recv_bytes\n",
      "    buf = self._recv_bytes(maxlength)\n",
      "  File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/multiprocessing/connection.py\", line 216, in recv_bytes\n",
      "    buf = self._recv_bytes(maxlength)\n",
      "  File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/multiprocessing/connection.py\", line 414, in _recv_bytes\n",
      "    buf = self._recv(4)\n",
      "  File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/multiprocessing/queues.py\", line 356, in get\n",
      "    res = self._reader.recv_bytes()\n",
      "  File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/multiprocessing/connection.py\", line 216, in recv_bytes\n",
      "    buf = self._recv_bytes(maxlength)\n",
      "  File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/multiprocessing/connection.py\", line 216, in recv_bytes\n",
      "    buf = self._recv_bytes(maxlength)\n",
      "  File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/multiprocessing/connection.py\", line 414, in _recv_bytes\n",
      "    buf = self._recv(4)\n",
      "  File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/multiprocessing/connection.py\", line 216, in recv_bytes\n",
      "    buf = self._recv_bytes(maxlength)\n",
      "  File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/multiprocessing/connection.py\", line 414, in _recv_bytes\n",
      "    buf = self._recv(4)\n",
      "  File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/multiprocessing/connection.py\", line 379, in _recv\n",
      "    chunk = read(handle, remaining)\n",
      "  File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/multiprocessing/connection.py\", line 414, in _recv_bytes\n",
      "    buf = self._recv(4)\n",
      "  File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/multiprocessing/connection.py\", line 216, in recv_bytes\n",
      "    buf = self._recv_bytes(maxlength)\n",
      "  File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/multiprocessing/connection.py\", line 414, in _recv_bytes\n",
      "    buf = self._recv(4)\n",
      "  File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/multiprocessing/connection.py\", line 414, in _recv_bytes\n",
      "    buf = self._recv(4)\n",
      "  File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/multiprocessing/connection.py\", line 414, in _recv_bytes\n",
      "    buf = self._recv(4)\n",
      "  File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/multiprocessing/connection.py\", line 379, in _recv\n",
      "    chunk = read(handle, remaining)\n",
      "  File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/multiprocessing/connection.py\", line 379, in _recv\n",
      "    chunk = read(handle, remaining)\n",
      "KeyboardInterrupt\n",
      "  File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/multiprocessing/connection.py\", line 379, in _recv\n",
      "    chunk = read(handle, remaining)\n",
      "  File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/multiprocessing/connection.py\", line 414, in _recv_bytes\n",
      "    buf = self._recv(4)\n",
      "  File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/multiprocessing/connection.py\", line 379, in _recv\n",
      "    chunk = read(handle, remaining)\n",
      "  File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/multiprocessing/connection.py\", line 379, in _recv\n",
      "    chunk = read(handle, remaining)\n",
      "KeyboardInterrupt\n",
      "  File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/multiprocessing/connection.py\", line 379, in _recv\n",
      "    chunk = read(handle, remaining)\n",
      "KeyboardInterrupt\n",
      "KeyboardInterrupt\n",
      "KeyboardInterrupt\n",
      "  File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/multiprocessing/connection.py\", line 379, in _recv\n",
      "    chunk = read(handle, remaining)\n",
      "KeyboardInterrupt\n",
      "KeyboardInterrupt\n",
      "KeyboardInterrupt\n"
     ]
    }
   ],
   "source": [
    "tuner.search(\n",
    "    train_generator,\n",
    "    validation_data     = val_generator,\n",
    "    callbacks           = [EarlyStopping(monitor='val_loss', patience=4)],\n",
    "    use_multiprocessing = True\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Step 2**: Show best model hyperparameters give a set of optimizer hyperparams:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Results summary\n",
      "Results in ./tunes/recommendations\n",
      "Showing 1 best trials\n",
      "Objective(name='val_loss', direction='min')\n",
      "Trial summary\n",
      "Hyperparameters:\n",
      "lr: 0.001\n",
      "units1: 250\n",
      "dropout1: 0.30000000000000004\n",
      "units2: 170\n",
      "dropout2: 0.8\n",
      "units3: 50\n",
      "dropout3: 0.1\n",
      "usersfactor: 150\n",
      "moviesfactor: 100\n",
      "tuner/epochs: 10\n",
      "tuner/initial_epoch: 4\n",
      "tuner/bracket: 3\n",
      "tuner/round: 2\n",
      "tuner/trial_id: efa1341fa039a6a419d842f769da3736\n",
      "Score: 0.7313058376312256\n"
     ]
    }
   ],
   "source": [
    "# Show a summary of the search\n",
    "tuner.results_summary(num_trials=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Step 3**: Get best model founded by the optimizer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "best_model = tuner.get_best_models(num_models=1)[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Evaluate best model on train validation an test sets to see loss:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.6856539249420166"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "evaluate(best_model, train_set, batch_size=train_batch_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7202911972999573"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "evaluate(best_model, val_set, batch_size=val_batch_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.609739363193512"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "evaluate(best_model, test_set, batch_size=val_batch_size)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Observations**\n",
    "\n",
    "* Loss under train set of greater than evalidation set. This good a signal.\n",
    "* Loss under evaliadtion an test sets if pratically the same."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Train model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Step 1**: Create model with best founded hyperparameters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model = create_best_model_from(tuner) \n",
    "plot_model(model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "# model.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Step 2**: Train model under train set only and plot train vs validation loss by epoch:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "hyperparameters = get_best_hyperparameters(tuner)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 2160x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " 51/100 [==============>...............] - ETA: 0s - loss: 0.5444\n",
      "\n",
      "Evaluate model each 51 steps(Batch-size: 201):\n",
      "1/1 [==============================] - 0s 13ms/step - loss: 0.8492\n",
      "\n",
      "Val metrics:\n",
      "  - Loss (14): 0.849228 (⟰ 0.13148040)\n",
      "\n",
      "Continue model train:\n",
      "100/100 [==============================] - 1s 10ms/step - loss: 0.5455 - val_loss: 0.7803\n"
     ]
    }
   ],
   "source": [
    "history = model.fit_generator(\n",
    "    generator=train_generator,\n",
    "    validation_data=val_generator,\n",
    "    epochs=50,\n",
    "    callbacks=[\n",
    "        create_metrics_callback(), \n",
    "        create_checkpoints_callback(),\n",
    "        EarlyStopping(monitor='val_loss', patience=5)\n",
    "    ],\n",
    "    use_multiprocessing=True,\n",
    "    verbose=1\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Step 3**: Evaluate model under train, validaiton an test set to see loss diferences. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.5634474158287048"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "evaluate(model, train_set, batch_size=train_batch_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8832972645759583"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "evaluate(model, val_set, batch_size=val_batch_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8314676880836487"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "evaluate(model, test_set, batch_size=val_batch_size)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Observations**\n",
    "\n",
    "* Again, loss under train set is greater than evalidation set. This good a signal.\n",
    "* Loss under evaluation set is less thant test sets, this is normal. Because test set have never been seen by the model but evalidation set was used to optimize the model.\n",
    "* Tran vs validation loss are very close each other, is a good signal. In principle, there is no overfitting."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Step 4**: Now we search epoch with lowest loss value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2022-02-28 18:34:45 INFO Lowest loss epoch: 2\n"
     ]
    }
   ],
   "source": [
    "val_loss_per_epoch = history.history['val_loss']\n",
    "plot_loss(val_loss_per_epoch)\n",
    "\n",
    "epochs = lowest_loss_epoch(val_loss_per_epoch)\n",
    "logging.info(f'Lowest loss epoch: {epochs}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Step 5**: Re train best model trainig only with lowest loss epoch value. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 2160x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " 51/100 [==============>...............] - ETA: 0s - loss: 0.7229\n",
      "\n",
      "Evaluate model each 51 steps(Batch-size: 201):\n",
      "1/1 [==============================] - 0s 10ms/step - loss: 0.6919\n",
      "\n",
      "Val metrics:\n",
      "  - Loss (4): 0.691940 (⟱ 0.15632284)\n",
      "\n",
      "Continue model train:\n",
      "100/100 [==============================] - 2s 13ms/step - loss: 0.7097 - val_loss: 0.7609\n"
     ]
    }
   ],
   "source": [
    "model = create_best_model_from(tuner)\n",
    "\n",
    "history = model.fit_generator(\n",
    "    generator=train_generator,\n",
    "    validation_data=val_generator,\n",
    "    epochs=epochs,\n",
    "    callbacks=[\n",
    "        create_metrics_callback(), \n",
    "        create_checkpoints_callback(),\n",
    "        EarlyStopping(monitor='val_loss', patience=3)\n",
    "    ],\n",
    "    use_multiprocessing=True,\n",
    "    verbose=1\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.6994607448577881"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "evaluate(model, train_set, batch_size=train_batch_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8061785101890564"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "evaluate(model, val_set, batch_size=val_batch_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.6707092523574829"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "evaluate(model, test_set, batch_size=val_batch_size)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Observations**\n",
    "\n",
    "* In this cause we found a model with less loss under test set."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Check rating prediction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Predict ratings used to train model:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'true_positives': '78.5%', 'false_positives': '21.5%'}"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_metrics = get_metrics(Dataset(test_set), max_error=1)\n",
    "\n",
    "{k: test_metrics[k] for k in ('true_positives', 'false_positives')}"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.5"
  },
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "state": {},
    "version_major": 2,
    "version_minor": 0
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}