gmf_with_full_dataset.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "gmf-with-full-dataset.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "code",
      "metadata": {
        "id": "Gk_HnEcbdmms"
      },
      "source": [
        "import datetime\n",
        "import gc\n",
        "import random\n",
        "import time\n",
        "\n",
        "import numpy\n",
        "import pandas\n",
        "import scipy\n",
        "import matplotlib.pyplot as plt\n",
        "import IPython.display as disp\n",
        "\n",
        "class Progress:\n",
        "    \"\"\"Wrapper for IPython.display.ProgressBar with improved performance\"\"\"\n",
        "\n",
        "    def __init__(self, total):\n",
        "        self.bar = disp.ProgressBar(total)\n",
        "        self.progress = 0\n",
        "        self.last = 0\n",
        "    def inc(self):\n",
        "        self.progress += 1\n",
        "        if time.monotonic_ns() - self.last > 1e8:\n",
        "            self.bar.progress = self.progress\n",
        "            self.bar.update()\n",
        "            self.last = time.monotonic_ns()\n",
        "    def __enter__(self):\n",
        "        return self\n",
        "    def __exit__(self, exc_type, exc_value, tb):\n",
        "        self.bar.progress = self.progress\n",
        "        self.bar.update()\n",
        "        return False"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NHqttWltd1kM",
        "outputId": "8fe818b9-7aae-4a92-e780-6ac796960f40"
      },
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount(\"/content/drive\", force_remount=True).\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-t1jMVsOd2dI"
      },
      "source": [
        "!test -d dataset || unzip /content/drive/Shareddrives/'STAT4609 Netflix'/dataset.zip -d dataset"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bdSTf2E8PK1_"
      },
      "source": [
        "!cp /content/drive/Shareddrives/'STAT4609 Netflix'/preprocess-dataset /usr/local/bin\n",
        "!chmod +x /usr/local/bin/preprocess-dataset\n",
        "!test -f dataset/output.npy || (cd dataset && preprocess-dataset)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "szSgxRM2PIiI",
        "outputId": "e048130e-5f43-41a6-f6e7-16fa701da675"
      },
      "source": [
        "print(\"Loading data...\")\n",
        "data = numpy.load(\"dataset/output.npy\")\n",
        "data_size = data.shape[0]\n",
        "\n",
        "data = data[data[:, 0] < 100000, :]\n",
        "\n",
        "print(\"Counting users and movies\")\n",
        "user_count = numpy.max(data[:, 0]) + 1\n",
        "movie_count = numpy.max(data[:, 1]) + 1"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Loading data...\n",
            "Counting users and movies\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "q2_xuP8jFFvn",
        "outputId": "8409ccce-5ebc-4126-d959-50d148b0e4e7"
      },
      "source": [
        "import numpy as np\n",
        "np.set_printoptions(suppress=True)\n",
        "print(data)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[    0     0     3 ...   248     1     0]\n",
            " [    1     0     5 ...   132     4     0]\n",
            " [    2     0     4 ...   291     2     0]\n",
            " ...\n",
            " [29251  8196     1 ...   219     5     0]\n",
            " [22793  8196     4 ...   148     4     0]\n",
            " [76269  8196     2 ...    68     3     0]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "O1CQxQFNGwZS",
        "outputId": "ae83a775-027c-45ba-ef06-46f9f5e3f02a"
      },
      "source": [
        "train = data[data[:, 6] == 0, :3].copy()\n",
        "evaluation = data[data[:, 6] == 1, :3].copy()\n",
        "\n",
        "del data\n",
        "gc.collect()\n",
        "\n",
        "print(f\"Train/test split: {train.shape[0]}/{evaluation.shape[0]}\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Train/test split: 47676921/301977\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "d7fALDkvd8n1"
      },
      "source": [
        "Model:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "beY7RtYX0xEm"
      },
      "source": [
        "from __future__ import print_function\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "import torch"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ttbU5ZgkExC8",
        "outputId": "11657dc3-a5d3-4b79-bb1e-24ca3911c125"
      },
      "source": [
        "# Training settings\n",
        "batch_size = 6400\n",
        "test_batch_size = 1000\n",
        "epochs = 5\n",
        "lr = 1.0\n",
        "gamma = 0.7\n",
        "seed = 1\n",
        "log_interval = 120\n",
        "save_model = True\n",
        "use_cuda = torch.cuda.is_available()\n",
        "torch.manual_seed(seed)\n",
        "device = torch.device(\"cuda\" if use_cuda else \"cpu\")\n",
        "print(device)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "cuda\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qdzVR2auE4Qi"
      },
      "source": [
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "\n",
        "class Feedforward(torch.nn.Module):\n",
        "    def __init__(self, user_size, movie_size, hidden_size):\n",
        "        super(Feedforward, self).__init__()\n",
        "        self.user_size = user_size\n",
        "        self.movie_size = movie_size\n",
        "        self.hidden_size  = hidden_size\n",
        "        self.embedding_user = torch.nn.Embedding(num_embeddings=self.user_size, embedding_dim=self.hidden_size)\n",
        "        self.embedding_movie = torch.nn.Embedding(num_embeddings=self.movie_size, embedding_dim=self.hidden_size)\n",
        "        self.fc1 = torch.nn.Linear(self.hidden_size, 1)\n",
        "        self.relu = torch.nn.ReLU()\n",
        "    def forward(self, user_id, movie_id):\n",
        "        user_embedding = self.embedding_user(user_id)\n",
        "        movie_embedding = self.embedding_movie(movie_id)\n",
        "        mul = torch.mul(user_embedding, movie_embedding)\n",
        "\n",
        "        output = self.fc1(mul)\n",
        "        return output"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dsPpUvquE825"
      },
      "source": [
        "# Optimizer \n",
        "import torch.optim as optim\n",
        "from torch.optim.lr_scheduler import StepLR\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9MLJ7_BZE-5-"
      },
      "source": [
        "class GeneralizedMatrixFactorization2:\n",
        "    def __init__(self, rank, epochs):\n",
        "        # model define here\n",
        "        self.model = Feedforward(user_count, movie_count, rank)\n",
        "        self.model = self.model.to(device)\n",
        "        self.criterion = nn.MSELoss()\n",
        "        \n",
        "        self.optimizer = optim.Adadelta(self.model.parameters(), lr=lr)\n",
        "        self.scheduler = StepLR(self.optimizer, step_size=1, gamma=gamma)\n",
        "\n",
        "        self.rank = rank\n",
        "        self.epochs = epochs\n",
        "\n",
        "    def train(self, ratings):\n",
        "        data_loader = torch.utils.data.DataLoader(ratings, batch_size=64)\n",
        "        self.model.train()\n",
        "        history = []\n",
        "        idx = 0\n",
        "        with Progress(self.epochs * len(data_loader)) as progress:\n",
        "            for epoch in range(self.epochs):\n",
        "                try:\n",
        "                    mse = 0\n",
        "                    for batch_idx, (user, movie, target) in enumerate(data_loader):\n",
        "                        user = user.to(device)\n",
        "                        movie = movie.to(device)\n",
        "                        target = target.to(device)\n",
        "                        # set the gradients to zero to avoid unwanted gradient accumulation, see \n",
        "                        # https://stackoverflow.com/questions/48001598/why-do-we-need-to-call-zero-grad-in-pytorch\n",
        "                        self.optimizer.zero_grad()\n",
        "                        \n",
        "                        # get model prediction\n",
        "                        output = self.model(user, movie)\n",
        "                        \n",
        "                        # insert you own loss fucntion here, note that we implemented a log_softmax() in our model\n",
        "                        loss = self.criterion(output.view(-1).float(), target.float())\n",
        "    \n",
        "                        mse += float(loss)\n",
        "                        \n",
        "                        # perform back propagation\n",
        "                        loss.backward()\n",
        "    \n",
        "                        self.optimizer.step()\n",
        "                        \n",
        "                        # update parameters\n",
        "                        progress.inc()\n",
        "                except KeyboardInterrupt:\n",
        "                    break\n",
        "                \n",
        "                history.append(np.sqrt(mse / len(data_loader)))\n",
        "                print(f\"Epoch {epoch}, mse = {mse / len(data_loader)}\")\n",
        "\n",
        "        plt.xlabel(\"Epochs\")\n",
        "        plt.ylabel(\"RMSE\")\n",
        "        plt.plot(np.arange(self.epochs), history)\n",
        "        plt.show()\n",
        "\n",
        "        return self\n",
        "\n",
        "    def predict(self, user, movie):\n",
        "        return float(self.model(torch.Tensor([user]).int().to(device),torch.Tensor([movie]).int().to(device)))\n",
        "\n",
        "    def evaluate(self, evaluation):\n",
        "        self.model.eval()\n",
        "        se = 0\n",
        "        for user, movie, rating in evaluation:\n",
        "            err = self.predict(user, movie) - float(rating)\n",
        "            se += err ** 2\n",
        "        print(\"Test RMSE: {}\".format(np.sqrt(se/len(evaluation))))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uOY18n9vXldM"
      },
      "source": [
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "\n",
        "class Feedforward2(torch.nn.Module):\n",
        "    def __init__(self, user_size, movie_size, hidden_size):\n",
        "        super(Feedforward2, self).__init__()\n",
        "        self.user_size = user_size\n",
        "        self.movie_size = movie_size\n",
        "        self.hidden_size  = hidden_size\n",
        "        self.embedding_user = torch.nn.Embedding(num_embeddings=self.user_size, embedding_dim=self.hidden_size)\n",
        "        self.embedding_movie = torch.nn.Embedding(num_embeddings=self.movie_size, embedding_dim=self.hidden_size)\n",
        "        self.fc1 = torch.nn.Linear(self.hidden_size, 1)\n",
        "    def forward(self, user_id, movie_id):\n",
        "        user_embedding = self.embedding_user(user_id)\n",
        "        movie_embedding = self.embedding_movie(movie_id)\n",
        "        mul = torch.mul(user_embedding, movie_embedding)\n",
        "\n",
        "        output = self.fc1(mul)\n",
        "        return output"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9oRq9C_FCVe0"
      },
      "source": [
        "class GeneralizedMatrixFactorization2:\n",
        "    def __init__(self, rank, learning_rate, gamma, batch_size, training_time):\n",
        "        # model define here\n",
        "        self.model = Feedforward2(user_count, movie_count, rank)\n",
        "        self.model = self.model.to(device)\n",
        "        self.criterion = nn.MSELoss()\n",
        "        \n",
        "        self.optimizer = optim.Adadelta(self.model.parameters(), lr=learning_rate, weight_decay=0.0)\n",
        "        self.scheduler = StepLR(self.optimizer, step_size=1, gamma=gamma)\n",
        "\n",
        "        self.rank = rank\n",
        "        self.batch_size = batch_size\n",
        "\n",
        "        self.training_time = training_time\n",
        "\n",
        "    def train(self, ratings):\n",
        "        data_loader = torch.utils.data.DataLoader(ratings, batch_size=self.batch_size)\n",
        "        self.model.train()\n",
        "        history = []\n",
        "        idx = 0\n",
        "        epoch = 0\n",
        "        with Progress(100 * len(data_loader)) as progress:\n",
        "            start_time = time.time()\n",
        "            while time.time() - start_time < self.training_time:\n",
        "                try:\n",
        "                    mse = 0\n",
        "                    for batch_idx, batch in enumerate(data_loader):\n",
        "                        user = batch[:, 0]\n",
        "                        movie = batch[:, 1]\n",
        "                        target = batch[:, 2]\n",
        "                        user = user.to(device)\n",
        "                        movie = movie.to(device)\n",
        "                        target = target.to(device)\n",
        "                        # set the gradients to zero to avoid unwanted gradient accumulation, see \n",
        "                        # https://stackoverflow.com/questions/48001598/why-do-we-need-to-call-zero-grad-in-pytorch\n",
        "                        self.optimizer.zero_grad()\n",
        "                        \n",
        "                        # get model prediction\n",
        "                        output = self.model(user, movie)\n",
        "                        \n",
        "                        # insert you own loss fucntion here, note that we implemented a log_softmax() in our model\n",
        "                        loss = self.criterion(output.view(-1).float(), target.float())\n",
        "    \n",
        "                        mse += float(loss)\n",
        "                        \n",
        "                        # perform back propagation\n",
        "                        loss.backward()\n",
        "    \n",
        "                        self.optimizer.step()\n",
        "                        \n",
        "                        # update parameters\n",
        "                        progress.inc()\n",
        "                except KeyboardInterrupt:\n",
        "                    break\n",
        "                finally:\n",
        "                    history.append(np.sqrt(mse / len(data_loader)))\n",
        "                    print(f\"Epoch {epoch} ({(time.time() - start_time) / 60} min), mse = {mse / len(data_loader)}\")\n",
        "                    epoch += 1\n",
        "\n",
        "        plt.xlabel(\"Epochs\")\n",
        "        plt.ylabel(\"RMSE\")\n",
        "        plt.plot(np.arange(epoch), history)\n",
        "        plt.show()\n",
        "\n",
        "        return self\n",
        "\n",
        "    def predict(self, user, movie):\n",
        "        return float(self.model(torch.Tensor([user]).int().to(device),torch.Tensor([movie]).int().to(device)))\n",
        "\n",
        "    def evaluate(self, evaluation):\n",
        "        self.model.eval()\n",
        "        se = 0\n",
        "        for user, movie, rating in evaluation:\n",
        "            err = self.predict(user, movie) - float(rating)\n",
        "            se += err ** 2\n",
        "        print(\"Test RMSE: {}\".format(np.sqrt(se/len(evaluation))))\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 470
        },
        "id": "JW3O9nHsO2Fk",
        "outputId": "25d3cc93-aa1d-483d-a696-587eeb0f3d65"
      },
      "source": [
        "g = GeneralizedMatrixFactorization2(100, 1.0, 0.7, 65535, 2000)\n",
        "g.train(train).evaluate(evaluation)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/html": [
              "<progress style='width:60ex' max='72800' value='6552'></progress>"
            ],
            "text/plain": [
              "[=====                                                       ] 6552/72800"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "Epoch 0 (3.730263078212738 min), mse = 5.6145525851419995\n",
            "Epoch 1 (7.496627128124237 min), mse = 1.1794887732837227\n",
            "Epoch 2 (11.2935755610466 min), mse = 1.1638430482247373\n",
            "Epoch 3 (15.126986002922058 min), mse = 1.1638430155568071\n",
            "Epoch 4 (18.902264416217804 min), mse = 1.1638429751926727\n",
            "Epoch 5 (22.69548547665278 min), mse = 1.1638429273779576\n",
            "Epoch 6 (26.48063761393229 min), mse = 1.163842882838223\n",
            "Epoch 7 (30.2784628311793 min), mse = 1.163842836006002\n",
            "Epoch 8 (34.062812407811485 min), mse = 1.1638427962968638\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "text": [
            "Test RMSE: 1.0861063132198032\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_E_5LhhGa6ZR",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 470
        },
        "outputId": "7a6ccd69-84c2-4c5c-e8fa-a7ed6cd543fe"
      },
      "source": [
        "g = GeneralizedMatrixFactorization2(300, 1.0, 0.7, 65535, 2000)\n",
        "g.train(train).evaluate(evaluation)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/html": [
              "<progress style='width:60ex' max='72800' value='6552'></progress>"
            ],
            "text/plain": [
              "[=====                                                       ] 6552/72800"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "Epoch 0 (3.993168214956919 min), mse = 5.710504464723251\n",
            "Epoch 1 (7.993724397818247 min), mse = 1.1817975305430182\n",
            "Epoch 2 (12.007093171278635 min), mse = 1.1649126354809647\n",
            "Epoch 3 (15.969143438339234 min), mse = 1.1649125120142003\n",
            "Epoch 4 (19.87429452339808 min), mse = 1.164912377985624\n",
            "Epoch 5 (23.78632361094157 min), mse = 1.1649122424014322\n",
            "Epoch 6 (27.735622298717498 min), mse = 1.1649121031328873\n",
            "Epoch 7 (31.66898326476415 min), mse = 1.1649119670574481\n",
            "Epoch 8 (35.587493065992994 min), mse = 1.1649118327013739\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEGCAYAAABo25JHAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAawklEQVR4nO3df5Dcd33f8efrbk+nk+52JXNnoV3JlZzaIO+CY3IQWifBQCEQGCAtLXGJM2HwmGSIY7dM4+BJ4mnpTCYNZRiXgKvajiFx7VJsKKVgSBMXwxAIsjG2TmeMsbEt6WSdLVs6ydbpfrz7x35PPs53tydpv/vdve/rMaPRd3e/t/uyRtZrv9/P9/v5KCIwM7P86so6gJmZZctFYGaWcy4CM7OccxGYmeWci8DMLOcKWQc4VYODg7Ft27asY5iZdZR777336YgYWuy1jiuCbdu2sWvXrqxjmJl1FEmPL/WaTw2ZmeWci8DMLOdcBGZmOeciMDPLudSKQNJWSXdL2iNpRNJVy+z7WknTkt6bVh4zM1tcmlcNTQMfiYj7JA0A90r6m4jYM38nSd3AnwHfSDGLmZktIbUjgogYi4j7ku0JYBSoLLLrlcAdwMG0spiZ2dJaMkYgaRtwEfC9Bc9XgF8HPtPg56+QtEvSrvHx8dPK8KMDE/zpV0c5Njl9Wj9vZrZapV4Ekvqpf+O/OiKOLHj5k8A1ETG73HtExM6IGI6I4aGhRW+Ma+jJQ8/zX+95lNGxhRHMzPIt1TuLJfVQL4FbI+LORXYZBm6XBDAI/Jqk6Yj4UrOz1ColAHbvO8zwtrOa/fZmZh0rtSJQ/V/3m4DRiPjEYvtExPZ5+98CfCWNEgDYVOxlsH8NI/t9RGBmNl+aRwQXA5cBD0q6P3nuWuAcgIi4IcXPfglJXFAusdtFYGb2M1Irgoj4NqBT2P+308oyp1YusvOeR5mcnqG30J32x5mZdYRc3VlcLZeYng0ePnA06yhmZm0jV0VQqxQBGNl/OOMkZmbtI1dFsHXjOgZ6C+x2EZiZnZSrIujqEheUi+ze5wFjM7M5uSoCqN9P8NCBI0zPLHsPm5lZbuSuCKrlIsenZnn06WNZRzEzawu5K4K5O4w9YGxmVpe7Ijh3cD29hS6PE5iZJXJXBIXuLnZsLvqIwMwskbsigPo4wci+I8zORtZRzMwyl8siqFVKTExO8+Szz2cdxcwsc/ksgvLcgLHHCczMclkE57+8n0KX2L3P4wRmZrksgt5CN+dtGvARgZkZOS0CSAaM9x8mwgPGZpZvuS2CWrnI00dPcHBiMusoZmaZym0RVOetYWxmlme5LYIdm4tI+A5jM8u93BZBf2+B7S9b7zuMzSz3clsEUD895CuHzCzvcl0EtXKRfc+9wLPHTmQdxcwsM6kVgaStku6WtEfSiKSrFtnn/ZIekPSgpO9IujCtPIup+g5jM7NUjwimgY9ExAXA64EPS7pgwT6PAW+IiFcBHwN2ppjnJaplL2ZvZlZI640jYgwYS7YnJI0CFWDPvH2+M+9HvgtsSSvPYjauX0NlQx+7fURgZjnWkjECSduAi4DvLbPbB4GvLfHzV0jaJWnX+Ph4U7PN3WFsZpZXqReBpH7gDuDqiFj0q7ekN1IvgmsWez0idkbEcEQMDw0NNTVftVzisaePcXRyuqnva2bWKVItAkk91Evg1oi4c4l9Xg3cCLw7Ip5JM89iapUiETA65tNDZpZPaV41JOAmYDQiPrHEPucAdwKXRcTDaWVZzsnF7D3VhJnlVGqDxcDFwGXAg5LuT567FjgHICJuAP4EeBnw6XpvMB0RwylmeomzB3oZ7F/jAWMzy600rxr6NqAG+1wOXJ5WhpWQRLXsO4zNLL9yfWfxnGq5yI+fmmByeibrKGZmLecioD5OMD0bPHzgaNZRzMxazkXAi3cY7/b9BGaWQy4C4Jyz1jGwtuBFaswsl1wEzA0YFz1gbGa55CJIVMslRseOMD0zm3UUM7OWchEkapUik9OzPPr0sayjmJm1lIsgMbc2gccJzCxvXASJcwfXs7any+MEZpY7LoJEobuLV7686CMCM8sdF8E8tUqRPfuPMDsbWUcxM2sZF8E81XKJiclpnnz2+ayjmJm1jItgntrJAWOPE5hZfrgI5jn/5f0UuuSlK80sV1wE8/QWujlv04DXJjCzXHERLFArFxnZd5gIDxibWT64CBaolos8c+wETx2ZzDqKmVlLuAgWmFvD2PcTmFleuAgW2LG5iITvMDaz3HARLLC+t8D2wfVepMbMcsNFsIhaucQeHxGYWU6kVgSStkq6W9IeSSOSrlpkH0m6XtIjkh6Q9Jq08pyKarnIvude4NljJ7KOYmaWujSPCKaBj0TEBcDrgQ9LumDBPm8Hzkt+XQF8JsU8KzY3YOxxAjPLg9SKICLGIuK+ZHsCGAUqC3Z7N/C5qPsusEHS5rQyrZQXszezPGnJGIGkbcBFwPcWvFQBnpz3eC8vLQskXSFpl6Rd4+PjacU8acO6NVQ29PmIwMxyIfUikNQP3AFcHRGn9S9rROyMiOGIGB4aGmpuwCVUkzuMzcxWu1SLQFIP9RK4NSLuXGSXfcDWeY+3JM9lrlYp8ejTxzg6OZ11FDOzVKV51ZCAm4DRiPjEErt9Gfit5Oqh1wOHI2IsrUynolapjxOMjvn0kJmtboUU3/ti4DLgQUn3J89dC5wDEBE3AF8Ffg14BHge+ECKeU7J/MXsX7vtrIzTmJmlJ7UiiIhvA2qwTwAfTivDmTh7oJfB/l4PGJvZquc7i5cgiWrZi9mb2ernIlhGrVLkkYNHOT41k3UUM7PUuAiWUS2XmJ4NHn5qIusoZmapcREsw4vZm1keuAiWsfWsPgbWFryYvZmtai6CZZwcMPaVQ2a2irkIGqiVSzw0doTpmdmso5iZpcJF0EC1UmRyepafjB/LOoqZWSpcBA3MDRh7nMDMVisXQQPnDvWztqfLVw6Z2arlImigu0vs2Fz0IjVmtmq5CFagWi4yuv8Is7ORdRQzs6ZzEaxArVxiYnKaJw49n3UUM7OmcxGsgBezN7PVzEWwAudt6qfQJY8TmNmq5CJYgd5CN+dvGvARgZmtSi6CFZpbzL6+lo6Z2erhIlihWqXEM8dOcODI8ayjmJk1lYtgharl+mL2I76xzMxWGRfBCu3YXETCA8Zmtuq4CFZofW+BcwfXe8DYzFad1IpA0s2SDkravcTrJUn/W9IPJY1I+kBaWZqlWi4x4sXszWyVSfOI4Bbgbcu8/mFgT0RcCFwC/GdJa1LMc8ZqlSL7Dx/n0LETWUcxM2uaZYtA0pvmbW9f8No/X+5nI+Ie4NByuwADkgT0J/tONwqcpaqnpDazVajREcHH523fseC1PzrDz/4UsAPYDzwIXBURiy4DJukKSbsk7RofHz/Djz19J68c8jiBma0ijYpAS2wv9vhU/SpwP1AGfh74lKTiYjtGxM6IGI6I4aGhoTP82NO3Yd0aKhv62O1xAjNbRRoVQSyxvdjjU/UB4M6oewR4DHjlGb5n6mqVoo8IzGxVKTR4/VxJX6b+7X9um+Tx9qV/bEWeAN4MfEvSJuAVwKNn+J6pq5VLfH3kKSaOTzGwtifrOGZmZ6xREbx73vbHF7y28PHPkHQb9auBBiXtBa4DegAi4gbgY8Atkh6kXizXRMTTK4+ejWqlfvZqdGyC120/K+M0ZmZnbtkiiIhvzn8sqQeoAfsi4mCDn720wev7gbeuMGfbmL+YvYvAzFaDRpeP3iCpmmyXgB8CnwN+IGnZf+hXq7OLaxns7/Vi9ma2ajQaLP7liBhJtj8APBwRrwJ+AfiDVJO1sfqAsa8cMrPVoVERzL+F9i3AlwAi4kBqiTpAtVzkxwePcnxqJusoZmZnrFERPCfpnZIuAi4G7gKQVAD60g7XrmrlEjOzwY8OTGQdxczsjDUqgg8Bvwf8JXD1vCOBNwP/J81g7ezFqSY8TmBmna/RVUMPs8jEcRHxdeDraYVqd1vP6mNgbcFrE5jZqrBsEUi6frnXI+L3mxunM0iiVi75iMDMVoVGN5T9DrAb+Dz1yeHOdH6hVaNaLvJX332c6ZlZCt1e38fMOlejItgM/EvgfdSniP4fwBci4rm0g7W7WqXE5PQsPxk/xitePpB1HDOz07bsV9mIeCYiboiIN1K/j2ADsEfSZS1J18bmpqT2TKRm1ulWdE5D0muAq4DfBL4G3JtmqE5w7lA/a3u6PGBsZh2v0WDxfwDeAYwCtwMfjYi2XkWsVbq7xI7NnpLazDpfoyOCP6J+OuhC4E+B+yQ9IOlBSQ+knq7N1col9uw/wuzsmS7NYGaWnUaDxWe65sCqVqvUrxx64tDzbBtcn3UcM7PT0uiGsscXe15SF3ApsOjreTF3h/Hu/YddBGbWsRpNQ12U9FFJn5L0VtVdSX0lsX/Vmojt67xN/fR0y+MEZtbRGp0a+ivgWeDvgcuBa6nfVPaeiLg/5Wxtr7fQzXlnD/gSUjPraA3XLE7WH0DSjcAYcE5EHE89WYeoVYr839GDRASSb7w2s87T6KqhqbmNiJgB9roEfla1XOLQsRMcOOI/FjPrTI2OCC6UNHcCXEBf8lhAREQx1XQdoFaZu8P4CJtLuV2iwcw6WKMpJrojopj8GoiIwrzt3JcAwI7NRSS8dKWZdazUps2UdLOkg5J2L7PPJZLulzQi6ZtpZUnTujUFzh1c78XszaxjpTl/8i0ssqjNHEkbgE8D74qIKvVZTjtSrVJij48IzKxDpVYEEXEPcGiZXf41cGdEPJHsfzCtLGmrlovsP3ycQ8dOZB3FzOyUZbmiyvnARkn/T9K9kn5rqR0lXSFpl6Rd4+PjLYy4MrWTaxj7qMDMOk+WRVAAfoH67Ka/CvyxpPMX2zEidkbEcEQMDw0NtTLjilxQfvHKITOzTtPo8tE07QWeiYhjwDFJ91Cf5fThDDOdlg3r1rBlY5/XJjCzjpTlEcH/An5JUkHSOuAXqa970JGq5SJ7POeQmXWg1I4IJN0GXAIMStoLXAf0ACTLX45Kugt4AJgFboyIJS81bXe1comvjzzFxPEpBtb2ZB3HzGzFUiuCiLh0Bfv8OfDnaWVopVqlPmA8OjbB67aflXEaM7OVy/LU0KrixezNrFO5CJrk7OJahgZ6vTaBmXUcF0ETVctF30tgZh3HRdBEtXKJHx88yvGpmayjmJmtmIugiarlIjOzwY8OTGQdxcxsxVwETTR35ZBvLDOzTuIiaKItG/sori14wNjMOoqLoIkkUS2XGPElpGbWQVwETVarFBk9MMHUzGzWUczMVsRF0GTVcokT07P8ZPxo1lHMzFbERdBk8xezNzPrBC6CJts+2E9fT7dvLDOzjuEiaLLuLrFj8wAjPiIwsw7hIkhBrVJiz9gRZmcj6yhmZg25CFJQLRc5OjnN44eezzqKmVlDLoIUVL2YvZl1EBdBCs7fNEBPt3zlkJl1BBdBCtYUujh/04CPCMysI7gIUlJfm+AIER4wNrP25iJISa1S4tCxE4wdPp51FDOzZbkIUjK3hrFnIjWzdpdaEUi6WdJBSbsb7PdaSdOS3ptWlizs2FxE8mL2Ztb+0jwiuAV423I7SOoG/gz4Roo5MrFuTYGfG+r3EYGZtb3UiiAi7gEONdjtSuAO4GBaObLkxezNrBNkNkYgqQL8OvCZrDKkrVYuMXb4OM8cncw6ipnZkrIcLP4kcE1ENFzBRdIVknZJ2jU+Pt6CaM3hAWMz6wRZFsEwcLuknwLvBT4t6T2L7RgROyNiOCKGh4aGWpnxjMxNNeHF7M2snRWy+uCI2D63LekW4CsR8aWs8qShtK6HLRv7fERgZm0ttSKQdBtwCTAoaS9wHdADEBE3pPW57abmxezNrM2lVgQRcekp7PvbaeXIWq1S5K6RA0wcn2JgbU/WcczMXsJ3Fqdsbpxgj08PmVmbchGkrFrxlUNm1t5cBCk7e2AtQwO9vnLIzNqWi6AFauWiF7M3s7blImiBarnEI+NHOT41k3UUM7OXcBG0QK1SZGY2eOjARNZRzMxewkXQAl7M3szamYugBbZs7KPU1+PF7M2sLbkIWkAS1XKRPT4iMLM25CJokWq5yOiBCaZmGk62ambWUi6CFqlVSpyYnuWRg0ezjmJm9jNcBC3itQnMrF25CFpk+2A/fT3dXszezNqOi6BFurvEjs0DnnzOzNqOi6CFapUSI/sPMzsbWUcxMzvJRdBCtXKJYydmePzQ81lHMTM7yUXQQhckA8YeJzCzduIiaKHzNw3Q0y1PSW1mbcVF0EJrCl2cv8kDxmbWXlwELVYrl9i97zARHjA2s/bgImixaqXIs89PMXb4eNZRzMwAF0HLzU1J7QFjM2sXqRWBpJslHZS0e4nX3y/pAUkPSvqOpAvTytJOdmweoEueasLM2keaRwS3AG9b5vXHgDdExKuAjwE7U8zSNtatKXDuUL8XqTGztpFaEUTEPcChZV7/TkQ8mzz8LrAlrSztplYu+ojAzNpGu4wRfBD42lIvSrpC0i5Ju8bHx1sYKx3Vcomxw8d5+uhk1lHMzLIvAklvpF4E1yy1T0TsjIjhiBgeGhpqXbiUVCuektrM2kemRSDp1cCNwLsj4pkss7RSdbMXszez9pFZEUg6B7gTuCwiHs4qRxZK63rYelYfI17M3szaQCGtN5Z0G3AJMChpL3Ad0AMQETcAfwK8DPi0JIDpiBhOK0+7qZVLPiIws7aQWhFExKUNXr8cuDytz2931XKRr+0+wJHjUxTX9mQdx8xyLPPB4ryqVurjBKMeMDazjLkIMjK3mP1uF4GZZcxFkJGzB9Zy9kAvI55zyMwy5iLIUNV3GJtZG3ARZKhWKfHI+FGOT81kHcXMcsxFkKFqucjMbPDQgYmso5hZjrkIMuS1CcysHbgIMrRlYx+lvh6PE5hZplwEGZKUDBj7iMDMsuMiyFitUuKhsQmmZmazjmJmOZXaFBO2MtVykRMzs+z447voLXTR29NNb6GLNYWu+uNCd/L8vO2553uW3mfNUj+78H2Szyt0iWTOJzPLGRdBxt56wcv56NtfyZHjU0xOzTI5Pcvk9Ez996n69omZ+vaRF6Zf8trk9CzHp2aYjTPL0SVOlsua7q6Tv3e5HMzaxvteu5XLf/ncpr+viyBjfWu6+dAbfu6M32d6Zq5EkoKYVyonlnh+YaHUH8/8zPuYWfsY7O9N5X1dBKtEobuLQncX69P5e2Jmq5gHi83Mcs5FYGaWcy4CM7OccxGYmeWci8DMLOdcBGZmOeciMDPLOReBmVnOKeIM5yZoMUnjwOOn+eODwNNNjNMs7ZoL2jebc50a5zo1qzHXP4qIocVe6LgiOBOSdkXEcNY5FmrXXNC+2Zzr1DjXqclbLp8aMjPLOReBmVnO5a0IdmYdYAntmgvaN5tznRrnOjW5ypWrMQIzM3upvB0RmJnZAi4CM7Ocy00RSHqbpB9JekTSH2adB0DSzZIOStqddZb5JG2VdLekPZJGJF2VdSYASWsl/YOkHya5/n3WmeaT1C3pB5K+knWWOZJ+KulBSfdL2pV1njmSNkj6gqSHJI1K+idtkOkVyZ/T3K8jkq7OOheApH+T/J3fLek2SWub+v55GCOQ1A08DLwF2At8H7g0IvZknOtXgKPA5yKilmWW+SRtBjZHxH2SBoB7gfe0wZ+XgPURcVRSD/Bt4KqI+G6WueZI+rfAMFCMiHdmnQfqRQAMR0Rb3Rwl6bPAtyLiRklrgHUR8VzWueYk/2bsA34xIk73BtZmZalQ/7t+QUS8IOnzwFcj4pZmfUZejgheBzwSEY9GxAngduDdGWciIu4BDmWdY6GIGIuI+5LtCWAUqGSbCqLuaPKwJ/nVFt9kJG0B3gHcmHWWdiepBPwKcBNARJxopxJIvBn4SdYlME8B6JNUANYB+5v55nkpggrw5LzHe2mDf9g6gaRtwEXA97JNUpecfrkfOAj8TUS0RS7gk8AfALNZB1kggG9IulfSFVmHSWwHxoG/TE6l3ShpfdahFvgN4LasQwBExD7g48ATwBhwOCK+0czPyEsR2GmQ1A/cAVwdEUeyzgMQETMR8fPAFuB1kjI/pSbpncDBiLg36yyL+KWIeA3wduDDyenIrBWA1wCfiYiLgGNAW4zbASSnqt4F/M+sswBI2kj9DMZ2oAysl/SbzfyMvBTBPmDrvMdbkudsCck5+DuAWyPizqzzLJScSrgbeFvWWYCLgXcl5+NvB94k6a+zjVSXfJskIg4CX6R+mjRre4G9847mvkC9GNrF24H7IuKprIMk/hnwWESMR8QUcCfwT5v5AXkpgu8D50nanrT9bwBfzjhT20oGZW8CRiPiE1nnmSNpSNKGZLuP+uD/Q9mmgoj4aERsiYht1P9u/V1ENPUb2+mQtD4Z7Cc59fJWIPMr1CLiAPCkpFckT70ZyPRChAUupU1OCyWeAF4vaV3y/+abqY/bNU2hmW/WriJiWtLvAV8HuoGbI2Ik41hIug24BBiUtBe4LiJuyjYVUP+GexnwYHI+HuDaiPhqhpkANgOfTa7o6AI+HxFtc6lmG9oEfLH+bwcF4L9HxF3ZRjrpSuDW5IvZo8AHMs4DnCzMtwAfyjrLnIj4nqQvAPcB08APaPJUE7m4fNTMzJaWl1NDZma2BBeBmVnOuQjMzHLORWBmlnMuAjOznHMRmCUkzSyYfbJpd7tK2tZus8yazcnFfQRmK/RCMn2FWa74iMCsgWRO//+UzOv/D5L+cfL8Nkl/J+kBSX8r6Zzk+U2Svpism/BDSXPTAXRL+m/JvPLfSO6ORtLvJ2s/PCDp9oz+My3HXARmL+pbcGroffNeOxwRrwI+RX2mUYD/Anw2Il4N3Apcnzx/PfDNiLiQ+hw6c3exnwf8RURUgeeAf5E8/4fARcn7/E5a/3FmS/GdxWYJSUcjon+R538KvCkiHk0m4zsQES+T9DT1BXymkufHImJQ0jiwJSIm573HNurTZp+XPL4G6ImI/yjpLuoLFH0J+NK8NRfMWsJHBGYrE0tsn4rJedszvDhG9w7gL6gfPXw/WXzErGVcBGYr8755v/99sv0d6rONArwf+Fay/bfA78LJhXRKS72ppC5ga0TcDVwDlICXHJWYpcnfPMxe1DdvtlWAuyJi7hLSjZIeoP6t/tLkuSupr7L176ivuDU3g+ZVwE5JH6T+zf93qa8stZhu4K+TshBwfRsu22irnMcIzBpo1wXgzZrFp4bMzHLORwRmZjnnIwIzs5xzEZiZ5ZyLwMws51wEZmY55yIwM8u5/w9O543tj+SYEQAAAABJRU5ErkJggg==\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "text": [
            "Test RMSE: 1.0869594688018298\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "usH-WEzla8jF",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 470
        },
        "outputId": "5f3d8cd5-ec2c-4231-ca5e-73c39d392002"
      },
      "source": [
        "g = GeneralizedMatrixFactorization2(100, 0.1, 0.9, 65535, 2000)\n",
        "g.train(train).evaluate(evaluation)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/html": [
              "<progress style='width:60ex' max='72800' value='6552'></progress>"
            ],
            "text/plain": [
              "[=====                                                       ] 6552/72800"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "Epoch 0 (3.7884937286376954 min), mse = 11.916761860742675\n",
            "Epoch 1 (7.5837215741475426 min), mse = 8.412799968824281\n",
            "Epoch 2 (11.400402887662251 min), mse = 5.199209842053088\n",
            "Epoch 3 (15.232778318723042 min), mse = 2.985623850436001\n",
            "Epoch 4 (19.055240015188854 min), mse = 1.8149193662863512\n",
            "Epoch 5 (22.876783843835195 min), mse = 1.3550932641540254\n",
            "Epoch 6 (26.71820987065633 min), mse = 1.2140063296307575\n",
            "Epoch 7 (30.513678809007008 min), mse = 1.1748250749084976\n",
            "Epoch 8 (34.28911795218786 min), mse = 1.1653551310300827\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "text": [
            "Test RMSE: 1.0881613129646628\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BK-TgIVVbLAB",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 470
        },
        "outputId": "ccd0d77f-5bdc-4d72-94f4-a07bea40a7b9"
      },
      "source": [
        "g = GeneralizedMatrixFactorization2(100, 1.0, 0.7, 4096, 2000)\n",
        "g.train(train).evaluate(evaluation)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/html": [
              "<progress style='width:60ex' max='1164000' value='104760'></progress>"
            ],
            "text/plain": [
              "[=====                                                       ] 104760/1164000"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "Epoch 0 (3.9307451486587524 min), mse = 1.4643752879600753\n",
            "Epoch 1 (7.933116865158081 min), mse = 1.1637031799175894\n",
            "Epoch 2 (11.894106205304464 min), mse = 1.1636992829208521\n",
            "Epoch 3 (15.860867126782734 min), mse = 1.1636953604026758\n",
            "Epoch 4 (19.837525296211243 min), mse = 1.163691402336781\n",
            "Epoch 5 (23.78875788450241 min), mse = 1.1636874283097454\n",
            "Epoch 6 (27.716263401508332 min), mse = 1.1636834287663915\n",
            "Epoch 7 (31.686163957913717 min), mse = 1.1636793919752553\n",
            "Epoch 8 (35.659867294629414 min), mse = 1.1636753165793583\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "text": [
            "Test RMSE: 1.0897713142694387\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AUPsKFjgeXWf",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 453
        },
        "outputId": "c87ae05b-76ea-4568-86eb-a0053b6a68e2"
      },
      "source": [
        "g = GeneralizedMatrixFactorization2(100, 1.0, 0.7, 1048576, 2000)\n",
        "g.train(train).evaluate(evaluation)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/html": [
              "<progress style='width:60ex' max='4600' value='368'></progress>"
            ],
            "text/plain": [
              "[====                                                        ] 368/4600"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "Epoch 0 (4.673669950167338 min), mse = 13.179858497951342\n",
            "Epoch 1 (8.936037731170654 min), mse = 11.899996052617611\n",
            "Epoch 2 (13.177859675884246 min), mse = 10.665002408234969\n",
            "Epoch 3 (17.38041772842407 min), mse = 9.437212031820547\n",
            "Epoch 4 (21.565734283129373 min), mse = 8.249012553173563\n",
            "Epoch 5 (25.756593600908914 min), mse = 7.125764888265858\n",
            "Epoch 6 (29.995626497268677 min), mse = 6.086495492769324\n",
            "Epoch 7 (34.198833203315736 min), mse = 5.144671284634134\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "text": [
            "Test RMSE: 2.2311285276387465\n"
          ],
          "name": "stdout"
        }
      ]
    }
  ]
}