User_Anime_Hybrid_Predictions.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "User-Anime Hybrid Predictions.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "machine_shape": "hm",
      "mount_file_id": "https://github.com/nomomon/anime-recommendations/blob/master/User_Anime_Hybrid_Predictions.ipynb",
      "authorship_tag": "ABX9TyNsVUc0/04Lkx/lNgkOBaI7"
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "code",
      "metadata": {
        "id": "PUNeUN_1JbAQ",
        "cellView": "form"
      },
      "source": [
        "#@title Kaggle API\n",
        "\n",
        "from IPython.display import clear_output\n",
        "\n",
        "username = str(input(\"username: \"))\n",
        "key = str(input(\"key: \"))\n",
        "\n",
        "clear_output()\n",
        "\n",
        "f = open(\"kaggle.json\", \"w\")\n",
        "f.write('{\"username\":\"'+username+'\",\"key\":\"'+key+'\"}')\n",
        "f.close()\n",
        "\n",
        "!mkdir -p ~/.kaggle\n",
        "!cp kaggle.json ~/.kaggle/\n",
        "!kaggle datasets download -d hernan4444/anime-recommendation-database-2020\n",
        "\n",
        "import os, re\n",
        "from zipfile import ZipFile\n",
        "\n",
        "with ZipFile('/content/anime-recommendation-database-2020.zip', 'r') as zipObj:\n",
        "   zipObj.extractall()\n",
        "\n",
        "def purge(dir, pattern):\n",
        "    for f in os.listdir(dir):\n",
        "        if pattern in f:\n",
        "            os.remove(os.path.join(dir, f))\n",
        "\n",
        "purge(\"/content/\", \".zip\")\n",
        "purge(\"/content/\", \".json\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "knCcMBuxBqIq"
      },
      "source": [
        "import pandas as pd\n",
        "import numpy as np\n",
        "import tensorflow as tf"
      ],
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DMWiDA25J2ws"
      },
      "source": [
        "# Data Preprocessing"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eyy-fObFKWIh"
      },
      "source": [
        "ratings = pd.read_csv(\"/content/animelist.csv\")"
      ],
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cDtMSZYSD2E9",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 204
        },
        "outputId": "2359076d-4960-4a82-cdad-05576c274d0f"
      },
      "source": [
        "ratings.head(5)"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "execute_result",
          "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_id</th>\n",
              "      <th>anime_id</th>\n",
              "      <th>rating</th>\n",
              "      <th>watching_status</th>\n",
              "      <th>watched_episodes</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>0</td>\n",
              "      <td>67</td>\n",
              "      <td>9</td>\n",
              "      <td>1</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>0</td>\n",
              "      <td>6702</td>\n",
              "      <td>7</td>\n",
              "      <td>1</td>\n",
              "      <td>4</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>0</td>\n",
              "      <td>242</td>\n",
              "      <td>10</td>\n",
              "      <td>1</td>\n",
              "      <td>4</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>0</td>\n",
              "      <td>4898</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>0</td>\n",
              "      <td>21</td>\n",
              "      <td>10</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "   user_id  anime_id  rating  watching_status  watched_episodes\n",
              "0        0        67       9                1                 1\n",
              "1        0      6702       7                1                 4\n",
              "2        0       242      10                1                 4\n",
              "3        0      4898       0                1                 1\n",
              "4        0        21      10                1                 0"
            ]
          },
          "metadata": {},
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6PN9jN7WLVLs"
      },
      "source": [
        "In the dataset, if a person hasn't left a rating to an anime, it was marked as a zero. Let's remove the zeros, as they will just introduce noise later on. Might as well remove the `watched_episodes`."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2rfk98wcLJT_"
      },
      "source": [
        "ratings = ratings[ratings[\"rating\"] > 0]\n",
        "ratings = ratings[ratings[\"watching_status\"] != 1]\n",
        "ratings = ratings.drop(columns = [\"watched_episodes\"])"
      ],
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ldNeDiKFZHo7"
      },
      "source": [
        "def transform(df):\n",
        "    df.loc[df[\"rating\"] <= 5, [\"watching_status\"]] = 0.0\n",
        "    df.loc[df[\"watching_status\"] == 2, [\"watching_status\"]] = 1.0\n",
        "    df.loc[df[\"watching_status\"] == 4, [\"watching_status\"]] = 0.0\n",
        "    \n",
        "    df.rename(columns = {'watching_status': 'interaction'}, inplace = True)"
      ],
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RKPbskD7ZRmA"
      },
      "source": [
        "transform(ratings)"
      ],
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 204
        },
        "id": "hqMLhFwEZV9c",
        "outputId": "6760c63d-0401-415a-e3a8-ff5d49ba1247"
      },
      "source": [
        "ratings.head()"
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "execute_result",
          "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_id</th>\n",
              "      <th>anime_id</th>\n",
              "      <th>rating</th>\n",
              "      <th>interaction</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>11</th>\n",
              "      <td>0</td>\n",
              "      <td>68</td>\n",
              "      <td>6</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>12</th>\n",
              "      <td>0</td>\n",
              "      <td>1689</td>\n",
              "      <td>6</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>13</th>\n",
              "      <td>0</td>\n",
              "      <td>2913</td>\n",
              "      <td>6</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>14</th>\n",
              "      <td>0</td>\n",
              "      <td>1250</td>\n",
              "      <td>7</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>15</th>\n",
              "      <td>0</td>\n",
              "      <td>356</td>\n",
              "      <td>9</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "    user_id  anime_id  rating  interaction\n",
              "11        0        68       6            1\n",
              "12        0      1689       6            1\n",
              "13        0      2913       6            1\n",
              "14        0      1250       7            1\n",
              "15        0       356       9            1"
            ]
          },
          "metadata": {},
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "I596PoxOg2gU",
        "outputId": "13d220ad-0abc-47d7-df25-3d7461d97c66",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "ratings = ratings[ratings[\"interaction\"] < 2]\n",
        "ratings[\"interaction\"].value_counts()"
      ],
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1    51306903\n",
              "0     8422493\n",
              "Name: interaction, dtype: int64"
            ]
          },
          "metadata": {},
          "execution_count": 16
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Z6O_FhTkPIv-",
        "outputId": "30ff161e-575b-4810-f092-a3778407a872"
      },
      "source": [
        "num_users = ratings[\"user_id\"].nunique()\n",
        "num_anime = ratings[\"anime_id\"].nunique()\n",
        "\n",
        "print(f\"There are a total of {num_users} users found.\")\n",
        "print(f\"There are a total of {num_anime} anime found.\")\n",
        "\n",
        "print(\"Max user id:\", ratings[\"user_id\"].max())\n",
        "print(\"Max anime id:\", ratings[\"anime_id\"].max())"
      ],
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "There are a total of 310362 users found.\n",
            "There are a total of 17136 anime found.\n",
            "Max user id: 353404\n",
            "Max anime id: 48456\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JFr1nQ7pK_4D"
      },
      "source": [
        "If we take a look at the anime and user ids, we can notice that some values there are missing. Let's make a two helper functions, for easy conversion between dataset ids and embedding ids."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fdrHdPV3Ptql"
      },
      "source": [
        "embId2user = sorted(ratings[\"user_id\"].unique())\n",
        "embId2anime = sorted(ratings[\"anime_id\"].unique())"
      ],
      "execution_count": 18,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kJB-XaGCQysw"
      },
      "source": [
        "user2embId = {v: k for k, v in enumerate(embId2user)}\n",
        "anime2embId = {v: k for k, v in enumerate(embId2anime)}"
      ],
      "execution_count": 19,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "l15b5d46MbO8"
      },
      "source": [
        "Now, let's make the dataset. It will look like a quadruples of `(user_id, anime_embId, rating, interaction)`. We'll make 3 sets: `train`, `test` and `val`."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xxPODUGFMflP"
      },
      "source": [
        "np.random.seed(seed = 42)\n",
        "\n",
        "def makeDataSet(df, split=0.95):\n",
        "    n = df.to_numpy()\n",
        "    \n",
        "    n = np.random.permutation(n)\n",
        "\n",
        "    x = n[:, :2]\n",
        "    y = n[:, 2:]\n",
        "\n",
        "    for i in range(x.shape[0]):\n",
        "        x[i][0] = user2embId[x[i][0]]\n",
        "        x[i][1] = anime2embId[x[i][1]]\n",
        "\n",
        "    s1 = int(split * n.shape[0])\n",
        "    s2 = s1 + int((1 - split) * n.shape[0] / 10)\n",
        "    \n",
        "    return (x[:s1], y[:s1], x[s1:s2], y[s1:s2], x[s2:], y[s2:])"
      ],
      "execution_count": 20,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "302P1G-FSQw1"
      },
      "source": [
        "x_train, y_train, x_test, y_test, x_val, y_val = makeDataSet(ratings)"
      ],
      "execution_count": 21,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HGUrVu_Rkgtu",
        "outputId": "da20a056-d329-41c2-e7c0-21ff7cc04841"
      },
      "source": [
        "y_train[:, 1].mean()"
      ],
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.8589878851154062"
            ]
          },
          "metadata": {},
          "execution_count": 22
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vpbNLzFSceej"
      },
      "source": [
        "# Models"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sOwjbc59J1Zk",
        "outputId": "036fa88d-6011-4f7d-e932-6650912a87c5"
      },
      "source": [
        "print(\"Num GPUs Available: \", len(tf.config.list_physical_devices('GPU')))"
      ],
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Num GPUs Available:  1\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pAwYHMLee3hm"
      },
      "source": [
        "## Neural Network"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "x2TEgnHvYjM6"
      },
      "source": [
        "class HybridNeuralNetworkModel(tf.keras.Model):\n",
        "    def __init__(self, num_users, num_items, embedding_dim):\n",
        "        super(HybridNeuralNetworkModel, self).__init__()\n",
        "        \n",
        "        self.embedding_dim = embedding_dim\n",
        "        \n",
        "        self.user_embeddings = tf.keras.layers.Embedding(num_users, embedding_dim)\n",
        "        self.item_embeddings = tf.keras.layers.Embedding(num_items, embedding_dim)\n",
        "\n",
        "        self.dense1 = tf.keras.layers.Dense(64, activation='relu')\n",
        "        self.dense2 = tf.keras.layers.Dense(1, activation='relu')\n",
        "        \n",
        "        self.dense3 = tf.keras.layers.Dense(1, activation='sigmoid')\n",
        "\n",
        "        self.concat = tf.keras.layers.Concatenate()\n",
        "        self.dropout = tf.keras.layers.Dropout(.5)\n",
        "\n",
        "    def call(self, inputs, training = False):\n",
        "        user_ids = inputs[:, 0]\n",
        "        item_ids = inputs[:, 1]\n",
        "\n",
        "        user_embedding = self.user_embeddings(user_ids)\n",
        "        item_embedding = self.item_embeddings(item_ids)\n",
        "\n",
        "        if training:\n",
        "            user_embedding = self.dropout(user_embedding, training = training)\n",
        "            item_embedding = self.dropout(item_embedding, training = training)\n",
        "\n",
        "        user_embedding = tf.reshape(user_embedding, [-1, self.embedding_dim])\n",
        "        item_embedding = tf.reshape(item_embedding, [-1, self.embedding_dim])\n",
        "\n",
        "        conc = self.concat([user_embedding, item_embedding])\n",
        "        x = self.dense1(conc)\n",
        "        \n",
        "        x1 = self.dense2(x)\n",
        "        x2 = self.dense3(x)\n",
        "\n",
        "        return x1, x2"
      ],
      "execution_count": 24,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7Z3Rx76ydbG-"
      },
      "source": [
        "hnn_model = HybridNeuralNetworkModel(num_users = num_users, \n",
        "                                     num_items = num_anime, \n",
        "                                     embedding_dim = 64)\n",
        "\n",
        "hnn_model.compile(\n",
        "    optimizer = tf.keras.optimizers.Adam(),\n",
        "    loss = {\n",
        "        \"output_1\": tf.keras.losses.MeanSquaredError(),\n",
        "        \"output_2\": tf.keras.losses.BinaryCrossentropy()\n",
        "    },\n",
        "    loss_weights = {\n",
        "        \"output_1\": 1.0,\n",
        "        \"output_2\": 5.0\n",
        "    },\n",
        "    metrics = {\n",
        "        \"output_1\": [\n",
        "            tf.keras.metrics.RootMeanSquaredError(\"RMSE\")\n",
        "        ],\n",
        "        \"output_2\": [\n",
        "            tf.keras.metrics.BinaryAccuracy(\"Acc\"),\n",
        "            tf.keras.metrics.Precision(name = \"P\"),\n",
        "            tf.keras.metrics.Recall(name = \"R\")\n",
        "        ]\n",
        "    },\n",
        "    run_eagerly = True\n",
        ")"
      ],
      "execution_count": 27,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9PDFoTbcdkoK",
        "outputId": "3a0a455f-67f9-431b-ac34-ba7037aba31b"
      },
      "source": [
        "callback = tf.keras.callbacks.EarlyStopping(monitor = 'loss', patience = 3)\n",
        "\n",
        "history = hnn_model.fit(\n",
        "    x = x_train, \n",
        "    y = {\n",
        "        \"output_1\": y_train[:, 0],\n",
        "        \"output_2\": y_train[:, 1]\n",
        "    },\n",
        "    batch_size = 64, \n",
        "    epochs = 100, \n",
        "    steps_per_epoch = 1000,\n",
        "    callbacks = [callback],\n",
        "    validation_data = (x_test, {\n",
        "        \"output_1\": y_test[:, 0],\n",
        "        \"output_2\": y_test[:, 1]\n",
        "    }),\n",
        "    validation_steps = 10,\n",
        "    validation_batch_size = 64\n",
        ")"
      ],
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/100\n",
            "1000/1000 [==============================] - 40s 37ms/step - loss: 11.7496 - output_1_loss: 9.6836 - output_2_loss: 0.4132 - output_1_RMSE: 3.1118 - output_2_Acc: 0.8537 - output_2_P: 0.8578 - output_2_R: 0.9943 - val_loss: 4.6529 - val_output_1_loss: 2.8144 - val_output_2_loss: 0.3677 - val_output_1_RMSE: 1.6776 - val_output_2_Acc: 0.8641 - val_output_2_P: 0.8641 - val_output_2_R: 1.0000\n",
            "Epoch 2/100\n",
            "1000/1000 [==============================] - 37s 37ms/step - loss: 4.4881 - output_1_loss: 2.6609 - output_2_loss: 0.3655 - output_1_RMSE: 1.6312 - output_2_Acc: 0.8635 - output_2_P: 0.8651 - output_2_R: 0.9971 - val_loss: 4.5685 - val_output_1_loss: 2.7619 - val_output_2_loss: 0.3613 - val_output_1_RMSE: 1.6619 - val_output_2_Acc: 0.8656 - val_output_2_P: 0.8712 - val_output_2_R: 0.9910\n",
            "Epoch 3/100\n",
            "1000/1000 [==============================] - 37s 37ms/step - loss: 4.3435 - output_1_loss: 2.5452 - output_2_loss: 0.3597 - output_1_RMSE: 1.5954 - output_2_Acc: 0.8647 - output_2_P: 0.8692 - output_2_R: 0.9921 - val_loss: 4.4326 - val_output_1_loss: 2.6603 - val_output_2_loss: 0.3545 - val_output_1_RMSE: 1.6310 - val_output_2_Acc: 0.8672 - val_output_2_P: 0.8714 - val_output_2_R: 0.9928\n",
            "Epoch 4/100\n",
            "1000/1000 [==============================] - 37s 37ms/step - loss: 4.2254 - output_1_loss: 2.4659 - output_2_loss: 0.3519 - output_1_RMSE: 1.5703 - output_2_Acc: 0.8669 - output_2_P: 0.8722 - output_2_R: 0.9900 - val_loss: 4.4222 - val_output_1_loss: 2.6531 - val_output_2_loss: 0.3538 - val_output_1_RMSE: 1.6288 - val_output_2_Acc: 0.8719 - val_output_2_P: 0.8756 - val_output_2_R: 0.9928\n",
            "Epoch 5/100\n",
            "1000/1000 [==============================] - 37s 37ms/step - loss: 4.1976 - output_1_loss: 2.4521 - output_2_loss: 0.3491 - output_1_RMSE: 1.5659 - output_2_Acc: 0.8664 - output_2_P: 0.8737 - output_2_R: 0.9872 - val_loss: 4.2866 - val_output_1_loss: 2.5566 - val_output_2_loss: 0.3460 - val_output_1_RMSE: 1.5989 - val_output_2_Acc: 0.8703 - val_output_2_P: 0.8742 - val_output_2_R: 0.9928\n",
            "Epoch 6/100\n",
            "1000/1000 [==============================] - 36s 36ms/step - loss: 4.1160 - output_1_loss: 2.4036 - output_2_loss: 0.3425 - output_1_RMSE: 1.5504 - output_2_Acc: 0.8687 - output_2_P: 0.8756 - output_2_R: 0.9877 - val_loss: 4.2923 - val_output_1_loss: 2.5654 - val_output_2_loss: 0.3454 - val_output_1_RMSE: 1.6017 - val_output_2_Acc: 0.8734 - val_output_2_P: 0.8782 - val_output_2_R: 0.9910\n",
            "Epoch 7/100\n",
            "1000/1000 [==============================] - 37s 37ms/step - loss: 4.0517 - output_1_loss: 2.3622 - output_2_loss: 0.3379 - output_1_RMSE: 1.5370 - output_2_Acc: 0.8699 - output_2_P: 0.8778 - output_2_R: 0.9858 - val_loss: 4.1615 - val_output_1_loss: 2.4792 - val_output_2_loss: 0.3365 - val_output_1_RMSE: 1.5745 - val_output_2_Acc: 0.8828 - val_output_2_P: 0.8855 - val_output_2_R: 0.9928\n",
            "Epoch 8/100\n",
            "1000/1000 [==============================] - 37s 37ms/step - loss: 3.9711 - output_1_loss: 2.2943 - output_2_loss: 0.3354 - output_1_RMSE: 1.5147 - output_2_Acc: 0.8717 - output_2_P: 0.8797 - output_2_R: 0.9855 - val_loss: 4.1112 - val_output_1_loss: 2.4465 - val_output_2_loss: 0.3329 - val_output_1_RMSE: 1.5641 - val_output_2_Acc: 0.8828 - val_output_2_P: 0.8880 - val_output_2_R: 0.9892\n",
            "Epoch 9/100\n",
            "1000/1000 [==============================] - 37s 37ms/step - loss: 3.9757 - output_1_loss: 2.2988 - output_2_loss: 0.3354 - output_1_RMSE: 1.5162 - output_2_Acc: 0.8695 - output_2_P: 0.8787 - output_2_R: 0.9836 - val_loss: 4.0279 - val_output_1_loss: 2.4189 - val_output_2_loss: 0.3218 - val_output_1_RMSE: 1.5553 - val_output_2_Acc: 0.8828 - val_output_2_P: 0.8867 - val_output_2_R: 0.9910\n",
            "Epoch 10/100\n",
            "1000/1000 [==============================] - 36s 36ms/step - loss: 3.9507 - output_1_loss: 2.2833 - output_2_loss: 0.3335 - output_1_RMSE: 1.5111 - output_2_Acc: 0.8712 - output_2_P: 0.8801 - output_2_R: 0.9839 - val_loss: 3.9641 - val_output_1_loss: 2.3770 - val_output_2_loss: 0.3174 - val_output_1_RMSE: 1.5418 - val_output_2_Acc: 0.8797 - val_output_2_P: 0.8889 - val_output_2_R: 0.9837\n",
            "Epoch 11/100\n",
            "1000/1000 [==============================] - 36s 36ms/step - loss: 3.8914 - output_1_loss: 2.2510 - output_2_loss: 0.3281 - output_1_RMSE: 1.5003 - output_2_Acc: 0.8730 - output_2_P: 0.8823 - output_2_R: 0.9833 - val_loss: 4.0041 - val_output_1_loss: 2.3946 - val_output_2_loss: 0.3219 - val_output_1_RMSE: 1.5475 - val_output_2_Acc: 0.8797 - val_output_2_P: 0.8876 - val_output_2_R: 0.9855\n",
            "Epoch 12/100\n",
            "1000/1000 [==============================] - 36s 36ms/step - loss: 3.8570 - output_1_loss: 2.2153 - output_2_loss: 0.3283 - output_1_RMSE: 1.4884 - output_2_Acc: 0.8724 - output_2_P: 0.8821 - output_2_R: 0.9830 - val_loss: 3.9447 - val_output_1_loss: 2.3315 - val_output_2_loss: 0.3226 - val_output_1_RMSE: 1.5269 - val_output_2_Acc: 0.8828 - val_output_2_P: 0.8918 - val_output_2_R: 0.9837\n",
            "Epoch 13/100\n",
            "1000/1000 [==============================] - 36s 36ms/step - loss: 3.8777 - output_1_loss: 2.2322 - output_2_loss: 0.3291 - output_1_RMSE: 1.4941 - output_2_Acc: 0.8715 - output_2_P: 0.8823 - output_2_R: 0.9810 - val_loss: 3.8830 - val_output_1_loss: 2.2989 - val_output_2_loss: 0.3168 - val_output_1_RMSE: 1.5162 - val_output_2_Acc: 0.8859 - val_output_2_P: 0.8934 - val_output_2_R: 0.9855\n",
            "Epoch 14/100\n",
            "1000/1000 [==============================] - 36s 36ms/step - loss: 3.8088 - output_1_loss: 2.1859 - output_2_loss: 0.3246 - output_1_RMSE: 1.4785 - output_2_Acc: 0.8737 - output_2_P: 0.8841 - output_2_R: 0.9818 - val_loss: 3.9412 - val_output_1_loss: 2.3327 - val_output_2_loss: 0.3217 - val_output_1_RMSE: 1.5273 - val_output_2_Acc: 0.8828 - val_output_2_P: 0.8880 - val_output_2_R: 0.9892\n",
            "Epoch 15/100\n",
            "1000/1000 [==============================] - 36s 36ms/step - loss: 3.8008 - output_1_loss: 2.1762 - output_2_loss: 0.3249 - output_1_RMSE: 1.4752 - output_2_Acc: 0.8738 - output_2_P: 0.8837 - output_2_R: 0.9822 - val_loss: 3.9385 - val_output_1_loss: 2.3241 - val_output_2_loss: 0.3229 - val_output_1_RMSE: 1.5245 - val_output_2_Acc: 0.8844 - val_output_2_P: 0.8894 - val_output_2_R: 0.9892\n",
            "Epoch 16/100\n",
            "1000/1000 [==============================] - 36s 36ms/step - loss: 3.7971 - output_1_loss: 2.1906 - output_2_loss: 0.3213 - output_1_RMSE: 1.4801 - output_2_Acc: 0.8744 - output_2_P: 0.8844 - output_2_R: 0.9825 - val_loss: 3.9467 - val_output_1_loss: 2.3560 - val_output_2_loss: 0.3181 - val_output_1_RMSE: 1.5349 - val_output_2_Acc: 0.8859 - val_output_2_P: 0.8974 - val_output_2_R: 0.9801\n",
            "Epoch 17/100\n",
            "1000/1000 [==============================] - 37s 37ms/step - loss: 3.7483 - output_1_loss: 2.1535 - output_2_loss: 0.3190 - output_1_RMSE: 1.4675 - output_2_Acc: 0.8770 - output_2_P: 0.8867 - output_2_R: 0.9828 - val_loss: 3.8269 - val_output_1_loss: 2.2448 - val_output_2_loss: 0.3164 - val_output_1_RMSE: 1.4983 - val_output_2_Acc: 0.8922 - val_output_2_P: 0.9020 - val_output_2_R: 0.9819\n",
            "Epoch 18/100\n",
            "1000/1000 [==============================] - 36s 36ms/step - loss: 3.7474 - output_1_loss: 2.1476 - output_2_loss: 0.3200 - output_1_RMSE: 1.4655 - output_2_Acc: 0.8752 - output_2_P: 0.8862 - output_2_R: 0.9809 - val_loss: 3.7929 - val_output_1_loss: 2.2371 - val_output_2_loss: 0.3112 - val_output_1_RMSE: 1.4957 - val_output_2_Acc: 0.8875 - val_output_2_P: 0.8962 - val_output_2_R: 0.9837\n",
            "Epoch 19/100\n",
            "1000/1000 [==============================] - 36s 36ms/step - loss: 3.7532 - output_1_loss: 2.1411 - output_2_loss: 0.3224 - output_1_RMSE: 1.4633 - output_2_Acc: 0.8738 - output_2_P: 0.8848 - output_2_R: 0.9806 - val_loss: 3.7208 - val_output_1_loss: 2.1951 - val_output_2_loss: 0.3051 - val_output_1_RMSE: 1.4816 - val_output_2_Acc: 0.8828 - val_output_2_P: 0.8983 - val_output_2_R: 0.9747\n",
            "Epoch 20/100\n",
            "1000/1000 [==============================] - 36s 36ms/step - loss: 3.7059 - output_1_loss: 2.1200 - output_2_loss: 0.3172 - output_1_RMSE: 1.4560 - output_2_Acc: 0.8764 - output_2_P: 0.8874 - output_2_R: 0.9804 - val_loss: 3.7534 - val_output_1_loss: 2.2394 - val_output_2_loss: 0.3028 - val_output_1_RMSE: 1.4965 - val_output_2_Acc: 0.8938 - val_output_2_P: 0.8995 - val_output_2_R: 0.9873\n",
            "Epoch 21/100\n",
            "1000/1000 [==============================] - 36s 36ms/step - loss: 3.6961 - output_1_loss: 2.1160 - output_2_loss: 0.3160 - output_1_RMSE: 1.4546 - output_2_Acc: 0.8770 - output_2_P: 0.8881 - output_2_R: 0.9805 - val_loss: 3.7750 - val_output_1_loss: 2.2532 - val_output_2_loss: 0.3044 - val_output_1_RMSE: 1.5011 - val_output_2_Acc: 0.8844 - val_output_2_P: 0.8946 - val_output_2_R: 0.9819\n",
            "Epoch 22/100\n",
            "1000/1000 [==============================] - 36s 36ms/step - loss: 3.6964 - output_1_loss: 2.1164 - output_2_loss: 0.3160 - output_1_RMSE: 1.4548 - output_2_Acc: 0.8772 - output_2_P: 0.8884 - output_2_R: 0.9805 - val_loss: 3.6705 - val_output_1_loss: 2.1648 - val_output_2_loss: 0.3011 - val_output_1_RMSE: 1.4713 - val_output_2_Acc: 0.8844 - val_output_2_P: 0.8959 - val_output_2_R: 0.9801\n",
            "Epoch 23/100\n",
            "1000/1000 [==============================] - 36s 36ms/step - loss: 3.6893 - output_1_loss: 2.1045 - output_2_loss: 0.3170 - output_1_RMSE: 1.4507 - output_2_Acc: 0.8762 - output_2_P: 0.8874 - output_2_R: 0.9804 - val_loss: 3.6481 - val_output_1_loss: 2.1343 - val_output_2_loss: 0.3028 - val_output_1_RMSE: 1.4609 - val_output_2_Acc: 0.8875 - val_output_2_P: 0.9015 - val_output_2_R: 0.9765\n",
            "Epoch 24/100\n",
            "1000/1000 [==============================] - 36s 36ms/step - loss: 3.6625 - output_1_loss: 2.0897 - output_2_loss: 0.3146 - output_1_RMSE: 1.4456 - output_2_Acc: 0.8781 - output_2_P: 0.8892 - output_2_R: 0.9804 - val_loss: 3.6673 - val_output_1_loss: 2.1581 - val_output_2_loss: 0.3018 - val_output_1_RMSE: 1.4690 - val_output_2_Acc: 0.8859 - val_output_2_P: 0.9013 - val_output_2_R: 0.9747\n",
            "Epoch 25/100\n",
            "1000/1000 [==============================] - 37s 37ms/step - loss: 3.6295 - output_1_loss: 2.0659 - output_2_loss: 0.3127 - output_1_RMSE: 1.4373 - output_2_Acc: 0.8775 - output_2_P: 0.8897 - output_2_R: 0.9790 - val_loss: 3.6768 - val_output_1_loss: 2.1553 - val_output_2_loss: 0.3043 - val_output_1_RMSE: 1.4681 - val_output_2_Acc: 0.8859 - val_output_2_P: 0.9000 - val_output_2_R: 0.9765\n",
            "Epoch 26/100\n",
            "1000/1000 [==============================] - 36s 36ms/step - loss: 3.6707 - output_1_loss: 2.0830 - output_2_loss: 0.3175 - output_1_RMSE: 1.4433 - output_2_Acc: 0.8765 - output_2_P: 0.8880 - output_2_R: 0.9800 - val_loss: 3.5857 - val_output_1_loss: 2.0950 - val_output_2_loss: 0.2981 - val_output_1_RMSE: 1.4474 - val_output_2_Acc: 0.8906 - val_output_2_P: 0.9005 - val_output_2_R: 0.9819\n",
            "Epoch 27/100\n",
            "1000/1000 [==============================] - 36s 36ms/step - loss: 3.6798 - output_1_loss: 2.0886 - output_2_loss: 0.3182 - output_1_RMSE: 1.4452 - output_2_Acc: 0.8742 - output_2_P: 0.8865 - output_2_R: 0.9783 - val_loss: 3.6890 - val_output_1_loss: 2.1662 - val_output_2_loss: 0.3046 - val_output_1_RMSE: 1.4718 - val_output_2_Acc: 0.8922 - val_output_2_P: 0.9047 - val_output_2_R: 0.9783\n",
            "Epoch 28/100\n",
            "1000/1000 [==============================] - 36s 36ms/step - loss: 3.6253 - output_1_loss: 2.0575 - output_2_loss: 0.3136 - output_1_RMSE: 1.4344 - output_2_Acc: 0.8776 - output_2_P: 0.8895 - output_2_R: 0.9790 - val_loss: 3.5788 - val_output_1_loss: 2.0718 - val_output_2_loss: 0.3014 - val_output_1_RMSE: 1.4394 - val_output_2_Acc: 0.9000 - val_output_2_P: 0.9015 - val_output_2_R: 0.9928\n",
            "Epoch 29/100\n",
            "1000/1000 [==============================] - 36s 36ms/step - loss: 3.6602 - output_1_loss: 2.0762 - output_2_loss: 0.3168 - output_1_RMSE: 1.4409 - output_2_Acc: 0.8763 - output_2_P: 0.8883 - output_2_R: 0.9787 - val_loss: 3.6522 - val_output_1_loss: 2.1237 - val_output_2_loss: 0.3057 - val_output_1_RMSE: 1.4573 - val_output_2_Acc: 0.8875 - val_output_2_P: 0.8988 - val_output_2_R: 0.9801\n",
            "Epoch 30/100\n",
            "1000/1000 [==============================] - 36s 36ms/step - loss: 3.5855 - output_1_loss: 2.0278 - output_2_loss: 0.3115 - output_1_RMSE: 1.4240 - output_2_Acc: 0.8785 - output_2_P: 0.8903 - output_2_R: 0.9794 - val_loss: 3.5804 - val_output_1_loss: 2.0632 - val_output_2_loss: 0.3034 - val_output_1_RMSE: 1.4364 - val_output_2_Acc: 0.8922 - val_output_2_P: 0.9033 - val_output_2_R: 0.9801\n",
            "Epoch 31/100\n",
            "1000/1000 [==============================] - 36s 36ms/step - loss: 3.6310 - output_1_loss: 2.0559 - output_2_loss: 0.3150 - output_1_RMSE: 1.4338 - output_2_Acc: 0.8750 - output_2_P: 0.8880 - output_2_R: 0.9774 - val_loss: 3.6162 - val_output_1_loss: 2.0939 - val_output_2_loss: 0.3045 - val_output_1_RMSE: 1.4470 - val_output_2_Acc: 0.8859 - val_output_2_P: 0.8987 - val_output_2_R: 0.9783\n",
            "Epoch 32/100\n",
            "1000/1000 [==============================] - 36s 36ms/step - loss: 3.6129 - output_1_loss: 2.0325 - output_2_loss: 0.3161 - output_1_RMSE: 1.4257 - output_2_Acc: 0.8779 - output_2_P: 0.8892 - output_2_R: 0.9797 - val_loss: 3.5702 - val_output_1_loss: 2.0691 - val_output_2_loss: 0.3002 - val_output_1_RMSE: 1.4384 - val_output_2_Acc: 0.8906 - val_output_2_P: 0.8979 - val_output_2_R: 0.9855\n",
            "Epoch 33/100\n",
            "1000/1000 [==============================] - 36s 36ms/step - loss: 3.6313 - output_1_loss: 2.0656 - output_2_loss: 0.3131 - output_1_RMSE: 1.4372 - output_2_Acc: 0.8771 - output_2_P: 0.8893 - output_2_R: 0.9784 - val_loss: 3.5872 - val_output_1_loss: 2.0719 - val_output_2_loss: 0.3031 - val_output_1_RMSE: 1.4394 - val_output_2_Acc: 0.8906 - val_output_2_P: 0.9032 - val_output_2_R: 0.9783\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MHZXZe9agMJz"
      },
      "source": [
        "hnn_model.save_weights(\n",
        "    \"/content/drive/Shareddrives/ML/Anime RecSys/Hybrid/NeuralNetworkModel/model\", overwrite=True\n",
        ")"
      ],
      "execution_count": 29,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "038DIWBigTxo",
        "outputId": "26061914-b9da-460c-e623-035ba6eacb1b"
      },
      "source": [
        "hnn_model.load_weights(\n",
        "    \"/content/drive/Shareddrives/ML/Anime RecSys/Hybrid/NeuralNetworkModel/model\"\n",
        ")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tensorflow.python.training.tracking.util.CheckpointLoadStatus at 0x7f8347e4ebd0>"
            ]
          },
          "metadata": {},
          "execution_count": 18
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DUdCmooRYjq4"
      },
      "source": [
        "## Comparing the models"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PTxFvxrbYna3",
        "outputId": "e1cfcb0a-2288-4213-a2f6-f6b0608949c1"
      },
      "source": [
        "hnn_model.evaluate(x = x_val, y = [y_val[:, 0], y_val[:, 1]])"
      ],
      "execution_count": 30,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "83995/83995 [==============================] - 1674s 20ms/step - loss: 3.5091 - output_1_loss: 1.9694 - output_2_loss: 0.3079 - output_1_RMSE: 1.4034 - output_2_Acc: 0.8790 - output_2_P: 0.8931 - output_2_R: 0.9759\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[3.5090746879577637,\n",
              " 1.969431757926941,\n",
              " 0.30792486667633057,\n",
              " 1.4033644199371338,\n",
              " 0.8789761066436768,\n",
              " 0.8931456804275513,\n",
              " 0.9758570194244385]"
            ]
          },
          "metadata": {},
          "execution_count": 30
        }
      ]
    }
  ]
}