MF_with_pytorch.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Matrix factorization with Pytorch"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this notebook we will write a matrix factorization model in pytorch to solve a recommendation problem. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The MovieLens dataset (ml-latest-small) describes 5-star rating and free-text tagging activity from MovieLens, a movie recommendation service. It contains 100004 ratings and 1296 tag applications across 9125 movies. https://grouplens.org/datasets/movielens/. To get the data:\n",
    "\n",
    "`wget http://files.grouplens.org/datasets/movielens/ml-latest-small.zip`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## MovieLens dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pathlib import Path\n",
    "import pandas as pd\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[PosixPath('../data/ml-latest-small/links.csv'),\n",
       " PosixPath('../data/ml-latest-small/tags.csv'),\n",
       " PosixPath('../data/ml-latest-small/ratings.csv'),\n",
       " PosixPath('../data/ml-latest-small/README.txt'),\n",
       " PosixPath('../data/ml-latest-small/movies.csv')]"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "PATH = Path(\"../data/ml-latest-small/\")\n",
    "list(PATH.iterdir())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "userId,movieId,rating,timestamp\r",
      "\r\n",
      "1,31,2.5,1260759144\r",
      "\r\n",
      "1,1029,3.0,1260759179\r",
      "\r\n",
      "1,1061,3.0,1260759182\r",
      "\r\n",
      "1,1129,2.0,1260759185\r",
      "\r\n",
      "1,1172,4.0,1260759205\r",
      "\r\n",
      "1,1263,2.0,1260759151\r",
      "\r\n",
      "1,1287,2.0,1260759187\r",
      "\r\n",
      "1,1293,2.0,1260759148\r",
      "\r\n",
      "1,1339,3.5,1260759125\r",
      "\r\n"
     ]
    }
   ],
   "source": [
    "! head ../data/ml-latest-small/ratings.csv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# reading a csv into pandas\n",
    "data = pd.read_csv(PATH/\"ratings.csv\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "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",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>31</td>\n",
       "      <td>2.5</td>\n",
       "      <td>1260759144</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>1029</td>\n",
       "      <td>3.0</td>\n",
       "      <td>1260759179</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>1</td>\n",
       "      <td>1061</td>\n",
       "      <td>3.0</td>\n",
       "      <td>1260759182</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>1</td>\n",
       "      <td>1129</td>\n",
       "      <td>2.0</td>\n",
       "      <td>1260759185</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>1</td>\n",
       "      <td>1172</td>\n",
       "      <td>4.0</td>\n",
       "      <td>1260759205</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   userId  movieId  rating   timestamp\n",
       "0       1       31     2.5  1260759144\n",
       "1       1     1029     3.0  1260759179\n",
       "2       1     1061     3.0  1260759182\n",
       "3       1     1129     2.0  1260759185\n",
       "4       1     1172     4.0  1260759205"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Encoding data\n",
    "We enconde the data to have contiguous ids for users and movies. You can think about this as a categorical encoding of our two categorical variables userId and movieId."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1339227110.6"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "time_80 = np.quantile(data.timestamp.values, 0.8)\n",
    "time_80"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [],
   "source": [
    "train = data[data[\"timestamp\"] < time_80].copy()\n",
    "val = data[data[\"timestamp\"] >= time_80].copy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "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",
       "      <td>790</td>\n",
       "      <td>11</td>\n",
       "      <td>50</td>\n",
       "      <td>5.0</td>\n",
       "      <td>1391658537</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>791</td>\n",
       "      <td>11</td>\n",
       "      <td>70</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1391656827</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>792</td>\n",
       "      <td>11</td>\n",
       "      <td>126</td>\n",
       "      <td>4.0</td>\n",
       "      <td>1391657561</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>793</td>\n",
       "      <td>11</td>\n",
       "      <td>169</td>\n",
       "      <td>3.0</td>\n",
       "      <td>1391657297</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>794</td>\n",
       "      <td>11</td>\n",
       "      <td>296</td>\n",
       "      <td>5.0</td>\n",
       "      <td>1391658423</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     userId  movieId  rating   timestamp\n",
       "790      11       50     5.0  1391658537\n",
       "791      11       70     1.0  1391656827\n",
       "792      11      126     4.0  1391657561\n",
       "793      11      169     3.0  1391657297\n",
       "794      11      296     5.0  1391658423"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "val.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 12, 13, 14, 15, 16])"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# encoding movies and user ids with continous ids\n",
    "\n",
    "train_user_ids = np.sort(np.unique(train.userId.values))\n",
    "train_user_ids[:15]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "547"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# number of unique ids\n",
    "num_users = len(train_user_ids)\n",
    "num_users"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [],
   "source": [
    "userid2idx = {o:i for i,o in enumerate(train_user_ids)}\n",
    "#userid2idx"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "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",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>31</td>\n",
       "      <td>2.5</td>\n",
       "      <td>1260759144</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>1029</td>\n",
       "      <td>3.0</td>\n",
       "      <td>1260759179</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "      <td>1061</td>\n",
       "      <td>3.0</td>\n",
       "      <td>1260759182</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>0</td>\n",
       "      <td>1129</td>\n",
       "      <td>2.0</td>\n",
       "      <td>1260759185</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>0</td>\n",
       "      <td>1172</td>\n",
       "      <td>4.0</td>\n",
       "      <td>1260759205</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   userId  movieId  rating   timestamp\n",
       "0       0       31     2.5  1260759144\n",
       "1       0     1029     3.0  1260759179\n",
       "2       0     1061     3.0  1260759182\n",
       "3       0     1129     2.0  1260759185\n",
       "4       0     1172     4.0  1260759205"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train[\"userId\"] = train[\"userId\"].apply(lambda x: userid2idx[x])\n",
    "train.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "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",
       "      <td>790</td>\n",
       "      <td>-1</td>\n",
       "      <td>50</td>\n",
       "      <td>5.0</td>\n",
       "      <td>1391658537</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>791</td>\n",
       "      <td>-1</td>\n",
       "      <td>70</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1391656827</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>792</td>\n",
       "      <td>-1</td>\n",
       "      <td>126</td>\n",
       "      <td>4.0</td>\n",
       "      <td>1391657561</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>793</td>\n",
       "      <td>-1</td>\n",
       "      <td>169</td>\n",
       "      <td>3.0</td>\n",
       "      <td>1391657297</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>794</td>\n",
       "      <td>-1</td>\n",
       "      <td>296</td>\n",
       "      <td>5.0</td>\n",
       "      <td>1391658423</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     userId  movieId  rating   timestamp\n",
       "790      -1       50     5.0  1391658537\n",
       "791      -1       70     1.0  1391656827\n",
       "792      -1      126     4.0  1391657561\n",
       "793      -1      169     3.0  1391657297\n",
       "794      -1      296     5.0  1391658423"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "val[\"userId\"] = val[\"userId\"].apply(lambda x: userid2idx.get(x, -1)) # -1 for users not in training\n",
    "val.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "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",
       "      <td>1019</td>\n",
       "      <td>13</td>\n",
       "      <td>216</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1349622582</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1057</td>\n",
       "      <td>13</td>\n",
       "      <td>367</td>\n",
       "      <td>2.0</td>\n",
       "      <td>1374637824</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1059</td>\n",
       "      <td>13</td>\n",
       "      <td>371</td>\n",
       "      <td>2.0</td>\n",
       "      <td>1443385370</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1060</td>\n",
       "      <td>13</td>\n",
       "      <td>372</td>\n",
       "      <td>3.0</td>\n",
       "      <td>1465793100</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1065</td>\n",
       "      <td>13</td>\n",
       "      <td>429</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1465955324</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      userId  movieId  rating   timestamp\n",
       "1019      13      216     1.0  1349622582\n",
       "1057      13      367     2.0  1374637824\n",
       "1059      13      371     2.0  1443385370\n",
       "1060      13      372     3.0  1465793100\n",
       "1065      13      429     1.0  1465955324"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "val = val[val[\"userId\"] >= 0].copy()\n",
    "val.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7356\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14])"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# now encoding movieId\n",
    "train_movie_ids = np.sort(np.unique(train.movieId.values))\n",
    "num_items = len(train_movie_ids)\n",
    "print(num_movies)\n",
    "train_movie_ids[:15]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [],
   "source": [
    "movieid2idx = {o:i for i,o in enumerate(train_movie_ids)}\n",
    "train[\"movieId\"] = train[\"movieId\"].apply(lambda x: movieid2idx[x])\n",
    "val[\"movieId\"] = val[\"movieId\"].apply(lambda x: movieid2idx.get(x, -1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "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",
       "      <td>1019</td>\n",
       "      <td>13</td>\n",
       "      <td>189</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1349622582</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1057</td>\n",
       "      <td>13</td>\n",
       "      <td>330</td>\n",
       "      <td>2.0</td>\n",
       "      <td>1374637824</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1059</td>\n",
       "      <td>13</td>\n",
       "      <td>334</td>\n",
       "      <td>2.0</td>\n",
       "      <td>1443385370</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1060</td>\n",
       "      <td>13</td>\n",
       "      <td>335</td>\n",
       "      <td>3.0</td>\n",
       "      <td>1465793100</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1065</td>\n",
       "      <td>13</td>\n",
       "      <td>378</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1465955324</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      userId  movieId  rating   timestamp\n",
       "1019      13      189     1.0  1349622582\n",
       "1057      13      330     2.0  1374637824\n",
       "1059      13      334     2.0  1443385370\n",
       "1060      13      335     3.0  1465793100\n",
       "1065      13      378     1.0  1465955324"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "val = val[val[\"movieId\"] >= 0].copy()\n",
    "val.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1861, 4)"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "val.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Embedding layer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Parameter containing:\n",
       "tensor([[ 0.3723,  0.2959, -0.4945],\n",
       "        [ 0.4870,  0.3067, -1.0038],\n",
       "        [ 1.0794, -0.8265,  0.9611],\n",
       "        [-1.0542, -0.2109,  0.9022],\n",
       "        [ 1.0893,  0.6853,  0.3724],\n",
       "        [-1.2803, -0.0501,  0.6630],\n",
       "        [-0.9828, -1.1450,  1.6664],\n",
       "        [ 0.3043,  0.6056, -0.7636],\n",
       "        [ 0.6878, -1.1852, -0.7511],\n",
       "        [ 0.6856, -0.3101,  1.0519]], requires_grad=True)"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# an Embedding module containing 10 users or items embedding size 3\n",
    "# embedding will be initialized at random\n",
    "embed = nn.Embedding(10, 3)\n",
    "embed.weight"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[[ 0.4870,  0.3067, -1.0038],\n",
       "         [ 0.3723,  0.2959, -0.4945],\n",
       "         [ 0.4870,  0.3067, -1.0038],\n",
       "         [ 1.0893,  0.6853,  0.3724],\n",
       "         [-1.2803, -0.0501,  0.6630],\n",
       "         [ 0.4870,  0.3067, -1.0038]]], grad_fn=<EmbeddingBackward>)"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# given a list of ids we can \"look up\" the embedding corresponing to each id\n",
    "# can you see that some vectors are the same?\n",
    "a = torch.LongTensor([[1,0,1,4,5,1]])\n",
    "embed(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Matrix factorization model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MF(nn.Module):\n",
    "    def __init__(self, num_users, num_items, emb_size=100):\n",
    "        super(MF, self).__init__()\n",
    "        self.user_emb = nn.Embedding(num_users, emb_size)\n",
    "        self.item_emb = nn.Embedding(num_items, emb_size)\n",
    "        # initlializing weights\n",
    "        self.user_emb.weight.data.uniform_(0,0.05)\n",
    "        self.item_emb.weight.data.uniform_(0,0.05)\n",
    "        \n",
    "    def forward(self, u, v):\n",
    "        u = self.user_emb(u)\n",
    "        v = self.item_emb(v)\n",
    "        return (u*v).sum(1)   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Debugging MF model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "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",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>3</td>\n",
       "      <td>3</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>5</td>\n",
       "      <td>4</td>\n",
       "      <td>0</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   userId  movieId  rating\n",
       "0       0        0       4\n",
       "1       0        1       5\n",
       "2       1        2       3\n",
       "3       1        1       1\n",
       "4       3        3       3\n",
       "5       4        0       4"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = pd.DataFrame({\"userId\": [0, 0, 1, 1, 3, 4], \"movieId\": [0, 1, 2, 1, 3, 0], \"rating\": [4, 5, 3, 1, 3, 4]})\n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_users = 5\n",
    "num_items = 4\n",
    "emb_size = 3\n",
    "\n",
    "user_emb = nn.Embedding(num_users, emb_size)\n",
    "item_emb = nn.Embedding(num_items, emb_size)\n",
    "users = torch.LongTensor(df.userId.values)\n",
    "items = torch.LongTensor(df.movieId.values)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [],
   "source": [
    "U = user_emb(users)\n",
    "V = item_emb(items)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([0, 0, 1, 1, 3, 4])"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "users"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[-0.1588,  0.6016, -0.0554],\n",
       "        [-0.1588,  0.6016, -0.0554],\n",
       "        [ 0.0773, -0.5758,  2.1042],\n",
       "        [ 0.0773, -0.5758,  2.1042],\n",
       "        [ 1.2791, -0.4015,  0.1770],\n",
       "        [ 0.5436,  1.0807,  0.8438]], grad_fn=<EmbeddingBackward>)"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "U"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[-0.0540, -0.6477,  0.0094],\n",
       "        [-0.3160, -0.7770, -0.0057],\n",
       "        [ 0.1396,  0.5970, -3.4700],\n",
       "        [ 0.1539,  0.7438,  0.2179],\n",
       "        [-0.7230,  0.1517,  0.2027],\n",
       "        [ 0.1850, -1.1636, -0.1432]], grad_fn=<MulBackward0>)"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# element wise multiplication\n",
    "U*V "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([-0.6924, -1.0988, -2.7334,  1.1156, -0.3686, -1.1218],\n",
       "       grad_fn=<SumBackward1>)"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# what we want is a dot product per row\n",
    "(U*V).sum(1) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training MF model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "547 7356\n"
     ]
    }
   ],
   "source": [
    "num_users = len(train.userId.unique())\n",
    "num_items = len(train.movieId.unique())\n",
    "print(num_users, num_items) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [],
   "source": [
    "# here we are not using data loaders because our data fits well in memory\n",
    "def train_epocs(model, epochs=10, lr=0.01, wd=0.0):\n",
    "    optimizer = torch.optim.Adam(model.parameters(), lr=lr, weight_decay=wd)\n",
    "    for i in range(epochs):\n",
    "        model.train()\n",
    "        users = torch.LongTensor(train.userId.values)  #.cuda()\n",
    "        items = torch.LongTensor(train.movieId.values) #.cuda()\n",
    "        ratings = torch.FloatTensor(train.rating.values)  #.cuda()\n",
    "    \n",
    "        y_hat = model(users, items)\n",
    "        loss = F.mse_loss(y_hat, ratings)\n",
    "        optimizer.zero_grad()\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        testloss = valid_loss(model)\n",
    "        print(\"train loss %.3f valid loss %.3f\" % (loss.item(), testloss)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [],
   "source": [
    "def valid_loss(model):\n",
    "    model.eval()\n",
    "    users = torch.LongTensor(val.userId.values) # .cuda()\n",
    "    items = torch.LongTensor(val.movieId.values) #.cuda()\n",
    "    ratings = torch.FloatTensor(val.rating.values) #.cuda()\n",
    "    y_hat = model(users, items)\n",
    "    loss = F.mse_loss(y_hat, ratings)\n",
    "    return loss.item()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = MF(num_users, num_items, emb_size=100)  # if you have a GPU .cuda()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train loss 13.252 valid loss 5.265\n",
      "train loss 5.123 valid loss 2.296\n",
      "train loss 2.341 valid loss 3.656\n",
      "train loss 3.302 valid loss 1.400\n",
      "train loss 0.891 valid loss 2.083\n",
      "train loss 1.860 valid loss 2.783\n",
      "train loss 2.763 valid loss 2.293\n",
      "train loss 2.240 valid loss 1.395\n",
      "train loss 1.110 valid loss 1.432\n",
      "train loss 0.928 valid loss 2.101\n",
      "train loss 1.697 valid loss 1.676\n",
      "train loss 1.462 valid loss 1.023\n",
      "train loss 0.817 valid loss 1.201\n",
      "train loss 0.937 valid loss 1.625\n",
      "train loss 1.360 valid loss 1.623\n",
      "train loss 1.389 valid loss 1.233\n",
      "train loss 1.006 valid loss 0.992\n",
      "train loss 0.705 valid loss 1.271\n",
      "train loss 0.867 valid loss 1.556\n",
      "train loss 1.075 valid loss 1.317\n"
     ]
    }
   ],
   "source": [
    "train_epocs(model, epochs=20, lr=0.1, wd=1e-5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train loss 0.873 valid loss 0.992\n",
      "train loss 0.661 valid loss 0.921\n",
      "train loss 0.669 valid loss 0.930\n",
      "train loss 0.710 valid loss 0.930\n",
      "train loss 0.704 valid loss 0.918\n",
      "train loss 0.671 valid loss 0.913\n",
      "train loss 0.641 valid loss 0.923\n",
      "train loss 0.631 valid loss 0.939\n",
      "train loss 0.633 valid loss 0.948\n",
      "train loss 0.634 valid loss 0.943\n",
      "train loss 0.624 valid loss 0.928\n",
      "train loss 0.609 valid loss 0.912\n",
      "train loss 0.596 valid loss 0.903\n",
      "train loss 0.590 valid loss 0.901\n",
      "train loss 0.590 valid loss 0.903\n"
     ]
    }
   ],
   "source": [
    "train_epocs(model, epochs=15, lr=0.01, wd=1e-5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train loss 0.589 valid loss 0.902\n",
      "train loss 0.581 valid loss 0.902\n",
      "train loss 0.575 valid loss 0.903\n",
      "train loss 0.571 valid loss 0.905\n",
      "train loss 0.567 valid loss 0.907\n",
      "train loss 0.564 valid loss 0.909\n",
      "train loss 0.562 valid loss 0.910\n",
      "train loss 0.559 valid loss 0.912\n",
      "train loss 0.557 valid loss 0.912\n",
      "train loss 0.555 valid loss 0.913\n",
      "train loss 0.554 valid loss 0.913\n",
      "train loss 0.552 valid loss 0.912\n",
      "train loss 0.550 valid loss 0.912\n",
      "train loss 0.548 valid loss 0.911\n",
      "train loss 0.546 valid loss 0.910\n"
     ]
    }
   ],
   "source": [
    "train_epocs(model, epochs=15, lr=0.001, wd=1e-5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train loss 0.543 valid loss 0.909\n",
      "train loss 0.541 valid loss 0.908\n",
      "train loss 0.538 valid loss 0.907\n",
      "train loss 0.536 valid loss 0.907\n",
      "train loss 0.533 valid loss 0.908\n",
      "train loss 0.531 valid loss 0.908\n",
      "train loss 0.528 valid loss 0.909\n",
      "train loss 0.526 valid loss 0.910\n",
      "train loss 0.523 valid loss 0.911\n",
      "train loss 0.520 valid loss 0.912\n",
      "train loss 0.518 valid loss 0.913\n",
      "train loss 0.515 valid loss 0.914\n",
      "train loss 0.513 valid loss 0.915\n",
      "train loss 0.510 valid loss 0.916\n",
      "train loss 0.507 valid loss 0.916\n"
     ]
    }
   ],
   "source": [
    "train_epocs(model, epochs=15, lr=0.001, wd=1e-5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## MF with bias"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MF_bias(nn.Module):\n",
    "    def __init__(self, num_users, num_items, emb_size=100):\n",
    "        super(MF_bias, self).__init__()\n",
    "        self.user_emb = nn.Embedding(num_users, emb_size)\n",
    "        self.user_bias = nn.Embedding(num_users, 1)\n",
    "        self.item_emb = nn.Embedding(num_items, emb_size)\n",
    "        self.item_bias = nn.Embedding(num_items, 1)\n",
    "        # init \n",
    "        self.user_emb.weight.data.uniform_(0,0.05)\n",
    "        self.item_emb.weight.data.uniform_(0,0.05)\n",
    "        self.user_bias.weight.data.uniform_(-0.01,0.01)\n",
    "        self.item_bias.weight.data.uniform_(-0.01,0.01)\n",
    "        \n",
    "    def forward(self, u, v):\n",
    "        U = self.user_emb(u)\n",
    "        V = self.item_emb(v)\n",
    "        b_u = self.user_bias(u).squeeze()\n",
    "        b_v = self.item_bias(v).squeeze()\n",
    "        return (U*V).sum(1) +  b_u  + b_v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = MF_bias(num_users, num_items, emb_size=100) #.cuda()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train loss 13.257 valid loss 4.438\n",
      "train loss 4.361 valid loss 3.416\n",
      "train loss 3.483 valid loss 2.749\n",
      "train loss 2.452 valid loss 1.156\n",
      "train loss 0.789 valid loss 2.013\n",
      "train loss 1.821 valid loss 2.616\n",
      "train loss 2.506 valid loss 2.296\n",
      "train loss 2.102 valid loss 1.641\n",
      "train loss 1.236 valid loss 1.508\n",
      "train loss 0.900 valid loss 1.899\n",
      "train loss 1.310 valid loss 1.741\n",
      "train loss 1.359 valid loss 1.151\n",
      "train loss 0.936 valid loss 0.986\n",
      "train loss 0.828 valid loss 1.220\n",
      "train loss 1.064 valid loss 1.394\n"
     ]
    }
   ],
   "source": [
    "train_epocs(model, epochs=15, lr=0.1, wd=1e-5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train loss 1.222 valid loss 1.105\n",
      "train loss 0.908 valid loss 0.937\n",
      "train loss 0.739 valid loss 0.888\n",
      "train loss 0.696 valid loss 0.912\n",
      "train loss 0.720 valid loss 0.954\n",
      "train loss 0.743 valid loss 0.980\n",
      "train loss 0.737 valid loss 0.988\n",
      "train loss 0.712 valid loss 0.987\n",
      "train loss 0.685 valid loss 0.984\n",
      "train loss 0.668 valid loss 0.983\n"
     ]
    }
   ],
   "source": [
    "train_epocs(model, epochs=10, lr=0.01, wd=1e-5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train loss 0.663 valid loss 0.972\n",
      "train loss 0.656 valid loss 0.962\n",
      "train loss 0.650 valid loss 0.952\n",
      "train loss 0.645 valid loss 0.943\n",
      "train loss 0.640 valid loss 0.935\n",
      "train loss 0.636 valid loss 0.928\n",
      "train loss 0.632 valid loss 0.921\n",
      "train loss 0.629 valid loss 0.915\n",
      "train loss 0.626 valid loss 0.910\n",
      "train loss 0.623 valid loss 0.905\n"
     ]
    }
   ],
   "source": [
    "train_epocs(model, epochs=10, lr=0.001, wd=1e-5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train loss 0.621 valid loss 0.902\n",
      "train loss 0.618 valid loss 0.899\n",
      "train loss 0.615 valid loss 0.896\n",
      "train loss 0.613 valid loss 0.894\n",
      "train loss 0.611 valid loss 0.892\n",
      "train loss 0.609 valid loss 0.890\n",
      "train loss 0.607 valid loss 0.889\n",
      "train loss 0.605 valid loss 0.887\n",
      "train loss 0.602 valid loss 0.886\n",
      "train loss 0.600 valid loss 0.885\n"
     ]
    }
   ],
   "source": [
    "train_epocs(model, epochs=10, lr=0.001, wd=1e-5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train loss 0.598 valid loss 0.885\n",
      "train loss 0.596 valid loss 0.885\n",
      "train loss 0.594 valid loss 0.884\n",
      "train loss 0.592 valid loss 0.884\n",
      "train loss 0.589 valid loss 0.884\n",
      "train loss 0.587 valid loss 0.885\n",
      "train loss 0.585 valid loss 0.885\n",
      "train loss 0.583 valid loss 0.885\n",
      "train loss 0.580 valid loss 0.885\n",
      "train loss 0.578 valid loss 0.885\n"
     ]
    }
   ],
   "source": [
    "train_epocs(model, epochs=10, lr=0.001, wd=1e-5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that these models are susceptible to weight initialization, optimization algorithm and regularization."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# References\n",
    "* This notebook is based on [lesson 5 of Jeremy Howard's Deep Learning Course](https://github.com/fastai/fastai/blob/master/courses/dl1/lesson5-movielens.ipynb)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.6"
  },
  "toc": {
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": "block",
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}