GRU4RECF.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# GRU4REC-F\n",
    "\n",
    "This notebook trains models from `models.py` on the input data, and evaluates their performance. \n",
    "\n",
    "It's set to train GRU4REC-F (our proposed non-attentive model) by default. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# -*- coding: utf-8 -*-\n",
    "\"\"\"\n",
    "Created on Tue Mar 23 08:39:11 2021\n",
    "\n",
    "@author: lpott\n",
    "\"\"\"\n",
    "import argparse\n",
    "from torch.utils.data import DataLoader\n",
    "import torch\n",
    "from tqdm import tqdm\n",
    "\n",
    "from preprocessing import *\n",
    "from dataset import *\n",
    "from metrics import *\n",
    "from model import *\n",
    "from utils import bert2dict\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# variables\n",
    "\n",
    "read_filename =\"data/movielens-1m/ratings.dat\"\n",
    "read_bert_filename = \"data/bert_sequence_1m.txt\"\n",
    "read_movie_filename = \"\"#\"movies-1m.csv\"\n",
    "size = \"1m\"\n",
    "\n",
    "num_epochs = 50\n",
    "lr = 1e-2\n",
    "batch_size = 64\n",
    "reg = 1e-5 # was 1e-5 before\n",
    "train_method = \"alternate\"\n",
    "loss_type = \"BPR_MAX\"\n",
    "num_neg_samples = 25\n",
    "reg_bpr = .8\n",
    "\n",
    "\n",
    "hidden_dim = 256\n",
    "embedding_dim = 256\n",
    "bert_dim= 768\n",
    "window = 0\n",
    "\n",
    "freeze_plot = False\n",
    "tied = False\n",
    "dropout= 0\n",
    "\n",
    "k = 10\n",
    "max_length = 200\n",
    "min_len = 10\n",
    "\n",
    "\n",
    "# nextitnet options...\n",
    "hidden_layers = 3\n",
    "dilations = [1,2,4,16]\n",
    "\n",
    "model_type = \"feature_add\"\n",
    "\n",
    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.cuda.empty_cache()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ------------------Data Initialization----------------------#\n",
    "\n",
    "# convert .dat file to time-sorted pandas dataframe\n",
    "ml_1m = create_df(read_filename,size=size)\n",
    "\n",
    "# remove users who have sessions lengths less than min_len\n",
    "ml_1m = filter_df(ml_1m,item_min=min_len)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ------------------Data Initialization----------------------#\n",
    "if read_movie_filename != \"\":\n",
    "    ml_movie_df = create_movie_df(read_movie_filename,size=size)\n",
    "    ml_movie_df = convert_genres(ml_movie_df)\n",
    "    \n",
    "    # initialize reset object\n",
    "    reset_object = reset_df()\n",
    "    \n",
    "    # map all user ids, item ids, and genres to range 0 - number of users/items/genres\n",
    "    ml_1m,ml_movie_df = reset_object.fit_transform(ml_1m,ml_movie_df)\n",
    "    \n",
    "    # value that padded genre tokens shall take\n",
    "    pad_genre_token = reset_object.genre_enc.transform([\"NULL\"]).item()\n",
    "    \n",
    "    genre_dim = len(np.unique(np.concatenate(ml_movie_df.genre))) - 1\n",
    "\n",
    "else:\n",
    "    # initialize reset object\n",
    "    reset_object = reset_df()\n",
    "    \n",
    "    # map all user ids and item ids to range 0 - Number of Users/Items \n",
    "    # i.e. [1,7,5] -> [0,2,1]\n",
    "    ml_1m = reset_object.fit_transform(ml_1m)\n",
    "    \n",
    "    pad_genre_token = None\n",
    "    ml_movie_df = None\n",
    "    genre_dim = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ------------------Data Initialization----------------------#\n",
    "# how many unique users, items, ratings and timestamps are there\n",
    "n_users,n_items,n_ratings,n_timestamp = ml_1m.nunique()\n",
    "\n",
    "# value that padded tokens shall take\n",
    "pad_token = n_items\n",
    "\n",
    "# the output dimension for softmax layer\n",
    "output_dim = n_items\n",
    "\n",
    "\n",
    "# get the item id : bert plot embedding dictionary\n",
    "if bert_dim != 0:\n",
    "    feature_embed = bert2dict(bert_filename=read_bert_filename)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create a dictionary of every user's session (history)\n",
    "# i.e. {user: [user clicks]}\n",
    "if size == \"1m\":\n",
    "    user_history = create_user_history(ml_1m)\n",
    "\n",
    "elif size == \"20m\":\n",
    "    import pickle\n",
    "    with open('userhistory.pickle', 'rb') as handle:\n",
    "        user_history = pickle.load(handle)\n",
    "# create a dictionary of all items a user has not clicked\n",
    "# i.e. {user: [items not clicked by user]}\n",
    "# user_noclicks = create_user_noclick(user_history,ml_1m,n_items)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# split data by leave-one-out strategy\n",
    "# have train dictionary {user: [last 41 items prior to last 2 items in user session]}\n",
    "# have val dictionary {user: [last 41 items prior to last item in user session]}\n",
    "# have test dictionary {user: [last 41 items]}\n",
    "# i.e. if max_length = 4, [1,2,3,4,5,6] -> [1,2,3,4] , [2,3,4,5] , [3,4,5,6]\n",
    "train_history,val_history,test_history = train_val_test_split(user_history,max_length=max_length)\n",
    "\n",
    "# initialize the train,validation, and test pytorch dataset objects\n",
    "# eval pads all items except last token to predict\n",
    "train_dataset = GRUDataset(train_history,genre_df=ml_movie_df,mode='train',max_length=max_length,pad_token=pad_token,pad_genre_token=pad_genre_token)\n",
    "val_dataset = GRUDataset(val_history,genre_df=ml_movie_df,mode='eval',max_length=max_length,pad_token=pad_token,pad_genre_token=pad_genre_token)\n",
    "test_dataset = GRUDataset(test_history,genre_df=ml_movie_df,mode='eval',max_length=max_length,pad_token=pad_token,pad_genre_token=pad_genre_token)\n",
    "\n",
    "# create the train,validation, and test pytorch dataloader objects\n",
    "train_dl = DataLoader(train_dataset,batch_size = batch_size,shuffle=True)\n",
    "val_dl = DataLoader(val_dataset,batch_size=64)\n",
    "test_dl = DataLoader(test_dataset,batch_size=64)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Bert dim: {:d}\".format(bert_dim))\n",
    "print(\"Genre dim: {:d}\".format(genre_dim))\n",
    "print(\"Pad Token: {}\".format(pad_token))\n",
    "print(\"Pad Genre Token: {}\".format(pad_genre_token))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ------------------Model Initialization----------------------#\n",
    "\n",
    "# initialize gru4rec model with arguments specified earlier\n",
    "if model_type == \"feature_add\":\n",
    "    model = gru4recF(embedding_dim=embedding_dim,\n",
    "             hidden_dim=hidden_dim,\n",
    "             output_dim=output_dim,\n",
    "             genre_dim=genre_dim,\n",
    "             batch_first=True,\n",
    "             max_length=max_length,\n",
    "             pad_token=pad_token,\n",
    "             pad_genre_token=pad_genre_token,\n",
    "             bert_dim=bert_dim,\n",
    "             tied = tied,\n",
    "             dropout=dropout)\n",
    "\n",
    "\n",
    "if model_type == \"feature_concat\":\n",
    "    model = gru4recFC(embedding_dim=embedding_dim,\n",
    "             hidden_dim=hidden_dim,\n",
    "             output_dim=output_dim,\n",
    "             genre_dim=genre_dim,\n",
    "             batch_first=True,\n",
    "             max_length=max_length,\n",
    "             pad_token=pad_token,\n",
    "             pad_genre_token=pad_genre_token,\n",
    "             bert_dim=bert_dim,\n",
    "             tied = tied,\n",
    "             dropout=dropout)\n",
    "\n",
    "if model_type == \"vanilla\":\n",
    "    model = gru4rec_vanilla(hidden_dim=hidden_dim,\n",
    "                            output_dim=output_dim,\n",
    "                            batch_first=True,\n",
    "                            max_length=max_length,\n",
    "                            pad_token=pad_token,\n",
    "                            tied=tied,\n",
    "                            embedding_dim=embedding_dim,\n",
    "                           device=device)\n",
    "\n",
    "if model_type ==\"feature_only\":\n",
    "    model = gru4rec_feature(hidden_dim=hidden_dim,\n",
    "                            output_dim=output_dim,\n",
    "                            batch_first=True,\n",
    "                            max_length=max_length,\n",
    "                            pad_token=pad_token,\n",
    "                            bert_dim=bert_dim)\n",
    "\n",
    "if model_type == \"conv\":\n",
    "    model = gru4rec_conv(embedding_dim,\n",
    "                 hidden_dim,\n",
    "                 output_dim,\n",
    "                 batch_first=True,\n",
    "                 max_length=200,\n",
    "                 pad_token=0,\n",
    "                 dropout=0,\n",
    "                 window=3,\n",
    "                 tied=tied)\n",
    "    \n",
    "if model_type == \"nextitnet\":\n",
    "    model = NextItNet(embedding_dim=embedding_dim,\n",
    "                      output_dim=output_dim,\n",
    "                      hidden_layers=hidden_layers,\n",
    "                      dilations=dilations,\n",
    "                      pad_token=n_items,\n",
    "                      max_len=max_length)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if bert_dim != 0:\n",
    "    model.init_weight(reset_object,feature_embed)\n",
    "    \n",
    "model = model.to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# initialize Adam optimizer with gru4rec model parameters\n",
    "if train_method != \"normal\":\n",
    "    optimizer_features = torch.optim.Adam([param for name,param in model.named_parameters() if ((\"movie\" not in name) or (\"plot_embedding\" in name) or (\"genre\" in name)) ],\n",
    "                                          lr=lr/10,weight_decay=reg)\n",
    "    \n",
    "    optimizer_ids = torch.optim.Adam([param for name,param in model.named_parameters() if (\"plot\" not in name) and (\"genre\" not in name)],\n",
    "                                     lr=lr,weight_decay=reg)\n",
    "\n",
    "elif train_method == \"normal\":\n",
    "    optimizer = torch.optim.Adam(model.parameters(),lr=lr,weight_decay=reg)\n",
    "    \n",
    "if freeze_plot and bert_dim !=0:\n",
    "    model.plot_embedding.weight.requires_grad = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if loss_type == \"XE\":\n",
    "    loss_fn = nn.CrossEntropyLoss(ignore_index=n_items)\n",
    "    \n",
    "elif loss_type == \"BPR\":\n",
    "    loss_fn = BPRLoss(user_history = user_history,\n",
    "                      n_items = n_items, \n",
    "                      df = ml_1m,\n",
    "                      device = device, \n",
    "                      samples=num_neg_samples)\n",
    "\n",
    "elif loss_type == \"BPR_MAX\":\n",
    "    loss_fn = BPRMaxLoss(user_history = user_history,\n",
    "                      n_items = n_items, \n",
    "                      df = ml_1m,\n",
    "                      device = device,\n",
    "                      reg = reg_bpr,\n",
    "                      samples=num_neg_samples)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Recall_Object = Recall_E_prob(ml_1m,user_history,n_users,n_items,k=k,device=device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#print(\"Baseline POP results: \",Recall_Object.popular_baseline())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#training_hit = Recall_Object(model,train_dl)\n",
    "#validation_hit = Recall_Object(model,val_dl)\n",
    "#testing_hit = Recall_Object(model,test_dl)\n",
    "#print(\"Training Hits@{:d}: {:.2f}\".format(k,training_hit))\n",
    "#print(\"Validation Hits@{:d}: {:.2f}\".format(k,validation_hit))\n",
    "#print(\"Testing Hits@{:d}: {:.2f}\".format(k,testing_hit))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# ------------------Training Initialization----------------------#\n",
    "max_train_hit = (0,0,0)\n",
    "max_val_hit = (0,0,0)\n",
    "max_test_hit = (0,0,0)\n",
    "\n",
    "max_train_ndcg = (0,0,0)\n",
    "max_val_ndcg = (0,0,0)\n",
    "max_test_ndcg = (0,0,0)\n",
    "\n",
    "max_train_mrr = 0\n",
    "max_val_mrr = 0\n",
    "max_test_mrr = 0\n",
    "i = 0;\n",
    "for epoch in range(num_epochs):\n",
    "    print(\"=\"*20,\"Epoch {}\".format(epoch+1),\"=\"*20)\n",
    "    \n",
    "    model.train()  \n",
    "    \n",
    "    running_loss = 0\n",
    "\n",
    "    for j,data in enumerate(tqdm(train_dl,position=0,leave=True)):\n",
    "        \n",
    "        if train_method != \"normal\":\n",
    "            optimizer_features.zero_grad()\n",
    "            optimizer_ids.zero_grad()\n",
    "            \n",
    "        elif train_method == \"normal\": \n",
    "            optimizer.zero_grad()\n",
    "        \n",
    "        if genre_dim != 0:            \n",
    "            inputs,genre_inputs,labels,x_lens,uid = data\n",
    "            outputs = model(x=inputs.to(device),x_lens=x_lens.squeeze().tolist(),x_genre=genre_inputs.to(device))\n",
    "        \n",
    "        elif genre_dim == 0:\n",
    "            inputs,labels,x_lens,uid = data \n",
    "            outputs = model(x=inputs.to(device),x_lens=x_lens.squeeze().tolist())\n",
    "       \n",
    "        if tied:\n",
    "            outputs_ignore_pad = outputs[:,:,:-1]\n",
    "            if loss_type == \"XE\":\n",
    "                loss = loss_fn(outputs_ignore_pad.view(-1,outputs_ignore_pad.size(-1)),labels.view(-1).to(device))\n",
    "            elif loss_type == \"BPR\" or loss_type == \"BPR_MAX\":\n",
    "                loss = loss_fn(outputs,labels.to(device),x_lens,uid)\n",
    "\n",
    "            \n",
    "        else:\n",
    "            if loss_type == \"XE\":\n",
    "                loss = loss_fn(outputs.view(-1,outputs.size(-1)),labels.view(-1).to(device))\n",
    "            elif loss_type == \"BPR\" or loss_type == \"BPR_MAX\":   \n",
    "                loss = loss_fn(outputs,labels.to(device),x_lens,uid)\n",
    "\n",
    "        loss.backward()\n",
    "        \n",
    "        \n",
    "        if train_method != \"normal\":\n",
    "            if train_method == \"interleave\":\n",
    "                # interleave on the epochs\n",
    "                if (j+1) % 2 == 0:\n",
    "                    optimizer_features.step()\n",
    "                else:\n",
    "                    optimizer_ids.step()\n",
    "\n",
    "            elif train_method == \"alternate\":\n",
    "                if (epoch+1) % 2 == 0:\n",
    "                    optimizer_features.step()\n",
    "                else:\n",
    "                    optimizer_ids.step()\n",
    "        \n",
    "    \n",
    "                    \n",
    "        elif train_method == \"normal\":\n",
    "            optimizer.step()\n",
    "\n",
    "        running_loss += loss.detach().cpu().item()\n",
    "\n",
    "    del outputs\n",
    "    torch.cuda.empty_cache()\n",
    "    training_hit,training_ndcg,training_mrr = Recall_Object(model,train_dl,\"train\")\n",
    "    validation_hit,validation_ndcg,validation_mrr = Recall_Object(model,val_dl,\"validation\")\n",
    "    testing_hit,testing_ndcg,testing_mrr = Recall_Object(model,test_dl,\"test\")\n",
    "    \n",
    "    if max_val_mrr < validation_mrr:\n",
    "        max_val_hit = validation_hit\n",
    "        max_test_hit = testing_hit\n",
    "        max_train_hit = training_hit\n",
    "        \n",
    "        max_train_ndcg = training_ndcg\n",
    "        max_val_ndcg = validation_ndcg\n",
    "        max_test_ndcg = testing_ndcg\n",
    "        \n",
    "        max_train_mrr = training_mrr\n",
    "        max_val_mrr = validation_mrr\n",
    "        max_test_mrr = testing_mrr\n",
    "    \n",
    "    torch.cuda.empty_cache()\n",
    "    print(\"Training Loss: {:.5f}\".format(running_loss/len(train_dl)))\n",
    "    \n",
    "    print(\"Train Hits \\t @10: {:.5f} \\t @5 : {:.5f} \\t @1 : {:.5f}\".format(*training_hit))\n",
    "    print(\"Train ndcg \\t @10: {:.5f} \\t @5 : {:.5f} \\t @1 : {:.5f}\".format(*training_ndcg))\n",
    "    print(\"Train mrr \\t {:.5f}\".format(training_mrr))\n",
    "\n",
    "\n",
    "    print(\"Valid Hits \\t @10: {:.5f} \\t @5 : {:.5f} \\t @1 : {:.5f}\".format(*validation_hit))\n",
    "    print(\"Valid ndcg \\t @10: {:.5f} \\t @5 : {:.5f} \\t @1 : {:.5f}\".format(*validation_ndcg))\n",
    "    print(\"Valid mrr \\t {:.5f}\".format(validation_mrr))\n",
    "\n",
    "    print(\"Test Hits \\t @10: {:.5f} \\t @5 : {:.5f} \\t @1 : {:.5f}\".format(*testing_hit))\n",
    "    print(\"Test ndcg \\t @10: {:.5f} \\t @5 : {:.5f} \\t @1 : {:.5f}\".format(*testing_ndcg))\n",
    "    print(\"Test mrr \\t {:.5f}\".format(testing_mrr))\n",
    "    \n",
    "print(\"=\"*100)\n",
    "print(\"Maximum Training Hit \\t @10: {:.5f} \\t @5 : {:.5f} \\t @1 : {:.5f}\".format(*max_train_hit))\n",
    "print(\"Maximum Validation Hit \\t @10: {:.5f} \\t @5 : {:.5f} \\t @1 : {:.5f}\".format(*max_val_hit))\n",
    "print(\"Maximum Testing Hit \\t @10: {:.5f} \\t @5 : {:.5f} \\t @1 : {:.5f}\".format(*max_test_hit))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"=\"*100)\n",
    "print(\"Maximum Train Hit \\t @10: {:.5f} \\t @5 : {:.5f} \\t @1 : {:.5f}\".format(*max_train_hit))\n",
    "print(\"Maximum Valid Hit \\t @10: {:.5f} \\t @5 : {:.5f} \\t @1 : {:.5f}\".format(*max_val_hit))\n",
    "print(\"Maximum Test Hit \\t @10: {:.5f} \\t @5 : {:.5f} \\t @1 : {:.5f}\".format(*max_test_hit))\n",
    "\n",
    "print(\"Maximum Train NDCG \\t @10: {:.5f} \\t @5 : {:.5f} \\t @1 : {:.5f}\".format(*training_ndcg))\n",
    "print(\"Maximum Valid NDCG \\t @10: {:.5f} \\t @5 : {:.5f} \\t @1 : {:.5f}\".format(*validation_ndcg))\n",
    "print(\"Maximum Test NDCG \\t @10: {:.5f} \\t @5 : {:.5f} \\t @1 : {:.5f}\".format(*testing_ndcg))\n",
    "\n",
    "print(\"Maximum Train MRR \\t {:.5f}\".format(training_mrr))\n",
    "print(\"Maximum Valid MRR \\t {:.5f}\".format(validation_mrr))\n",
    "print(\"Maximum Test MRR \\t {:.5f}\".format(testing_mrr))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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.9.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}