NCF.ipynb

{
  "cells": [
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6vuy068Ew8n5",
        "outputId": "07febe74-52c8-43f2-d194-e083926d4c3c"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "--2022-09-21 20:47:14--  http://files.grouplens.org/datasets/movielens/ml-latest-small.zip\n",
            "Resolving files.grouplens.org (files.grouplens.org)... 128.101.65.152\n",
            "Connecting to files.grouplens.org (files.grouplens.org)|128.101.65.152|:80... connected.\n",
            "HTTP request sent, awaiting response... 200 OK\n",
            "Length: 978202 (955K) [application/zip]\n",
            "Saving to: ‘ml-latest-small.zip’\n",
            "\n",
            "ml-latest-small.zip 100%[===================>] 955.28K  --.-KB/s    in 0.1s    \n",
            "\n",
            "2022-09-21 20:47:14 (6.59 MB/s) - ‘ml-latest-small.zip’ saved [978202/978202]\n",
            "\n",
            "Archive:  ml-latest-small.zip\n",
            "   creating: ml-latest-small/\n",
            "  inflating: ml-latest-small/links.csv  \n",
            "  inflating: ml-latest-small/tags.csv  \n",
            "  inflating: ml-latest-small/ratings.csv  \n",
            "  inflating: ml-latest-small/README.txt  \n",
            "  inflating: ml-latest-small/movies.csv  \n",
            "--2022-09-21 20:47:14--  http://www2.informatik.uni-freiburg.de/~cziegler/BX/BX-CSV-Dump.zip\n",
            "Resolving www2.informatik.uni-freiburg.de (www2.informatik.uni-freiburg.de)... 132.230.105.133\n",
            "Connecting to www2.informatik.uni-freiburg.de (www2.informatik.uni-freiburg.de)|132.230.105.133|:80... connected.\n",
            "HTTP request sent, awaiting response... 200 OK\n",
            "Length: 26085508 (25M) [application/zip]\n",
            "Saving to: ‘BX-CSV-Dump.zip’\n",
            "\n",
            "BX-CSV-Dump.zip     100%[===================>]  24.88M  17.8MB/s    in 1.4s    \n",
            "\n",
            "2022-09-21 20:47:16 (17.8 MB/s) - ‘BX-CSV-Dump.zip’ saved [26085508/26085508]\n",
            "\n",
            "Archive:  BX-CSV-Dump.zip\n",
            "  inflating: BX-Book-Ratings.csv     \n",
            "  inflating: BX-Books.csv            \n",
            "  inflating: BX-Users.csv            \n"
          ]
        }
      ],
      "source": [
        "# Downloading the movielens datasets and Book-Crossing Dataset\n",
        "\n",
        "# Movielens Dataset\n",
        "!wget http://files.grouplens.org/datasets/movielens/ml-latest-small.zip\n",
        "!unzip ml-latest-small.zip\n",
        "# Book-Crossing Dataset\n",
        "!wget http://www2.informatik.uni-freiburg.de/~cziegler/BX/BX-CSV-Dump.zip\n",
        "!unzip BX-CSV-Dump.zip"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "X8iEuxC44KU-"
      },
      "outputs": [],
      "source": [
        "# Importing reuired packages\n",
        "import pandas as pd\n",
        "import numpy as np\n",
        "import tensorflow as tf\n",
        "import torch\n",
        "from tensorflow import keras\n",
        "from tensorflow.keras import layers\n",
        "from keras.models import Model\n",
        "from keras.layers import Dense, Dropout, merge\n",
        "import pickle\n",
        "import matplotlib.pyplot as plt\n",
        "%matplotlib inline"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "RgPwL4E14N7v"
      },
      "outputs": [],
      "source": [
        "# Reading required files\n",
        "ratings = pd.read_csv(\"ml-latest-small/ratings.csv\")\n",
        "movies = pd.read_csv(\"ml-latest-small/movies.csv\")\n",
        "book_rating_data = pd.read_csv(\"BX-Book-Ratings.csv\", encoding='latin1', sep=';')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IAR0MWhI4Qwo",
        "outputId": "993b601d-3bbb-451c-c6e8-8ee0a6b458d2"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "   userId  movieId  rating  timestamp\n",
            "0       1        1     4.0  964982703\n",
            "1       1        3     4.0  964981247\n",
            "2       1        6     4.0  964982224\n",
            "3       1       47     5.0  964983815\n",
            "4       1       50     5.0  964982931\n",
            "   movieId                               title  \\\n",
            "0        1                    Toy Story (1995)   \n",
            "1        2                      Jumanji (1995)   \n",
            "2        3             Grumpier Old Men (1995)   \n",
            "3        4            Waiting to Exhale (1995)   \n",
            "4        5  Father of the Bride Part II (1995)   \n",
            "\n",
            "                                        genres  \n",
            "0  Adventure|Animation|Children|Comedy|Fantasy  \n",
            "1                   Adventure|Children|Fantasy  \n",
            "2                               Comedy|Romance  \n",
            "3                         Comedy|Drama|Romance  \n",
            "4                                       Comedy  \n",
            "   User-ID        ISBN  Book-Rating\n",
            "0   276725  034545104X            0\n",
            "1   276726  0155061224            5\n",
            "2   276727  0446520802            0\n",
            "3   276729  052165615X            3\n",
            "4   276729  0521795028            6\n"
          ]
        }
      ],
      "source": [
        "# Snapshot of the loaded dataset\n",
        "print(ratings.head())\n",
        "print(movies.head())\n",
        "print(book_rating_data.head())"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "j9gs5BNY5ffi"
      },
      "outputs": [],
      "source": [
        "# Function to create index on the basis of user-id and item-id\n",
        "def user_item_index(col):\n",
        "  user_item_ids = col.unique().tolist()\n",
        "  user_item_idx = {x: i for i, x in enumerate(user_item_ids)}\n",
        "  idx_user_item = {i: x for i, x in enumerate(user_item_ids)}\n",
        "  return user_item_idx"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "j7x87u6N5imp"
      },
      "outputs": [],
      "source": [
        "# Implementing the indexing function on user-id and item-id\n",
        "ratings[\"user\"] = ratings[\"userId\"].map(user_item_index(ratings[\"userId\"]))\n",
        "ratings[\"item\"] = ratings[\"movieId\"].map(user_item_index(ratings[\"movieId\"]))\n",
        "\n",
        "\n",
        "book_rating_data[\"user\"] = book_rating_data[\"User-ID\"].map(user_item_index(book_rating_data[\"User-ID\"]))\n",
        "book_rating_data[\"item\"] = book_rating_data[\"ISBN\"].map(user_item_index(book_rating_data[\"ISBN\"]))\n",
        "book_rating_data.rename(columns = {'Book-Rating':'rating'}, inplace=True)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QrGwI_0N5lCv",
        "outputId": "66cec743-e1dc-400e-849d-99836326b881"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "   userId  movieId  rating  timestamp  user  item\n",
            "0       1        1     4.0  964982703     0     0\n",
            "1       1        3     4.0  964981247     0     1\n",
            "2       1        6     4.0  964982224     0     2\n",
            "3       1       47     5.0  964983815     0     3\n",
            "4       1       50     5.0  964982931     0     4\n",
            "   User-ID        ISBN  rating  user  item\n",
            "0   276725  034545104X       0     0     0\n",
            "1   276726  0155061224       5     1     1\n",
            "2   276727  0446520802       0     2     2\n",
            "3   276729  052165615X       3     3     3\n",
            "4   276729  0521795028       6     3     4\n"
          ]
        }
      ],
      "source": [
        "print(ratings.head())\n",
        "print(book_rating_data.head())"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8_Y0rnuf5o_Q",
        "outputId": "5c725346-0ebd-4423-d151-c9e88f8c5b3b"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "610\n",
            "9724\n",
            "105283\n",
            "340556\n"
          ]
        }
      ],
      "source": [
        "num_users = len(ratings[\"userId\"].unique().tolist())\n",
        "num_items = len(ratings[\"movieId\"].unique().tolist())\n",
        "\n",
        "br_num_users = len(book_rating_data[\"User-ID\"].unique().tolist())\n",
        "br_num_items = len(book_rating_data[\"ISBN\"].unique().tolist())\n",
        "\n",
        "\n",
        "print(num_users)\n",
        "print(num_items)\n",
        "print(br_num_users)\n",
        "print(br_num_items)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uIzqSaAhkmNQ"
      },
      "source": [
        "#**Implementing GMF (Element-wise product)**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BC6JX3h_jGVp",
        "outputId": "cdd986c1-eed6-4774-e190-076d7d1b1d5e"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(70585, 2)\n",
            "(70585,)\n",
            "(30251, 2)\n",
            "(30251,)\n"
          ]
        }
      ],
      "source": [
        "# Change the dataset name as per the interest - movielens dataset > ratings, book rating dataset > book_rating_data\n",
        "\n",
        "rating = ratings  #Change it to different dataset accordingly\n",
        "rating[\"rating\"] = rating[\"rating\"].values.astype(np.float32)\n",
        "\n",
        "min_rating = min(rating[\"rating\"])\n",
        "max_rating = max(rating[\"rating\"])\n",
        "\n",
        "# Creation of train and validation dataset\n",
        "data = rating.sample(frac=1, random_state=1)\n",
        "x = data[[\"user\",\"item\"]].values\n",
        "y = data[\"rating\"].apply(lambda x: (x - min_rating) / (max_rating - min_rating)).values\n",
        "#y = data[\"rating\"]\n",
        "\n",
        "\n",
        "train_indices = int(0.7 * data.shape[0])\n",
        "\n",
        "x_train, x_val, y_train, y_val = (x[:train_indices], x[train_indices:], y[:train_indices], y[train_indices:])\n",
        "\n",
        "print(x_train.shape)\n",
        "print(y_train.shape)\n",
        "print(x_val.shape)\n",
        "print(y_val.shape)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "03wSIy0C8Ubc"
      },
      "outputs": [],
      "source": [
        "# Model creation using Generalized Matrix Factorisation Methodology\n",
        "class GMF(keras.Model):\n",
        "  def __init__(self, num_users, num_items, embedding_size, **kwargs):\n",
        "    super(GMF, self).__init__(**kwargs)\n",
        "    self.num_users = num_users\n",
        "    self.num_items = num_items\n",
        "    self.embedding_size = embedding_size\n",
        "    self.user_embed = layers.Embedding(\n",
        "        num_users,\n",
        "        embedding_size,\n",
        "        embeddings_initializer=\"uniform\",\n",
        "        embeddings_regularizer=keras.regularizers.l2(1e-6)\n",
        "    )\n",
        "    self.user_bias = layers.Embedding(num_users, 1)\n",
        "    self.item_embed = layers.Embedding(\n",
        "        num_items,\n",
        "        embedding_size,\n",
        "        embeddings_initializer=\"uniform\",\n",
        "        embeddings_regularizer=keras.regularizers.l2(1e-6)\n",
        "    )\n",
        "    self.item_bias = layers.Embedding(num_items, 1)\n",
        "    self.output_layer = Dense(1, activation='sigmoid')\n",
        "\n",
        "\n",
        "\n",
        "  def call(self, inputs):\n",
        "    user_vector = self.user_embed(inputs[:,0])\n",
        "    user_bias = self.user_bias(inputs[:,0])\n",
        "    item_vector = self.item_embed(inputs[:,1])\n",
        "    item_bias = self.item_bias(inputs[:,1])\n",
        "    user_item_interaction = user_vector * item_vector\n",
        "    final_input = user_item_interaction + user_bias + item_bias\n",
        "    final_output = self.output_layer(final_input)\n",
        "\n",
        "\n",
        "    return final_output"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "E19-RLXBlJc6",
        "outputId": "661947b8-c78c-4caf-b93a-bfd5bbaeb983"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Epoch 1/5\n",
            "552/552 [==============================] - 3s 4ms/step - loss: 0.6929 - val_loss: 0.6926\n",
            "Epoch 2/5\n",
            "552/552 [==============================] - 2s 4ms/step - loss: 0.6925 - val_loss: 0.6923\n",
            "Epoch 3/5\n",
            "552/552 [==============================] - 2s 4ms/step - loss: 0.6922 - val_loss: 0.6920\n",
            "Epoch 4/5\n",
            "552/552 [==============================] - 2s 4ms/step - loss: 0.6920 - val_loss: 0.6918\n",
            "Epoch 5/5\n",
            "552/552 [==============================] - 2s 4ms/step - loss: 0.6918 - val_loss: 0.6917\n",
            "Epoch 1/5\n",
            "552/552 [==============================] - 3s 4ms/step - loss: 0.6943 - val_loss: 0.6941\n",
            "Epoch 2/5\n",
            "552/552 [==============================] - 2s 4ms/step - loss: 0.6938 - val_loss: 0.6937\n",
            "Epoch 3/5\n",
            "552/552 [==============================] - 2s 4ms/step - loss: 0.6934 - val_loss: 0.6933\n",
            "Epoch 4/5\n",
            "552/552 [==============================] - 2s 4ms/step - loss: 0.6931 - val_loss: 0.6930\n",
            "Epoch 5/5\n",
            "552/552 [==============================] - 2s 4ms/step - loss: 0.6928 - val_loss: 0.6928\n",
            "Epoch 1/5\n",
            "552/552 [==============================] - 3s 4ms/step - loss: 0.6930 - val_loss: 0.6927\n",
            "Epoch 2/5\n",
            "552/552 [==============================] - 2s 4ms/step - loss: 0.6925 - val_loss: 0.6924\n",
            "Epoch 3/5\n",
            "552/552 [==============================] - 2s 4ms/step - loss: 0.6923 - val_loss: 0.6921\n",
            "Epoch 4/5\n",
            "552/552 [==============================] - 2s 4ms/step - loss: 0.6920 - val_loss: 0.6919\n",
            "Epoch 5/5\n",
            "552/552 [==============================] - 2s 4ms/step - loss: 0.6918 - val_loss: 0.6918\n",
            "Epoch 1/5\n",
            "552/552 [==============================] - 3s 5ms/step - loss: 0.6933 - val_loss: 0.6931\n",
            "Epoch 2/5\n",
            "552/552 [==============================] - 3s 5ms/step - loss: 0.6929 - val_loss: 0.6927\n",
            "Epoch 3/5\n",
            "552/552 [==============================] - 2s 4ms/step - loss: 0.6926 - val_loss: 0.6925\n",
            "Epoch 4/5\n",
            "552/552 [==============================] - 2s 4ms/step - loss: 0.6924 - val_loss: 0.6923\n",
            "Epoch 5/5\n",
            "552/552 [==============================] - 2s 4ms/step - loss: 0.6922 - val_loss: 0.6921\n"
          ]
        }
      ],
      "source": [
        "# Creating training loop for the purpose of training the model\n",
        "\n",
        "Embedding_size = [8, 16, 32, 64] \n",
        "\n",
        "\n",
        "new = {'val_loss':[]}\n",
        "for i in Embedding_size:\n",
        "  model = GMF(num_users, num_items, i)\n",
        "  model.compile(loss = tf.keras.losses.BinaryCrossentropy(), optimizer=keras.optimizers.Adagrad(lr=0.0001))\n",
        "  history = model.fit(\n",
        "    x=x_train,\n",
        "    y=y_train,\n",
        "    batch_size=128,\n",
        "    epochs=5,\n",
        "    verbose=1,\n",
        "    validation_data=(x_val, y_val)\n",
        "  )\n",
        "\n",
        "  new['val_loss'].append(history.history['val_loss'])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 295
        },
        "id": "z5lELqsXVmze",
        "outputId": "2949b398-055e-47d6-f76f-90f26a8c11ed"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "# 'new_output' is a dataframe with stacked validation losses fro different Embedding Dimensions\n",
        "val_losses_data_ML = pd.DataFrame(new)\n",
        "val_losses_data_ML['Dim'] = Embedding_size\n",
        "val_losses_data_ML.set_index(['Dim'])\n",
        "\n",
        "\n",
        "for i, v in val_losses_data_ML.iterrows():\n",
        "  plt.plot(val_losses_data_ML['val_loss'][i], '-o')\n",
        "plt.title('Model Loss for different dimensions for MovieLens Data - GMF')\n",
        "plt.ylabel('val_loss')\n",
        "plt.xlabel('epoch')\n",
        "plt.legend(val_losses_data_ML['Dim'], loc='lower left')\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jXNdJL4Yj7kI"
      },
      "source": [
        "GMF for Book Rating Dataset"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "oXRvEVw1j6-c",
        "outputId": "d2013c94-7ba9-42c1-c387-da33f5e4be2b"
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/keras/optimizer_v2/adagrad.py:74: UserWarning: The `lr` argument is deprecated, use `learning_rate` instead.\n",
            "  super(Adagrad, self).__init__(name, **kwargs)\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Epoch 1/5\n",
            "276/276 [==============================] - 8s 5ms/step - loss: 0.6973 - val_loss: 0.6971\n",
            "Epoch 2/5\n",
            "276/276 [==============================] - 1s 5ms/step - loss: 0.6969 - val_loss: 0.6968\n",
            "Epoch 3/5\n",
            "276/276 [==============================] - 1s 5ms/step - loss: 0.6966 - val_loss: 0.6965\n",
            "Epoch 4/5\n",
            "276/276 [==============================] - 1s 5ms/step - loss: 0.6963 - val_loss: 0.6963\n",
            "Epoch 5/5\n",
            "276/276 [==============================] - 1s 5ms/step - loss: 0.6961 - val_loss: 0.6961\n",
            "Epoch 1/5\n",
            "276/276 [==============================] - 3s 7ms/step - loss: 0.6988 - val_loss: 0.6986\n",
            "Epoch 2/5\n",
            "276/276 [==============================] - 2s 6ms/step - loss: 0.6985 - val_loss: 0.6984\n",
            "Epoch 3/5\n",
            "276/276 [==============================] - 2s 7ms/step - loss: 0.6983 - val_loss: 0.6982\n",
            "Epoch 4/5\n",
            "276/276 [==============================] - 2s 6ms/step - loss: 0.6981 - val_loss: 0.6981\n",
            "Epoch 5/5\n",
            "276/276 [==============================] - 2s 7ms/step - loss: 0.6980 - val_loss: 0.6979\n",
            "Epoch 1/5\n",
            "276/276 [==============================] - 4s 11ms/step - loss: 0.7061 - val_loss: 0.7060\n",
            "Epoch 2/5\n",
            "276/276 [==============================] - 3s 10ms/step - loss: 0.7057 - val_loss: 0.7056\n",
            "Epoch 3/5\n",
            "276/276 [==============================] - 3s 11ms/step - loss: 0.7053 - val_loss: 0.7053\n",
            "Epoch 4/5\n",
            "276/276 [==============================] - 3s 10ms/step - loss: 0.7050 - val_loss: 0.7050\n",
            "Epoch 5/5\n",
            "276/276 [==============================] - 3s 10ms/step - loss: 0.7047 - val_loss: 0.7047\n",
            "Epoch 1/5\n",
            "276/276 [==============================] - 5s 17ms/step - loss: 0.7175 - val_loss: 0.7172\n",
            "Epoch 2/5\n",
            "276/276 [==============================] - 4s 16ms/step - loss: 0.7172 - val_loss: 0.7169\n",
            "Epoch 3/5\n",
            "276/276 [==============================] - 5s 17ms/step - loss: 0.7169 - val_loss: 0.7167\n",
            "Epoch 4/5\n",
            "276/276 [==============================] - 5s 18ms/step - loss: 0.7167 - val_loss: 0.7165\n",
            "Epoch 5/5\n",
            "276/276 [==============================] - 4s 16ms/step - loss: 0.7166 - val_loss: 0.7164\n"
          ]
        }
      ],
      "source": [
        "Embedding_size = [8, 16, 32, 64] \n",
        "\n",
        "\n",
        "new = {'val_loss':[]}\n",
        "for i in Embedding_size:\n",
        "  model = GMF(br_num_users, br_num_items, i)\n",
        "  model.compile(loss = tf.keras.losses.BinaryCrossentropy(), optimizer=keras.optimizers.Adagrad(lr=0.0001))\n",
        "  history = model.fit(\n",
        "    x=x_train,\n",
        "    y=y_train,\n",
        "    batch_size=256,\n",
        "    epochs=5,\n",
        "    verbose=1,\n",
        "    validation_data=(x_val, y_val)\n",
        "  )\n",
        "\n",
        "  new['val_loss'].append(history.history['val_loss'])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 295
        },
        "id": "PaYNRrH2J4WB",
        "outputId": "ea35e4b4-bebf-4d9e-a0aa-b05064944f2c"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "# 'new_output' is a dataframe with stacked validation losses fro different Embedding Dimensions\n",
        "val_losses_data_ML = pd.DataFrame(new)\n",
        "val_losses_data_ML['Dim'] = Embedding_size\n",
        "val_losses_data_ML.set_index(['Dim'])\n",
        "\n",
        "\n",
        "for i, v in val_losses_data_ML.iterrows():\n",
        "  plt.plot(val_losses_data_ML['val_loss'][i], '-o')\n",
        "plt.title('Model Loss for different dimensions for Book Rating Data - GMF')\n",
        "plt.ylabel('val_loss')\n",
        "plt.xlabel('epoch')\n",
        "plt.legend(val_losses_data_ML['Dim'], loc='lower left')\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "UokQGLGyW-mA"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "NuMwhVlLW-iO"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "NCHdMwLsW-dz"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BRgPhLOKyLoN"
      },
      "source": [
        "# **MLP - Multi Layer Perceptron (NCL-II)** "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6BSC1Ad3Qilq",
        "outputId": "b2e1e0cb-c777-4e5a-aa2c-604259ea28a8"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(804846, 2)\n",
            "(804846,)\n",
            "(344934, 2)\n",
            "(344934,)\n"
          ]
        }
      ],
      "source": [
        "# Change the dataset name as per the interest - movielens dataset > ratings, book rating dataset > book_rating_data\n",
        "\n",
        "rating = book_rating_data  #Change it to different dataset accordingly\n",
        "rating[\"rating\"] = rating[\"rating\"].values.astype(np.float32)\n",
        "\n",
        "min_rating = min(rating[\"rating\"])\n",
        "max_rating = max(rating[\"rating\"])\n",
        "\n",
        "# Creation of train and validation dataset\n",
        "data = rating.sample(frac=1, random_state=1)\n",
        "x = data[[\"user\",\"item\"]].values\n",
        "y = data[\"rating\"].apply(lambda x: (x - min_rating) / (max_rating - min_rating)).values\n",
        "#y = data[\"rating\"]\n",
        "\n",
        "\n",
        "train_indices = int(0.7 * data.shape[0])\n",
        "\n",
        "x_train, x_val, y_train, y_val = (x[:train_indices], x[train_indices:], y[:train_indices], y[train_indices:])\n",
        "\n",
        "print(x_train.shape)\n",
        "print(y_train.shape)\n",
        "print(x_val.shape)\n",
        "print(y_val.shape)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "FGV5Hg3uW-ZT"
      },
      "outputs": [],
      "source": [
        "# Model creation using Multi-Layer Perceptron Methodology\n",
        "class MLP(keras.Model):\n",
        "  def __init__(self, num_users, num_items, embedding_size, **kwargs):\n",
        "    super(MLP, self).__init__(**kwargs)\n",
        "    self.num_users = num_users\n",
        "    self.num_items = num_items\n",
        "    self.embedding_size = embedding_size\n",
        "    self.user_embed = layers.Embedding(\n",
        "        num_users,\n",
        "        embedding_size,\n",
        "        embeddings_initializer=\"uniform\",\n",
        "        embeddings_regularizer=keras.regularizers.l2(1e-6)\n",
        "    )\n",
        "    self.user_bias = layers.Embedding(num_users, 1)\n",
        "    self.item_embed = layers.Embedding(\n",
        "        num_items,\n",
        "        embedding_size,\n",
        "        embeddings_initializer=\"uniform\",\n",
        "        embeddings_regularizer=keras.regularizers.l2(1e-6)\n",
        "    )\n",
        "    self.item_bias = layers.Embedding(num_items, 1)\n",
        "    self.layer1 = Dense(256, activation='relu')\n",
        "    #self.layer_d1 = Dropout(0.3)\n",
        "    self.layer2 = Dense(128, activation='relu')\n",
        "    #self.layer3 = Dense(64, activation='relu')\n",
        "    #self.layer_d2 = Dropout(0.2)\n",
        "    self.layer4 = Dense(64, activation='relu')\n",
        "    self.output_layer = Dense(1, activation='sigmoid')\n",
        "\n",
        "\n",
        "\n",
        "  def call(self, inputs):\n",
        "    user_vector = self.user_embed(inputs[:,0])\n",
        "    user_bias = self.user_bias(inputs[:,0])\n",
        "    item_vector = self.item_embed(inputs[:,1])\n",
        "    item_bias = self.item_bias(inputs[:,1])\n",
        "    user_item_interaction = layers.Concatenate()([user_vector ,item_vector])\n",
        "    final_input = user_item_interaction + user_bias + item_bias\n",
        "    out1 = self.layer1(final_input)\n",
        "    #d1 = self.layer_d1(out1)\n",
        "    out2 = self.layer2(out1)\n",
        "    #d2 = self.layer_d2(out2)\n",
        "    #out3 = self.layer3(out2)\n",
        "    out4 = self.layer4(out2)\n",
        "    final_output = self.output_layer(out4)\n",
        "\n",
        "    #x = new #+ user_bias + item_bias\n",
        "    return final_output"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "F7As4Svk5lYe",
        "outputId": "78670168-f185-4d92-d6fa-2add84e36049"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/5\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/keras/optimizer_v2/adagrad.py:74: UserWarning: The `lr` argument is deprecated, use `learning_rate` instead.\n",
            "  super(Adagrad, self).__init__(name, **kwargs)\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "552/552 [==============================] - 3s 5ms/step - loss: 0.6920 - val_loss: 0.6907\n",
            "Epoch 2/5\n",
            "552/552 [==============================] - 3s 5ms/step - loss: 0.6896 - val_loss: 0.6887\n",
            "Epoch 3/5\n",
            "552/552 [==============================] - 2s 4ms/step - loss: 0.6879 - val_loss: 0.6870\n",
            "Epoch 4/5\n",
            "552/552 [==============================] - 3s 5ms/step - loss: 0.6861 - val_loss: 0.6853\n",
            "Epoch 5/5\n",
            "552/552 [==============================] - 2s 4ms/step - loss: 0.6844 - val_loss: 0.6836\n",
            "Epoch 1/5\n",
            "552/552 [==============================] - 3s 5ms/step - loss: 0.6922 - val_loss: 0.6906\n",
            "Epoch 2/5\n",
            "552/552 [==============================] - 2s 4ms/step - loss: 0.6893 - val_loss: 0.6881\n",
            "Epoch 3/5\n",
            "552/552 [==============================] - 3s 5ms/step - loss: 0.6869 - val_loss: 0.6858\n",
            "Epoch 4/5\n",
            "552/552 [==============================] - 2s 4ms/step - loss: 0.6846 - val_loss: 0.6836\n",
            "Epoch 5/5\n",
            "552/552 [==============================] - 2s 4ms/step - loss: 0.6825 - val_loss: 0.6816\n",
            "Epoch 1/5\n",
            "552/552 [==============================] - 3s 5ms/step - loss: 0.6905 - val_loss: 0.6888\n",
            "Epoch 2/5\n",
            "552/552 [==============================] - 3s 5ms/step - loss: 0.6873 - val_loss: 0.6859\n",
            "Epoch 3/5\n",
            "552/552 [==============================] - 3s 5ms/step - loss: 0.6846 - val_loss: 0.6833\n",
            "Epoch 4/5\n",
            "552/552 [==============================] - 3s 5ms/step - loss: 0.6820 - val_loss: 0.6809\n",
            "Epoch 5/5\n",
            "552/552 [==============================] - 3s 5ms/step - loss: 0.6797 - val_loss: 0.6787\n",
            "Epoch 1/5\n",
            "552/552 [==============================] - 3s 5ms/step - loss: 0.6895 - val_loss: 0.6875\n",
            "Epoch 2/5\n",
            "552/552 [==============================] - 2s 4ms/step - loss: 0.6858 - val_loss: 0.6843\n",
            "Epoch 3/5\n",
            "552/552 [==============================] - 3s 5ms/step - loss: 0.6828 - val_loss: 0.6816\n",
            "Epoch 4/5\n",
            "552/552 [==============================] - 3s 5ms/step - loss: 0.6803 - val_loss: 0.6793\n",
            "Epoch 5/5\n",
            "552/552 [==============================] - 3s 5ms/step - loss: 0.6780 - val_loss: 0.6771\n"
          ]
        }
      ],
      "source": [
        "# Training loop\n",
        "\n",
        "Embedding_size = [8, 16, 32, 64] \n",
        "\n",
        "\n",
        "new = {'val_loss':[]}\n",
        "for i in Embedding_size:\n",
        "  model = MLP(num_users, num_items, i)\n",
        "  model.compile(loss = tf.keras.losses.BinaryCrossentropy(), optimizer=keras.optimizers.Adagrad(lr=0.0001))\n",
        "  history = model.fit(\n",
        "    x=x_train,\n",
        "    y=y_train,\n",
        "    batch_size=128,\n",
        "    epochs=5,\n",
        "    verbose=1,\n",
        "    validation_data=(x_val, y_val)\n",
        "  )\n",
        "\n",
        "  new['val_loss'].append(history.history['val_loss'])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 295
        },
        "id": "uya-qPBRW-WG",
        "outputId": "b320183f-0fe0-458b-c5e4-7924985837db"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "# 'new_output' is a dataframe with stacked validation losses fro different Embedding Dimensions\n",
        "val_losses_data_ML = pd.DataFrame(new)\n",
        "val_losses_data_ML['Dim'] = Embedding_size\n",
        "val_losses_data_ML.set_index(['Dim'])\n",
        "\n",
        "\n",
        "for i, v in val_losses_data_ML.iterrows():\n",
        "  plt.plot(val_losses_data_ML['val_loss'][i], '-o')\n",
        "plt.title('Model Loss for different dimensions for MovieLenes Rating Data - MLP')\n",
        "plt.ylabel('val_loss')\n",
        "plt.xlabel('epoch')\n",
        "plt.legend(val_losses_data_ML['Dim'], loc='lower left')\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BTmcAsJ4VxtW",
        "outputId": "480d13cf-e89d-40b5-d5d8-d4c95d4dea7f"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/5\n",
            "6288/6288 [==============================] - 32s 5ms/step - loss: 0.6804 - val_loss: 0.6676\n",
            "Epoch 2/5\n",
            "6288/6288 [==============================] - 32s 5ms/step - loss: 0.6581 - val_loss: 0.6492\n",
            "Epoch 3/5\n",
            "6288/6288 [==============================] - 31s 5ms/step - loss: 0.6418 - val_loss: 0.6345\n",
            "Epoch 4/5\n",
            "6288/6288 [==============================] - 31s 5ms/step - loss: 0.6287 - val_loss: 0.6229\n",
            "Epoch 5/5\n",
            "6288/6288 [==============================] - 32s 5ms/step - loss: 0.6187 - val_loss: 0.6144\n",
            "Epoch 1/5\n",
            "6288/6288 [==============================] - 47s 7ms/step - loss: 0.6730 - val_loss: 0.6570\n",
            "Epoch 2/5\n",
            "6288/6288 [==============================] - 42s 7ms/step - loss: 0.6459 - val_loss: 0.6357\n",
            "Epoch 3/5\n",
            "6288/6288 [==============================] - 47s 7ms/step - loss: 0.6283 - val_loss: 0.6214\n",
            "Epoch 4/5\n",
            "6288/6288 [==============================] - 42s 7ms/step - loss: 0.6170 - val_loss: 0.6129\n",
            "Epoch 5/5\n",
            "6288/6288 [==============================] - 47s 7ms/step - loss: 0.6107 - val_loss: 0.6084\n",
            "Epoch 1/5\n",
            "6288/6288 [==============================] - 67s 10ms/step - loss: 0.6882 - val_loss: 0.6746\n",
            "Epoch 2/5\n",
            "6288/6288 [==============================] - 63s 10ms/step - loss: 0.6640 - val_loss: 0.6540\n",
            "Epoch 3/5\n",
            "6288/6288 [==============================] - 65s 10ms/step - loss: 0.6459 - val_loss: 0.6382\n",
            "Epoch 4/5\n",
            "6288/6288 [==============================] - 62s 10ms/step - loss: 0.6324 - val_loss: 0.6267\n",
            "Epoch 5/5\n",
            "6288/6288 [==============================] - 66s 11ms/step - loss: 0.6229 - val_loss: 0.6191\n",
            "Epoch 1/5\n",
            "6288/6288 [==============================] - 105s 17ms/step - loss: 0.7062 - val_loss: 0.6953\n",
            "Epoch 2/5\n",
            "6288/6288 [==============================] - 104s 17ms/step - loss: 0.6866 - val_loss: 0.6782\n",
            "Epoch 3/5\n",
            "6288/6288 [==============================] - 114s 18ms/step - loss: 0.6707 - val_loss: 0.6631\n",
            "Epoch 4/5\n",
            "6288/6288 [==============================] - 103s 16ms/step - loss: 0.6567 - val_loss: 0.6502\n",
            "Epoch 5/5\n",
            "6288/6288 [==============================] - 104s 17ms/step - loss: 0.6451 - val_loss: 0.6399\n"
          ]
        }
      ],
      "source": [
        "# Training for Book Rating Dataset using MLP (NCF-II)\n",
        "Embedding_size = [8, 16, 32, 64] \n",
        "\n",
        "\n",
        "new = {'val_loss':[]}\n",
        "for i in Embedding_size:\n",
        "  model = MLP(br_num_users, br_num_items, i)\n",
        "  model.compile(loss = tf.keras.losses.BinaryCrossentropy(), optimizer=keras.optimizers.Adagrad(lr=0.0001))\n",
        "  history = model.fit(\n",
        "    x=x_train,\n",
        "    y=y_train,\n",
        "    batch_size=128,\n",
        "    epochs=5,\n",
        "    verbose=1,\n",
        "    validation_data=(x_val, y_val)\n",
        "  )\n",
        "\n",
        "  new['val_loss'].append(history.history['val_loss'])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 295
        },
        "id": "1p1VRdasZHup",
        "outputId": "8d2915a3-0479-4b1b-b5b7-77f509dfbe15"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "# 'new_output' is a dataframe with stacked validation losses fro different Embedding Dimensions\n",
        "val_losses_data_ML = pd.DataFrame(new)\n",
        "val_losses_data_ML['Dim'] = Embedding_size\n",
        "val_losses_data_ML.set_index(['Dim'])\n",
        "\n",
        "\n",
        "for i, v in val_losses_data_ML.iterrows():\n",
        "  plt.plot(val_losses_data_ML['val_loss'][i], '-o')\n",
        "plt.title('Model Loss for different dimensions for Book Rating Dataset - MLP')\n",
        "plt.ylabel('val_loss')\n",
        "plt.xlabel('epoch')\n",
        "plt.legend(val_losses_data_ML['Dim'], loc='lower left')\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "VBtJeiaVZHm1"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "98ZZ1tX0Zh2X"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "YkPm8M7NZh5D"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "XQzo6DcdZh7-"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "9rOxOuzBZh_w"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "8s8ayH0yZiCf"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Q6lCwQoX2Ek7"
      },
      "source": [
        "#**Combining the GMF and MLP to consolitdate the version of Neural Collaborative Filtering (NCF)**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5-mXjIiT_kxb",
        "outputId": "c95f8047-7467-4b12-c2d5-43a3555188f1"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(804846, 2)\n",
            "(804846,)\n",
            "(344934, 2)\n",
            "(344934,)\n"
          ]
        }
      ],
      "source": [
        "# Change the dataset name as per the interest - movielens dataset > ratings, book rating dataset > book_rating_data\n",
        "\n",
        "rating = book_rating_data  #Change it to different dataset accordingly\n",
        "rating[\"rating\"] = rating[\"rating\"].values.astype(np.float32)\n",
        "\n",
        "min_rating = min(rating[\"rating\"])\n",
        "max_rating = max(rating[\"rating\"])\n",
        "\n",
        "# Creation of train and validation dataset\n",
        "data = rating.sample(frac=1, random_state=1)\n",
        "x = data[[\"user\",\"item\"]].values\n",
        "y = data[\"rating\"].apply(lambda x: (x - min_rating) / (max_rating - min_rating)).values\n",
        "#y = data[\"rating\"]\n",
        "\n",
        "\n",
        "train_indices = int(0.7 * data.shape[0])\n",
        "\n",
        "x_train, x_val, y_train, y_val = (x[:train_indices], x[train_indices:], y[:train_indices], y[train_indices:])\n",
        "\n",
        "print(x_train.shape)\n",
        "print(y_train.shape)\n",
        "print(x_val.shape)\n",
        "print(y_val.shape)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "q7-IqiZUZHie"
      },
      "outputs": [],
      "source": [
        "# Model creation combining GMF and MLP\n",
        "class NCF(keras.Model):\n",
        "  def __init__(self, num_users, num_items, embedding_size, **kwargs):\n",
        "    super(NCF, self).__init__(**kwargs)\n",
        "    self.num_users = num_users\n",
        "    self.num_items = num_items\n",
        "    self.embedding_size = embedding_size\n",
        "    self.user_embed = layers.Embedding(\n",
        "        num_users,\n",
        "        embedding_size,\n",
        "        embeddings_initializer=\"uniform\",\n",
        "        embeddings_regularizer=keras.regularizers.l2(1e-6)\n",
        "    )\n",
        "    self.user_bias = layers.Embedding(num_users, 1)\n",
        "    self.item_embed = layers.Embedding(\n",
        "        num_items,\n",
        "        embedding_size,\n",
        "        embeddings_initializer=\"uniform\",\n",
        "        embeddings_regularizer=keras.regularizers.l2(1e-6)\n",
        "    )\n",
        "    self.item_bias = layers.Embedding(num_items, 1)\n",
        "    #MLP layers\n",
        "    self.layer1 = Dense(256, activation='relu')\n",
        "    self.layer2 = Dense(128, activation='relu')\n",
        "    self.layer3 = Dense(64, activation='relu')\n",
        "    #self.layer4 = Dense(32, activation='relu')\n",
        "    self.output_layer = Dense(1, activation='sigmoid')\n",
        "\n",
        "\n",
        "\n",
        "  def call(self, inputs):\n",
        "    user_vector = self.user_embed(inputs[:,0])\n",
        "    user_bias = self.user_bias(inputs[:,0])\n",
        "    item_vector = self.item_embed(inputs[:,1])\n",
        "    item_bias = self.item_bias(inputs[:,1])\n",
        "    GMF_output = user_vector * item_vector\n",
        "    MLP_output = layers.Concatenate()([user_vector ,item_vector])\n",
        "    MLP_out1 = self.layer1(MLP_output)\n",
        "    MLP_out2 = self.layer2(MLP_out1)\n",
        "    MLP_out3 = self.layer3(MLP_out2)\n",
        "    #MLP_out4 = self.layer4(MLP_out3)\n",
        "    final_input = layers.Concatenate()([GMF_output, MLP_out3])\n",
        "    final_output = self.output_layer(final_input)\n",
        "\n",
        "    #x = new #+ user_bias + item_bias\n",
        "    return final_output"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ecoepMmUZNuh",
        "outputId": "4d552c0e-3f04-4d09-c39f-a0c64222f3de"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/5\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "WARNING:tensorflow:Gradients do not exist for variables ['ncf_12/embedding_49/embeddings:0', 'ncf_12/embedding_51/embeddings:0'] when minimizing the loss. If you're using `model.compile()`, did you forget to provide a `loss`argument?\n",
            "WARNING:tensorflow:Gradients do not exist for variables ['ncf_12/embedding_49/embeddings:0', 'ncf_12/embedding_51/embeddings:0'] when minimizing the loss. If you're using `model.compile()`, did you forget to provide a `loss`argument?\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "276/276 [==============================] - 2s 5ms/step - loss: 0.6915 - val_loss: 0.6901\n",
            "Epoch 2/5\n",
            "276/276 [==============================] - 1s 4ms/step - loss: 0.6888 - val_loss: 0.6877\n",
            "Epoch 3/5\n",
            "276/276 [==============================] - 1s 4ms/step - loss: 0.6866 - val_loss: 0.6857\n",
            "Epoch 4/5\n",
            "276/276 [==============================] - 1s 4ms/step - loss: 0.6847 - val_loss: 0.6839\n",
            "Epoch 5/5\n",
            "276/276 [==============================] - 1s 4ms/step - loss: 0.6831 - val_loss: 0.6823\n",
            "Epoch 1/5\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "WARNING:tensorflow:Gradients do not exist for variables ['ncf_13/embedding_53/embeddings:0', 'ncf_13/embedding_55/embeddings:0'] when minimizing the loss. If you're using `model.compile()`, did you forget to provide a `loss`argument?\n",
            "WARNING:tensorflow:Gradients do not exist for variables ['ncf_13/embedding_53/embeddings:0', 'ncf_13/embedding_55/embeddings:0'] when minimizing the loss. If you're using `model.compile()`, did you forget to provide a `loss`argument?\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "276/276 [==============================] - 2s 5ms/step - loss: 0.6927 - val_loss: 0.6918\n",
            "Epoch 2/5\n",
            "276/276 [==============================] - 1s 4ms/step - loss: 0.6911 - val_loss: 0.6904\n",
            "Epoch 3/5\n",
            "276/276 [==============================] - 1s 4ms/step - loss: 0.6898 - val_loss: 0.6892\n",
            "Epoch 4/5\n",
            "276/276 [==============================] - 1s 4ms/step - loss: 0.6886 - val_loss: 0.6881\n",
            "Epoch 5/5\n",
            "276/276 [==============================] - 1s 4ms/step - loss: 0.6876 - val_loss: 0.6872\n",
            "Epoch 1/5\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "WARNING:tensorflow:Gradients do not exist for variables ['ncf_14/embedding_57/embeddings:0', 'ncf_14/embedding_59/embeddings:0'] when minimizing the loss. If you're using `model.compile()`, did you forget to provide a `loss`argument?\n",
            "WARNING:tensorflow:Gradients do not exist for variables ['ncf_14/embedding_57/embeddings:0', 'ncf_14/embedding_59/embeddings:0'] when minimizing the loss. If you're using `model.compile()`, did you forget to provide a `loss`argument?\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "276/276 [==============================] - 2s 5ms/step - loss: 0.6919 - val_loss: 0.6913\n",
            "Epoch 2/5\n",
            "276/276 [==============================] - 1s 4ms/step - loss: 0.6907 - val_loss: 0.6903\n",
            "Epoch 3/5\n",
            "276/276 [==============================] - 1s 5ms/step - loss: 0.6898 - val_loss: 0.6894\n",
            "Epoch 4/5\n",
            "276/276 [==============================] - 1s 4ms/step - loss: 0.6889 - val_loss: 0.6885\n",
            "Epoch 5/5\n",
            "276/276 [==============================] - 1s 4ms/step - loss: 0.6881 - val_loss: 0.6877\n",
            "Epoch 1/5\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "WARNING:tensorflow:Gradients do not exist for variables ['ncf_15/embedding_61/embeddings:0', 'ncf_15/embedding_63/embeddings:0'] when minimizing the loss. If you're using `model.compile()`, did you forget to provide a `loss`argument?\n",
            "WARNING:tensorflow:Gradients do not exist for variables ['ncf_15/embedding_61/embeddings:0', 'ncf_15/embedding_63/embeddings:0'] when minimizing the loss. If you're using `model.compile()`, did you forget to provide a `loss`argument?\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "276/276 [==============================] - 2s 5ms/step - loss: 0.6915 - val_loss: 0.6909\n",
            "Epoch 2/5\n",
            "276/276 [==============================] - 1s 4ms/step - loss: 0.6903 - val_loss: 0.6898\n",
            "Epoch 3/5\n",
            "276/276 [==============================] - 1s 4ms/step - loss: 0.6893 - val_loss: 0.6888\n",
            "Epoch 4/5\n",
            "276/276 [==============================] - 1s 4ms/step - loss: 0.6884 - val_loss: 0.6879\n",
            "Epoch 5/5\n",
            "276/276 [==============================] - 1s 4ms/step - loss: 0.6875 - val_loss: 0.6871\n"
          ]
        }
      ],
      "source": [
        "# Training for Book Rating Dataset using GMF + MLP (NCF)\n",
        "Embedding_size = [8, 16, 32, 64] \n",
        "\n",
        "\n",
        "new = {'val_loss':[]}\n",
        "for i in Embedding_size:\n",
        "  model = NCF(num_users, num_items, i)\n",
        "  model.compile(loss = tf.keras.losses.BinaryCrossentropy(), optimizer=keras.optimizers.Adagrad(lr=0.0001))\n",
        "  history = model.fit(\n",
        "    x=x_train,\n",
        "    y=y_train,\n",
        "    batch_size=256,\n",
        "    epochs=5,\n",
        "    verbose=1,\n",
        "    validation_data=(x_val, y_val)\n",
        "  )\n",
        "\n",
        "  new['val_loss'].append(history.history['val_loss'])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 295
        },
        "id": "1_bitYBEZHfd",
        "outputId": "7baf9c3d-fe63-43c6-db8e-ffd26bd9c01f"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "# 'new_output' is a dataframe with stacked validation losses for different Embedding Dimensions\n",
        "val_losses_data_ML = pd.DataFrame(new)\n",
        "val_losses_data_ML['Dim'] = Embedding_size\n",
        "val_losses_data_ML.set_index(['Dim'])\n",
        "\n",
        "\n",
        "for i, v in val_losses_data_ML.iterrows():\n",
        "  plt.plot(val_losses_data_ML['val_loss'][i], '-o')\n",
        "plt.title('Model Loss for different dimensions for MovieLens Dataset - NCF')\n",
        "plt.ylabel('val_loss')\n",
        "plt.xlabel('epoch')\n",
        "plt.legend(val_losses_data_ML['Dim'], loc='lower left')\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sYCyjtnZZHcc",
        "outputId": "5d043bcd-7e37-4eab-dba3-8886b1c2b35e"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/5\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "WARNING:tensorflow:Gradients do not exist for variables ['ncf_28/embedding_113/embeddings:0', 'ncf_28/embedding_115/embeddings:0'] when minimizing the loss. If you're using `model.compile()`, did you forget to provide a `loss`argument?\n",
            "WARNING:tensorflow:Gradients do not exist for variables ['ncf_28/embedding_113/embeddings:0', 'ncf_28/embedding_115/embeddings:0'] when minimizing the loss. If you're using `model.compile()`, did you forget to provide a `loss`argument?\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "6288/6288 [==============================] - 37s 6ms/step - loss: 0.6769 - val_loss: 0.6626\n",
            "Epoch 2/5\n",
            "6288/6288 [==============================] - 36s 6ms/step - loss: 0.6525 - val_loss: 0.6431\n",
            "Epoch 3/5\n",
            "6288/6288 [==============================] - 31s 5ms/step - loss: 0.6356 - val_loss: 0.6284\n",
            "Epoch 4/5\n",
            "6288/6288 [==============================] - 36s 6ms/step - loss: 0.6229 - val_loss: 0.6176\n",
            "Epoch 5/5\n",
            "6288/6288 [==============================] - 36s 6ms/step - loss: 0.6140 - val_loss: 0.6103\n",
            "Epoch 1/5\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "WARNING:tensorflow:Gradients do not exist for variables ['ncf_29/embedding_117/embeddings:0', 'ncf_29/embedding_119/embeddings:0'] when minimizing the loss. If you're using `model.compile()`, did you forget to provide a `loss`argument?\n",
            "WARNING:tensorflow:Gradients do not exist for variables ['ncf_29/embedding_117/embeddings:0', 'ncf_29/embedding_119/embeddings:0'] when minimizing the loss. If you're using `model.compile()`, did you forget to provide a `loss`argument?\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "6288/6288 [==============================] - 47s 7ms/step - loss: 0.6768 - val_loss: 0.6615\n",
            "Epoch 2/5\n",
            "6288/6288 [==============================] - 42s 7ms/step - loss: 0.6502 - val_loss: 0.6399\n",
            "Epoch 3/5\n",
            "6288/6288 [==============================] - 47s 7ms/step - loss: 0.6322 - val_loss: 0.6250\n",
            "Epoch 4/5\n",
            "6288/6288 [==============================] - 46s 7ms/step - loss: 0.6200 - val_loss: 0.6152\n",
            "Epoch 5/5\n",
            "6288/6288 [==============================] - 49s 8ms/step - loss: 0.6125 - val_loss: 0.6096\n",
            "Epoch 1/5\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "WARNING:tensorflow:Gradients do not exist for variables ['ncf_30/embedding_121/embeddings:0', 'ncf_30/embedding_123/embeddings:0'] when minimizing the loss. If you're using `model.compile()`, did you forget to provide a `loss`argument?\n",
            "WARNING:tensorflow:Gradients do not exist for variables ['ncf_30/embedding_121/embeddings:0', 'ncf_30/embedding_123/embeddings:0'] when minimizing the loss. If you're using `model.compile()`, did you forget to provide a `loss`argument?\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "6288/6288 [==============================] - 67s 11ms/step - loss: 0.6902 - val_loss: 0.6794\n",
            "Epoch 2/5\n",
            "6288/6288 [==============================] - 69s 11ms/step - loss: 0.6710 - val_loss: 0.6629\n",
            "Epoch 3/5\n",
            "6288/6288 [==============================] - 69s 11ms/step - loss: 0.6556 - val_loss: 0.6484\n",
            "Epoch 4/5\n",
            "6288/6288 [==============================] - 66s 10ms/step - loss: 0.6423 - val_loss: 0.6362\n",
            "Epoch 5/5\n",
            "6288/6288 [==============================] - 63s 10ms/step - loss: 0.6315 - val_loss: 0.6266\n",
            "Epoch 1/5\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "WARNING:tensorflow:Gradients do not exist for variables ['ncf_31/embedding_125/embeddings:0', 'ncf_31/embedding_127/embeddings:0'] when minimizing the loss. If you're using `model.compile()`, did you forget to provide a `loss`argument?\n",
            "WARNING:tensorflow:Gradients do not exist for variables ['ncf_31/embedding_125/embeddings:0', 'ncf_31/embedding_127/embeddings:0'] when minimizing the loss. If you're using `model.compile()`, did you forget to provide a `loss`argument?\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "6288/6288 [==============================] - 105s 17ms/step - loss: 0.7013 - val_loss: 0.6901\n",
            "Epoch 2/5\n",
            "6288/6288 [==============================] - 104s 16ms/step - loss: 0.6808 - val_loss: 0.6720\n",
            "Epoch 3/5\n",
            "6288/6288 [==============================] - 103s 16ms/step - loss: 0.6644 - val_loss: 0.6570\n",
            "Epoch 4/5\n",
            "6288/6288 [==============================] - 103s 16ms/step - loss: 0.6510 - val_loss: 0.6450\n",
            "Epoch 5/5\n",
            "6288/6288 [==============================] - 103s 16ms/step - loss: 0.6405 - val_loss: 0.6360\n"
          ]
        }
      ],
      "source": [
        "# Training for Book Rating Dataset using GMF + MLP (NCF)\n",
        "Embedding_size = [8, 16, 32, 64] \n",
        "\n",
        "\n",
        "new = {'val_loss':[]}\n",
        "for i in Embedding_size:\n",
        "  model = NCF(br_num_users, br_num_items, i)\n",
        "  model.compile(loss = tf.keras.losses.BinaryCrossentropy(), optimizer=keras.optimizers.Adagrad(lr=0.0001))\n",
        "  history = model.fit(\n",
        "    x=x_train,\n",
        "    y=y_train,\n",
        "    batch_size=128,\n",
        "    epochs=5,\n",
        "    verbose=1,\n",
        "    validation_data=(x_val, y_val)\n",
        "  )\n",
        "\n",
        "  new['val_loss'].append(history.history['val_loss'])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 295
        },
        "id": "imA1dR19ZHZH",
        "outputId": "ed835af5-9be3-48b1-8c39-8c450b0704ce"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "val_losses_data_ML = pd.DataFrame(new)\n",
        "val_losses_data_ML['Dim'] = Embedding_size\n",
        "val_losses_data_ML.set_index(['Dim'])\n",
        "\n",
        "\n",
        "for i, v in val_losses_data_ML.iterrows():\n",
        "  plt.plot(val_losses_data_ML['val_loss'][i], '-o')\n",
        "plt.title('Model Loss for different dimensions for Book Rating Dataset - NCF')\n",
        "plt.ylabel('val_loss')\n",
        "plt.xlabel('epoch')\n",
        "plt.legend(val_losses_data_ML['Dim'], loc='lower left')\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ku05wKMaLD9d"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "po3Vov23LD54"
      },
      "outputs": [],
      "source": []
    }
  ],
  "metadata": {
    "colab": {
      "collapsed_sections": [],
      "provenance": [],
      "authorship_tag": "ABX9TyOi2FdXh7DBoEt+mcJSvwup"
    },
    "gpuClass": "standard",
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}