tuning.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "75BUUUalfiKu",
    "outputId": "f1ea4d43-be45-45a1-eb24-0061bbd38fb7",
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Importing initial packages\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import dask.dataframe as dd\n",
    "# from scipy.sparse import csr_matrix\n",
    "import tqdm as tqdm\n",
    "from sklearn.model_selection import ParameterGrid, KFold\n",
    "import seaborn as sns\n",
    "\n",
    "# PyTorch Imports\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "import torch.nn.functional as F\n",
    "from torch.cuda.amp import autocast, GradScaler\n",
    "from torch.optim.lr_scheduler import StepLR\n",
    "from torch.utils.data import DataLoader, Dataset, random_split"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Setting Hyperparameters\n",
    "\n",
    "batch_size = 256\n",
    "epochs = 5\n",
    "lr = 0.005\n",
    "accumulation_steps = 4\n",
    "weight_decay = 1e-5\n",
    "step_size = 10\n",
    "gamma = 0.1\n",
    "patience = 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cuda\n"
     ]
    }
   ],
   "source": [
    "# Setting the device to GPU for parallelization\n",
    "device = 'mps' if torch.backends.mps.is_available() else 'cuda' if torch.cuda.is_available() else 'cpu'\n",
    "print(device)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "UclxqEQlfiKy"
   },
   "source": [
    "## Data Loading, Cleaning, and Preprocessing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "wtJcTHXffiKz"
   },
   "source": [
    "### Data Loading"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "id": "UWZoeHglfiKz",
    "tags": []
   },
   "outputs": [],
   "source": [
    "# In my project folder I added a data folder with both files (found in repo README) but did not push (gitignore) due to size\n",
    "\n",
    "movies = pandas.read_csv('ml-25m/movies.csv')\n",
    "ratings = pandas.read_csv('ml-25m/ratings_filled.csv')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "hmdDDjElfiK0"
   },
   "source": [
    "### Data Anlayst"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "dhJ2CH_RfiK0",
    "outputId": "d856adf0-f50f-49fe-8079-171e07b94aa7",
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The shape of movies is: (<dask_expr.expr.Scalar: expr=ReadCSV(f3f7dc5).size() // 3, dtype=int64>, 3)\n",
      "The shape of rating is: (<dask_expr.expr.Scalar: expr=ReadCSV(f3c592b).size() // 4, dtype=int64>, 4)\n",
      "The columns of movies is: ['movieId', 'title', 'genres']\n",
      "The columns of rating is: ['userId', 'movieId', 'rating', 'timestamp']\n",
      "\n",
      "* Notice that both df's have a movieId column, which will be useful for merging\n"
     ]
    }
   ],
   "source": [
    "print(f\"\"\"The shape of movies is: {movies.shape}\n",
    "The shape of rating is: {ratings.shape}\"\"\")\n",
    "\n",
    "print(f\"\"\"The columns of movies is: {movies.columns.to_list()}\n",
    "The columns of rating is: {ratings.columns.to_list()}\n",
    "\n",
    "* Notice that both df's have a movieId column, which will be useful for merging\"\"\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 206
    },
    "id": "R4rJrhOsfiK1",
    "outputId": "b3440d83-71fc-48bb-9d11-18ca7c1a9295",
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>movieId</th>\n",
       "      <th>title</th>\n",
       "      <th>genres</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>Toy Story (1995)</td>\n",
       "      <td>Adventure|Animation|Children|Comedy|Fantasy</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2</td>\n",
       "      <td>Jumanji (1995)</td>\n",
       "      <td>Adventure|Children|Fantasy</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3</td>\n",
       "      <td>Grumpier Old Men (1995)</td>\n",
       "      <td>Comedy|Romance</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>4</td>\n",
       "      <td>Waiting to Exhale (1995)</td>\n",
       "      <td>Comedy|Drama|Romance</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>5</td>\n",
       "      <td>Father of the Bride Part II (1995)</td>\n",
       "      <td>Comedy</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   movieId                               title  \\\n",
       "0        1                    Toy Story (1995)   \n",
       "1        2                      Jumanji (1995)   \n",
       "2        3             Grumpier Old Men (1995)   \n",
       "3        4            Waiting to Exhale (1995)   \n",
       "4        5  Father of the Bride Part II (1995)   \n",
       "\n",
       "                                        genres  \n",
       "0  Adventure|Animation|Children|Comedy|Fantasy  \n",
       "1                   Adventure|Children|Fantasy  \n",
       "2                               Comedy|Romance  \n",
       "3                         Comedy|Drama|Romance  \n",
       "4                                       Comedy  "
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Creating encoders and decoders for our movie ids\n",
    "movie_ids = list(movies.movieId)\n",
    "moviesid_to_title = dict(zip(movies.movieId,movies.title))    # Decoder\n",
    "movietitle_to_id = {j:i for i,j in moviesid_to_title.items()} # Encoder\n",
    "\n",
    "movies.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 206
    },
    "id": "Ge_Pb07ufiK2",
    "outputId": "03be3e68-d690-41bc-f467-cd571ca2b2ac",
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>userId</th>\n",
       "      <th>movieId</th>\n",
       "      <th>rating</th>\n",
       "      <th>timestamp</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>296</td>\n",
       "      <td>5.0</td>\n",
       "      <td>1147880044</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>306</td>\n",
       "      <td>3.5</td>\n",
       "      <td>1147868817</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1</td>\n",
       "      <td>307</td>\n",
       "      <td>5.0</td>\n",
       "      <td>1147868828</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1</td>\n",
       "      <td>665</td>\n",
       "      <td>5.0</td>\n",
       "      <td>1147878820</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1</td>\n",
       "      <td>899</td>\n",
       "      <td>3.5</td>\n",
       "      <td>1147868510</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   userId  movieId  rating   timestamp\n",
       "0       1      296     5.0  1147880044\n",
       "1       1      306     3.5  1147868817\n",
       "2       1      307     5.0  1147868828\n",
       "3       1      665     5.0  1147878820\n",
       "4       1      899     3.5  1147868510"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ratings.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "2JcPMLvDfiK3"
   },
   "source": [
    "We'll inspect the distribution of the dataset, to get a better understanding of the spread of reviews"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 449
    },
    "id": "7UC6R1nJfiK4",
    "outputId": "bbf1024e-887c-4507-9e53-2803c207b9dd",
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjcAAAHHCAYAAABDUnkqAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/OQEPoAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA5SUlEQVR4nO3de1wWZf7/8ffN6UZEMUFAEMXSPKTiKV2yUjeMzCxrKzNPkNpWUiraulYrHaUyDTdNt4OSueWhLetXnkglMy1PWdl6Pt0eAMVKBBUR5veHX+/tDlS4RQaG1/PxmD/muq+Z+Qw3ybtrrpmxGYZhCAAAwCI8zC4AAACgPBFuAACApRBuAACApRBuAACApRBuAACApRBuAACApRBuAACApRBuAACApRBuAACApRBugEro2Weflc1mq5BjdevWTd26dXOup6eny2az6aOPPqqQ48fFxSkyMrJCjuWu3NxcDR06VKGhobLZbBo5cqTZJTnZbDY9++yzZpcBVCqEG+AKS01Nlc1mcy6+vr4KCwtTbGys/vnPf+rEiRPlcpzDhw/r2Wef1ebNm8tlf+WpMtdWGhMmTFBqaqoeffRRvf/++xo4cOAF+0ZGRrp83zVr1lSnTp00e/Zst4+/aNEiAgxQBjbeLQVcWampqYqPj9fzzz+vxo0bq6CgQJmZmUpPT1daWpoaNmyozz77TG3atHFuc/bsWZ09e1a+vr6lPs6GDRt0/fXXa9asWYqLiyv1dmfOnJEk+fj4SDo3ctO9e3ctWLBA9957b6n3425tBQUFKioqkt1uL5djXQl/+tOf5OXlpdWrV1+yb2RkpK666iqNHj1akpSRkaF33nlHO3bs0FtvvaVhw4aV+fgJCQmaNm2aSvrn+vTp0/Ly8pKXl1eZ9wtYFf81ABWkZ8+e6tixo3N93LhxWrFihe644w7deeed2rp1q2rUqCFJFfLH6uTJk/Lz83OGGrN4e3ubevzSOHLkiFq2bFnq/uHh4RowYIBzPS4uTldffbVef/11t8LNxZQlAAPVBZelABP9+c9/1j/+8Q/t379fc+bMcbaXNOcmLS1NN954o+rUqSN/f381a9ZMTz31lKRzoy3XX3+9JCk+Pt55SSQ1NVXSuXk1rVq10saNG3XzzTfLz8/Pue0f59ycV1hYqKeeekqhoaGqWbOm7rzzTh04cMClT2RkZImjRL/f56VqK2nOTV5enkaPHq2IiAjZ7XY1a9ZMr732WrGRC5vNpoSEBC1cuFCtWrWS3W7XddddpyVLlpT8A/+DI0eOaMiQIQoJCZGvr6+ioqL03nvvOT8/P/9o7969+uKLL5y179u3r1T7P69evXpq3ry5du/e7dL+9ddf67777lPDhg1lt9sVERGhUaNG6dSpU84+cXFxmjZtmvN8zy+//xn8/pLV+d+dXbt2KS4uTnXq1FFAQIDi4+N18uRJl+OfOnVKTzzxhIKCglSrVi3deeedOnToULF9njhxQiNHjlRkZKTsdruCg4PVo0cPbdq0qUw/B6CiMHIDmGzgwIF66qmntGzZsgv+X/3PP/+sO+64Q23atNHzzz8vu92uXbt26ZtvvpEktWjRQs8//7zGjx+vhx9+WDfddJMk6YYbbnDu49ixY+rZs6ceeOABDRgwQCEhIRet66WXXpLNZtPYsWN15MgRpaSkKCYmRps3b3aOMJVGaWr7PcMwdOedd2rlypUaMmSI2rZtq6VLl+rJJ5/UoUOH9Prrr7v0X716tT7++GM99thjqlWrlv75z3/qL3/5ixwOhwIDAy9Y16lTp9StWzft2rVLCQkJaty4sRYsWKC4uDj99ttvGjFihFq0aKH3339fo0aNUoMGDZyXmurVq1fq85fOXWY8ePCgrrrqKpf2BQsW6OTJk3r00UcVGBiodevW6Y033tDBgwe1YMECSdJf//pXHT58WGlpaXr//fdLfcz7779fjRs3VnJysjZt2qR33nlHwcHBeuWVV5x94uLiNH/+fA0cOFB/+tOf9NVXX6lXr17F9vXII4/oo48+UkJCglq2bKljx45p9erV2rp1q9q3b1+mnwVQIQwAV9SsWbMMScb69esv2CcgIMBo166dcz0pKcn4/X+er7/+uiHJOHr06AX3sX79ekOSMWvWrGKfde3a1ZBkzJgxo8TPunbt6lxfuXKlIckIDw83cnJynO3z5883JBlTpkxxtjVq1MgYPHjwJfd5sdoGDx5sNGrUyLm+cOFCQ5Lx4osvuvS79957DZvNZuzatcvZJsnw8fFxafvhhx8MScYbb7xR7Fi/l5KSYkgy5syZ42w7c+aMER0dbfj7+7uce6NGjYxevXpddH+/73vrrbcaR48eNY4ePWr89NNPxsCBAw1JxvDhw136njx5stj2ycnJhs1mM/bv3+9sGz58uHGhf64lGUlJSc718787Dz30kEu/u+++2wgMDHSub9y40ZBkjBw50qVfXFxcsX0GBAQUqx2ozLgsBVQC/v7+F71rqk6dOpKkTz/9VEVFRW4dw263Kz4+vtT9Bw0apFq1ajnX7733XtWvX1+LFi1y6/iltWjRInl6euqJJ55waR89erQMw9DixYtd2mNiYnTNNdc419u0aaPatWtrz549lzxOaGio+vXr52zz9vbWE088odzcXH311Vdun8OyZctUr1491atXT61bt9b777+v+Ph4TZw40aXf70fA8vLylJ2drRtuuEGGYej77793+/jSudGW37vpppt07Ngx5eTkSJLz0t1jjz3m0u/xxx8vtq86derou+++0+HDhy+rJqCiVOtws2rVKvXu3VthYWGy2WxauHBhmfdhGIZee+01XXvttbLb7QoPD9dLL71U/sXC0nJzc12CxB/17dtXXbp00dChQxUSEqIHHnhA8+fPL1PQCQ8PL9Pk4aZNm7qs22w2NWnSpMzzTcpq//79CgsLK/bzaNGihfPz32vYsGGxfVx11VX69ddfL3mcpk2bysPD9Z/BCx2nLDp37qy0tDQtWbJEr732murUqaNff/212M/f4XAoLi5OdevWlb+/v+rVq6euXbtKko4fP+728aXiP5fzl8TO/1z2798vDw8PNW7c2KVfkyZNiu3r1Vdf1ZYtWxQREaFOnTrp2WefvWR4BMxUrcNNXl6eoqKinJP13DFixAi98847eu2117Rt2zZ99tln6tSpUzlWCas7ePCgjh8/XuIflfNq1KihVatW6csvv9TAgQP1448/qm/fvurRo4cKCwtLdZyyzJMprQs9aLC0NZUHT0/PEtsNE59yERQUpJiYGMXGxmr06NGaM2eOFi5cqClTpjj7FBYWqkePHvriiy80duxYLVy4UGlpac6J1u6O0J1Xnj+X+++/X3v27NEbb7yhsLAwTZw4Udddd12xUTSgsqjW4aZnz5568cUXdffdd5f4eX5+vsaMGaPw8HDVrFlTnTt3Vnp6uvPzrVu3avr06fr000915513qnHjxurQoYN69OhRQWcAKzg/STQ2Nvai/Tw8PHTLLbdo8uTJ+u9//6uXXnpJK1as0MqVKyVdOGi4a+fOnS7rhmFo165dLnc2XXXVVfrtt9+KbfvHUY+y1NaoUSMdPny42GW6bdu2OT8vD40aNdLOnTuLhYjyPo4k9erVS127dtWECROUl5cnSfrpp5+0Y8cOTZo0SWPHjtVdd92lmJgYhYWFFdv+SjytulGjRioqKtLevXtd2nft2lVi//r16+uxxx7TwoULtXfvXgUGBjJKjUqrWoebS0lISNDatWs1d+5c/fjjj7rvvvt02223Of/R/3//7//p6quv1ueff67GjRsrMjJSQ4cO1S+//GJy5agqVqxYoRdeeEGNGzdW//79L9ivpN+ptm3bSjoXwiWpZs2aklRi2HDH7NmzXQLGRx99pIyMDPXs2dPZds011+jbb791PghQkj7//PNit4yXpbbbb79dhYWFmjp1qkv766+/LpvN5nL8y3H77bcrMzNT8+bNc7adPXtWb7zxhvz9/Z2Xh8rL2LFjdezYMb399tuS/jey8vuRFMMwXEZ3zivv71b6X5h+8803XdrfeOMNl/XCwsJil8iCg4MVFhbm/N0DKhtuBb8Ah8OhWbNmyeFwOP9PasyYMVqyZIlmzZqlCRMmaM+ePdq/f78WLFig2bNnq7CwUKNGjdK9996rFStWmHwGqGwWL16sbdu26ezZs8rKytKKFSuUlpamRo0a6bPPPrvow9ief/55rVq1Sr169VKjRo105MgRvfnmm2rQoIFuvPFGSeeCRp06dTRjxgzVqlXLOdr4xzkVpVW3bl3deOONio+PV1ZWllJSUtSkSROX29WHDh2qjz76SLfddpvuv/9+7d69W3PmzHGZ4FvW2nr37q3u3bvr6aef1r59+xQVFaVly5bp008/1ciRI4vt210PP/yw/vWvfykuLk4bN25UZGSkPvroI33zzTdKSUm56Bwod/Ts2VOtWrXS5MmTNXz4cDVv3lzXXHONxowZo0OHDql27dr6z3/+U+JcoQ4dOkiSnnjiCcXGxsrT01MPPPDAZdXToUMH/eUvf1FKSoqOHTvmvBV8x44dkv43WnTixAk1aNBA9957r6KiouTv768vv/xS69ev16RJky6rBuCKMe9GrcpFkvHJJ5841z///HNDklGzZk2XxcvLy7j//vsNwzCMYcOGGZKM7du3O7c7f3vltm3bKvoUUEmdvxX8/OLj42OEhoYaPXr0MKZMmeJyy/F5f7wVfPny5cZdd91lhIWFGT4+PkZYWJjRr18/Y8eOHS7bffrpp0bLli0NLy8vl1uvu3btalx33XUl1nehW8E//PBDY9y4cUZwcLBRo0YNo1evXi63J583adIkIzw83LDb7UaXLl2MDRs2FNvnxWr7463ghmEYJ06cMEaNGmWEhYUZ3t7eRtOmTY2JEycaRUVFLv1Uwu3VhnHhW9T/KCsry4iPjzeCgoIMHx8fo3Xr1iXerl7WW8Ev1Dc1NdXl3P/73/8aMTExhr+/vxEUFGQMGzbMeSv77+s4e/as8fjjjxv16tUzbDaby++GLnAr+B8fG3D+93Dv3r3Otry8PGP48OFG3bp1DX9/f6NPnz7G9u3bDUnGyy+/bBiGYeTn5xtPPvmkERUVZdSqVcuoWbOmERUVZbz55pul+nkAZuDdUv/HZrPpk08+UZ8+fSRJ8+bNU//+/fXzzz8Xm5jn7++v0NBQJSUlacKECSooKHB+durUKfn5+WnZsmXMvQFQ5WzevFnt2rXTnDlzLnqpFKjMuCx1Ae3atVNhYaGOHDnifKLqH3Xp0kVnz57V7t27nUPl54d0y3MyIgBcCadOnSp2F11KSoo8PDx08803m1QVcPmqdbjJzc11uTNg79692rx5s+rWratrr71W/fv316BBgzRp0iS1a9dOR48e1fLly9WmTRv16tVLMTExat++vR566CGlpKSoqKhIw4cPV48ePXTttdeaeGYAcGmvvvqqNm7cqO7du8vLy0uLFy/W4sWL9fDDDysiIsLs8gC3VevLUunp6erevXux9sGDBys1NVUFBQV68cUXNXv2bB06dEhBQUH605/+pOeee06tW7eWJB0+fFiPP/64li1bppo1a6pnz56aNGmS6tatW9GnAwBlkpaWpueee07//e9/lZubq4YNG2rgwIF6+umnr/hb6YErqVqHGwAAYD085wYAAFiKqeGmrO92+vjjj9WjRw/Vq1dPtWvXVnR0tJYuXVoxxQIAgCrB1Iuq59/t9NBDD+mee+65ZP9Vq1apR48emjBhgurUqaNZs2apd+/e+u6779SuXbtSHbOoqEiHDx9WrVq1rsgjzQEAQPkzDEMnTpxQWFhYsRfe/lGlmXPzx+fMlNZ1112nvn37avz48aXqf/DgQe4CAACgijpw4IAaNGhw0T5Vejp8UVGRTpw4cdE7k/Lz813ef3I+yx04cEC1a9e+4jUCAIDLl5OTo4iIiFK9GqVKh5vXXntNubm5uv/++y/YJzk5Wc8991yx9tq1axNuAACoYkozpaTK3i31wQcf6LnnntP8+fMVHBx8wX7jxo3T8ePHncsf31YMAACspUqO3MydO1dDhw7VggULFBMTc9G+drtddru9gioDAABmq3IjNx9++KHi4+P14YcfqlevXmaXAwAAKhlTR24u9m6nhg0baty4cTp06JBmz54t6dylqMGDB2vKlCnq3LmzMjMzJUk1atRQQECAKecAAAAqF1NHbjZs2KB27do5n1GTmJiodu3aOW/rzsjIkMPhcPZ/6623dPbsWQ0fPlz169d3LiNGjDClfgAAUPlUmufcVJScnBwFBATo+PHj3C0FAEAVUZa/31Vuzg0AAMDFEG4AAIClEG4AAIClEG4AAIClEG4AAIClEG4AAIClEG4AAIClEG4AAIClVMkXZwIAzOVwOJSdnW12GWUWFBSkhg0bml0GrjDCDQCgTBwOh5o1b6HTp06aXUqZ+dbw0/ZtWwk4Fke4AQCUSXZ2tk6fOqnAO0bLOzDC7HJKreDYAR37fJKys7MJNxZHuAEAuMU7MEL20CZmlwEUw4RiAABgKYQbAABgKYQbAABgKYQbAABgKYQbAABgKYQbAABgKYQbAABgKYQbAABgKYQbAABgKYQbAABgKYQbAABgKYQbAABgKYQbAABgKYQbAABgKYQbAABgKYQbAABgKYQbAABgKYQbAABgKYQbAABgKYQbAABgKYQbAABgKYQbAABgKYQbAABgKYQbAABgKYQbAABgKYQbAABgKYQbAABgKYQbAABgKYQbAABgKYQbAABgKYQbAABgKYQbAABgKYQbAABgKYQbAABgKYQbAABgKYQbAABgKYQbAABgKYQbAABgKaaGm1WrVql3794KCwuTzWbTwoULL7lNenq62rdvL7vdriZNmig1NfWK1wkAAKoOU8NNXl6eoqKiNG3atFL137t3r3r16qXu3btr8+bNGjlypIYOHaqlS5de4UoBAEBV4WXmwXv27KmePXuWuv+MGTPUuHFjTZo0SZLUokULrV69Wq+//rpiY2OvVJkAAKAKqVJzbtauXauYmBiXttjYWK1du9akigAAQGVj6shNWWVmZiokJMSlLSQkRDk5OTp16pRq1KhRbJv8/Hzl5+c713Nycq54nQAAwDxVauTGHcnJyQoICHAuERERZpcEAACuoCoVbkJDQ5WVleXSlpWVpdq1a5c4aiNJ48aN0/Hjx53LgQMHKqJUAABgkip1WSo6OlqLFi1yaUtLS1N0dPQFt7Hb7bLb7Ve6NAAAUEmYOnKTm5urzZs3a/PmzZLO3eq9efNmORwOSedGXQYNGuTs/8gjj2jPnj3629/+pm3btunNN9/U/PnzNWrUKDPKBwAAlZCp4WbDhg1q166d2rVrJ0lKTExUu3btNH78eElSRkaGM+hIUuPGjfXFF18oLS1NUVFRmjRpkt555x1uAwcAAE6mXpbq1q2bDMO44OclPX24W7du+v77769gVQAAoCqrUhOKAQAALoVwAwAALIVwAwAALIVwAwAALIVwAwAALIVwAwAALIVwAwAALIVwAwAALIVwAwAALIVwAwAALIVwAwAALIVwAwAALIVwAwAALIVwAwAALIVwAwAALIVwAwAALIVwAwAALIVwAwAALIVwAwAALIVwAwAALIVwAwAALIVwAwAALIVwAwAALIVwAwAALIVwAwAALIVwAwAALIVwAwAALIVwAwAALIVwAwAALIVwAwAALIVwAwAALIVwAwAALIVwAwAALIVwAwAALIVwAwAALIVwAwAALIVwAwAALIVwAwAALIVwAwAALIVwAwAALIVwAwAALIVwAwAALMXL7AIAoDw5HA5lZ2ebXUaZBAUFqWHDhmaXAVgG4QaAZTgcDjVr3kKnT500u5Qy8a3hp+3bthJwgHJCuAFgGdnZ2Tp96qQC7xgt78AIs8splYJjB3Ts80nKzs4m3ADlhHADwHK8AyNkD21idhkATMKEYgAAYCmEGwAAYCmEGwAAYCmEGwAAYCmmh5tp06YpMjJSvr6+6ty5s9atW3fR/ikpKWrWrJlq1KihiIgIjRo1SqdPn66gagEAQGVnariZN2+eEhMTlZSUpE2bNikqKkqxsbE6cuRIif0/+OAD/f3vf1dSUpK2bt2qd999V/PmzdNTTz1VwZUDAIDKytRwM3nyZA0bNkzx8fFq2bKlZsyYIT8/P82cObPE/mvWrFGXLl304IMPKjIyUrfeeqv69et3ydEeAABQfZgWbs6cOaONGzcqJibmf8V4eCgmJkZr164tcZsbbrhBGzdudIaZPXv2aNGiRbr99tsrpGYAAFD5mfYQv+zsbBUWFiokJMSlPSQkRNu2bStxmwcffFDZ2dm68cYbZRiGzp49q0ceeeSil6Xy8/OVn5/vXM/JySmfEwAAAJWS6ROKyyI9PV0TJkzQm2++qU2bNunjjz/WF198oRdeeOGC2yQnJysgIMC5RERUjUeyAwAA95g2chMUFCRPT09lZWW5tGdlZSk0NLTEbf7xj39o4MCBGjp0qCSpdevWysvL08MPP6ynn35aHh7Fs9q4ceOUmJjoXM/JySHgAABgYaaN3Pj4+KhDhw5avny5s62oqEjLly9XdHR0iducPHmyWIDx9PSUJBmGUeI2drtdtWvXdlkAAIB1mfrizMTERA0ePFgdO3ZUp06dlJKSory8PMXHx0uSBg0apPDwcCUnJ0uSevfurcmTJ6tdu3bq3Lmzdu3apX/84x/q3bu3M+QAAIDqzdRw07dvXx09elTjx49XZmam2rZtqyVLljgnGTscDpeRmmeeeUY2m03PPPOMDh06pHr16ql379566aWXzDoFAABQyZgabiQpISFBCQkJJX6Wnp7usu7l5aWkpCQlJSVVQGUAAKAqqlJ3SwEAAFwK4QYAAFgK4QYAAFgK4QYAAFgK4QYAAFgK4QYAAFgK4QYAAFgK4QYAAFgK4QYAAFgK4QYAAFgK4QYAAFgK4QYAAFgK4QYAAFgK4QYAAFgK4QYAAFgK4QYAAFgK4QYAAFgK4QYAAFgK4QYAAFgK4QYAAFgK4QYAAFiKW+Fmz5495V0HAABAuXAr3DRp0kTdu3fXnDlzdPr06fKuCQAAwG1uhZtNmzapTZs2SkxMVGhoqP76179q3bp15V0bAABAmbkVbtq2baspU6bo8OHDmjlzpjIyMnTjjTeqVatWmjx5so4ePVredQIAAJTKZU0o9vLy0j333KMFCxbolVde0a5duzRmzBhFRERo0KBBysjIKK86AQAASuWyws2GDRv02GOPqX79+po8ebLGjBmj3bt3Ky0tTYcPH9Zdd91VXnUCAACUipc7G02ePFmzZs3S9u3bdfvtt2v27Nm6/fbb5eFxLis1btxYqampioyMLM9aAQAALsmtcDN9+nQ99NBDiouLU/369UvsExwcrHffffeyigMAACgrt8LNzp07L9nHx8dHgwcPdmf3AAAAbnNrzs2sWbO0YMGCYu0LFizQe++9d9lFAQAAuMutcJOcnKygoKBi7cHBwZowYcJlFwUAAOAut8KNw+FQ48aNi7U3atRIDofjsosCAABwl1vhJjg4WD/++GOx9h9++EGBgYGXXRQAAIC73Ao3/fr10xNPPKGVK1eqsLBQhYWFWrFihUaMGKEHHnigvGsEAAAoNbfulnrhhRe0b98+3XLLLfLyOreLoqIiDRo0iDk3AADAVG6FGx8fH82bN08vvPCCfvjhB9WoUUOtW7dWo0aNyrs+AACAMnEr3Jx37bXX6tprry2vWgAAAC6bW+GmsLBQqampWr58uY4cOaKioiKXz1esWFEuxQEAAJSVW+FmxIgRSk1NVa9evdSqVSvZbLbyrgsAAMAtboWbuXPnav78+br99tvLux4AAIDL4tat4D4+PmrSpEl51wIAAHDZ3Ao3o0eP1pQpU2QYRnnXAwAAcFncuiy1evVqrVy5UosXL9Z1110nb29vl88//vjjcikOAACgrNwKN3Xq1NHdd99d3rUAAABcNrfCzaxZs8q7DgAAUAKHw6Hs7GyzyyiToKAgNWzY0LTju/0Qv7Nnzyo9PV27d+/Wgw8+qFq1aunw4cOqXbu2/P39y7NGAACqJYfDoWbNW+j0qZNml1ImvjX8tH3bVtMCjlvhZv/+/brtttvkcDiUn5+vHj16qFatWnrllVeUn5+vGTNmlHedAABUO9nZ2Tp96qQC7xgt78AIs8splYJjB3Ts80nKzs6uWuFmxIgR6tixo3744QcFBgY62++++24NGzas3IoDAACSd2CE7KE8gqW03Ao3X3/9tdasWSMfHx+X9sjISB06dKhcCgMAAHCHW8+5KSoqUmFhYbH2gwcPqlatWpddFAAAgLvcCje33nqrUlJSnOs2m025ublKSkoq8ysZpk2bpsjISPn6+qpz585at27dRfv/9ttvGj58uOrXry+73a5rr71WixYtcuc0AACABbl1WWrSpEmKjY1Vy5Ytdfr0aT344IPauXOngoKC9OGHH5Z6P/PmzVNiYqJmzJihzp07KyUlRbGxsdq+fbuCg4OL9T9z5ox69Oih4OBgffTRRwoPD9f+/ftVp04dd04DAABYkFvhpkGDBvrhhx80d+5c/fjjj8rNzdWQIUPUv39/1ahRo9T7mTx5soYNG6b4+HhJ0owZM/TFF19o5syZ+vvf/16s/8yZM/XLL79ozZo1zqciR0ZGunMKAADAotx+zo2Xl5cGDBjg9oHPnDmjjRs3aty4cc42Dw8PxcTEaO3atSVu89lnnyk6OlrDhw/Xp59+qnr16unBBx/U2LFj5enpWeI2+fn5ys/Pd67n5OS4XTMAAKj83Ao3s2fPvujngwYNuuQ+srOzVVhYqJCQEJf2kJAQbdu2rcRt9uzZoxUrVqh///5atGiRdu3apccee0wFBQVKSkoqcZvk5GQ999xzl6wHAABYg9vPufm9goICnTx5Uj4+PvLz8ytVuHFHUVGRgoOD9dZbb8nT01MdOnTQoUOHNHHixAuGm3HjxikxMdG5npOTo4iIqvEgJAAAUHZuhZtff/21WNvOnTv16KOP6sknnyzVPoKCguTp6amsrCyX9qysLIWGhpa4Tf369eXt7e1yCapFixbKzMzUmTNnij13R5LsdrvsdnupagIAAFWfW7eCl6Rp06Z6+eWXi43qXIiPj486dOig5cuXO9uKioq0fPlyRUdHl7hNly5dtGvXLhUVFTnbduzYofr165cYbAAAQPVTbuFGOjfJ+PDhw6Xun5iYqLffflvvvfeetm7dqkcffVR5eXnOu6cGDRrkMuH40Ucf1S+//KIRI0Zox44d+uKLLzRhwgQNHz68PE8DAABUYW5dlvrss89c1g3DUEZGhqZOnaouXbqUej99+/bV0aNHNX78eGVmZqpt27ZasmSJc5Kxw+GQh8f/8ldERISWLl2qUaNGqU2bNgoPD9eIESM0duxYd04DAABYkFvhpk+fPi7rNptN9erV05///GdNmjSpTPtKSEhQQkJCiZ+lp6cXa4uOjta3335bpmMAAIDqw61w8/s5LwAAAJVJuc65AQAAMJtbIze/f27MpUyePNmdQwAAALjFrXDz/fff6/vvv1dBQYGaNWsm6dwt2Z6enmrfvr2zn81mK58qAQAASsmtcNO7d2/VqlVL7733nq666ipJ5x7sFx8fr5tuukmjR48u1yIBAABKy605N5MmTVJycrIz2EjSVVddpRdffLHMd0sBAACUJ7fCTU5Ojo4ePVqs/ejRozpx4sRlFwUAAOAut8LN3Xffrfj4eH388cc6ePCgDh48qP/85z8aMmSI7rnnnvKuEQAAoNTcmnMzY8YMjRkzRg8++KAKCgrO7cjLS0OGDNHEiRPLtUAAqA62bt1qdgmlVpVqRfXkVrjx8/PTm2++qYkTJ2r37t2SpGuuuUY1a9Ys1+IAwOoKc3+VbDYNGDDA7FIAy3Ar3JyXkZGhjIwM3XzzzapRo4YMw+D2bwAog6L8XMkwFHjHaHkHRphdTqmc2rNBx7+eY3YZwAW5FW6OHTum+++/XytXrpTNZtPOnTt19dVXa8iQIbrqqqu4YwoAysg7MEL20CZml1EqBccOmF0CcFFuTSgeNWqUvL295XA45Ofn52zv27evlixZUm7FAQAAlJVbIzfLli3T0qVL1aBBA5f2pk2bav/+/eVSGAAAgDvcGrnJy8tzGbE575dffpHdbr/sogAAANzlVri56aabNHv2bOe6zWZTUVGRXn31VXXv3r3cigMAACgrty5Lvfrqq7rlllu0YcMGnTlzRn/729/0888/65dfftE333xT3jUCAACUmlsjN61atdKOHTt044036q677lJeXp7uueceff/997rmmmvKu0YAAIBSK/PITUFBgW677TbNmDFDTz/99JWoCQAAwG1lHrnx9vbWjz/+eCVqAQAAuGxuXZYaMGCA3n333fKuBQAA4LK5NaH47Nmzmjlzpr788kt16NCh2DulJk+eXC7FAQAAlFWZws2ePXsUGRmpLVu2qH379pKkHTt2uPTh3VIAAMBMZQo3TZs2VUZGhlauXCnp3OsW/vnPfyokJOSKFAcAAFBWZZpzYxiGy/rixYuVl5dXrgUBAABcDrcmFJ/3x7ADAABgtjKFG5vNVmxODXNsAABAZVKmOTeGYSguLs75cszTp0/rkUceKXa31Mcff1x+FQIAAJRBmcLN4MGDXdYHDBhQrsUAAABcrjKFm1mzZl2pOgAAAMrFZU0oBgAAqGwINwAAwFIINwAAwFIINwAAwFIINwAAwFIINwAAwFIINwAAwFIINwAAwFIINwAAwFIINwAAwFIINwAAwFIINwAAwFIINwAAwFIINwAAwFIINwAAwFIINwAAwFIINwAAwFIINwAAwFIINwAAwFIINwAAwFIqRbiZNm2aIiMj5evrq86dO2vdunWl2m7u3Lmy2Wzq06fPlS0QAABUGaaHm3nz5ikxMVFJSUnatGmToqKiFBsbqyNHjlx0u3379mnMmDG66aabKqhSAABQFZgebiZPnqxhw4YpPj5eLVu21IwZM+Tn56eZM2decJvCwkL1799fzz33nK6++uoKrBYAAFR2poabM2fOaOPGjYqJiXG2eXh4KCYmRmvXrr3gds8//7yCg4M1ZMiQSx4jPz9fOTk5LgsAALAuU8NNdna2CgsLFRIS4tIeEhKizMzMErdZvXq13n33Xb399tulOkZycrICAgKcS0RExGXXDQAAKi/TL0uVxYkTJzRw4EC9/fbbCgoKKtU248aN0/Hjx53LgQMHrnCVAADATF5mHjwoKEienp7Kyspyac/KylJoaGix/rt379a+ffvUu3dvZ1tRUZEkycvLS9u3b9c111zjso3dbpfdbr8C1QMAgMrI1JEbHx8fdejQQcuXL3e2FRUVafny5YqOji7Wv3nz5vrpp5+0efNm53LnnXeqe/fu2rx5M5ecAACAuSM3kpSYmKjBgwerY8eO6tSpk1JSUpSXl6f4+HhJ0qBBgxQeHq7k5GT5+vqqVatWLtvXqVNHkoq1AwBQkq1bt5pdQqlVpVorE9PDTd++fXX06FGNHz9emZmZatu2rZYsWeKcZOxwOOThUaWmBgEAKqHC3F8lm00DBgwwuxRcYaaHG0lKSEhQQkJCiZ+lp6dfdNvU1NTyLwgAYDlF+bmSYSjwjtHyDqwa0xhO7dmg41/PMbuMKqdShBsAACqKd2CE7KFNzC6jVAqOcYevO7jeAwAALIVwAwAALIVwAwAALIVwAwAALIVwAwAALIVwAwAALIVwAwAALIVwAwAALIVwAwAALIVwAwAALIVwAwAALIVwAwAALIVwAwAALIVwAwAALIVwAwAALIVwAwAALIVwAwAALIVwAwAALIVwAwAALIVwAwAALIVwAwAALIVwAwAALIVwAwAALIVwAwAALIVwAwAALIVwAwAALIVwAwAALMXL7AKA6sLhcCg7O9vsMsokKChIDRs2NLsMACgTwg1QARwOh5o1b6HTp06aXUqZ+Nbw0/ZtWwk4AKoUwg1QAbKzs3X61EkF3jFa3oERZpdTKgXHDujY55OUnZ1NuAFQpRBugArkHRghe2gTs8sAAEtjQjEAALAUwg0AALAUwg0AALAUwg0AALAUwg0AALAUwg0AALAUwg0AALAUwg0AALAUwg0AALAUwg0AALAUwg0AALAUwg0AALAUwg0AALAUwg0AALAUwg0AALAUwg0AALAUL7MLAFC5bd261ewSSq0q1QrgyiHcAChRYe6vks2mAQMGmF0KAJRJpQg306ZN08SJE5WZmamoqCi98cYb6tSpU4l93377bc2ePVtbtmyRJHXo0EETJky4YH8A7inKz5UMQ4F3jJZ3YITZ5ZTKqT0bdPzrOWaXAcBkpoebefPmKTExUTNmzFDnzp2VkpKi2NhYbd++XcHBwcX6p6enq1+/frrhhhvk6+urV155Rbfeeqt+/vlnhYeHm3AGgLV5B0bIHtrE7DJKpeDYAbNLAFAJmD6hePLkyRo2bJji4+PVsmVLzZgxQ35+fpo5c2aJ/f/973/rscceU9u2bdW8eXO98847Kioq0vLlyyu4cgAAUBmZGm7OnDmjjRs3KiYmxtnm4eGhmJgYrV27tlT7OHnypAoKClS3bt0SP8/Pz1dOTo7LAgAArMvUcJOdna3CwkKFhIS4tIeEhCgzM7NU+xg7dqzCwsJcAtLvJScnKyAgwLlERFSNuQMAAMA9pl+Wuhwvv/yy5s6dq08++US+vr4l9hk3bpyOHz/uXA4c4Jo8AABWZuqE4qCgIHl6eiorK8ulPSsrS6GhoRfd9rXXXtPLL7+sL7/8Um3atLlgP7vdLrvdXi71AgCAys/UkRsfHx916NDBZTLw+cnB0dHRF9zu1Vdf1QsvvKAlS5aoY8eOFVEqAACoIky/FTwxMVGDBw9Wx44d1alTJ6WkpCgvL0/x8fGSpEGDBik8PFzJycmSpFdeeUXjx4/XBx98oMjISOfcHH9/f/n7+5t2HgAAoHIwPdz07dtXR48e1fjx45WZmam2bdtqyZIlzknGDodDHh7/G2CaPn26zpw5o3vvvddlP0lJSXr22WcrsnQAAFAJmR5uJCkhIUEJCQklfpaenu6yvm/fvitfEAAAqLKq9N1SAAAAf0S4AQAAlkK4AQAAlkK4AQAAlkK4AQAAlkK4AQAAlkK4AQAAlkK4AQAAlkK4AQAAlkK4AQAAlkK4AQAAlkK4AQAAllIpXpwJczkcDmVnZ5tdRpkEBQWpYcOGZpcBAKiECDfVnMPhULPmLXT61EmzSykT3xp+2r5tKwEHAFAM4aaay87O1ulTJxV4x2h5B0aYXU6pFBw7oGOfT1J2djbhBgBQDOEGkiTvwAjZQ5uYXQYAAJeNCcUAAMBSCDcAAMBSCDcAAMBSCDcAAMBSCDcAAMBSCDcAAMBSCDcAAMBSCDcAAMBSCDcAAMBSCDcAAMBSCDcAAMBSCDcAAMBSCDcAAMBSCDcAAMBSCDcAAMBSCDcAAMBSvMwuAHDX1q1bzS6h1KpSrQBQ1RFuypnD4VB2drbZZZRaVfyjW5j7q2SzacCAAWaXAgCohAg35cjhcKhZ8xY6feqk2aVYWlF+rmQYCrxjtLwDI8wup1RO7dmg41/PMbsMAKgWCDflKDs7W6dPneSPbgXxDoyQPbSJ2WWUSsGxA2aXAADVBuHmCuCPLgAA5uFuKQAAYCmEGwAAYCmEGwAAYCmEGwAAYCmEGwAAYCmEGwAAYCmEGwAAYCmEGwAAYCmEGwAAYCmEGwAAYCmEGwAAYCmEGwAAYCmEGwAAYCmVItxMmzZNkZGR8vX1VefOnbVu3bqL9l+wYIGaN28uX19ftW7dWosWLaqgSgEAQGVneriZN2+eEhMTlZSUpE2bNikqKkqxsbE6cuRIif3XrFmjfv36aciQIfr+++/Vp08f9enTR1u2bKngygEAQGVkeriZPHmyhg0bpvj4eLVs2VIzZsyQn5+fZs6cWWL/KVOm6LbbbtOTTz6pFi1a6IUXXlD79u01derUCq4cAABURqaGmzNnzmjjxo2KiYlxtnl4eCgmJkZr164tcZu1a9e69Jek2NjYC/YHAADVi5eZB8/OzlZhYaFCQkJc2kNCQrRt27YSt8nMzCyxf2ZmZon98/PzlZ+f71w/fvy4JCknJ+dySi9Rbm7uuWNm7lLRmdPlvv8roeDYAUnUfKVRc8Wg5opRFWuWqmbdVbLmXw5KOvc3sTz/1p7fl2EYl+5smOjQoUOGJGPNmjUu7U8++aTRqVOnErfx9vY2PvjgA5e2adOmGcHBwSX2T0pKMiSxsLCwsLCwWGA5cODAJfOFqSM3QUFB8vT0VFZWlkt7VlaWQkNDS9wmNDS0TP3HjRunxMRE53pRUZF++eUXBQYGymazXeYZWFNOTo4iIiJ04MAB1a5d2+xyqj2+j8qF76Py4TupXK7U92EYhk6cOKGwsLBL9jU13Pj4+KhDhw5avny5+vTpI+lc+Fi+fLkSEhJK3CY6OlrLly/XyJEjnW1paWmKjo4usb/dbpfdbndpq1OnTnmUb3m1a9fmH4pKhO+jcuH7qHz4TiqXK/F9BAQElKqfqeFGkhITEzV48GB17NhRnTp1UkpKivLy8hQfHy9JGjRokMLDw5WcnCxJGjFihLp27apJkyapV69emjt3rjZs2KC33nrLzNMAAACVhOnhpm/fvjp69KjGjx+vzMxMtW3bVkuWLHFOGnY4HPLw+N9NXTfccIM++OADPfPMM3rqqafUtGlTLVy4UK1atTLrFAAAQCVieriRpISEhAtehkpPTy/Wdt999+m+++67wlVVX3a7XUlJScUu58EcfB+VC99H5cN3UrlUhu/DZhiluacKAACgajD9CcUAAADliXADAAAshXADAAAshXADAAAshXADp1WrVql3794KCwuTzWbTwoULzS6pWktOTtb111+vWrVqKTg4WH369NH27dvNLqvamj59utq0aeN8MFl0dLQWL15sdln4Py+//LJsNpvLA15RcZ599lnZbDaXpXnz5qbVQ7iBU15enqKiojRt2jSzS4Gkr776SsOHD9e3336rtLQ0FRQU6NZbb1VeXp7ZpVVLDRo00Msvv6yNGzdqw4YN+vOf/6y77rpLP//8s9mlVXvr16/Xv/71L7Vp08bsUqq16667ThkZGc5l9erVptVSKZ5zg8qhZ8+e6tmzp9ll4P8sWbLEZT01NVXBwcHauHGjbr75ZpOqqr569+7tsv7SSy9p+vTp+vbbb3XdddeZVBVyc3PVv39/vf3223rxxRfNLqda8/LyuuB7HisaIzdAFXH8+HFJUt26dU2uBIWFhZo7d67y8vIu+F47VIzhw4erV69eiomJMbuUam/nzp0KCwvT1Vdfrf79+8vhcJhWCyM3QBVQVFSkkSNHqkuXLrxqxEQ//fSToqOjdfr0afn7++uTTz5Ry5YtzS6r2po7d642bdqk9evXm11Ktde5c2elpqaqWbNmysjI0HPPPaebbrpJW7ZsUa1atSq8HsINUAUMHz5cW7ZsMfUaNqRmzZpp8+bNOn78uD766CMNHjxYX331FQHHBAcOHNCIESOUlpYmX19fs8up9n4/paFNmzbq3LmzGjVqpPnz52vIkCEVXg/hBqjkEhIS9Pnnn2vVqlVq0KCB2eVUaz4+PmrSpIkkqUOHDlq/fr2mTJmif/3rXyZXVv1s3LhRR44cUfv27Z1thYWFWrVqlaZOnar8/Hx5enqaWGH1VqdOHV177bXatWuXKccn3ACVlGEYevzxx/XJJ58oPT1djRs3Nrsk/EFRUZHy8/PNLqNauuWWW/TTTz+5tMXHx6t58+YaO3YswcZkubm52r17twYOHGjK8Qk3cMrNzXVJ2Xv37tXmzZtVt25dNWzY0MTKqqfhw4frgw8+0KeffqpatWopMzNTkhQQEKAaNWqYXF31M27cOPXs2VMNGzbUiRMn9MEHHyg9PV1Lly41u7RqqVatWsXmn9WsWVOBgYHMSzPBmDFj1Lt3bzVq1EiHDx9WUlKSPD091a9fP1PqIdzAacOGDerevbtzPTExUZI0ePBgpaammlRV9TV9+nRJUrdu3VzaZ82apbi4uIovqJo7cuSIBg0apIyMDAUEBKhNmzZaunSpevToYXZpgOkOHjyofv366dixY6pXr55uvPFGffvtt6pXr54p9dgMwzBMOTIAAMAVwHNuAACApRBuAACApRBuAACApRBuAACApRBuAACApRBuAACApRBuAACApRBuAFhOenq6bDabfvvtN7NLAWACwg0A08TFxclms8lms8nb21uNGzfW3/72N50+fbrU++jWrZtGjhzp0nbDDTc4nyQMoPrh9QsATHXbbbdp1qxZKigo0MaNGzV48GDZbDa98sorbu/Tx8dHoaGh5VglgKqEkRsAprLb7QoNDVVERIT69OmjmJgYpaWlSZKOHTumfv36KTw8XH5+fmrdurU+/PBD57ZxcXH66quvNGXKFOcI0L59+4pdlkpNTVWdOnW0dOlStWjRQv7+/rrtttuUkZHh3NfZs2f1xBNPqE6dOgoMDNTYsWM1ePBg9enTpyJ/HADKAeEGQKWxZcsWrVmzRj4+PpKk06dPq0OHDvriiy+0ZcsWPfzwwxo4cKDWrVsnSZoyZYqio6M1bNgwZWRkKCMjQxERESXu++TJk3rttdf0/vvva9WqVXI4HBozZozz81deeUX//ve/NWvWLH3zzTfKycnRwoULr/g5Ayh/XJYCYKrPP/9c/v7+Onv2rPLz8+Xh4aGpU6dKksLDw10CyOOPP66lS5dq/vz56tSpkwICAuTj4yM/P79LXoYqKCjQjBkzdM0110iSEhIS9Pzzzzs/f+ONNzRu3DjdfffdkqSpU6dq0aJF5X26ACoA4QaAqbp3767p06crLy9Pr7/+ury8vPSXv/xFklRYWKgJEyZo/vz5OnTokM6cOaP8/Hz5+fmV+Th+fn7OYCNJ9evX15EjRyRJx48fV1ZWljp16uT83NPTUx06dFBRUdFlniGAisZlKQCmqlmzppo0aaKoqCjNnDlT3333nd59911J0sSJEzVlyhSNHTtWK1eu1ObNmxUbG6szZ86U+Tje3t4u6zabTYZhlMs5AKhcCDcAKg0PDw899dRTeuaZZ3Tq1Cl98803uuuuuzRgwABFRUXp6quv1o4dO1y28fHxUWFh4WUdNyAgQCEhIVq/fr2zrbCwUJs2bbqs/QIwB+EGQKVy3333ydPTU9OmTVPTpk2VlpamNWvWaOvWrfrrX/+qrKwsl/6RkZH67rvvtG/fPmVnZ7t9Genxxx9XcnKyPv30U23fvl0jRozQr7/+KpvNVh6nBaACEW4AVCpeXl5KSEjQq6++qtGjR6t9+/aKjY1Vt27dFBoaWuzW7DFjxsjT01MtW7ZUvXr15HA43Dru2LFj1a9fPw0aNEjR0dHy9/dXbGysfH19y+GsAFQkm8FFZwAopqioSC1atND999+vF154wexyAJQBd0sBgKT9+/dr2bJl6tq1q/Lz8zV16lTt3btXDz74oNmlASgjLksBgM5NZk5NTdX111+vLl266KefftKXX36pFi1amF0agDLishQAALAURm4AAIClEG4AAIClEG4AAIClEG4AAIClEG4AAIClEG4AAIClEG4AAIClEG4AAIClEG4AAICl/H/509bitQVWGgAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Create the histogram\n",
    "plt.hist(ratings['rating'], bins=10, edgecolor='black')\n",
    "\n",
    "# Adding title and labels\n",
    "plt.title('Distribution of Ratings')\n",
    "plt.xlabel('Rating')\n",
    "plt.ylabel('Frequency')\n",
    "\n",
    "# Display the plot\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "r7ZEscd9fiK5"
   },
   "source": [
    "### Data Preprocessing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Loading Data with Dask and Creating Mappings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 287
    },
    "id": "g9WB18WvfiK5",
    "outputId": "e9948bff-9a56-4187-a467-26e5e4138861",
    "tags": []
   },
   "outputs": [],
   "source": [
    "\n",
    "# Extract unique user and movie IDs to create mappings\n",
    "unique_user_ids = ratings['userId'].unique().compute()\n",
    "unique_movie_ids = ratings['movieId'].unique().compute()\n",
    "\n",
    "# Create index mappings\n",
    "user_id_mapping = {user_id: idx for idx, user_id in enumerate(unique_user_ids)}\n",
    "movie_id_mapping = {movie_id: idx for idx, movie_id in enumerate(unique_movie_ids)}\n",
    "\n",
    "# Initialize the user-rating matrix with zeros\n",
    "num_users = len(unique_user_ids)\n",
    "num_movies = len(unique_movie_ids)\n",
    "user_rating_matrix = np.zeros((num_users, num_movies), dtype=np.float32)\n",
    "\n",
    "# Function to process each chunk and update the user-rating matrix\n",
    "def process_chunk(chunk, user_id_mapping, movie_id_mapping, user_rating_matrix):\n",
    "    for row in chunk.itertuples(index=False):\n",
    "        user_idx = user_id_mapping[row.userId]\n",
    "        movie_idx = movie_id_mapping[row.movieId]\n",
    "        user_rating_matrix[user_idx, movie_idx] = row.rating\n",
    "\n",
    "# Read and process data in chunks\n",
    "chunk_size = 100000  # You can adjust this based on your system's memory\n",
    "chunks = pd.read_csv('ml-25m/ratings_filled.csv', chunksize=chunk_size)\n",
    "\n",
    "for chunk in chunks:\n",
    "    process_chunk(chunk, user_id_mapping, movie_id_mapping, user_rating_matrix)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "g7i-_ypofiK5",
    "outputId": "204edc6a-7a8f-49e6-c852-fa9fbd2640d2",
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shape of the numpy matrix: (28468, 35577); represting 28468 users with 35577 movies.\n"
     ]
    }
   ],
   "source": [
    "# Convert this from a pandas df to numpy array\n",
    "user_rating_matrix_np = user_rating_matrix \n",
    "print(f\"Shape of the numpy matrix: {user_rating_matrix_np.shape}; represting {user_rating_matrix_np.shape[0]} users with {user_rating_matrix_np.shape[1]} movies.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "id": "8ybj5rEGfiK5",
    "tags": []
   },
   "outputs": [],
   "source": [
    "user_rating_matrix_tensor = torch.tensor(user_rating_matrix_np, dtype=torch.float32)\n",
    "\n",
    "# Get the number of samples\n",
    "num_samples = user_rating_matrix_tensor.shape[0]\n",
    "\n",
    "# Define the split ratio\n",
    "test_size = 0.2\n",
    "split_index = int(num_samples * (1 - test_size))\n",
    "\n",
    "# Shuffle the data\n",
    "indices = torch.randperm(num_samples)\n",
    "\n",
    "# Split the dataset\n",
    "train_indices = indices[:split_index]\n",
    "test_indices = indices[split_index:]\n",
    "\n",
    "train_data = user_rating_matrix_tensor[train_indices]\n",
    "test_data = user_rating_matrix_tensor[test_indices]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "id": "yC1SvVLdfiK6",
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Convert to PyTorch tensors\n",
    "train_data = torch.FloatTensor(train_data)\n",
    "test_data = torch.FloatTensor(test_data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Ykj-jxOMfiK6"
   },
   "source": [
    "### Creating DataLoader"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "PWhuP5ZJfiK6",
    "outputId": "5839d48b-09c0-4cb6-b897-173da9d1c71e",
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Batch size: 256\n",
      "Number of samples in train_dataset: 3484292\n",
      "Number of samples in test_dataset: 840198\n"
     ]
    }
   ],
   "source": [
    "class RatingsDataset(Dataset):\n",
    "    def __init__(self, data):\n",
    "        self.data = data.nonzero(as_tuple=True) # Get the indices of non-zero elements\n",
    "        self.ratings = data[self.data]          # Using non-zero indiced to extract those ratings\n",
    "\n",
    "    def __len__ (self):\n",
    "        return len(self.data[0])\n",
    "\n",
    "    def __getitem__ (self, idx):\n",
    "        user = self.data[0][idx]\n",
    "        item = self.data[1][idx]\n",
    "        rating = self.ratings[idx]\n",
    "\n",
    "        return user, item, rating\n",
    "\n",
    "# Create training and testing datasets\n",
    "train_dataset = RatingsDataset(train_data)\n",
    "test_dataset = RatingsDataset(test_data)\n",
    "\n",
    "# Create data loaders\n",
    "train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True, num_workers=4, pin_memory=True)\n",
    "test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False, num_workers=4, pin_memory=True)\n",
    "\n",
    "# Print dataset information\n",
    "print(f\"Batch size: {batch_size}\")\n",
    "print(f\"Number of samples in train_dataset: {len(train_dataset)}\")\n",
    "print(f\"Number of samples in test_dataset: {len(test_dataset)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "SOvuzPZHfiK7"
   },
   "source": [
    "## Model Development"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "yrunYKK5fiK7"
   },
   "source": [
    "### Defining Recommender model\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "id": "bjgpzR5FfiK7",
    "tags": []
   },
   "outputs": [],
   "source": [
    "class MFRecommender(nn.Module):\n",
    "    def __init__(self, num_users, num_items, n_factors=50, dropout_rate=0.2):\n",
    "        super(MFRecommender, self).__init__()\n",
    "        self.user_embedding = nn.Embedding(num_users, n_factors)\n",
    "        self.item_embedding = nn.Embedding(num_items, n_factors)\n",
    "        \n",
    "        self.fc1 = nn.Linear(n_factors, 128)\n",
    "        self.fc2 = nn.Linear(128, 64)\n",
    "        self.fc3 = nn.Linear(64, 1)\n",
    "        \n",
    "        self.dropout = nn.Dropout(dropout_rate)  # Dropout to prevent overfitting\n",
    "\n",
    "        # Embedding Initialization\n",
    "        nn.init.normal_(self.user_embedding.weight, std=0.01)\n",
    "        nn.init.normal_(self.item_embedding.weight, std=0.01)\n",
    "\n",
    "    def forward(self, user, item):\n",
    "        user_emb = self.user_embedding(user)\n",
    "        item_emb = self.item_embedding(item)\n",
    "        x = user_emb * item_emb\n",
    "        x = torch.relu(self.fc1(x))\n",
    "        x = self.dropout(x)  # Apply dropout\n",
    "        x = torch.relu(self.fc2(x))\n",
    "        x = self.dropout(x)  # Apply dropout\n",
    "        return self.fc3(x)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Initializing the Model\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "num_users, num_items = user_rating_matrix_np.shape\n",
    "\n",
    "\n",
    "model = MFRecommender(num_users, num_items).to(device)\n",
    "\n",
    "# Adjust the model initialization\n",
    "optimizer = optim.Adam(model.parameters(), lr=lr, weight_decay=weight_decay)  # Add weight decay for regularization\n",
    "scheduler = StepLR(optimizer, step_size, gamma)\n",
    "criterion = nn.MSELoss().to(device)\n",
    "\n",
    "# Use mixed precision training (if supported)\n",
    "scaler = torch.cuda.amp.GradScaler()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "wIHCQiB3fiK8"
   },
   "source": [
    "### Defining traing loop function "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "bqDmlseCfiK8",
    "outputId": "ba439356-28e0-4774-eaaf-e917126e1c76",
    "tags": []
   },
   "outputs": [],
   "source": [
    "def training_loop(model, train_loader, optimizer, criterion, scaler, scheduler, epochs, patience=None):\n",
    "    model.train()\n",
    "    best_loss = float('inf')\n",
    "    patience_counter = 0\n",
    "    loss_dict = {'train_loss': []}\n",
    "\n",
    "    for epoch in range(epochs):\n",
    "        epoch_loss = 0\n",
    "        # Initialize tqdm progress bar\n",
    "        with tqdm(total=len(train_loader), desc=f\"Epoch {epoch+1}/{epochs}\", unit=\"batch\") as pbar:\n",
    "            for user_batch, item_batch, rating_batch in train_loader:\n",
    "                user_batch = user_batch.to(device)\n",
    "                item_batch = item_batch.to(device)\n",
    "                rating_batch = rating_batch.to(device)\n",
    "                \n",
    "                optimizer.zero_grad()\n",
    "                \n",
    "                with torch.cuda.amp.autocast():\n",
    "                    output = model(user_batch, item_batch).squeeze()\n",
    "                    loss = criterion(output, rating_batch)\n",
    "                \n",
    "                scaler.scale(loss).backward()\n",
    "                scaler.step(optimizer)\n",
    "                scaler.update()\n",
    "                \n",
    "                epoch_loss += loss.item()\n",
    "                pbar.set_postfix({\"loss\": loss.item()})\n",
    "                pbar.update(1)\n",
    "        \n",
    "        scheduler.step()\n",
    "        avg_loss = epoch_loss / len(train_loader)\n",
    "        loss_dict['train_loss'].append(avg_loss)\n",
    "        print(f\"Epoch {epoch+1}/{epochs}, Loss: {avg_loss}\")\n",
    "\n",
    "        if patience is not None:\n",
    "            if avg_loss < best_loss:\n",
    "                best_loss = avg_loss\n",
    "                patience_counter = 0\n",
    "            else:\n",
    "                patience_counter += 1\n",
    "                if patience_counter >= patience:\n",
    "                    print(\"Early stopping triggered\")\n",
    "                    break\n",
    "    \n",
    "    return loss_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 472
    },
    "id": "BRLEZeJ8fiK8",
    "outputId": "bc69a9bf-6649-4e6f-e5c3-2296c705f07f",
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/5, Loss: 0.854516135466965\n",
      "Epoch 2/5, Loss: 0.7457179148523333\n",
      "Epoch 3/5, Loss: 0.7390900971861294\n",
      "Epoch 4/5, Loss: 0.735290099299109\n",
      "Epoch 5/5, Loss: 0.7317272157416302\n"
     ]
    }
   ],
   "source": [
    "# Run Training Loop (the firs one)\n",
    "loss_dict = training_loop(model, train_loader, optimizer, criterion, scaler, scheduler, epochs, patience=patience)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "0orsWftAfiK9"
   },
   "source": [
    "### Model Evaluation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "iuO2Z7EPfiK9",
    "outputId": "3c67869e-eb46-469c-d9f9-fa0c76ba4968",
    "tags": []
   },
   "outputs": [],
   "source": [
    "def evaluate_model(model, test_loader, criterion):\n",
    "    model.eval()  # Set the model to evaluation mode\n",
    "    total_loss = 0\n",
    "    with torch.no_grad():\n",
    "        for user, item, rating in test_loader:\n",
    "            user, item, rating = user.to(device), item.to(device), rating.to(device)\n",
    "            output = model(user, item).squeeze()\n",
    "            loss = criterion(output, rating)\n",
    "            total_loss += loss.item()\n",
    "    \n",
    "    average_loss = total_loss / len(test_loader)\n",
    "    print(f'Test Loss: {average_loss}')\n",
    "    return average_loss\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test Loss: 1.113952849871623\n"
     ]
    }
   ],
   "source": [
    "# initial  the model\n",
    "initial_test_loss = evaluate_model(model, test_loader, criterion)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "qrcEko4afiK9"
   },
   "source": [
    "### Hyperparameter Tuning with Cross-Validation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "tWbloeJVfiK-",
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing parameters: {'batch_size': 128, 'dropout_rate': 0.2, 'lr': 0.001, 'n_factors': 20}\n",
      "Epoch 1/5, Loss: 0.8580951008137395\n",
      "Epoch 2/5, Loss: 0.6725316793093743\n",
      "Epoch 3/5, Loss: 0.6443351633085177\n",
      "Epoch 4/5, Loss: 0.6338467179816876\n",
      "Epoch 5/5, Loss: 0.6289469833805837\n",
      "Test Loss: 1.1673996841718726\n",
      "Epoch 1/5, Loss: 0.8490801637580532\n",
      "Epoch 2/5, Loss: 0.6693446288399593\n",
      "Epoch 3/5, Loss: 0.6413824815458297\n",
      "Epoch 4/5, Loss: 0.6306578145032101\n",
      "Epoch 5/5, Loss: 0.6253379033020385\n",
      "Test Loss: 1.1756998192342605\n",
      "Epoch 1/5, Loss: 0.8519822481051648\n",
      "Epoch 2/5, Loss: 0.6687772915292775\n",
      "Epoch 3/5, Loss: 0.6398399519862301\n",
      "Epoch 4/5, Loss: 0.6283799770093165\n",
      "Epoch 5/5, Loss: 0.6228438742954646\n",
      "Test Loss: 1.174799253308923\n",
      "Epoch 1/5, Loss: 0.8456961483633261\n",
      "Epoch 2/5, Loss: 0.671956247822824\n"
     ]
    }
   ],
   "source": [
    "# Define the parameter grid\n",
    "param_grid = {\n",
    "    'n_factors': [20, 50, 100],\n",
    "    'lr': [0.001, 0.005, 0.01],\n",
    "    'batch_size': [128, 256, 512],\n",
    "    'dropout_rate': [0.2, 0.5]\n",
    "}\n",
    "\n",
    "param_list = list(ParameterGrid(param_grid))\n",
    "\n",
    "# Function for cross-validation\n",
    "kf = KFold(n_splits=5)\n",
    "\n",
    "def cross_validate_model(params):\n",
    "    fold_losses = []\n",
    "    for train_index, val_index in kf.split(dataset):\n",
    "        train_data, val_data = dataset[train_index], dataset[val_index]\n",
    "        train_loader = DataLoader(RatingsDataset(train_data), batch_size=params['batch_size'], shuffle=True)\n",
    "        val_loader = DataLoader(RatingsDataset(val_data), batch_size=params['batch_size'], shuffle=False)\n",
    "        \n",
    "        model = MFRecommender(num_users, num_movies, n_factors=params['n_factors'], dropout_rate=params['dropout_rate']).to(device)\n",
    "        optimizer = optim.Adam(model.parameters(), lr=params['lr'], weight_decay=weight_decay)\n",
    "        scheduler = StepLR(optimizer, step_size, gamma)\n",
    "        criterion = nn.MSELoss().to(device)\n",
    "        scaler = torch.cuda.amp.GradScaler()\n",
    "        \n",
    "        # Train the model\n",
    "        training_loop(model, train_loader, optimizer, criterion, scaler, scheduler, epochs, patience)\n",
    "        \n",
    "        # Evaluate the model\n",
    "        val_loss = evaluate_model(model, val_loader, criterion)\n",
    "        fold_losses.append(val_loss)\n",
    "    \n",
    "    return np.mean(fold_losses)\n",
    "\n",
    "\n",
    "# Run the cross-validation\n",
    "results = []\n",
    "best_loss = float('inf')\n",
    "best_params = None\n",
    "for params in param_list:\n",
    "    print(f\"Testing parameters: {params}\")\n",
    "    avg_val_loss = cross_validate_model(params)\n",
    "    results.append({\n",
    "        'n_factors': params['n_factors'],\n",
    "        'lr': params['lr'],\n",
    "        'batch_size': params['batch_size'],\n",
    "        'dropout_rate': params['dropout_rate'],\n",
    "        'val_loss': avg_val_loss\n",
    "    })\n",
    "    print(f\"Average Validation Loss: {avg_val_loss}\")\n",
    "    \n",
    "    if avg_val_loss < best_loss:\n",
    "        best_loss = avg_val_loss\n",
    "        best_params = params\n",
    "\n",
    "print(f\"Best parameters: {best_params}\")\n",
    "print(f\"Best validation loss: {best_loss}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Visualize Hyperparameter Tuning Results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "results_df = pd.DataFrame(results)\n",
    "\n",
    "# Pivot table for heatmap\n",
    "heatmap_data = results_df.pivot_table(index='n_factors', columns='lr', values='val_loss')\n",
    "sns.heatmap(heatmap_data, annot=True, cmap=\"viridis\")\n",
    "plt.title('Validation Loss for Different Hyperparameter Combinations')\n",
    "plt.xlabel('Learning Rate')\n",
    "plt.ylabel('Number of Factors')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Train Final Model with Best Hyperparameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Train the final model with the best hyperparameters\n",
    "final_model = MFRecommender(num_users, num_movies, n_factors=best_params['n_factors'], dropout_rate=best_params['dropout_rate']).to(device)\n",
    "final_optimizer = optim.Adam(final_model.parameters(), lr=best_params['lr'], weight_decay=weight_decay)\n",
    "final_scheduler = StepLR(final_optimizer, step_size, gamma)\n",
    "final_criterion = nn.MSELoss().to(device)\n",
    "final_scaler = torch.cuda.amp.GradScaler()\n",
    "\n",
    "# Use the entire dataset for training\n",
    "final_train_loader = DataLoader(RatingsDataset(dataset), batch_size=best_params['batch_size'], shuffle=True)\n",
    "\n",
    "# Train the final model\n",
    "final_loss_dict = training_loop(final_model, final_train_loader, final_optimizer, final_criterion, final_scaler, final_scheduler, epochs, patience)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Evaluate Final Model\n",
    "final_test_loss = evaluate_model(final_model, test_loader, final_criterion)\n",
    "print(f'Final Test Loss: {final_test_loss}')\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Visualize the initial and final test loss\n",
    "performance_data = {\n",
    "    'Model': ['Initial Model', 'Final Model'],\n",
    "    'Test Loss': [initial_test_loss, final_test_loss]\n",
    "}\n",
    "\n",
    "performance_df = pd.DataFrame(performance_data)\n",
    "\n",
    "sns.barplot(data=performance_df, x='Model', y='Test Loss', palette='viridis')\n",
    "plt.title('Comparison of Initial and Final Model Test Loss')\n",
    "plt.xlabel('Model')\n",
    "plt.ylabel('Test Loss')\n",
    "plt.show()\n",
    "\n",
    "# Visualize the training loss over epochs for both models\n",
    "initial_loss_df = pd.DataFrame(list(initial_loss_dict.items()), columns=['Epoch', 'Loss'])\n",
    "final_loss_df = pd.DataFrame(list(final_loss_dict.items()), columns=['Epoch', 'Loss'])\n",
    "\n",
    "plt.plot(initial_loss_df['Epoch'], initial_loss_df['Loss'], label='Initial Model', marker='o')\n",
    "plt.plot(final_loss_df['Epoch'], final_loss_df['Loss'], label='Final Model', marker='o')\n",
    "plt.title('Training Loss Over Epochs')\n",
    "plt.xlabel('Epoch')\n",
    "plt.ylabel('Training Loss')\n",
    "plt.legend()\n",
    "plt.show()\n"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}