svd_full_submit.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "svd-full.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "metadata": {
        "id": "DfU9gBvVdnWA"
      },
      "source": [
        "import datetime\n",
        "import gc\n",
        "import random\n",
        "import time\n",
        "\n",
        "import numpy, numpy.random\n",
        "import pandas\n",
        "import scipy\n",
        "from scipy import sparse\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.total = total\n",
        "        self.progress = 0\n",
        "        self.last = 0\n",
        "        self.start = time.monotonic_ns()\n",
        "\n",
        "    def inc(self, delta=1):\n",
        "        self.progress += delta\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",
        "\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",
        "        print(f\"Completed {self.progress}/{self.total} in {(time.monotonic_ns() - self.start) / 1000000}ms\")\n",
        "        return False\n",
        "\n",
        "class Timer:\n",
        "    def __init__(self, name):\n",
        "        self.name = name\n",
        "    \n",
        "    def __enter__(self):\n",
        "        self.start = time.monotonic_ns()\n",
        "        print(f\"Task: {self.name}\")\n",
        "\n",
        "    def __exit__(self, exc_type, exc_value, tb):\n",
        "        end = time.monotonic_ns()\n",
        "        time_ns = end - self.start\n",
        "        print(f\"Took {time_ns / 1000000}ms\")\n",
        "        return False"
      ],
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sF43KZfGd4vs",
        "outputId": "30877d79-f89a-4215-9f0c-c3a625e03d72"
      },
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Mounted at /content/drive\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IUBdKi0Pd6AT",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "82cbf655-fbf8-4121-dc22-1c74940ca05d"
      },
      "source": [
        "!test -d dataset || unzip /content/drive/Shareddrives/'STAT4609 Netflix'/dataset.zip -d dataset"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Archive:  /content/drive/Shareddrives/STAT4609 Netflix/dataset.zip\n",
            "  inflating: dataset/README          \n",
            "  inflating: dataset/combined_data_1.txt  \n",
            "  inflating: dataset/combined_data_2.txt  \n",
            "  inflating: dataset/combined_data_3.txt  \n",
            "  inflating: dataset/combined_data_4.txt  \n",
            "  inflating: dataset/movie_titles.csv  \n",
            "  inflating: dataset/probe.txt       \n",
            "  inflating: dataset/qualifying.txt  \n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "36ivpwyyd7yv",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3f8a9ecb-9ef6-48a9-b1a8-caa6bad1f217"
      },
      "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": 8,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Read 1000000 lines of probe\n",
            "Read 1000000 lines\n",
            "Read 2000000 lines\n",
            "Read 3000000 lines\n",
            "Read 4000000 lines\n",
            "Read 5000000 lines\n",
            "Read 6000000 lines\n",
            "Read 7000000 lines\n",
            "Read 8000000 lines\n",
            "Read 9000000 lines\n",
            "Read 10000000 lines\n",
            "Read 11000000 lines\n",
            "Read 12000000 lines\n",
            "Read 13000000 lines\n",
            "Read 14000000 lines\n",
            "Read 15000000 lines\n",
            "Read 16000000 lines\n",
            "Read 17000000 lines\n",
            "Read 18000000 lines\n",
            "Read 19000000 lines\n",
            "Read 20000000 lines\n",
            "Read 21000000 lines\n",
            "Read 22000000 lines\n",
            "Read 23000000 lines\n",
            "Read 24000000 lines\n",
            "Empty line!\n",
            "Read 25000000 lines\n",
            "Read 26000000 lines\n",
            "Read 27000000 lines\n",
            "Read 28000000 lines\n",
            "Read 29000000 lines\n",
            "Read 30000000 lines\n",
            "Read 31000000 lines\n",
            "Read 32000000 lines\n",
            "Read 33000000 lines\n",
            "tcmalloc: large alloc 1879048192 bytes == 0x55cfec484000 @  0x7f0e4b1b62a4 0x55cf7a2a0120 0x55cf7a2a0265 0x55cf7a29ef2a 0x55cf7a29d5de 0x55cf7a29f956 0x55cf7a29f96c 0x55cf7a2ba30a 0x55cf7a29f855 0x7f0e4a777bf7 0x55cf7a29be3e\n",
            "Read 34000000 lines\n",
            "Read 35000000 lines\n",
            "Read 36000000 lines\n",
            "Read 37000000 lines\n",
            "Read 38000000 lines\n",
            "Read 39000000 lines\n",
            "Read 40000000 lines\n",
            "Read 41000000 lines\n",
            "Read 42000000 lines\n",
            "Read 43000000 lines\n",
            "Read 44000000 lines\n",
            "Read 45000000 lines\n",
            "Read 46000000 lines\n",
            "Read 47000000 lines\n",
            "Read 48000000 lines\n",
            "Read 49000000 lines\n",
            "Read 50000000 lines\n",
            "Read 51000000 lines\n",
            "Empty line!\n",
            "Read 52000000 lines\n",
            "Read 53000000 lines\n",
            "Read 54000000 lines\n",
            "Read 55000000 lines\n",
            "Read 56000000 lines\n",
            "Read 57000000 lines\n",
            "Read 58000000 lines\n",
            "Read 59000000 lines\n",
            "Read 60000000 lines\n",
            "Read 61000000 lines\n",
            "Read 62000000 lines\n",
            "Read 63000000 lines\n",
            "Read 64000000 lines\n",
            "Read 65000000 lines\n",
            "Read 66000000 lines\n",
            "Read 67000000 lines\n",
            "tcmalloc: large alloc 3758096384 bytes == 0x55d05c484000 @  0x7f0e4b1b62a4 0x55cf7a2a0120 0x55cf7a2a0265 0x55cf7a29ef2a 0x55cf7a29d698 0x55cf7a29f956 0x55cf7a29f96c 0x55cf7a2ba30a 0x55cf7a29f855 0x7f0e4a777bf7 0x55cf7a29be3e\n",
            "Read 68000000 lines\n",
            "Read 69000000 lines\n",
            "Read 70000000 lines\n",
            "Read 71000000 lines\n",
            "Read 72000000 lines\n",
            "Read 73000000 lines\n",
            "Empty line!\n",
            "Read 74000000 lines\n",
            "Read 75000000 lines\n",
            "Read 76000000 lines\n",
            "Read 77000000 lines\n",
            "Read 78000000 lines\n",
            "Read 79000000 lines\n",
            "Read 80000000 lines\n",
            "Read 81000000 lines\n",
            "Read 82000000 lines\n",
            "Read 83000000 lines\n",
            "Read 84000000 lines\n",
            "Read 85000000 lines\n",
            "Read 86000000 lines\n",
            "Read 87000000 lines\n",
            "Read 88000000 lines\n",
            "Read 89000000 lines\n",
            "Read 90000000 lines\n",
            "Read 91000000 lines\n",
            "Read 92000000 lines\n",
            "Read 93000000 lines\n",
            "Read 94000000 lines\n",
            "Read 95000000 lines\n",
            "Read 96000000 lines\n",
            "Read 97000000 lines\n",
            "Read 98000000 lines\n",
            "Read 99000000 lines\n",
            "Read 100000000 lines\n",
            "Empty line!\n",
            "Wrote 1000000 lines\n",
            "Wrote 2000000 lines\n",
            "Wrote 3000000 lines\n",
            "Wrote 4000000 lines\n",
            "Wrote 5000000 lines\n",
            "Wrote 6000000 lines\n",
            "Wrote 7000000 lines\n",
            "Wrote 8000000 lines\n",
            "Wrote 9000000 lines\n",
            "Wrote 10000000 lines\n",
            "Wrote 11000000 lines\n",
            "Wrote 12000000 lines\n",
            "Wrote 13000000 lines\n",
            "Wrote 14000000 lines\n",
            "Wrote 15000000 lines\n",
            "Wrote 16000000 lines\n",
            "Wrote 17000000 lines\n",
            "Wrote 18000000 lines\n",
            "Wrote 19000000 lines\n",
            "Wrote 20000000 lines\n",
            "Wrote 21000000 lines\n",
            "Wrote 22000000 lines\n",
            "Wrote 23000000 lines\n",
            "Wrote 24000000 lines\n",
            "Wrote 25000000 lines\n",
            "Wrote 26000000 lines\n",
            "Wrote 27000000 lines\n",
            "Wrote 28000000 lines\n",
            "Wrote 29000000 lines\n",
            "Wrote 30000000 lines\n",
            "Wrote 31000000 lines\n",
            "Wrote 32000000 lines\n",
            "Wrote 33000000 lines\n",
            "Wrote 34000000 lines\n",
            "Wrote 35000000 lines\n",
            "Wrote 36000000 lines\n",
            "Wrote 37000000 lines\n",
            "Wrote 38000000 lines\n",
            "Wrote 39000000 lines\n",
            "Wrote 40000000 lines\n",
            "Wrote 41000000 lines\n",
            "Wrote 42000000 lines\n",
            "Wrote 43000000 lines\n",
            "Wrote 44000000 lines\n",
            "Wrote 45000000 lines\n",
            "Wrote 46000000 lines\n",
            "Wrote 47000000 lines\n",
            "Wrote 48000000 lines\n",
            "Wrote 49000000 lines\n",
            "Wrote 50000000 lines\n",
            "Wrote 51000000 lines\n",
            "Wrote 52000000 lines\n",
            "Wrote 53000000 lines\n",
            "Wrote 54000000 lines\n",
            "Wrote 55000000 lines\n",
            "Wrote 56000000 lines\n",
            "Wrote 57000000 lines\n",
            "Wrote 58000000 lines\n",
            "Wrote 59000000 lines\n",
            "Wrote 60000000 lines\n",
            "Wrote 61000000 lines\n",
            "Wrote 62000000 lines\n",
            "Wrote 63000000 lines\n",
            "Wrote 64000000 lines\n",
            "Wrote 65000000 lines\n",
            "Wrote 66000000 lines\n",
            "Wrote 67000000 lines\n",
            "Wrote 68000000 lines\n",
            "Wrote 69000000 lines\n",
            "Wrote 70000000 lines\n",
            "Wrote 71000000 lines\n",
            "Wrote 72000000 lines\n",
            "Wrote 73000000 lines\n",
            "Wrote 74000000 lines\n",
            "Wrote 75000000 lines\n",
            "Wrote 76000000 lines\n",
            "Wrote 77000000 lines\n",
            "Wrote 78000000 lines\n",
            "Wrote 79000000 lines\n",
            "Wrote 80000000 lines\n",
            "Wrote 81000000 lines\n",
            "Wrote 82000000 lines\n",
            "Wrote 83000000 lines\n",
            "Wrote 84000000 lines\n",
            "Wrote 85000000 lines\n",
            "Wrote 86000000 lines\n",
            "Wrote 87000000 lines\n",
            "Wrote 88000000 lines\n",
            "Wrote 89000000 lines\n",
            "Wrote 90000000 lines\n",
            "Wrote 91000000 lines\n",
            "Wrote 92000000 lines\n",
            "Wrote 93000000 lines\n",
            "Wrote 94000000 lines\n",
            "Wrote 95000000 lines\n",
            "Wrote 96000000 lines\n",
            "Wrote 97000000 lines\n",
            "Wrote 98000000 lines\n",
            "Wrote 99000000 lines\n",
            "Wrote 100000000 lines\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sceZ7Gc3d8lZ",
        "outputId": "9bfb03a8-b3fa-475e-8ed5-966be173aeaa"
      },
      "source": [
        "COL_USER = 0\n",
        "COL_MOVIE = 1\n",
        "COL_RATING = 2\n",
        "COL_YEAR = 3\n",
        "COL_DOY = 4\n",
        "COL_DOW = 5\n",
        "COL_PROBED = 6\n",
        "\n",
        "with Timer(\"Loading data...\"):\n",
        "    data = numpy.load(\"dataset/output.npy\")\n",
        "    data_size = data.shape[0]\n",
        "\n",
        "with Timer(\"Counting users and movies\"):\n",
        "    user_count = numpy.max(data[:, COL_USER]) + 1\n",
        "    movie_count = numpy.max(data[:, COL_MOVIE]) + 1\n",
        "\n",
        "with Timer(\"Copying train/test split\"):\n",
        "    train = data[data[:, 6] == 0, :3].copy()\n",
        "    evaluation = data[data[:, 6] == 1, :3].copy()\n",
        "\n",
        "# Free the memory used to hold the whole dataset\n",
        "del data\n",
        "gc.collect()\n",
        "\n",
        "print(f\"Train/test size: {train.shape[0]}/{evaluation.shape[0]}\")\n",
        "\n",
        "evaluation_results = {}"
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Task: Loading data...\n",
            "Took 3274.540201ms\n",
            "Task: Counting users and movies\n",
            "Took 481.818865ms\n",
            "Task: Copying train/test split\n",
            "Took 4687.778191ms\n",
            "Train/test size: 99072112/1408395\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "y5QJVv_pn40U"
      },
      "source": [
        "class SliceLoader:\n",
        "    def __init__(self, matrix, batch_size):\n",
        "        self.matrix = matrix\n",
        "        self.batch_size = batch_size\n",
        "        self.ptr = 0\n",
        "\n",
        "    def __iter__(self):\n",
        "        return self\n",
        "\n",
        "    def __next__(self):\n",
        "        end = min(self.ptr + self.batch_size, self.matrix.shape[0])\n",
        "        size = end - self.ptr\n",
        "        if size == 0:\n",
        "            raise StopIteration\n",
        "        ret = self.matrix[self.ptr:end, :]\n",
        "        self.ptr = end\n",
        "        return ret"
      ],
      "execution_count": 15,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oAr65FapeJoy"
      },
      "source": [
        "class SvdRecommend:\n",
        "    def __init__(self, alpha, reg, rank, batch_size, epochs):\n",
        "        self.alpha = alpha\n",
        "        self.reg = reg\n",
        "        self.rank = rank\n",
        "        self.batch_size = batch_size\n",
        "        self.epochs = epochs\n",
        "\n",
        "    def get_params(self):\n",
        "        return (self.alpha, self.reg, self.rank, self.batch_size, self.epochs)\n",
        "\n",
        "    def fit(self, ratings):\n",
        "        raise Exception(\"Uninitialized function\")\n",
        "\n",
        "    def predict_rating(self, user_id, movie_id):\n",
        "        raise Exception(\"Uninitialized function\")\n",
        "\n",
        "    def evaluate(self, max_user=None, max_movie=None):\n",
        "        gc.collect()\n",
        "\n",
        "        train_sample = train\n",
        "        test_sample = evaluation\n",
        "\n",
        "        if max_user is not None:\n",
        "            train_sample = train_sample[train_sample[:, COL_USER] <= max_user]\n",
        "            test_sample = test_sample[test_sample[:, COL_USER] <= max_user]\n",
        "\n",
        "        if max_movie is not None:\n",
        "            train_sample = train_sample[train_sample[:, COL_MOVIE] <= max_movie]\n",
        "            test_sample = test_sample[test_sample[:, COL_MOVIE] <= max_movie]\n",
        "        \n",
        "        self.fit(train_sample)\n",
        "\n",
        "        print(f\"Evaluating {test_sample.shape[0]} probe rows\")\n",
        "\n",
        "        pred = self.predict(test_sample[:, [COL_USER, COL_MOVIE]])\n",
        "        target = test_sample[:, COL_RATING]\n",
        "        nan_count = numpy.isnan(pred).sum()\n",
        "        if nan_count > 0:\n",
        "            print(f\"{nan_count} predicted rows are inconclusive\")\n",
        "\n",
        "        rmse = numpy.sqrt(numpy.nanmean((pred - target) ** 2))\n",
        "        evaluation_results[self.get_params()] = rmse\n",
        "\n",
        "        print(f\"Hyperparameters: {self.get_params()}\")\n",
        "        print(f\"Probe RMSE: {rmse}\")\n",
        "        plt.plot(numpy.arange(self.epochs) + 1, self.rmse_history)\n",
        "        plt.xlabel(\"Epochs\")\n",
        "        plt.ylabel(\"RMSE\")\n",
        "        plt.show()"
      ],
      "execution_count": 53,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pU6HNGIlg0fx"
      },
      "source": [
        "def _fit(self, ratings):\n",
        "    gc.collect()\n",
        "\n",
        "    # express as a sparse matrix such that coo[user, movie] = rating\n",
        "    with Timer(\"Counting users and movies\"):\n",
        "        user_count = ratings[:, COL_USER].max() + 1\n",
        "        movie_count = ratings[:, COL_MOVIE].max() + 1\n",
        "\n",
        "    with Timer(\"Packing data in COO format\"):\n",
        "        coo = sparse.coo_matrix((ratings[:, COL_RATING], (ratings[:, COL_USER], ratings[:, COL_MOVIE])))\n",
        "    with Timer(\"Computing global mean\"):\n",
        "        mu = ratings[:, COL_RATING].mean()\n",
        "\n",
        "    with Timer(\"Counting ratings per user\"):\n",
        "        per_user_ratings = numpy.asarray((coo != 0.0).sum(axis=1)).flatten()\n",
        "    with Timer(\"Counting ratings per movie\"):\n",
        "        per_movie_ratings = numpy.asarray((coo != 0.0).sum(axis=0)).flatten()\n",
        "\n",
        "    with Timer(\"Computing user bias\"):\n",
        "        bias_users = numpy.asarray(coo.sum(axis=1)).flatten() / per_user_ratings - mu\n",
        "    with Timer(\"Computing movie bias\"):\n",
        "        bias_movies = numpy.asarray(coo.sum(axis=0)).flatten() / per_movie_ratings - mu\n",
        "    \n",
        "    with Timer(\"Initializing parameters\"):\n",
        "        var = numpy.std(ratings[:, COL_RATING]) / 100\n",
        "\n",
        "        # bias_users = numpy.clip(numpy.random.normal(scale=var, size=user_count), -1, 1)\n",
        "        # bias_movies = numpy.clip(numpy.random.normal(scale=var, size=movie_count), -1, 1)\n",
        "\n",
        "        latent_users = numpy.clip(numpy.random.normal(scale=var, size=(user_count, self.rank)), -1, 1)\n",
        "        latent_movies = numpy.clip(numpy.random.normal(scale=var, size=(movie_count, self.rank)), -1, 1)\n",
        "\n",
        "    with Timer(\"Performing gradient descent\"):\n",
        "        rmse_history = numpy.empty(self.epochs)\n",
        "\n",
        "        with Progress(self.epochs * ratings.shape[0]) as progress:\n",
        "            um_prod_buf = numpy.empty((self.batch_size, self.rank))\n",
        "            e_prod_buf = numpy.empty((self.batch_size, self.rank))\n",
        "            r_prod_buf = numpy.empty((self.batch_size, self.rank))\n",
        "\n",
        "            try:\n",
        "                for epoch in range(self.epochs):\n",
        "                    mse_sum = 0.0\n",
        "    \n",
        "                    loader = SliceLoader(ratings, self.batch_size)\n",
        "                    for batch in loader:\n",
        "                        b = batch.shape[0]\n",
        "    \n",
        "                        users = batch[:, COL_USER]\n",
        "                        movies = batch[:, COL_MOVIE]\n",
        "                        targets = batch[:, COL_RATING].astype(float)\n",
        "    \n",
        "                        um_prod = um_prod_buf[:b, :]\n",
        "                        numpy.multiply(latent_users[users, :], latent_movies[movies, :], out=um_prod)\n",
        "    \n",
        "                        pred = mu.copy()\n",
        "                        pred += bias_users[users]\n",
        "                        pred += bias_movies[movies]\n",
        "                        pred += um_prod.sum(axis=1)\n",
        "    \n",
        "                        err = targets - pred\n",
        "                        mse = numpy.dot(err, err)\n",
        "                        mse_sum += mse\n",
        "                        # print(numpy.sqrt(mse / b))\n",
        "    \n",
        "                        # Caution: in the lines below,\n",
        "                        # use numpy.add.at(a, k, b) instead of a[k] += b\n",
        "                        # because `users` may contain duplicate entries\n",
        "    \n",
        "                        # delta = self.alpha * (err - self.reg * bias_users[users])\n",
        "                        # delta /= numpy.sqrt(per_user_ratings[users])\n",
        "                        \"\"\"\n",
        "                        _, axes = plt.subplots(1, 5, figsize=(30, 5))\n",
        "                        axes[0].hist(bias_users)\n",
        "                        axes[0].set_title(\"bias_users before\")\n",
        "                        axes[1].hist(bias_users[users])\n",
        "                        axes[1].set_title(\"bias_users[users] before\")\n",
        "                        axes[2].hist(delta)\n",
        "                        axes[2].set_title(\"bias_users delta\")\n",
        "                        \"\"\"\n",
        "                        # numpy.add.at(bias_users, users, delta)\n",
        "                        \"\"\"\n",
        "                        axes[3].hist(bias_users)\n",
        "                        axes[3].set_title(\"bias_users after\")\n",
        "                        axes[4].hist(bias_users[users])\n",
        "                        axes[4].set_title(\"bias_users[users] after\")\n",
        "                        plt.show()\n",
        "                        \"\"\"\n",
        "    \n",
        "                        # delta = self.alpha * (err - self.reg * bias_movies[movies])\n",
        "                        # delta /= numpy.sqrt(per_movie_ratings[movies])\n",
        "                        # numpy.add.at(bias_movies, movies, delta)\n",
        "    \n",
        "                        # Unvectorized version:\n",
        "                        # latent_users[user, :] += self.learning_rate * (err * latent_movies[movie, :] - self.regularization * latent_users[user, :])\n",
        "                        e_prod = e_prod_buf[:b, :]\n",
        "                        numpy.multiply(latent_movies[movies, :], err.reshape((-1, 1)), out=e_prod)\n",
        "                        r_prod = r_prod_buf[:b, :]\n",
        "                        r_prod[:, :] = latent_users[users, :]\n",
        "                        r_prod *= self.reg\n",
        "                        e_prod /= numpy.sqrt(per_user_ratings[users].reshape(-1, 1))\n",
        "                        r_prod /= per_user_ratings[users].reshape(-1, 1)\n",
        "                        e_prod -= r_prod\n",
        "                        e_prod *= self.alpha\n",
        "                        numpy.add.at(latent_users, users, e_prod) \n",
        "                        numpy.clip(latent_users, -5, 5, out=latent_users)\n",
        "    \n",
        "                        # Unvectorized version:\n",
        "                        # latent_movies[movie, :] += self.learning_rate * (err * latent_users[user, :] - self.regularization * latent_movies[movie, :])\n",
        "                        numpy.multiply(latent_users[users, :], err.reshape((-1, 1)), out=e_prod)\n",
        "                        r_prod[:, :] = latent_movies[movies, :]\n",
        "                        r_prod *= self.reg\n",
        "                        e_prod /= numpy.sqrt(per_movie_ratings[movies].reshape(-1, 1))\n",
        "                        r_prod /= per_movie_ratings[movies].reshape(-1, 1)\n",
        "                        e_prod -= r_prod\n",
        "                        e_prod *= self.alpha\n",
        "                        numpy.add.at(latent_movies, movies, e_prod)\n",
        "                        numpy.clip(latent_movies, -5, 5, out=latent_movies)\n",
        "    \n",
        "                        progress.inc(delta=b)\n",
        "    \n",
        "                        # print(bias_users)\n",
        "                        # print(bias_movies)\n",
        "                        # print(latent_users)\n",
        "                        # print(latent_movies)\n",
        "    \n",
        "                    rmse_history[epoch] = numpy.sqrt(mse_sum / ratings.shape[0])\n",
        "                    print(f\"Epoch {epoch}: {rmse_history[epoch]}\")\n",
        "    \n",
        "                    \"\"\"\n",
        "                    _, axes = plt.subplots(1, 4, figsize=(20, 5))\n",
        "                    axes[0].hist(bias_users)\n",
        "                    axes[0].set_title(\"bias_users\")\n",
        "                    axes[1].hist(bias_movies)\n",
        "                    axes[1].set_title(\"bias_movies\")\n",
        "                    axes[2].hist(latent_users.flatten())\n",
        "                    axes[2].set_title(\"latent_users\")\n",
        "                    axes[3].hist(latent_movies.flatten())\n",
        "                    axes[3].set_title(\"latent_movies\")\n",
        "                    plt.show()\n",
        "                    \"\"\"\n",
        "            except KeyboardInterrupt:\n",
        "                pass\n",
        "\n",
        "    self.mu = mu\n",
        "    self.bias_users = bias_users\n",
        "    self.bias_movies = bias_movies\n",
        "    self.latent_users = latent_users\n",
        "    self.latent_movies = latent_movies\n",
        "\n",
        "    self.rmse_history = rmse_history\n",
        "\n",
        "    return self\n",
        "\n",
        "\n",
        "SvdRecommend.fit = _fit"
      ],
      "execution_count": 73,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3-RfIvbJyuFD"
      },
      "source": [
        "def _predict(self, um):\n",
        "    \"\"\"um is an n*2 matrix.\n",
        "    The first column is the user ID.\n",
        "    The second column is the movie ID.\n",
        "    Returns a size n vector of predicted ratings.\"\"\"\n",
        "\n",
        "    users = um[:, COL_USER]\n",
        "    movies = um[:, COL_MOVIE]\n",
        "\n",
        "    ret = self.mu.copy()\n",
        "    ret += self.bias_users[users]\n",
        "    ret += self.bias_movies[movies]\n",
        "    ret += numpy.sum(self.latent_users[users, :] * self.latent_movies[movies, :], axis=1)\n",
        "\n",
        "    return ret\n",
        "\n",
        "SvdRecommend.predict = _predict"
      ],
      "execution_count": 67,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "Wt9FUYeBiTi5",
        "outputId": "2abc0b08-40d0-4dda-a301-78b141013441"
      },
      "source": [
        "numpy.random.seed(4609)\n",
        "model = SvdRecommend(0.05, 0.0, 10, 1048576, 20)\n",
        "model.evaluate()"
      ],
      "execution_count": 68,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Task: Counting users and movies\n",
            "Took 273.631099ms\n",
            "Task: Packing data in COO format\n",
            "Took 798.892142ms\n",
            "Task: Computing global mean\n",
            "Took 168.567799ms\n",
            "Task: Counting ratings per user\n",
            "Took 14817.296819ms\n",
            "Task: Counting ratings per movie\n",
            "Took 14442.07016ms\n",
            "Task: Computing user bias\n",
            "Took 1202.819485ms\n",
            "Task: Computing movie bias\n",
            "Took 1711.884201ms\n",
            "Task: Initializing parameters\n",
            "Took 876.170257ms\n",
            "Task: Performing gradient descent\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "text/html": [
              "<progress style='width:60ex' max='1981442240' value='1981442240'></progress>"
            ],
            "text/plain": [
              "[============================================================] 1981442240/1981442240"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "Epoch 0: 0.9244260981478505\n",
            "Epoch 1: 0.9244222509525296\n",
            "Epoch 2: 0.9244176035884472\n",
            "Epoch 3: 0.9244110067959971\n",
            "Epoch 4: 0.9243997797660728\n",
            "Epoch 5: 0.9243759971771623\n",
            "Epoch 6: 0.9243124483306707\n",
            "Epoch 7: 0.9241077025305277\n",
            "Epoch 8: 0.9233750706576282\n",
            "Epoch 9: 0.9207522378796467\n",
            "Epoch 10: 0.9130757075937047\n",
            "Epoch 11: 0.9011763882162023\n",
            "Epoch 12: 0.8942749366360823\n",
            "Epoch 13: 0.8897828971368414\n",
            "Epoch 14: 0.8843184225341888\n",
            "Epoch 15: 0.8773809562675267\n",
            "Epoch 16: 0.8698065778716306\n",
            "Epoch 17: 0.8622861125461294\n",
            "Epoch 18: 0.855292441300142\n",
            "Epoch 19: 0.8492551079630799\n",
            "Completed 1981442240/1981442240 in 5020962.681109ms\n",
            "Took 5020963.693498ms\n",
            "Evaluating 1408395 probe rows\n",
            "Hyperparameters: (0.05, 0.0, 10, 1048576, 20)\n",
            "Probe RMSE: 0.9572792349478484\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"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "2-dCqcOVB_P9",
        "outputId": "4865b4da-6aeb-4846-86d3-bf4808c00eed"
      },
      "source": [
        "numpy.random.seed(4609)\n",
        "model = SvdRecommend(0.05, 0.01, 10, 1048576, 20)\n",
        "model.evaluate()"
      ],
      "execution_count": 69,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Task: Counting users and movies\n",
            "Took 259.896432ms\n",
            "Task: Packing data in COO format\n",
            "Took 761.334923ms\n",
            "Task: Computing global mean\n",
            "Took 171.595082ms\n",
            "Task: Counting ratings per user\n",
            "Took 19981.724548ms\n",
            "Task: Counting ratings per movie\n",
            "Took 14827.719012ms\n",
            "Task: Computing user bias\n",
            "Took 1172.250306ms\n",
            "Task: Computing movie bias\n",
            "Took 1683.939606ms\n",
            "Task: Initializing parameters\n",
            "Took 884.709544ms\n",
            "Task: Performing gradient descent\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "text/html": [
              "<progress style='width:60ex' max='1981442240' value='1981442240'></progress>"
            ],
            "text/plain": [
              "[============================================================] 1981442240/1981442240"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "Epoch 0: 0.9244260981170793\n",
            "Epoch 1: 0.9244222545745737\n",
            "Epoch 2: 0.9244176197017419\n",
            "Epoch 3: 0.9244110491710368\n",
            "Epoch 4: 0.9243998757812218\n",
            "Epoch 5: 0.9243762161512199\n",
            "Epoch 6: 0.9243130105872612\n",
            "Epoch 7: 0.9241094306060045\n",
            "Epoch 8: 0.9233812226548432\n",
            "Epoch 9: 0.9207743625731215\n",
            "Epoch 10: 0.9131345558663901\n",
            "Epoch 11: 0.9012410153462539\n",
            "Epoch 12: 0.8943158922545479\n",
            "Epoch 13: 0.8898384102652717\n",
            "Epoch 14: 0.8844035899034468\n",
            "Epoch 15: 0.8774937134373425\n",
            "Epoch 16: 0.8699345913437568\n",
            "Epoch 17: 0.8624209277208523\n",
            "Epoch 18: 0.855423075140603\n",
            "Epoch 19: 0.8493734009153564\n",
            "Completed 1981442240/1981442240 in 5360143.419568ms\n",
            "Took 5360144.27702ms\n",
            "Evaluating 1408395 probe rows\n",
            "Hyperparameters: (0.05, 0.01, 10, 1048576, 20)\n",
            "Probe RMSE: 0.95725717504297\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"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "EvRWWdYxIk6I",
        "outputId": "1c3b800a-1d17-4f30-a7c3-ba0c4bcebdeb"
      },
      "source": [
        "numpy.random.seed(4609)\n",
        "model = SvdRecommend(0.05, 0.05, 10, 1048576, 20)\n",
        "model.evaluate()"
      ],
      "execution_count": 70,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Task: Counting users and movies\n",
            "Took 424.942266ms\n",
            "Task: Packing data in COO format\n",
            "Took 1261.786608ms\n",
            "Task: Computing global mean\n",
            "Took 240.524189ms\n",
            "Task: Counting ratings per user\n",
            "Took 26933.777959ms\n",
            "Task: Counting ratings per movie\n",
            "Took 25889.632854ms\n",
            "Task: Computing user bias\n",
            "Took 1717.51018ms\n",
            "Task: Computing movie bias\n",
            "Took 2589.502075ms\n",
            "Task: Initializing parameters\n",
            "Took 1139.229506ms\n",
            "Task: Performing gradient descent\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "text/html": [
              "<progress style='width:60ex' max='1981442240' value='1981442240'></progress>"
            ],
            "text/plain": [
              "[============================================================] 1981442240/1981442240"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "Epoch 0: 0.9244260979942264\n",
            "Epoch 1: 0.9244222690371573\n",
            "Epoch 2: 0.9244176838939092\n",
            "Epoch 3: 0.9244112176013041\n",
            "Epoch 4: 0.9244002565984151\n",
            "Epoch 5: 0.9243770829969676\n",
            "Epoch 6: 0.9243152329226585\n",
            "Epoch 7: 0.9241162525573434\n",
            "Epoch 8: 0.9234054886217891\n",
            "Epoch 9: 0.9208616824005764\n",
            "Epoch 10: 0.9133681659227774\n",
            "Epoch 11: 0.9015011828305467\n",
            "Epoch 12: 0.8944792474673915\n",
            "Epoch 13: 0.8900576327465718\n",
            "Epoch 14: 0.8847404639485441\n",
            "Epoch 15: 0.8779423522292793\n",
            "Epoch 16: 0.8704460242830381\n",
            "Epoch 17: 0.8629615703198097\n",
            "Epoch 18: 0.8559496469018197\n",
            "Epoch 19: 0.8498524163106955\n",
            "Completed 1981442240/1981442240 in 5719301.57884ms\n",
            "Took 5719304.150234ms\n",
            "Evaluating 1408395 probe rows\n",
            "Hyperparameters: (0.05, 0.05, 10, 1048576, 20)\n",
            "Probe RMSE: 0.9571810589441522\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"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 800
        },
        "id": "Y-o_GEmDJNcd",
        "outputId": "e525854c-0b8e-4a50-9d26-ea8bbbb8c960"
      },
      "source": [
        "numpy.random.seed(4609)\n",
        "model = SvdRecommend(0.2, 0.01, 10, 1048576, 20)\n",
        "model.evaluate()"
      ],
      "execution_count": 74,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Task: Counting users and movies\n",
            "Took 427.379726ms\n",
            "Task: Packing data in COO format\n",
            "Took 1265.095379ms\n",
            "Task: Computing global mean\n",
            "Took 232.467886ms\n",
            "Task: Counting ratings per user\n",
            "Took 21788.222637ms\n",
            "Task: Counting ratings per movie\n",
            "Took 21568.823259ms\n",
            "Task: Computing user bias\n",
            "Took 1678.577457ms\n",
            "Task: Computing movie bias\n",
            "Took 2553.723855ms\n",
            "Task: Initializing parameters\n",
            "Took 1036.572861ms\n",
            "Task: Performing gradient descent\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "text/html": [
              "<progress style='width:60ex' max='1981442240' value='694553360'></progress>"
            ],
            "text/plain": [
              "[=====================                                       ] 694553360/1981442240"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "Epoch 0: 0.9244261157924357\n",
            "Epoch 1: 0.9243993954132889\n",
            "Epoch 2: 0.9241161340956554\n",
            "Epoch 3: 0.9176232615185957\n",
            "Epoch 4: 0.9041405046622937\n",
            "Epoch 5: 2.17593350392664\n",
            "Epoch 6: 44.04031644047382\n",
            "Completed 694553360/1981442240 in 2015566.864126ms\n",
            "Took 2015567.125231ms\n",
            "Evaluating 1408395 probe rows\n",
            "Hyperparameters: (0.2, 0.01, 10, 1048576, 20)\n",
            "Probe RMSE: 91.53377141266354\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"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 939
        },
        "id": "u_0P6bVHIHZd",
        "outputId": "801a1115-44e7-46df-976f-2d182eed912a"
      },
      "source": [
        "numpy.random.seed(4609)\n",
        "model = SvdRecommend(0.05, 0.01, 20, 1048576, 15)\n",
        "model.evaluate()"
      ],
      "execution_count": 75,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Task: Counting users and movies\n",
            "Took 439.276115ms\n",
            "Task: Packing data in COO format\n",
            "Took 1244.485014ms\n",
            "Task: Computing global mean\n",
            "Took 234.36775ms\n",
            "Task: Counting ratings per user\n",
            "Took 28860.958795ms\n",
            "Task: Counting ratings per movie\n",
            "Took 28092.561753ms\n",
            "Task: Computing user bias\n",
            "Took 1698.441778ms\n",
            "Task: Computing movie bias\n",
            "Took 2563.542958ms\n",
            "Task: Initializing parameters\n",
            "Took 1364.168312ms\n",
            "Task: Performing gradient descent\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "text/html": [
              "<progress style='width:60ex' max='1486081680' value='1486081680'></progress>"
            ],
            "text/plain": [
              "[============================================================] 1486081680/1486081680"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "Epoch 0: 0.9244261876607375\n",
            "Epoch 1: 0.9244183884411168\n",
            "Epoch 2: 0.924408427534641\n",
            "Epoch 3: 0.924391979321987\n",
            "Epoch 4: 0.9243549751193394\n",
            "Epoch 5: 0.9242448299213566\n",
            "Epoch 6: 0.9238559130821002\n",
            "Epoch 7: 0.9224075799947182\n",
            "Epoch 8: 0.9175079970061103\n",
            "Epoch 9: 0.9066518617172681\n",
            "Epoch 10: 0.8973571801599142\n",
            "Epoch 11: 0.8934371539512002\n",
            "Epoch 12: 0.8899770240024012\n",
            "Epoch 13: 0.8851134544463649\n",
            "Epoch 14: 0.8777147848469126\n",
            "Completed 1486081680/1486081680 in 7349393.96206ms\n",
            "Took 7349396.537532ms\n",
            "Evaluating 1408395 probe rows\n",
            "Hyperparameters: (0.05, 0.01, 20, 1048576, 15)\n",
            "Probe RMSE: 0.969087852155832\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"
          }
        }
      ]
    }
  ]
}