user-movie-genres-model/3.train-model-spark.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": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "sys.path.append('../src')\n",
    "\n",
    "import math\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import tensorflow as tf\n",
    "\n",
    "from util import tf_detected_devices, \\\n",
    "                 tf_version, \\\n",
    "                 plot_model, \\\n",
    "                 Config, \\\n",
    "                 LoggerFactory, \\\n",
    "                 create_path\n",
    "\n",
    "from callback import MetricsPlotter\n",
    "\n",
    "from data import DataFrameDataGenerator\n",
    "\n",
    "from recommendation import UserMovieGenderEmbeddingDenseModelFactory, \\\n",
    "                           RecommendationsDataGenerator\n",
    "\n",
    "from spark import SparkSessionFactory, \\\n",
    "                  read_csv, \\\n",
    "                  column_values, \\\n",
    "                  train_test_split, \\\n",
    "                  PageSet, \\\n",
    "                  get_columns, \\\n",
    "                  get_rows\n",
    "\n",
    "import pyspark.sql.types as t\n",
    "import pyspark.sql as s\n",
    "import pyspark.sql.functions as f"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Logger config"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<RootLogger root (INFO)>"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "config = Config(path='../config/config.yaml')\n",
    "LoggerFactory(config['logger']).create()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Config parameters"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Setup test_mode variable to enable or disable model train before check their prediction precision:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_model = True"
   ]
  },
  {
   "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": 33,
   "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": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Tensorflow version: 2.8.0'"
      ]
     },
     "execution_count": 34,
     "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": 35,
   "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>488M</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   488M   \n",
       "\n",
       "                                         Description  \n",
       "0                                                     \n",
       "1  device: 0, name: NVIDIA GeForce RTX 3080, pci ...  "
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tf_detected_devices()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "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": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tf.test.is_built_with_cuda()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[PhysicalDevice(name='/physical_device:GPU:0', device_type='GPU')]"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tf.config.list_physical_devices('GPU')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Prepare model input data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Step 1**: Create a predefined spark session. this is used to create a pipeline that build the model input features. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "            <div>\n",
       "                <p><b>SparkSession - in-memory</b></p>\n",
       "                \n",
       "        <div>\n",
       "            <p><b>SparkContext</b></p>\n",
       "\n",
       "            <p><a href=\"http://skynet:4040\">Spark UI</a></p>\n",
       "\n",
       "            <dl>\n",
       "              <dt>Version</dt>\n",
       "                <dd><code>v3.2.0</code></dd>\n",
       "              <dt>Master</dt>\n",
       "                <dd><code>local[*]</code></dd>\n",
       "              <dt>AppName</dt>\n",
       "                <dd><code>recommendations</code></dd>\n",
       "            </dl>\n",
       "        </div>\n",
       "        \n",
       "            </div>\n",
       "        "
      ],
      "text/plain": [
       "<pyspark.sql.session.SparkSession at 0x7f7528668a60>"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "session = SparkSessionFactory.create()\n",
    "session"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('spark.app.startTime', '1645981041991'),\n",
       " ('spark.executor.instances', '12'),\n",
       " ('spark.sql.warehouse.dir',\n",
       "  'file:/home/adrian/development/machine-learning/recommendations/user-movie-genres-model/spark-warehouse'),\n",
       " ('spark.executor.id', 'driver'),\n",
       " ('spark.executor.memory', '1G'),\n",
       " ('spark.app.name', 'recommendations'),\n",
       " ('spark.driver.host', 'skynet'),\n",
       " ('spark.rdd.compress', 'True'),\n",
       " ('spark.serializer.objectStreamReset', '100'),\n",
       " ('spark.app.id', 'local-1645981042022'),\n",
       " ('spark.master', 'local[*]'),\n",
       " ('spark.driver.port', '37985'),\n",
       " ('spark.submit.pyFiles', ''),\n",
       " ('spark.submit.deployMode', 'client'),\n",
       " ('spark.driver.memory', '4G'),\n",
       " ('spark.ui.showConsoleProgress', 'true')]"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "session.sparkContext.getConf().getAll()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note**: When create a spark session this run a new spark cluster with one instance in localhost. You can monitor instance jobs clicking the **Spark UI** link. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Step 2**: Load raw dataset to a spark dataset. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "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'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train set size: 70,288 samples.\n",
      "Validation set size: 20,198 samples.\n",
      "Test set size: 8,851 samples.\n"
     ]
    }
   ],
   "source": [
    "train_set = read_csv(session, f'{TRAIN_PATH}/*.csv')\n",
    "val_set   = read_csv(session, f'{VAL_PATH}/*.csv')\n",
    "test_set  = read_csv(session, f'{TEST_PATH}/*.csv')\n",
    "\n",
    "print(f'Train set size: {\"{:,}\".format(train_set.count())} samples.')\n",
    "print(f'Validation set size: {\"{:,}\".format(val_set.count())} samples.')\n",
    "print(f'Test set size: {\"{:,}\".format(test_set.count())} samples.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Step 3:** Let's see min and max value of rating column."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ratting - min:  0.5 max: 5.0\n"
     ]
    }
   ],
   "source": [
    "min_max = train_set.agg(f.min('rating'), f.max('rating')).collect()[0]\n",
    "min_rating, max_rating = min_max[0], min_max[1]\n",
    "\n",
    "print('Ratting - min: ', min_rating, 'max:', max_rating)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Step 4:** Let's see all dataset columns."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ColumnService:\n",
    "    def __init__(self, columns):\n",
    "        excluded_columns = ['user_id', 'movie_id']\n",
    "        self.labels = ['rating']\n",
    "\n",
    "        features = list(set(columns) - set(self.labels) - set(excluded_columns))\n",
    "        features = sorted(features, key=lambda x: 'gen_' in x)\n",
    "\n",
    "        self.gender_features = [c for c in features if 'gen_' in c]\n",
    "        self.emb_features = [c for c in features if '_seq' in c]\n",
    "        self.emb_features = sorted(self.emb_features, key=lambda x: 'user' in x, reverse=True)\n",
    "   \n",
    "        self.features = self.emb_features + self.gender_features\n",
    "\n",
    "column_manager = ColumnService(train_set.columns)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Step 5**: Calculate train, val batch_size and plot interval."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Batch Size      : 702.\n",
      "Validation Batch Size : 201.\n",
      "Plot Interval         : 10\n",
      "Evaluate Interval     : 11\n",
      "Epochs                : 20\n"
     ]
    }
   ],
   "source": [
    "steps             = 100\n",
    "epochs            = 20\n",
    "plot_interval     = math.floor(steps / 10)\n",
    "\n",
    "train_batch_size  = math.floor(train_set.count() / steps)\n",
    "val_batch_size    = math.floor(val_set.count() / steps)\n",
    "evaluate_interval = plot_interval + 1\n",
    "\n",
    "\n",
    "print(f'Train Batch Size      : {\"{:,}\".format(train_batch_size)}.')\n",
    "print(f'Validation Batch Size : {\"{:,}\".format(val_batch_size)}.')\n",
    "print('Plot Interval         :', plot_interval)\n",
    "print('Evaluate Interval     :', evaluate_interval)\n",
    "print('Epochs                :', epochs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2022-02-27 13:58:47 INFO Page Size: 702\n",
      "2022-02-27 13:58:47 INFO Pages Count: 101\n",
      "2022-02-27 13:58:47 INFO Total elements: 70288\n",
      "2022-02-27 13:58:47 INFO Page Size: 201\n",
      "2022-02-27 13:58:47 INFO Pages Count: 101\n",
      "2022-02-27 13:58:47 INFO Total elements: 20198\n"
     ]
    }
   ],
   "source": [
    "train_generator = RecommendationsDataGenerator(\n",
    "    train_set,\n",
    "    train_batch_size,\n",
    "    column_manager,\n",
    "    shuffle = True,\n",
    "    name    = 'train'\n",
    ")\n",
    "\n",
    "val_generator = RecommendationsDataGenerator(\n",
    "    val_set,\n",
    "    val_batch_size,\n",
    "    column_manager,\n",
    "    shuffle = False,\n",
    "    name    = 'val'\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train set size: 610.\n",
      "Validation set size: 8,454.\n"
     ]
    }
   ],
   "source": [
    "n_users = train_set.select('user_seq') \\\n",
    "            .union(val_set.select('user_seq')) \\\n",
    "            .union(test_set.select('user_seq')) \\\n",
    "            .distinct() \\\n",
    "            .count()\n",
    "\n",
    "n_movies = train_set.select('movie_seq') \\\n",
    "            .union(val_set.select('movie_seq')) \\\n",
    "            .union(test_set.select('movie_seq')) \\\n",
    "            .distinct() \\\n",
    "            .count()\n",
    "\n",
    "print(f'Train set size: {\"{:,}\".format(n_users)}.')\n",
    "print(f'Validation set size: {\"{:,}\".format(n_movies)}.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model = UserMovieGenderEmbeddingDenseModelFactory.create(\n",
    "    n_users,\n",
    "    n_movies,\n",
    "    n_genders           = len(column_manager.gender_features),\n",
    "    min_rating          = min_rating, \n",
    "    max_rating          = max_rating,\n",
    "    user_n_min_factors  = 50,\n",
    "    movie_n_min_factors = 50,\n",
    "    lr                  = 0.001,\n",
    "    units               = [512, 512, 512, 512],\n",
    "    dropout             = [0.5, 0.5, 0.5, 0.5]\n",
    ")\n",
    "\n",
    "plot_model(model, rankdir=\"TB\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"Embedding_Feature_Layers_Plus_Dense_Layer_Model\"\n",
      "__________________________________________________________________________________________________\n",
      " Layer (type)                   Output Shape         Param #     Connected to                     \n",
      "==================================================================================================\n",
      " users_idx (InputLayer)         [(None, 1)]          0           []                               \n",
      "                                                                                                  \n",
      " movies_idx (InputLayer)        [(None, 1)]          0           []                               \n",
      "                                                                                                  \n",
      " users_embedding (Embedding)    (None, 1, 50)        30500       ['users_idx[0][0]']              \n",
      "                                                                                                  \n",
      " movies_embedding (Embedding)   (None, 1, 50)        422700      ['movies_idx[0][0]']             \n",
      "                                                                                                  \n",
      " users_embedding_3_to_2_dim (Re  (None, 50)          0           ['users_embedding[0][0]']        \n",
      " shape)                                                                                           \n",
      "                                                                                                  \n",
      " movies_embedding_3_to_2_dim (R  (None, 50)          0           ['movies_embedding[0][0]']       \n",
      " eshape)                                                                                          \n",
      "                                                                                                  \n",
      " concatenate_2 (Concatenate)    (None, 100)          0           ['users_embedding_3_to_2_dim[0][0\n",
      "                                                                 ]',                              \n",
      "                                                                  'movies_embedding_3_to_2_dim[0][\n",
      "                                                                 0]']                             \n",
      "                                                                                                  \n",
      " dropout_4 (Dropout)            (None, 100)          0           ['concatenate_2[0][0]']          \n",
      "                                                                                                  \n",
      " dense_4 (Dense)                (None, 512)          51712       ['dropout_4[0][0]']              \n",
      "                                                                                                  \n",
      " activation_2 (Activation)      (None, 512)          0           ['dense_4[0][0]']                \n",
      "                                                                                                  \n",
      " dropout_5 (Dropout)            (None, 512)          0           ['activation_2[0][0]']           \n",
      "                                                                                                  \n",
      " dense_5 (Dense)                (None, 1)            513         ['dropout_5[0][0]']              \n",
      "                                                                                                  \n",
      " sigmoid_activation (Activation  (None, 1)           0           ['dense_5[0][0]']                \n",
      " )                                                                                                \n",
      "                                                                                                  \n",
      " genders (InputLayer)           [(None, 20)]         0           []                               \n",
      "                                                                                                  \n",
      " user_rating_prediction (Lambda  (None, 1)           0           ['sigmoid_activation[0][0]']     \n",
      " )                                                                                                \n",
      "                                                                                                  \n",
      "==================================================================================================\n",
      "Total params: 505,425\n",
      "Trainable params: 505,425\n",
      "Non-trainable params: 0\n",
      "__________________________________________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss\n",
      "Epoch 1/20\n"
     ]
    },
    {
     "ename": "InternalError",
     "evalue": "Graph execution error:\n\nDetected at node 'Embedding_Feature_Layers_Plus_Dense_Layer_Model/dense_4/MatMul' defined at (most recent call last):\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/runpy.py\", line 194, in _run_module_as_main\n      return _run_code(code, main_globals, None,\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/runpy.py\", line 87, in _run_code\n      exec(code, run_globals)\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/site-packages/ipykernel_launcher.py\", line 16, in <module>\n      app.launch_new_instance()\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/site-packages/traitlets/config/application.py\", line 845, in launch_instance\n      app.start()\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/site-packages/ipykernel/kernelapp.py\", line 612, in start\n      self.io_loop.start()\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/site-packages/tornado/platform/asyncio.py\", line 149, in start\n      self.asyncio_loop.run_forever()\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/asyncio/base_events.py\", line 570, in run_forever\n      self._run_once()\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/asyncio/base_events.py\", line 1859, in _run_once\n      handle._run()\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/asyncio/events.py\", line 81, in _run\n      self._context.run(self._callback, *self._args)\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/site-packages/tornado/ioloop.py\", line 690, in <lambda>\n      lambda f: self._run_callback(functools.partial(callback, future))\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/site-packages/tornado/ioloop.py\", line 743, in _run_callback\n      ret = callback()\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/site-packages/tornado/gen.py\", line 787, in inner\n      self.run()\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/site-packages/tornado/gen.py\", line 748, in run\n      yielded = self.gen.send(value)\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/site-packages/ipykernel/kernelbase.py\", line 365, in process_one\n      yield gen.maybe_future(dispatch(*args))\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/site-packages/tornado/gen.py\", line 209, in wrapper\n      yielded = next(result)\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/site-packages/ipykernel/kernelbase.py\", line 268, in dispatch_shell\n      yield gen.maybe_future(handler(stream, idents, msg))\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/site-packages/tornado/gen.py\", line 209, in wrapper\n      yielded = next(result)\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/site-packages/ipykernel/kernelbase.py\", line 543, in execute_request\n      self.do_execute(\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/site-packages/tornado/gen.py\", line 209, in wrapper\n      yielded = next(result)\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/site-packages/ipykernel/ipkernel.py\", line 306, in do_execute\n      res = shell.run_cell(code, store_history=store_history, silent=silent)\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/site-packages/ipykernel/zmqshell.py\", line 536, in run_cell\n      return super(ZMQInteractiveShell, self).run_cell(*args, **kwargs)\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/site-packages/IPython/core/interactiveshell.py\", line 2876, in run_cell\n      result = self._run_cell(\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/site-packages/IPython/core/interactiveshell.py\", line 2922, in _run_cell\n      return runner(coro)\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/site-packages/IPython/core/async_helpers.py\", line 68, in _pseudo_sync_runner\n      coro.send(None)\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/site-packages/IPython/core/interactiveshell.py\", line 3145, in run_cell_async\n      has_raised = await self.run_ast_nodes(code_ast.body, cell_name,\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/site-packages/IPython/core/interactiveshell.py\", line 3337, in run_ast_nodes\n      if (await self.run_code(code, result,  async_=asy)):\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/site-packages/IPython/core/interactiveshell.py\", line 3417, in run_code\n      exec(code_obj, self.user_global_ns, self.user_ns)\n    File \"<ipython-input-55-000925bb503f>\", line 2, in <module>\n      history = model.fit_generator(\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/site-packages/keras/engine/training.py\", line 2209, in fit_generator\n      return self.fit(\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/site-packages/keras/utils/traceback_utils.py\", line 64, in error_handler\n      return fn(*args, **kwargs)\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/site-packages/keras/engine/training.py\", line 1384, in fit\n      tmp_logs = self.train_function(iterator)\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/site-packages/keras/engine/training.py\", line 1021, in train_function\n      return step_function(self, iterator)\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/site-packages/keras/engine/training.py\", line 1010, in step_function\n      outputs = model.distribute_strategy.run(run_step, args=(data,))\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/site-packages/keras/engine/training.py\", line 1000, in run_step\n      outputs = model.train_step(data)\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/site-packages/keras/engine/training.py\", line 859, in train_step\n      y_pred = self(x, training=True)\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/site-packages/keras/utils/traceback_utils.py\", line 64, in error_handler\n      return fn(*args, **kwargs)\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/site-packages/keras/engine/base_layer.py\", line 1096, in __call__\n      outputs = call_fn(inputs, *args, **kwargs)\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/site-packages/keras/utils/traceback_utils.py\", line 92, in error_handler\n      return fn(*args, **kwargs)\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/site-packages/keras/engine/functional.py\", line 451, in call\n      return self._run_internal_graph(\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/site-packages/keras/engine/functional.py\", line 589, in _run_internal_graph\n      outputs = node.layer(*args, **kwargs)\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/site-packages/keras/utils/traceback_utils.py\", line 64, in error_handler\n      return fn(*args, **kwargs)\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/site-packages/keras/engine/base_layer.py\", line 1096, in __call__\n      outputs = call_fn(inputs, *args, **kwargs)\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/site-packages/keras/utils/traceback_utils.py\", line 92, in error_handler\n      return fn(*args, **kwargs)\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/site-packages/keras/layers/core/dense.py\", line 219, in call\n      outputs = tf.matmul(a=inputs, b=self.kernel)\nNode: 'Embedding_Feature_Layers_Plus_Dense_Layer_Model/dense_4/MatMul'\nAttempting to perform BLAS operation using StreamExecutor without BLAS support\n\t [[{{node Embedding_Feature_Layers_Plus_Dense_Layer_Model/dense_4/MatMul}}]] [Op:__inference_train_function_2082]",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mInternalError\u001b[0m                             Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-55-000925bb503f>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mtrain_model\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m     history = model.fit_generator(\n\u001b[0m\u001b[1;32m      3\u001b[0m         \u001b[0mgenerator\u001b[0m       \u001b[0;34m=\u001b[0m \u001b[0mtrain_generator\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m         \u001b[0mvalidation_data\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mval_generator\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m         \u001b[0mepochs\u001b[0m          \u001b[0;34m=\u001b[0m \u001b[0mepochs\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/.conda/envs/recommendations/lib/python3.8/site-packages/keras/engine/training.py\u001b[0m in \u001b[0;36mfit_generator\u001b[0;34m(self, generator, steps_per_epoch, epochs, verbose, callbacks, validation_data, validation_steps, validation_freq, class_weight, max_queue_size, workers, use_multiprocessing, shuffle, initial_epoch)\u001b[0m\n\u001b[1;32m   2207\u001b[0m         \u001b[0;34m'Please use `Model.fit`, which supports generators.'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2208\u001b[0m         stacklevel=2)\n\u001b[0;32m-> 2209\u001b[0;31m     return self.fit(\n\u001b[0m\u001b[1;32m   2210\u001b[0m         \u001b[0mgenerator\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2211\u001b[0m         \u001b[0msteps_per_epoch\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0msteps_per_epoch\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/.conda/envs/recommendations/lib/python3.8/site-packages/keras/utils/traceback_utils.py\u001b[0m in \u001b[0;36merror_handler\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m     65\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m  \u001b[0;31m# pylint: disable=broad-except\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     66\u001b[0m       \u001b[0mfiltered_tb\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_process_traceback_frames\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0me\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__traceback__\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 67\u001b[0;31m       \u001b[0;32mraise\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwith_traceback\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfiltered_tb\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     68\u001b[0m     \u001b[0;32mfinally\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     69\u001b[0m       \u001b[0;32mdel\u001b[0m \u001b[0mfiltered_tb\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/.conda/envs/recommendations/lib/python3.8/site-packages/tensorflow/python/eager/execute.py\u001b[0m in \u001b[0;36mquick_execute\u001b[0;34m(op_name, num_outputs, inputs, attrs, ctx, name)\u001b[0m\n\u001b[1;32m     52\u001b[0m   \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     53\u001b[0m     \u001b[0mctx\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mensure_initialized\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 54\u001b[0;31m     tensors = pywrap_tfe.TFE_Py_Execute(ctx._handle, device_name, op_name,\n\u001b[0m\u001b[1;32m     55\u001b[0m                                         inputs, attrs, num_outputs)\n\u001b[1;32m     56\u001b[0m   \u001b[0;32mexcept\u001b[0m \u001b[0mcore\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_NotOkStatusException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mInternalError\u001b[0m: Graph execution error:\n\nDetected at node 'Embedding_Feature_Layers_Plus_Dense_Layer_Model/dense_4/MatMul' defined at (most recent call last):\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/runpy.py\", line 194, in _run_module_as_main\n      return _run_code(code, main_globals, None,\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/runpy.py\", line 87, in _run_code\n      exec(code, run_globals)\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/site-packages/ipykernel_launcher.py\", line 16, in <module>\n      app.launch_new_instance()\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/site-packages/traitlets/config/application.py\", line 845, in launch_instance\n      app.start()\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/site-packages/ipykernel/kernelapp.py\", line 612, in start\n      self.io_loop.start()\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/site-packages/tornado/platform/asyncio.py\", line 149, in start\n      self.asyncio_loop.run_forever()\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/asyncio/base_events.py\", line 570, in run_forever\n      self._run_once()\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/asyncio/base_events.py\", line 1859, in _run_once\n      handle._run()\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/asyncio/events.py\", line 81, in _run\n      self._context.run(self._callback, *self._args)\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/site-packages/tornado/ioloop.py\", line 690, in <lambda>\n      lambda f: self._run_callback(functools.partial(callback, future))\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/site-packages/tornado/ioloop.py\", line 743, in _run_callback\n      ret = callback()\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/site-packages/tornado/gen.py\", line 787, in inner\n      self.run()\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/site-packages/tornado/gen.py\", line 748, in run\n      yielded = self.gen.send(value)\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/site-packages/ipykernel/kernelbase.py\", line 365, in process_one\n      yield gen.maybe_future(dispatch(*args))\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/site-packages/tornado/gen.py\", line 209, in wrapper\n      yielded = next(result)\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/site-packages/ipykernel/kernelbase.py\", line 268, in dispatch_shell\n      yield gen.maybe_future(handler(stream, idents, msg))\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/site-packages/tornado/gen.py\", line 209, in wrapper\n      yielded = next(result)\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/site-packages/ipykernel/kernelbase.py\", line 543, in execute_request\n      self.do_execute(\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/site-packages/tornado/gen.py\", line 209, in wrapper\n      yielded = next(result)\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/site-packages/ipykernel/ipkernel.py\", line 306, in do_execute\n      res = shell.run_cell(code, store_history=store_history, silent=silent)\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/site-packages/ipykernel/zmqshell.py\", line 536, in run_cell\n      return super(ZMQInteractiveShell, self).run_cell(*args, **kwargs)\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/site-packages/IPython/core/interactiveshell.py\", line 2876, in run_cell\n      result = self._run_cell(\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/site-packages/IPython/core/interactiveshell.py\", line 2922, in _run_cell\n      return runner(coro)\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/site-packages/IPython/core/async_helpers.py\", line 68, in _pseudo_sync_runner\n      coro.send(None)\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/site-packages/IPython/core/interactiveshell.py\", line 3145, in run_cell_async\n      has_raised = await self.run_ast_nodes(code_ast.body, cell_name,\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/site-packages/IPython/core/interactiveshell.py\", line 3337, in run_ast_nodes\n      if (await self.run_code(code, result,  async_=asy)):\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/site-packages/IPython/core/interactiveshell.py\", line 3417, in run_code\n      exec(code_obj, self.user_global_ns, self.user_ns)\n    File \"<ipython-input-55-000925bb503f>\", line 2, in <module>\n      history = model.fit_generator(\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/site-packages/keras/engine/training.py\", line 2209, in fit_generator\n      return self.fit(\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/site-packages/keras/utils/traceback_utils.py\", line 64, in error_handler\n      return fn(*args, **kwargs)\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/site-packages/keras/engine/training.py\", line 1384, in fit\n      tmp_logs = self.train_function(iterator)\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/site-packages/keras/engine/training.py\", line 1021, in train_function\n      return step_function(self, iterator)\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/site-packages/keras/engine/training.py\", line 1010, in step_function\n      outputs = model.distribute_strategy.run(run_step, args=(data,))\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/site-packages/keras/engine/training.py\", line 1000, in run_step\n      outputs = model.train_step(data)\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/site-packages/keras/engine/training.py\", line 859, in train_step\n      y_pred = self(x, training=True)\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/site-packages/keras/utils/traceback_utils.py\", line 64, in error_handler\n      return fn(*args, **kwargs)\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/site-packages/keras/engine/base_layer.py\", line 1096, in __call__\n      outputs = call_fn(inputs, *args, **kwargs)\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/site-packages/keras/utils/traceback_utils.py\", line 92, in error_handler\n      return fn(*args, **kwargs)\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/site-packages/keras/engine/functional.py\", line 451, in call\n      return self._run_internal_graph(\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/site-packages/keras/engine/functional.py\", line 589, in _run_internal_graph\n      outputs = node.layer(*args, **kwargs)\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/site-packages/keras/utils/traceback_utils.py\", line 64, in error_handler\n      return fn(*args, **kwargs)\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/site-packages/keras/engine/base_layer.py\", line 1096, in __call__\n      outputs = call_fn(inputs, *args, **kwargs)\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/site-packages/keras/utils/traceback_utils.py\", line 92, in error_handler\n      return fn(*args, **kwargs)\n    File \"/home/adrian/.conda/envs/recommendations/lib/python3.8/site-packages/keras/layers/core/dense.py\", line 219, in call\n      outputs = tf.matmul(a=inputs, b=self.kernel)\nNode: 'Embedding_Feature_Layers_Plus_Dense_Layer_Model/dense_4/MatMul'\nAttempting to perform BLAS operation using StreamExecutor without BLAS support\n\t [[{{node Embedding_Feature_Layers_Plus_Dense_Layer_Model/dense_4/MatMul}}]] [Op:__inference_train_function_2082]"
     ]
    }
   ],
   "source": [
    "if train_model:\n",
    "    history = model.fit_generator(\n",
    "        generator       = train_generator,\n",
    "        validation_data = val_generator,\n",
    "        epochs          = epochs,\n",
    "        verbose         = 1, \n",
    "        callbacks       = [\n",
    "            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",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Check model loss after training process:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def evaluate_xy_model(model, column_manager, data_frame, batch_size):\n",
    "    data_generator = RecommendationsDataGenerator(\n",
    "        data_frame,\n",
    "        column_manager.features,\n",
    "        column_manager.labels,\n",
    "        data_frame.count(),\n",
    "        shuffle=False\n",
    "    )\n",
    "    X, y = data_generator[0]\n",
    "    return model.evaluate(X, y, batch_size=batch_size, verbose=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "val_loss = evaluate_xy_model(model, column_manager, val_set, val_batch_size)\n",
    "val_loss"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Save the weights tthat model has learned:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## WEIGHTS_PATH = create_path(f'../weights')\n",
    "WEIGHTS_FILE = f'{WEIGHTS_PATH}/user_movie_genders_deep_model_weights_val_loss_{val_loss}.h5'\n",
    "model.save_weights(WEIGHTS_FILE)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "session.stop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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
}