7. lab_jupyter_cf_Neural Network Embedding based recommender system & Comparison.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align:center\">\n",
    "    <a href=\"https://skills.network/?utm_medium=Exinfluencer&utm_source=Exinfluencer&utm_content=000026UJ&utm_term=10006555&utm_id=NA-SkillsNetwork-Channel-SkillsNetworkCoursesIBMML321ENSkillsNetwork32585014-2022-01-01\" target=\"_blank\">\n",
    "    <img src=\"https://cf-courses-data.s3.us.cloud-object-storage.appdomain.cloud/assets/logos/SN_web_lightmode.png\" width=\"200\" alt=\"Skills Network Logo\"  />\n",
    "    </a>\n",
    "</p>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# **Course Rating Prediction using Neural Networks**\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Estimated time needed: **60** minutes\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the previous labs, we have crafted several types of user and item feature vectors.  For example, given a user `i`, we may build its profile feature vector and course rating feature vector, and given an item `j`, we may create its genre vector and user enrollment vectors.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With these explicit features vectors, we can perform machine learning tasks such as calculating the similarities among users or items, finding nearest neighbors, and using dot-product to estimate a rating value.\n",
    "\n",
    "The main advantage of using these explicit features is they are highly interpretable and yield very good performance as well. The main disadvantage is we need to spend quite some effort to build and store them.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](https://cf-courses-data.s3.us.cloud-object-storage.appdomain.cloud/IBM-ML321EN-SkillsNetwork/labs/module\\_4/images/explicit_user_item_features.png)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Is it possible to predict a rating without building explicit feature vectors beforehand?\n",
    "\n",
    "Yes, as you may recall, the Non-negative Matrix Factorization decomposes the user-item interaction matrix into user matrix and item matrix, which contain the latent features of users and items and you can simply dot-product them to get an estimated rating.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](https://cf-courses-data.s3.us.cloud-object-storage.appdomain.cloud/IBM-ML321EN-SkillsNetwork/labs/module\\_4/images/nmf.png)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In addition to NMF, neural networks can also be used to extract the latent user and item features?  In fact,  neural networks are very good at learning patterns from data and are widely used to extract latent features.  When training neural networks, it gradually captures and stores the features within its hidden layers as weight matrices and can be extracted to represent the original data.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this lab, you will be training neural networks to predict course ratings while simultaneously extracting users' and items' latent features.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Objectives\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After completing this lab you will be able to:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*   Use `tensorflow` to train neural networks to extract the user and item latent features from the hidden's layers\n",
    "*   Predict course ratings with trained neural networks\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Prepare and setup lab environment\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Install tensorflow 2.7 if not installed before in your Python environment\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Collecting tensorflow==2.7.0\n",
      "  Downloading tensorflow-2.7.0-cp37-cp37m-manylinux2010_x86_64.whl (489.6 MB)\n",
      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m489.6/489.6 MB\u001b[0m \u001b[31m869.5 kB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m00:01\u001b[0m00:01\u001b[0m\n",
      "\u001b[?25hCollecting tensorflow-io-gcs-filesystem>=0.21.0\n",
      "  Downloading tensorflow_io_gcs_filesystem-0.27.0-cp37-cp37m-manylinux_2_12_x86_64.manylinux2010_x86_64.whl (2.4 MB)\n",
      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m2.4/2.4 MB\u001b[0m \u001b[31m55.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m00:01\u001b[0m\n",
      "\u001b[?25hRequirement already satisfied: wheel<1.0,>=0.32.0 in /home/jupyterlab/conda/envs/python/lib/python3.7/site-packages (from tensorflow==2.7.0) (0.37.1)\n",
      "Collecting tensorboard~=2.6\n",
      "  Downloading tensorboard-2.10.0-py3-none-any.whl (5.9 MB)\n",
      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m5.9/5.9 MB\u001b[0m \u001b[31m46.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m00:01\u001b[0m00:01\u001b[0m\n",
      "\u001b[?25hCollecting libclang>=9.0.1\n",
      "  Downloading libclang-14.0.6-py2.py3-none-manylinux2010_x86_64.whl (14.1 MB)\n",
      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m14.1/14.1 MB\u001b[0m \u001b[31m41.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m00:01\u001b[0m00:01\u001b[0m\n",
      "\u001b[?25hRequirement already satisfied: keras-preprocessing>=1.1.1 in /home/jupyterlab/conda/envs/python/lib/python3.7/site-packages (from tensorflow==2.7.0) (1.1.2)\n",
      "Collecting opt-einsum>=2.3.2\n",
      "  Downloading opt_einsum-3.3.0-py3-none-any.whl (65 kB)\n",
      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m65.5/65.5 kB\u001b[0m \u001b[31m8.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
      "\u001b[?25hRequirement already satisfied: grpcio<2.0,>=1.24.3 in /home/jupyterlab/conda/envs/python/lib/python3.7/site-packages (from tensorflow==2.7.0) (1.48.0)\n",
      "Collecting gast<0.5.0,>=0.2.1\n",
      "  Downloading gast-0.4.0-py3-none-any.whl (9.8 kB)\n",
      "Collecting astunparse>=1.6.0\n",
      "  Downloading astunparse-1.6.3-py2.py3-none-any.whl (12 kB)\n",
      "Requirement already satisfied: absl-py>=0.4.0 in /home/jupyterlab/conda/envs/python/lib/python3.7/site-packages (from tensorflow==2.7.0) (1.2.0)\n",
      "Requirement already satisfied: six>=1.12.0 in /home/jupyterlab/conda/envs/python/lib/python3.7/site-packages (from tensorflow==2.7.0) (1.16.0)\n",
      "Requirement already satisfied: termcolor>=1.1.0 in /home/jupyterlab/conda/envs/python/lib/python3.7/site-packages (from tensorflow==2.7.0) (1.1.0)\n",
      "Requirement already satisfied: wrapt>=1.11.0 in /home/jupyterlab/conda/envs/python/lib/python3.7/site-packages (from tensorflow==2.7.0) (1.14.1)\n",
      "Requirement already satisfied: google-pasta>=0.1.1 in /home/jupyterlab/conda/envs/python/lib/python3.7/site-packages (from tensorflow==2.7.0) (0.2.0)\n",
      "Collecting keras<2.8,>=2.7.0rc0\n",
      "  Downloading keras-2.7.0-py2.py3-none-any.whl (1.3 MB)\n",
      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.3/1.3 MB\u001b[0m \u001b[31m49.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
      "\u001b[?25hRequirement already satisfied: protobuf>=3.9.2 in /home/jupyterlab/conda/envs/python/lib/python3.7/site-packages (from tensorflow==2.7.0) (4.21.5)\n",
      "Requirement already satisfied: typing-extensions>=3.6.6 in /home/jupyterlab/conda/envs/python/lib/python3.7/site-packages (from tensorflow==2.7.0) (4.3.0)\n",
      "Collecting h5py>=2.9.0\n",
      "  Downloading h5py-3.7.0-cp37-cp37m-manylinux_2_12_x86_64.manylinux2010_x86_64.whl (4.1 MB)\n",
      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m4.1/4.1 MB\u001b[0m \u001b[31m52.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m00:01\u001b[0m00:01\u001b[0m\n",
      "\u001b[?25hCollecting flatbuffers<3.0,>=1.12\n",
      "  Downloading flatbuffers-2.0.7-py2.py3-none-any.whl (26 kB)\n",
      "Requirement already satisfied: numpy>=1.14.5 in /home/jupyterlab/conda/envs/python/lib/python3.7/site-packages (from tensorflow==2.7.0) (1.21.6)\n",
      "Collecting tensorflow-estimator<2.8,~=2.7.0rc0\n",
      "  Downloading tensorflow_estimator-2.7.0-py2.py3-none-any.whl (463 kB)\n",
      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m463.1/463.1 kB\u001b[0m \u001b[31m37.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
      "\u001b[?25hCollecting tensorboard-plugin-wit>=1.6.0\n",
      "  Downloading tensorboard_plugin_wit-1.8.1-py3-none-any.whl (781 kB)\n",
      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m781.3/781.3 kB\u001b[0m \u001b[31m49.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
      "\u001b[?25hCollecting google-auth-oauthlib<0.5,>=0.4.1\n",
      "  Downloading google_auth_oauthlib-0.4.6-py2.py3-none-any.whl (18 kB)\n",
      "Requirement already satisfied: werkzeug>=1.0.1 in /home/jupyterlab/conda/envs/python/lib/python3.7/site-packages (from tensorboard~=2.6->tensorflow==2.7.0) (2.2.2)\n",
      "Requirement already satisfied: markdown>=2.6.8 in /home/jupyterlab/conda/envs/python/lib/python3.7/site-packages (from tensorboard~=2.6->tensorflow==2.7.0) (3.4.1)\n",
      "Collecting tensorboard-data-server<0.7.0,>=0.6.0\n",
      "  Downloading tensorboard_data_server-0.6.1-py3-none-manylinux2010_x86_64.whl (4.9 MB)\n",
      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m4.9/4.9 MB\u001b[0m \u001b[31m46.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0ma \u001b[36m0:00:01\u001b[0m\n",
      "\u001b[?25hRequirement already satisfied: setuptools>=41.0.0 in /home/jupyterlab/conda/envs/python/lib/python3.7/site-packages (from tensorboard~=2.6->tensorflow==2.7.0) (65.3.0)\n",
      "Requirement already satisfied: requests<3,>=2.21.0 in /home/jupyterlab/conda/envs/python/lib/python3.7/site-packages (from tensorboard~=2.6->tensorflow==2.7.0) (2.28.1)\n",
      "Collecting protobuf>=3.9.2\n",
      "  Downloading protobuf-3.19.4-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (1.1 MB)\n",
      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.1/1.1 MB\u001b[0m \u001b[31m27.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m00:01\u001b[0m\n",
      "\u001b[?25hCollecting google-auth<3,>=1.6.3\n",
      "  Downloading google_auth-2.11.0-py2.py3-none-any.whl (167 kB)\n",
      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m167.2/167.2 kB\u001b[0m \u001b[31m16.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
      "\u001b[?25hRequirement already satisfied: pyasn1-modules>=0.2.1 in /home/jupyterlab/conda/envs/python/lib/python3.7/site-packages (from google-auth<3,>=1.6.3->tensorboard~=2.6->tensorflow==2.7.0) (0.2.8)\n",
      "Collecting cachetools<6.0,>=2.0.0\n",
      "  Downloading cachetools-5.2.0-py3-none-any.whl (9.3 kB)\n",
      "Collecting rsa<5,>=3.1.4\n",
      "  Using cached rsa-4.9-py3-none-any.whl (34 kB)\n",
      "Collecting requests-oauthlib>=0.7.0\n",
      "  Using cached requests_oauthlib-1.3.1-py2.py3-none-any.whl (23 kB)\n",
      "Requirement already satisfied: importlib-metadata>=4.4 in /home/jupyterlab/conda/envs/python/lib/python3.7/site-packages (from markdown>=2.6.8->tensorboard~=2.6->tensorflow==2.7.0) (4.11.4)\n",
      "Requirement already satisfied: charset-normalizer<3,>=2 in /home/jupyterlab/conda/envs/python/lib/python3.7/site-packages (from requests<3,>=2.21.0->tensorboard~=2.6->tensorflow==2.7.0) (2.1.1)\n",
      "Requirement already satisfied: certifi>=2017.4.17 in /home/jupyterlab/conda/envs/python/lib/python3.7/site-packages (from requests<3,>=2.21.0->tensorboard~=2.6->tensorflow==2.7.0) (2022.6.15)\n",
      "Requirement already satisfied: urllib3<1.27,>=1.21.1 in /home/jupyterlab/conda/envs/python/lib/python3.7/site-packages (from requests<3,>=2.21.0->tensorboard~=2.6->tensorflow==2.7.0) (1.26.11)\n",
      "Requirement already satisfied: idna<4,>=2.5 in /home/jupyterlab/conda/envs/python/lib/python3.7/site-packages (from requests<3,>=2.21.0->tensorboard~=2.6->tensorflow==2.7.0) (3.3)\n",
      "Requirement already satisfied: MarkupSafe>=2.1.1 in /home/jupyterlab/conda/envs/python/lib/python3.7/site-packages (from werkzeug>=1.0.1->tensorboard~=2.6->tensorflow==2.7.0) (2.1.1)\n",
      "Requirement already satisfied: zipp>=0.5 in /home/jupyterlab/conda/envs/python/lib/python3.7/site-packages (from importlib-metadata>=4.4->markdown>=2.6.8->tensorboard~=2.6->tensorflow==2.7.0) (3.8.1)\n",
      "Requirement already satisfied: pyasn1<0.5.0,>=0.4.6 in /home/jupyterlab/conda/envs/python/lib/python3.7/site-packages (from pyasn1-modules>=0.2.1->google-auth<3,>=1.6.3->tensorboard~=2.6->tensorflow==2.7.0) (0.4.8)\n",
      "Collecting oauthlib>=3.0.0\n",
      "  Downloading oauthlib-3.2.1-py3-none-any.whl (151 kB)\n",
      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m151.7/151.7 kB\u001b[0m \u001b[31m17.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
      "\u001b[?25hInstalling collected packages: tensorflow-estimator, tensorboard-plugin-wit, libclang, keras, flatbuffers, tensorflow-io-gcs-filesystem, tensorboard-data-server, rsa, protobuf, opt-einsum, oauthlib, h5py, gast, cachetools, astunparse, requests-oauthlib, google-auth, google-auth-oauthlib, tensorboard, tensorflow\n",
      "  Attempting uninstall: tensorflow-estimator\n",
      "    Found existing installation: tensorflow-estimator 1.14.0\n",
      "    Uninstalling tensorflow-estimator-1.14.0:\n",
      "      Successfully uninstalled tensorflow-estimator-1.14.0\n",
      "  Attempting uninstall: keras\n",
      "    Found existing installation: Keras 2.1.6\n",
      "    Uninstalling Keras-2.1.6:\n",
      "      Successfully uninstalled Keras-2.1.6\n",
      "  Attempting uninstall: protobuf\n",
      "    Found existing installation: protobuf 4.21.5\n",
      "    Uninstalling protobuf-4.21.5:\n",
      "      Successfully uninstalled protobuf-4.21.5\n",
      "  Attempting uninstall: h5py\n",
      "    Found existing installation: h5py 2.8.0\n",
      "    Uninstalling h5py-2.8.0:\n",
      "      Successfully uninstalled h5py-2.8.0\n",
      "  Attempting uninstall: gast\n",
      "    Found existing installation: gast 0.5.3\n",
      "    Uninstalling gast-0.5.3:\n",
      "      Successfully uninstalled gast-0.5.3\n",
      "  Attempting uninstall: tensorboard\n",
      "    Found existing installation: tensorboard 1.14.0\n",
      "    Uninstalling tensorboard-1.14.0:\n",
      "      Successfully uninstalled tensorboard-1.14.0\n",
      "  Attempting uninstall: tensorflow\n",
      "    Found existing installation: tensorflow 1.14.0\n",
      "    Uninstalling tensorflow-1.14.0:\n",
      "      Successfully uninstalled tensorflow-1.14.0\n",
      "Successfully installed astunparse-1.6.3 cachetools-5.2.0 flatbuffers-2.0.7 gast-0.4.0 google-auth-2.11.0 google-auth-oauthlib-0.4.6 h5py-3.7.0 keras-2.7.0 libclang-14.0.6 oauthlib-3.2.1 opt-einsum-3.3.0 protobuf-3.19.4 requests-oauthlib-1.3.1 rsa-4.9 tensorboard-2.10.0 tensorboard-data-server-0.6.1 tensorboard-plugin-wit-1.8.1 tensorflow-2.7.0 tensorflow-estimator-2.7.0 tensorflow-io-gcs-filesystem-0.27.0\n"
     ]
    }
   ],
   "source": [
    "!pip install tensorflow==2.7.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and import required libraries:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import tensorflow as tf\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from tensorflow import keras\n",
    "from tensorflow.keras import layers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# also set a random state\n",
    "rs = 123"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Load and processing rating dataset\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "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>user</th>\n",
       "      <th>item</th>\n",
       "      <th>rating</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1889878</td>\n",
       "      <td>CC0101EN</td>\n",
       "      <td>3.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1342067</td>\n",
       "      <td>CL0101EN</td>\n",
       "      <td>3.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1990814</td>\n",
       "      <td>ML0120ENv3</td>\n",
       "      <td>3.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>380098</td>\n",
       "      <td>BD0211EN</td>\n",
       "      <td>3.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>779563</td>\n",
       "      <td>DS0101EN</td>\n",
       "      <td>3.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      user        item  rating\n",
       "0  1889878    CC0101EN     3.0\n",
       "1  1342067    CL0101EN     3.0\n",
       "2  1990814  ML0120ENv3     3.0\n",
       "3   380098    BD0211EN     3.0\n",
       "4   779563    DS0101EN     3.0"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rating_url = \"https://cf-courses-data.s3.us.cloud-object-storage.appdomain.cloud/IBM-ML321EN-SkillsNetwork/labs/datasets/ratings.csv\"\n",
    "rating_df = pd.read_csv(rating_url)\n",
    "rating_df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is the same rating dataset we have been using in previous lab, which contains the three main columns: `user`, `item`, and `rating`.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, let's figure out how many unique users and items, their total numbers will determine the sizes of one-hot encoding vectors.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "There are total `33901` of users and `126` items\n"
     ]
    }
   ],
   "source": [
    "num_users = len(rating_df['user'].unique())\n",
    "num_items = len(rating_df['item'].unique())\n",
    "print(f\"There are total `{num_users}` of users and `{num_items}` items\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It means our each user can be represented as a `33901 x 1` one-hot vector and each item can be represented as `126 x 1` one-hot vector.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The goal is to create a neural network structure that can take the user and item one-hot vectors as inputs and outputs a rating estimation or the probability of interaction (such as the probability of completing a course).\n",
    "\n",
    "While training and updating the weights in the neural network, its hidden layers should be able to capture the pattern or features for each user and item. Based on this idea, we can design a simple neural network architecture like the following:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](https://cf-courses-data.s3.us.cloud-object-storage.appdomain.cloud/IBM-ML321EN-SkillsNetwork/labs/module\\_4/images/embedding_feature_vector.png)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The network inputs are two one-hot encoding vectors, the blue one is for the user and the green one is for the item. Then on top of them, we added two embedding layers. Here embedding means embedding the one-hot encoding vector into a latent feature space. The embedding layer is a fully-connected layer that outputs the embedding feature vectors. For example, the user embedding layer takes `33901 x 1` one-hot vector as input and outputs a `16 x 1` embedding vector.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The embedding layer outputs two embedding vectors, which are similar to Non-negative matrix factorization. Then we could simply dot the product the user and item embedding vector to output a rating estimation.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Implementing the recommender neural network using tensorflow\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This network architecture could be defined and implemented as a sub-class inheriting the `tensorflow.keras.Model` super class, let's call it `RecommenderNet()`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class RecommenderNet(keras.Model):\n",
    "    \n",
    "    def __init__(self, num_users, num_items, embedding_size=16, **kwargs):\n",
    "        \"\"\"\n",
    "           Constructor\n",
    "           :param int num_users: number of users\n",
    "           :param int num_items: number of items\n",
    "           :param int embedding_size: the size of embedding vector\n",
    "        \"\"\"\n",
    "        super(RecommenderNet, self).__init__(**kwargs)\n",
    "        self.num_users = num_users\n",
    "        self.num_items = num_items\n",
    "        self.embedding_size = embedding_size\n",
    "        \n",
    "        # Define a user_embedding vector\n",
    "        # Input dimension is the num_users\n",
    "        # Output dimension is the embedding size\n",
    "        self.user_embedding_layer = layers.Embedding(\n",
    "            input_dim=num_users,\n",
    "            output_dim=embedding_size,\n",
    "            name='user_embedding_layer',\n",
    "            embeddings_initializer=\"he_normal\",\n",
    "            embeddings_regularizer=keras.regularizers.l2(1e-6),\n",
    "        )\n",
    "        # Define a user bias layer\n",
    "        self.user_bias = layers.Embedding(\n",
    "            input_dim=num_users,\n",
    "            output_dim=1,\n",
    "            name=\"user_bias\")\n",
    "        \n",
    "        # Define an item_embedding vector\n",
    "        # Input dimension is the num_items\n",
    "        # Output dimension is the embedding size\n",
    "        self.item_embedding_layer = layers.Embedding(\n",
    "            input_dim=num_items,\n",
    "            output_dim=embedding_size,\n",
    "            name='item_embedding_layer',\n",
    "            embeddings_initializer=\"he_normal\",\n",
    "            embeddings_regularizer=keras.regularizers.l2(1e-6),\n",
    "        )\n",
    "        # Define an item bias layer\n",
    "        self.item_bias = layers.Embedding(\n",
    "            input_dim=num_items,\n",
    "            output_dim=1,\n",
    "            name=\"item_bias\")\n",
    "        \n",
    "    def call(self, inputs):\n",
    "        \"\"\"\n",
    "           method to be called during model fitting\n",
    "           \n",
    "           :param inputs: user and item one-hot vectors\n",
    "        \"\"\"\n",
    "        # Compute the user embedding vector\n",
    "        user_vector = self.user_embedding_layer(inputs[:, 0])\n",
    "        user_bias = self.user_bias(inputs[:, 0])\n",
    "        item_vector = self.item_embedding_layer(inputs[:, 1])\n",
    "        item_bias = self.item_bias(inputs[:, 1])\n",
    "        dot_user_item = tf.tensordot(user_vector, item_vector, 2)\n",
    "        # Add all the components (including bias)\n",
    "        x = dot_user_item + user_bias + item_bias\n",
    "        # Sigmoid output layer to output the probability\n",
    "        return tf.nn.relu(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### TASK: Train and evaluate the RecommenderNet()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now it's time to train and evaluate the defined `RecommenderNet()`. First, we need to process the original rating dataset a little bit by converting the actual user ids and item ids into integer indices for `tensorflow` to creating the one-hot encoding vectors.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def process_dataset(raw_data):\n",
    "    \n",
    "    encoded_data = raw_data.copy()\n",
    "    \n",
    "    # Mapping user ids to indices\n",
    "    user_list = encoded_data[\"user\"].unique().tolist()\n",
    "    user_id2idx_dict = {x: i for i, x in enumerate(user_list)}\n",
    "    user_idx2id_dict = {i: x for i, x in enumerate(user_list)}\n",
    "    \n",
    "    # Mapping course ids to indices\n",
    "    course_list = encoded_data[\"item\"].unique().tolist()\n",
    "    course_id2idx_dict = {x: i for i, x in enumerate(course_list)}\n",
    "    course_idx2id_dict = {i: x for i, x in enumerate(course_list)}\n",
    "\n",
    "    # Convert original user ids to idx\n",
    "    encoded_data[\"user\"] = encoded_data[\"user\"].map(user_id2idx_dict)\n",
    "    # Convert original course ids to idx\n",
    "    encoded_data[\"item\"] = encoded_data[\"item\"].map(course_id2idx_dict)\n",
    "    # Convert rating to int\n",
    "    encoded_data[\"rating\"] = encoded_data[\"rating\"].values.astype(\"int\")\n",
    "\n",
    "    return encoded_data, user_idx2id_dict, course_idx2id_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "encoded_data, user_idx2id_dict, course_idx2id_dict = process_dataset(rating_df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "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>user</th>\n",
       "      <th>item</th>\n",
       "      <th>rating</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2</td>\n",
       "      <td>2</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>3</td>\n",
       "      <td>3</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>4</td>\n",
       "      <td>4</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   user  item  rating\n",
       "0     0     0       3\n",
       "1     1     1       3\n",
       "2     2     2       3\n",
       "3     3     3       3\n",
       "4     4     4       3"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "encoded_data.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then we can split the encoded dataset into training and testing datasets.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_train_test_datasets(dataset, scale=True):\n",
    "\n",
    "    min_rating = min(dataset[\"rating\"])\n",
    "    max_rating = max(dataset[\"rating\"])\n",
    "\n",
    "    dataset = dataset.sample(frac=1, random_state=42)\n",
    "    x = dataset[[\"user\", \"item\"]].values\n",
    "    if scale:\n",
    "        y = dataset[\"rating\"].apply(lambda x: (x - min_rating) / (max_rating - min_rating)).values\n",
    "    else:\n",
    "        y = dataset[\"rating\"].values\n",
    "\n",
    "    # Assuming training on 80% of the data and validating on 10%, and testing 10%\n",
    "    train_indices = int(0.8 * dataset.shape[0])\n",
    "    test_indices = int(0.9 * dataset.shape[0])\n",
    "\n",
    "    x_train, x_val, x_test, y_train, y_val, y_test = (\n",
    "        x[:train_indices],\n",
    "        x[train_indices:test_indices],\n",
    "        x[test_indices:],\n",
    "        y[:train_indices],\n",
    "        y[train_indices:test_indices],\n",
    "        y[test_indices:],\n",
    "    )\n",
    "    return x_train, x_val, x_test, y_train, y_val, y_test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_train, x_val, x_test, y_train, y_val, y_test = generate_train_test_datasets(encoded_data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we take a look at the training input data, it is simply just a list of user indices and item indices, which is a dense format of one-hot encoding vectors.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 8376,  7659, 10717, ...,  3409, 28761,  4973], dtype=int64)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "user_indices = x_train[:, 0]\n",
    "user_indices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([12, 29,  3, ..., 18, 19, 17], dtype=int64)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "item_indices = x_train[:, 1]\n",
    "item_indices"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and training output labels are a list of 0s and 1s indicating if the user has completed a course or not.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[16103,    27],\n",
       "       [17742,    30],\n",
       "       [31855,    81],\n",
       "       ...,\n",
       "       [ 2999,    66],\n",
       "       [11082,    56],\n",
       "       [ 4824,     4]], dtype=int64)"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[16053,    27],\n",
       "       [ 2715,    62],\n",
       "       [21019,     9],\n",
       "       ...,\n",
       "       [ 2246,    37],\n",
       "       [ 4799,   100],\n",
       "       [17814,     4]], dtype=int64)"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_val"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1., 1., 1., ..., 1., 0., 1.])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_train"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then we can choose a small embedding vector size to be 16 and create a `RecommenderNet()` model to be trained\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "embedding_size = 16\n",
    "model = RecommenderNet(num_users, num_items, embedding_size)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*TODO: Train the RecommenderNet() model*\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "def call(self, inputs):\n",
    "    \"\"\"\n",
    "    Method to be called during model fitting\n",
    "       \n",
    "    :param inputs: Tuple of user and item indices tensors\n",
    "    \"\"\"\n",
    "    # Split the inputs tuple\n",
    "    user_indices = inputs[0]\n",
    "    item_indices = inputs[1]\n",
    "    \n",
    "    # Compute the user embedding vector\n",
    "    user_vector = self.user_embedding_layer(user_indices[:, 0])\n",
    "    user_bias = self.user_bias(user_indices[:, 0])\n",
    "    \n",
    "    # Compute the item embedding vector\n",
    "    item_vector = self.item_embedding_layer(item_indices[:, 0])\n",
    "    item_bias = self.item_bias(item_indices[:, 0])\n",
    "    \n",
    "    # Compute the dot product of user and item vectors\n",
    "    dot_user_item = tf.reduce_sum(tf.multiply(user_vector, item_vector), axis=1, keepdims=True)\n",
    "    \n",
    "    # Add biases\n",
    "    x = dot_user_item + user_bias + item_bias\n",
    "    \n",
    "    # Apply ReLU activation\n",
    "    return tf.nn.relu(x)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/10\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1m2917/2917\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m24s\u001b[0m 7ms/step - loss: 0.2943 - root_mean_squared_error: 0.5148 - val_loss: 0.0435 - val_root_mean_squared_error: 0.2072\n",
      "Epoch 2/10\n",
      "\u001b[1m2917/2917\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m19s\u001b[0m 7ms/step - loss: 0.0430 - root_mean_squared_error: 0.2052 - val_loss: 0.0337 - val_root_mean_squared_error: 0.1815\n",
      "Epoch 3/10\n",
      "\u001b[1m2917/2917\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m19s\u001b[0m 7ms/step - loss: 0.0277 - root_mean_squared_error: 0.1638 - val_loss: 0.0264 - val_root_mean_squared_error: 0.1594\n",
      "Epoch 4/10\n",
      "\u001b[1m2917/2917\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m20s\u001b[0m 7ms/step - loss: 0.0214 - root_mean_squared_error: 0.1426 - val_loss: 0.0225 - val_root_mean_squared_error: 0.1460\n",
      "Epoch 5/10\n",
      "\u001b[1m2917/2917\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m20s\u001b[0m 7ms/step - loss: 0.0179 - root_mean_squared_error: 0.1291 - val_loss: 0.0210 - val_root_mean_squared_error: 0.1400\n",
      "Epoch 6/10\n",
      "\u001b[1m2917/2917\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m20s\u001b[0m 7ms/step - loss: 0.0150 - root_mean_squared_error: 0.1167 - val_loss: 0.0195 - val_root_mean_squared_error: 0.1345\n",
      "Epoch 7/10\n",
      "\u001b[1m2917/2917\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m20s\u001b[0m 7ms/step - loss: 0.0135 - root_mean_squared_error: 0.1098 - val_loss: 0.0185 - val_root_mean_squared_error: 0.1303\n",
      "Epoch 8/10\n",
      "\u001b[1m2917/2917\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m20s\u001b[0m 7ms/step - loss: 0.0121 - root_mean_squared_error: 0.1026 - val_loss: 0.0179 - val_root_mean_squared_error: 0.1275\n",
      "Epoch 9/10\n",
      "\u001b[1m2917/2917\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m20s\u001b[0m 7ms/step - loss: 0.0108 - root_mean_squared_error: 0.0957 - val_loss: 0.0171 - val_root_mean_squared_error: 0.1242\n",
      "Epoch 10/10\n",
      "\u001b[1m2917/2917\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m20s\u001b[0m 7ms/step - loss: 0.0098 - root_mean_squared_error: 0.0898 - val_loss: 0.0166 - val_root_mean_squared_error: 0.1221\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "## WRITE YOUR CODE HERE:\n",
    "\n",
    "## - call model.compile() method to set up the loss and optimizer and metrics for the model training, you may use\n",
    "##  - - tf.keras.losses.MeanSquaredError() as training loss\n",
    "##  - - keras.optimizers.Adam() as optimizer\n",
    "##  - - tf.keras.metrics.RootMeanSquaredError() as metric\n",
    "\n",
    "## - call model.fit() to train the model\n",
    "\n",
    "## - optionally call model.save() to save the model\n",
    "\n",
    "## - plot the train and validation loss\n",
    "\n",
    "# Define the embedding size\n",
    "embedding_size = 16\n",
    "\n",
    "# Create the RecommenderNet model\n",
    "model = RecommenderNet(num_users, num_items, embedding_size)\n",
    "\n",
    "# Compile the model\n",
    "model.compile(loss=tf.keras.losses.MeanSquaredError(),\n",
    "              optimizer=keras.optimizers.Adam(),\n",
    "              metrics=[tf.keras.metrics.RootMeanSquaredError()])\n",
    "\n",
    "# Train the model\n",
    "history = model.fit(x=x_train, y=y_train,\n",
    "                    validation_data=(x_val, y_val),\n",
    "                    epochs=10, batch_size=64, verbose=1)\n",
    "\n",
    "\n",
    "# Optionally, save the model\n",
    "# model.save(\"recommender_model.h5\")\n",
    "\n",
    "# Plot the train and validation loss\n",
    "plt.plot(history.history[\"loss\"], label=\"Train Loss\")\n",
    "plt.plot(history.history[\"val_loss\"], label=\"Validation Loss\")\n",
    "plt.xlabel(\"Epoch\")\n",
    "plt.ylabel(\"Loss\")\n",
    "plt.title(\"Train and Validation Loss\")\n",
    "plt.legend()\n",
    "plt.show()\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*TODO:* Evaluate the trained model\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1m 35/730\u001b[0m \u001b[37m━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[1m1s\u001b[0m 1ms/step - loss: 0.0174 - root_mean_squared_error: 0.1248  "
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1m730/730\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 1ms/step - loss: 0.0163 - root_mean_squared_error: 0.1205\n",
      "Test Loss: 0.015951082110404968\n",
      "Test RMSE: 0.11930131912231445\n"
     ]
    }
   ],
   "source": [
    "### WRITE YOUR CODE HERE\n",
    "### - call model.evaluate() to evaluate the model\n",
    "# Evaluate the model\n",
    "test_loss, test_rmse = model.evaluate(x=x_test, y=y_test)\n",
    "\n",
    "print(\"Test Loss:\", test_loss)\n",
    "print(\"Test RMSE:\", test_rmse)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Extract the user and item embedding vectors as latent feature vectors\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, we have trained the `RecommenderNet()` model and it can predict the ratings with relatively small RMSE.\n",
    "\n",
    "If we print the trained model then we can see its layers and their parameters/weights.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\">Model: \"recommender_net_11\"</span>\n",
       "</pre>\n"
      ],
      "text/plain": [
       "\u001b[1mModel: \"recommender_net_11\"\u001b[0m\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\">┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n",
       "┃<span style=\"font-weight: bold\"> Layer (type)                    </span>┃<span style=\"font-weight: bold\"> Output Shape           </span>┃<span style=\"font-weight: bold\">       Param # </span>┃\n",
       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n",
       "│ user_embedding_layer            │ ?                      │       <span style=\"color: #00af00; text-decoration-color: #00af00\">542,416</span> │\n",
       "│ (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Embedding</span>)                     │                        │               │\n",
       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
       "│ user_bias (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Embedding</span>)           │ ?                      │        <span style=\"color: #00af00; text-decoration-color: #00af00\">33,901</span> │\n",
       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
       "│ item_embedding_layer            │ ?                      │         <span style=\"color: #00af00; text-decoration-color: #00af00\">2,016</span> │\n",
       "│ (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Embedding</span>)                     │                        │               │\n",
       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
       "│ item_bias (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Embedding</span>)           │ ?                      │           <span style=\"color: #00af00; text-decoration-color: #00af00\">126</span> │\n",
       "└─────────────────────────────────┴────────────────────────┴───────────────┘\n",
       "</pre>\n"
      ],
      "text/plain": [
       "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n",
       "┃\u001b[1m \u001b[0m\u001b[1mLayer (type)                   \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mOutput Shape          \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m      Param #\u001b[0m\u001b[1m \u001b[0m┃\n",
       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n",
       "│ user_embedding_layer            │ ?                      │       \u001b[38;5;34m542,416\u001b[0m │\n",
       "│ (\u001b[38;5;33mEmbedding\u001b[0m)                     │                        │               │\n",
       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
       "│ user_bias (\u001b[38;5;33mEmbedding\u001b[0m)           │ ?                      │        \u001b[38;5;34m33,901\u001b[0m │\n",
       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
       "│ item_embedding_layer            │ ?                      │         \u001b[38;5;34m2,016\u001b[0m │\n",
       "│ (\u001b[38;5;33mEmbedding\u001b[0m)                     │                        │               │\n",
       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
       "│ item_bias (\u001b[38;5;33mEmbedding\u001b[0m)           │ ?                      │           \u001b[38;5;34m126\u001b[0m │\n",
       "└─────────────────────────────────┴────────────────────────┴───────────────┘\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Total params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">1,735,379</span> (6.62 MB)\n",
       "</pre>\n"
      ],
      "text/plain": [
       "\u001b[1m Total params: \u001b[0m\u001b[38;5;34m1,735,379\u001b[0m (6.62 MB)\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Trainable params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">578,459</span> (2.21 MB)\n",
       "</pre>\n"
      ],
      "text/plain": [
       "\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m578,459\u001b[0m (2.21 MB)\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Non-trainable params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> (0.00 B)\n",
       "</pre>\n"
      ],
      "text/plain": [
       "\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m0\u001b[0m (0.00 B)\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Optimizer params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">1,156,920</span> (4.41 MB)\n",
       "</pre>\n"
      ],
      "text/plain": [
       "\u001b[1m Optimizer params: \u001b[0m\u001b[38;5;34m1,156,920\u001b[0m (4.41 MB)\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "model.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the `RecommenderNet`, the `user_embedding_layer` and `item_embedding_layer` layers contain the trained weights. Essentially, they are the latent user and item features learned by `RecommenderNet` and will be used to predict the interaction. As such, while training the neural network to predict rating, the embedding layers are simultaneously trained to extract the embedding user and item features.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can easily get the actual weights using `model.get_layer().get_weights()` methods\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "User features shape: (33901, 16)\n"
     ]
    }
   ],
   "source": [
    "# User features\n",
    "user_latent_features = model.get_layer('user_embedding_layer').get_weights()[0]\n",
    "print(f\"User features shape: {user_latent_features.shape}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.15163654, -0.10307053,  0.06807988, -0.00506921, -0.08192259,\n",
       "       -0.05915001,  0.10078707,  0.02655453,  0.10344388,  0.01446066,\n",
       "        0.0097742 ,  0.04317766, -0.05590243,  0.14854746,  0.02034351,\n",
       "        0.06593837], dtype=float32)"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "user_latent_features[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Item features shape: (126, 16)\n"
     ]
    }
   ],
   "source": [
    "item_latent_features = model.get_layer('item_embedding_layer').get_weights()[0]\n",
    "print(f\"Item features shape: {item_latent_features.shape}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-7.77874654e-03,  7.09496858e-03,  1.37114357e-02,  2.62278627e-04,\n",
       "       -1.25620235e-02,  2.54252125e-02,  1.62382089e-02,  1.41896761e-03,\n",
       "       -1.15355477e-02,  1.09473933e-02, -1.58534814e-02,  5.33819478e-03,\n",
       "        2.61505076e-04, -8.66310205e-03, -4.46607446e-05,  1.98148992e-02],\n",
       "      dtype=float32)"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "item_latent_features[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, each user of the total 33901 users has been transformed into a 16 x 1 latent feature vector and each item of the total 126 has been transformed into a 16 x 1 latent feature vector.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### TASK (Optional): Customize the RecommenderNet to potentially improve the model performance\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The pre-defined `RecommenderNet()` is a actually very basic neural network, you are encouraged to customize it to see if model prediction performance will be improved. Here are some directions:\n",
    "\n",
    "*   Hyperparameter tuning, such as the embedding layer dimensions\n",
    "*   Add more hidden layers\n",
    "*   Try different activation functions such as `ReLu`\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/10\n",
      "\u001b[1m2917/2917\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 10ms/step - loss: 0.0683 - root_mean_squared_error: 0.2404 - val_loss: 0.0164 - val_root_mean_squared_error: 0.1281\n",
      "Epoch 2/10\n",
      "\u001b[1m2917/2917\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 10ms/step - loss: 0.0035 - root_mean_squared_error: 0.0588 - val_loss: 0.0162 - val_root_mean_squared_error: 0.1274\n",
      "Epoch 3/10\n",
      "\u001b[1m2917/2917\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 10ms/step - loss: 6.6445e-04 - root_mean_squared_error: 0.0257 - val_loss: 0.0168 - val_root_mean_squared_error: 0.1295\n",
      "Epoch 4/10\n",
      "\u001b[1m2917/2917\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 10ms/step - loss: 3.4962e-04 - root_mean_squared_error: 0.0186 - val_loss: 0.0195 - val_root_mean_squared_error: 0.1398\n",
      "Epoch 5/10\n",
      "\u001b[1m2917/2917\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 10ms/step - loss: 5.3753e-04 - root_mean_squared_error: 0.0230 - val_loss: 0.0193 - val_root_mean_squared_error: 0.1388\n",
      "Epoch 6/10\n",
      "\u001b[1m2917/2917\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 10ms/step - loss: 7.2274e-04 - root_mean_squared_error: 0.0267 - val_loss: 0.0203 - val_root_mean_squared_error: 0.1424\n",
      "Epoch 7/10\n",
      "\u001b[1m2917/2917\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 10ms/step - loss: 0.0012 - root_mean_squared_error: 0.0347 - val_loss: 0.0204 - val_root_mean_squared_error: 0.1429\n",
      "Epoch 8/10\n",
      "\u001b[1m2917/2917\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 10ms/step - loss: 0.0015 - root_mean_squared_error: 0.0383 - val_loss: 0.0224 - val_root_mean_squared_error: 0.1499\n",
      "Epoch 9/10\n",
      "\u001b[1m2917/2917\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 11ms/step - loss: 0.0014 - root_mean_squared_error: 0.0368 - val_loss: 0.0218 - val_root_mean_squared_error: 0.1477\n",
      "Epoch 10/10\n",
      "\u001b[1m2917/2917\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 10ms/step - loss: 9.4201e-04 - root_mean_squared_error: 0.0306 - val_loss: 0.0228 - val_root_mean_squared_error: 0.1512\n",
      "\u001b[1m730/730\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 945us/step - loss: 0.0234 - root_mean_squared_error: 0.1529\n",
      "Test Loss: 0.023513315245509148\n",
      "Test RMSE: 0.15343578159809113\n"
     ]
    }
   ],
   "source": [
    "## WRITE YOUR CODE HERE\n",
    "\n",
    "## Update RecommenderNet() class\n",
    "\n",
    "## compile and fit the updated model\n",
    "\n",
    "## evaluate the updated model\n",
    "\n",
    "class CustomRecommenderNet(tf.keras.Model):\n",
    "    def __init__(self, num_users, num_items, embedding_size, hidden_units):\n",
    "        super(CustomRecommenderNet, self).__init__()\n",
    "        \n",
    "        self.user_embedding_layer = layers.Embedding(num_users, embedding_size)\n",
    "        self.user_bias = layers.Embedding(num_users, 1)\n",
    "        \n",
    "        self.item_embedding_layer = layers.Embedding(num_items, embedding_size)\n",
    "        self.item_bias = layers.Embedding(num_items, 1)\n",
    "        \n",
    "        self.hidden_layers = [layers.Dense(units, activation='relu') for units in hidden_units]\n",
    "        \n",
    "        self.output_layer = layers.Dense(1)\n",
    "        \n",
    "    def call(self, inputs):\n",
    "        user_indices, item_indices = inputs\n",
    "        \n",
    "        user_vector = self.user_embedding_layer(user_indices)\n",
    "        user_bias = self.user_bias(user_indices)\n",
    "        \n",
    "        item_vector = self.item_embedding_layer(item_indices)\n",
    "        item_bias = self.item_bias(item_indices)\n",
    "        \n",
    "        dot_user_item = tf.reduce_sum(tf.multiply(user_vector, item_vector), axis=1, keepdims=True)\n",
    "        \n",
    "        x = dot_user_item + user_bias + item_bias\n",
    "        \n",
    "        for layer in self.hidden_layers:\n",
    "            x = layer(x)\n",
    "        \n",
    "        return self.output_layer(x)\n",
    "\n",
    "# Define hyperparameters\n",
    "embedding_size = 32\n",
    "hidden_units = [64, 32]\n",
    "\n",
    "# Create the custom model\n",
    "custom_model = CustomRecommenderNet(num_users, num_items, embedding_size, hidden_units)\n",
    "\n",
    "# Compile the model\n",
    "custom_model.compile(loss=tf.keras.losses.MeanSquaredError(),\n",
    "                     optimizer=tf.keras.optimizers.Adam(),\n",
    "                     metrics=[tf.keras.metrics.RootMeanSquaredError()])\n",
    "\n",
    "# Train the model\n",
    "custom_history = custom_model.fit(x=[x_train[:, 0], x_train[:, 1]], y=y_train,\n",
    "                                  validation_data=([x_val[:, 0], x_val[:, 1]], y_val),\n",
    "                                  epochs=10, batch_size=64, verbose=1)\n",
    "\n",
    "# Evaluate the model\n",
    "test_loss, test_rmse = custom_model.evaluate(x=[x_test[:, 0], x_test[:, 1]], y=y_test)\n",
    "print(\"Test Loss:\", test_loss)\n",
    "print(\"Test RMSE:\", test_rmse)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test RMSE: 0.1534\n"
     ]
    }
   ],
   "source": [
    "print(f\"Test RMSE: {test_rmse:.4f}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# List model dan RMSE\n",
    "models = ['KNN', 'NMF', 'Neural Network']\n",
    "rmse_values = [0.2063, 0.2048, 0.1534]\n",
    "\n",
    "# Plot\n",
    "plt.figure(figsize=(8, 6))\n",
    "plt.bar(models, rmse_values, color=['blue', 'green', 'orange'])\n",
    "plt.xlabel('Recommender Systems')\n",
    "plt.ylabel('RMSE')\n",
    "plt.title('Comparison of Collaborative Filtering Models')\n",
    "plt.ylim(0, 0.25)\n",
    "\n",
    "# Tampilkan nilai RMSE di atas tiap bar\n",
    "for i in range(len(models)):\n",
    "    plt.text(i, rmse_values[i] + 0.01, str(rmse_values[i]), ha='center')\n",
    "\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Comparison of Collaborative Filtering Models\n",
    "\n",
    "We compared the performance of three collaborative filtering models: KNN-based recommender system, NMF-based recommender system, and Neural Network Embedding-based recommender system.\n",
    "\n",
    "### Results:\n",
    "\n",
    "- **KNN-based Recommender System**: RMSE = 0.2063\n",
    "- **NMF-based Recommender System**: RMSE = 0.2048\n",
    "- **Neural Network Embedding-based Recommender System**: RMSE = 0.1534\n",
    "\n",
    "Based on the evaluation results, the Neural Network Embedding-based recommender system achieved the lowest RMSE value of 0.1534, indicating the best performance among the three models in predicting user-item interactions. Therefore, we consider the Neural Network Embedding-based recommender system to be the most effective model for collaborative filtering in this scenario.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Summary\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this lab, you have learned and practiced predicting course ratings using neural networks. With a predefined and trained neural network, we can extract or embed users and items into latent feature spaces and further predict the interaction between a user and an item with the latent feature vectors.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Authors\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Yan Luo](https://www.linkedin.com/in/yan-luo-96288783/?utm_medium=Exinfluencer&utm_source=Exinfluencer&utm_content=000026UJ&utm_term=10006555&utm_id=NA-SkillsNetwork-Channel-SkillsNetworkCoursesIBMML321ENSkillsNetwork32585014-2022-01-01)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Other Contributors\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Change Log\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "| Date (YYYY-MM-DD) | Version | Changed By | Change Description          |\n",
    "| ----------------- | ------- | ---------- | --------------------------- |\n",
    "| 2021-10-25        | 1.0     | Yan        | Created the initial version |\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Copyright © 2021 IBM Corporation. All rights reserved.\n"
   ]
  }
 ],
 "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.12.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}