notes/rs/rs_Embedding.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "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",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "      <td>3.5</td>\n",
       "      <td>2005-04-02 23:53:47</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>29</td>\n",
       "      <td>3.5</td>\n",
       "      <td>2005-04-02 23:31:16</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1</td>\n",
       "      <td>32</td>\n",
       "      <td>3.5</td>\n",
       "      <td>2005-04-02 23:33:39</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1</td>\n",
       "      <td>47</td>\n",
       "      <td>3.5</td>\n",
       "      <td>2005-04-02 23:32:07</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1</td>\n",
       "      <td>50</td>\n",
       "      <td>3.5</td>\n",
       "      <td>2005-04-02 23:29:40</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   userId  movieId  rating            timestamp\n",
       "0       1        2     3.5  2005-04-02 23:53:47\n",
       "1       1       29     3.5  2005-04-02 23:31:16\n",
       "2       1       32     3.5  2005-04-02 23:33:39\n",
       "3       1       47     3.5  2005-04-02 23:32:07\n",
       "4       1       50     3.5  2005-04-02 23:29:40"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import math\n",
    "from tqdm import tqdm\n",
    "from datetime import datetime\n",
    "from heapq import heappush,heappop\n",
    "from collections import Counter,defaultdict\n",
    "import multiprocessing as mp\n",
    "import tensorflow as tf\n",
    "from sklearn.utils import shuffle\n",
    "import time\n",
    "\n",
    "PATH=\"/home/yui/Documents/data/recommender/movieLens20M/rating.csv\"\n",
    "df = pd.read_csv(PATH)\n",
    "df.head(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "def findNMatches(df,targetUser,leastCommon=25,minMoviesWatched=50,noRef=25):\n",
    "    tardf = df[df[\"userId\"]==targetUser]\n",
    "    u2m = defaultdict(dict)\n",
    "    valCountsUserId = df[\"userId\"].value_counts()\n",
    "\n",
    "    for j in range(tardf.shape[0]):\n",
    "        movieId = tardf.iloc[j][\"movieId\"]\n",
    "        u2m[targetUser][movieId] = tardf.iloc[j][\"rating\"]\n",
    "    avg = np.array(list(u2m[targetUser].values())).mean()\n",
    "    u2m[targetUser] = (u2m[targetUser],avg)\n",
    "    tarSet = set(u2m[targetUser][0])\n",
    "    # print(tarSet)\n",
    "    prevId,storeSet,storeDict = 0,set(),dict()\n",
    "    for i in tqdm(range(df.shape[0])):\n",
    "        row = df.iloc[i]\n",
    "        userId = row[\"userId\"]\n",
    "        if valCountsUserId[userId]<minMoviesWatched:\n",
    "            continue\n",
    "        if userId==targetUser:\n",
    "            continue\n",
    "        if userId!=prevId:\n",
    "            if len(tarSet&storeSet)>=leastCommon:\n",
    "                avg = np.array(list(storeDict.values())).mean()\n",
    "                u2m[prevId]=(storeDict,avg)\n",
    "            storeSet,storeDict=set(),dict()\n",
    "        prevId = userId\n",
    "        storeSet.add(row[\"movieId\"])\n",
    "        storeDict[row[\"movieId\"]]=row[\"rating\"]\n",
    "        if len(u2m)>noRef:\n",
    "            break\n",
    "    return u2m\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MF:\n",
    "    def __init__(self,u2m,K=100,penalty=0.1):\n",
    "        self.u2m = u2m\n",
    "        self.penalty = penalty\n",
    "        self.K = K\n",
    "        self.allmovies = dict()\n",
    "        self.mean,i=0,0\n",
    "        for candidate in u2m:\n",
    "            for movie in u2m[candidate][0]:\n",
    "                t,c = self.allmovies.get(movie,(0,0))\n",
    "                c+=1\n",
    "                t+=u2m[candidate][0][movie]\n",
    "                self.allmovies[movie]=(t,c)\n",
    "                i+=1\n",
    "                self.mean+=u2m[candidate][0][movie]\n",
    "        self.mean/=i\n",
    "        for movie in self.allmovies:\n",
    "            t,c = self.allmovies[movie]\n",
    "            self.allmovies[movie] = (t/c,c)\n",
    "        self.m2id = {key:i for i,key in enumerate(self.allmovies)}\n",
    "        self.id2m = {i:key for i,key in enumerate(self.allmovies)}\n",
    "        self.u2id = {key:i for i,key in enumerate(u2m)}\n",
    "        self.id2u = {i:key for i,key in enumerate(u2m)}\n",
    "        self.N = len(u2m)\n",
    "        self.M = len(self.allmovies)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Embedding Layers\n",
    "\n",
    "It is a lookup table, which can convert ids to embedding vector. So we can input user id $x_1\\rightarrow i$ and movie id $x_2\\rightarrow j$, get their respective vectors $w_i$ and $u_j$, and add their dot product with user bias $b_i$ and movie bias $c_j$ to predict the difference between rating $r_{ij}$ and global mean $\\mu$.\n",
    "\n",
    "$$y = r_{ij}-\\mu = w_i^Tu_j + b_i + c_j$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class nnMF:\n",
    "    def __init__(self,df,targetUser,K=100,split=0.85,batch_size=16):\n",
    "        self.u2m = findNMatches(df,targetUser)\n",
    "        self.mf = MF(self.u2m,K=K)\n",
    "        tdf = df[df[\"userId\"].isin(list(self.u2m.keys()))]\n",
    "        self.tdf = shuffle(tdf)\n",
    "        self.split = split\n",
    "        self.batch_size = batch_size\n",
    "        self.prepareData()\n",
    "        self.getModel()\n",
    "    def getX1X2Y(self,dataset):\n",
    "        w = [self.mf.u2id[i] for i in list(dataset['userId'])]\n",
    "        XW = np.array(w).reshape(-1,1,1)\n",
    "        u = [self.mf.m2id[i] for i in list(dataset['movieId'])]\n",
    "        XU = np.array(u).reshape(-1,1,1)\n",
    "        Y = np.array(dataset['rating'])-self.mf.mean\n",
    "        return XW,XU,Y\n",
    "    def prepareData(self):\n",
    "        trainSet = self.tdf.iloc[:int(self.split*self.tdf.shape[0])]\n",
    "        testSet = self.tdf.iloc[int(self.split*self.tdf.shape[0]):]\n",
    "        trainXW,trainXU,trainY = self.getX1X2Y(trainSet)\n",
    "        testXW,testXU,testY = self.getX1X2Y(testSet)\n",
    "        train_dataset = tf.data.Dataset.from_tensor_slices(\\\n",
    "            (trainXW,trainXU,trainY))\n",
    "        self.train_dataset = train_dataset.shuffle(buffer_size=1024)\\\n",
    "                    .batch(self.batch_size)\n",
    "        val_dataset = tf.data.Dataset.from_tensor_slices(\\\n",
    "            (testXW,testXU,testY))\n",
    "        self.val_dataset = val_dataset.batch(self.batch_size)\n",
    "    def getModel(self):\n",
    "        n1 = tf.keras.Input(shape=(1,))\n",
    "        m1 = tf.keras.Input(shape=(1,))\n",
    "        k1n = tf.keras.layers.Embedding(self.mf.N,self.mf.K)(n1)\n",
    "        k1m = tf.keras.layers.Embedding(self.mf.M,self.mf.K)(m1)\n",
    "        b = tf.keras.layers.Embedding(self.mf.N,1)(n1)\n",
    "        c = tf.keras.layers.Embedding(self.mf.M,1)(m1)\n",
    "        y = tf.multiply(k1n,k1m)\n",
    "        y = tf.reduce_sum(y,axis=2,keepdims=True)\n",
    "        y = tf.add_n([y,b,c])\n",
    "        y = tf.reshape(y,[-1])\n",
    "        self.model = tf.keras.Model(inputs=[n1,m1],outputs=[y])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  0%|          | 15441/20000263 [00:01<32:56, 10110.63it/s]\n"
     ]
    }
   ],
   "source": [
    "mf = nnMF(df,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 0 Train loss: 1.2185\n",
      "Epoch 0 Validation loss: 1.1052\n",
      "Epoch 50 Train loss: 0.0077\n",
      "Epoch 50 Validation loss: 0.8802\n",
      "Epoch 100 Train loss: 0.0047\n",
      "Epoch 100 Validation loss: 0.8713\n",
      "Epoch 150 Train loss: 0.0036\n",
      "Epoch 150 Validation loss: 0.8679\n",
      "Epoch 200 Train loss: 0.0031\n",
      "Epoch 200 Validation loss: 0.8703\n",
      "Epoch 250 Train loss: 0.0027\n",
      "Epoch 250 Validation loss: 0.8671\n",
      "Epoch 300 Train loss: 0.0024\n",
      "Epoch 300 Validation loss: 0.8640\n",
      "Epoch 350 Train loss: 0.0023\n",
      "Epoch 350 Validation loss: 0.8716\n",
      "Epoch 400 Train loss: 0.0021\n",
      "Epoch 400 Validation loss: 0.8767\n",
      "Epoch 450 Train loss: 0.0019\n",
      "Epoch 450 Validation loss: 0.8757\n"
     ]
    }
   ],
   "source": [
    "epochs = 500\n",
    "opt = tf.keras.optimizers.Adam(learning_rate=1e-3)\n",
    "printInterval = 50\n",
    "trainLosses = []\n",
    "testLosses = []\n",
    "\n",
    "for epoch in range(epochs):\n",
    "    total_train_loss=0\n",
    "    for i,(x1,x2,y) in enumerate(mf.train_dataset):\n",
    "        with tf.GradientTape() as tape:\n",
    "            pred=mf.model([x1,x2],training=True)\n",
    "            loss = tf.keras.losses.mean_squared_error(y,pred)\n",
    "            total_train_loss+=tf.reduce_sum(loss)\n",
    "        grads = tape.gradient(loss,mf.model.trainable_weights)\n",
    "        opt.apply_gradients(zip(grads,mf.model.trainable_weights))\n",
    "    \n",
    "    if epoch%printInterval==0:\n",
    "        total_val_loss = 0\n",
    "        for j,(x1,x2,y) in enumerate(mf.val_dataset):\n",
    "            pred=mf.model([x1,x2],training=False)\n",
    "            total_val_loss+=tf.reduce_sum(\\\n",
    "                tf.keras.losses.mean_squared_error(y,pred))\n",
    "        print(\"Epoch {} Train loss: {:.4f}\".format(\\\n",
    "                epoch,float(total_train_loss/(i+1))))\n",
    "        print(\"Epoch {} Validation loss: {:.4f}\".format(\\\n",
    "                epoch,float(total_val_loss/(j+1))))\n",
    "        trainLosses.append(total_train_loss/(i+1))\n",
    "        testLosses.append(total_val_loss/(j+1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'loss')"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(range(0,epochs,printInterval),\n",
    "         trainLosses,label='train loss')\n",
    "plt.plot(range(0,epochs,printInterval),\n",
    "         testLosses,label='test loss')\n",
    "plt.legend()\n",
    "plt.xlabel('epochs')\n",
    "plt.ylabel('loss')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Movie 2: 3.5 (truth) 3.4731 (pred)\n",
      "Movie 29: 3.5 (truth) 3.5464 (pred)\n",
      "Movie 32: 3.5 (truth) 3.6001 (pred)\n",
      "Movie 47: 3.5 (truth) 3.5910 (pred)\n",
      "Movie 50: 3.5 (truth) 3.5583 (pred)\n",
      "Movie 112: 3.5 (truth) 3.4893 (pred)\n",
      "Movie 151: 4.0 (truth) 3.4752 (pred)\n",
      "Movie 223: 4.0 (truth) 4.0552 (pred)\n",
      "Movie 253: 4.0 (truth) 3.9902 (pred)\n",
      "Movie 260: 4.0 (truth) 3.9916 (pred)\n",
      "Movie 293: 4.0 (truth) 4.0455 (pred)\n",
      "Movie 296: 4.0 (truth) 4.0385 (pred)\n",
      "Movie 318: 4.0 (truth) 4.0178 (pred)\n",
      "Movie 337: 3.5 (truth) 3.4843 (pred)\n",
      "Movie 367: 3.5 (truth) 3.0604 (pred)\n",
      "Movie 541: 4.0 (truth) 4.0087 (pred)\n",
      "Movie 589: 3.5 (truth) 3.5465 (pred)\n",
      "Movie 593: 3.5 (truth) 3.5281 (pred)\n",
      "Movie 653: 3.0 (truth) 3.0210 (pred)\n",
      "Movie 919: 3.5 (truth) 3.5290 (pred)\n",
      "Movie 924: 3.5 (truth) 3.4552 (pred)\n",
      "Movie 1009: 3.5 (truth) 3.4552 (pred)\n",
      "Movie 1036: 4.0 (truth) 3.9852 (pred)\n",
      "Movie 1079: 4.0 (truth) 3.9989 (pred)\n",
      "Movie 1080: 3.5 (truth) 3.4838 (pred)\n",
      "Movie 1089: 3.5 (truth) 3.5052 (pred)\n",
      "Movie 1090: 4.0 (truth) 3.9952 (pred)\n",
      "Movie 1097: 4.0 (truth) 3.7695 (pred)\n",
      "Movie 1136: 3.5 (truth) 3.4568 (pred)\n",
      "Movie 1193: 3.5 (truth) 3.5602 (pred)\n",
      "Movie 1196: 4.5 (truth) 4.4118 (pred)\n",
      "Movie 1198: 4.5 (truth) 4.5025 (pred)\n",
      "Movie 1200: 4.0 (truth) 3.6405 (pred)\n",
      "Movie 1201: 3.0 (truth) 3.0238 (pred)\n",
      "Movie 1208: 3.5 (truth) 3.4223 (pred)\n",
      "Movie 1214: 4.0 (truth) 3.9680 (pred)\n",
      "Movie 1215: 4.0 (truth) 4.1074 (pred)\n",
      "Movie 1217: 3.5 (truth) 3.4948 (pred)\n",
      "Movie 1219: 4.0 (truth) 3.9993 (pred)\n",
      "Movie 1222: 3.5 (truth) 3.4613 (pred)\n",
      "Movie 1240: 4.0 (truth) 3.9962 (pred)\n",
      "Movie 1243: 3.0 (truth) 2.9759 (pred)\n",
      "Movie 1246: 3.5 (truth) 3.5733 (pred)\n",
      "Movie 1249: 4.0 (truth) 4.0075 (pred)\n",
      "Movie 1258: 4.0 (truth) 3.9905 (pred)\n",
      "Movie 1259: 4.0 (truth) 4.0000 (pred)\n",
      "Movie 1261: 3.5 (truth) 3.5869 (pred)\n",
      "Movie 1262: 3.5 (truth) 3.4725 (pred)\n",
      "Movie 1266: 4.0 (truth) 4.0613 (pred)\n",
      "Movie 1278: 4.0 (truth) 3.9833 (pred)\n",
      "Movie 1291: 3.5 (truth) 4.0293 (pred)\n",
      "Movie 1304: 3.0 (truth) 3.0447 (pred)\n",
      "Movie 1321: 4.0 (truth) 3.9986 (pred)\n",
      "Movie 1333: 4.0 (truth) 4.0189 (pred)\n",
      "Movie 1348: 3.5 (truth) 3.5310 (pred)\n",
      "Movie 1350: 3.5 (truth) 3.5141 (pred)\n",
      "Movie 1358: 4.0 (truth) 4.0579 (pred)\n",
      "Movie 1370: 3.0 (truth) 3.0094 (pred)\n",
      "Movie 1374: 4.0 (truth) 4.0630 (pred)\n",
      "Movie 1387: 4.0 (truth) 4.0363 (pred)\n",
      "Movie 1525: 3.0 (truth) 3.0420 (pred)\n",
      "Movie 1584: 3.5 (truth) 3.3845 (pred)\n",
      "Movie 1750: 3.5 (truth) 3.5079 (pred)\n",
      "Movie 1848: 3.5 (truth) 3.5207 (pred)\n",
      "Movie 1920: 3.5 (truth) 3.4825 (pred)\n",
      "Movie 1967: 4.0 (truth) 3.6339 (pred)\n",
      "Movie 1994: 3.5 (truth) 3.5090 (pred)\n",
      "Movie 1997: 3.5 (truth) 3.5456 (pred)\n",
      "Movie 2021: 4.0 (truth) 3.9290 (pred)\n",
      "Movie 2100: 4.0 (truth) 3.9612 (pred)\n",
      "Movie 2118: 4.0 (truth) 4.0274 (pred)\n",
      "Movie 2138: 4.0 (truth) 4.0266 (pred)\n",
      "Movie 2140: 4.0 (truth) 4.0125 (pred)\n",
      "Movie 2143: 4.0 (truth) 3.9754 (pred)\n",
      "Movie 2173: 4.0 (truth) 3.9532 (pred)\n",
      "Movie 2174: 4.0 (truth) 3.9625 (pred)\n",
      "Movie 2193: 4.0 (truth) 3.9629 (pred)\n",
      "Movie 2194: 3.5 (truth) 3.4431 (pred)\n",
      "Movie 2253: 3.5 (truth) 3.3609 (pred)\n",
      "Movie 2288: 4.0 (truth) 4.1080 (pred)\n",
      "Movie 2291: 4.0 (truth) 3.9786 (pred)\n",
      "Movie 2542: 4.0 (truth) 3.9390 (pred)\n",
      "Movie 2628: 4.0 (truth) 4.0179 (pred)\n",
      "Movie 2644: 3.5 (truth) 3.5308 (pred)\n",
      "Movie 2648: 3.5 (truth) 3.5279 (pred)\n",
      "Movie 2664: 3.5 (truth) 3.4363 (pred)\n",
      "Movie 2683: 3.5 (truth) 3.3962 (pred)\n",
      "Movie 2692: 3.5 (truth) 3.5120 (pred)\n",
      "Movie 2716: 3.5 (truth) 3.4861 (pred)\n",
      "Movie 2761: 3.0 (truth) 3.0783 (pred)\n",
      "Movie 2762: 4.0 (truth) 3.9783 (pred)\n",
      "Movie 2804: 3.5 (truth) 3.9117 (pred)\n",
      "Movie 2872: 4.0 (truth) 3.9073 (pred)\n",
      "Movie 2918: 3.5 (truth) 3.4962 (pred)\n",
      "Movie 2944: 4.0 (truth) 4.0230 (pred)\n",
      "Movie 2947: 3.5 (truth) 3.5197 (pred)\n",
      "Movie 2959: 4.0 (truth) 4.0386 (pred)\n",
      "Movie 2968: 4.0 (truth) 3.9547 (pred)\n",
      "Movie 3000: 3.5 (truth) 3.5078 (pred)\n",
      "Movie 3030: 3.0 (truth) 2.9899 (pred)\n"
     ]
    }
   ],
   "source": [
    "targetUser,limit = 1,100\n",
    "x1 = np.array([mf.mf.u2id[targetUser]]).reshape(1,1,1)\n",
    "res = []\n",
    "for i,movie in enumerate(mf.mf.allmovies):\n",
    "    x2 = np.array([mf.mf.m2id[movie]]).reshape(1,1,1)\n",
    "    pred=mf.model([x1,x2],training=False)+mf.mf.mean\n",
    "    if movie in mf.u2m[targetUser][0]:\n",
    "        if i<limit:\n",
    "            print(\"Movie {}: {} (truth) {:.4f} (pred)\".format(\\\n",
    "            movie,mf.u2m[targetUser][0][movie],\n",
    "            pred[0]))\n",
    "    else:\n",
    "        store = -pred.numpy()[0]\n",
    "        heappush(res,(store,movie))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(-4.556903, 2329),\n",
       " (-4.5160446, 1234),\n",
       " (-4.350629, 2858),\n",
       " (-4.460514, 7361),\n",
       " (-4.442555, 6016),\n",
       " (-4.204738, 30707),\n",
       " (-4.324671, 79132),\n",
       " (-4.418446, 1203),\n",
       " (-4.4559, 44555),\n",
       " (-4.2956815, 527)]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "res[:10]"
   ]
  },
  {
   "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"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}