Run.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-07-25T03:22:47.664449Z",
     "start_time": "2019-07-25T03:22:43.816763Z"
    }
   },
   "outputs": [],
   "source": [
    "import os\n",
    "import time\n",
    "import random\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "from torch.autograd import Variable\n",
    "from MetaMF import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-07-25T03:22:47.670434Z",
     "start_time": "2019-07-25T03:22:43.822Z"
    }
   },
   "outputs": [],
   "source": [
    "random.seed(1)\n",
    "np.random.seed(1)\n",
    "torch.manual_seed(1)#set random seed for cpu\n",
    "torch.cuda.manual_seed(1)#set random seed for current gpu\n",
    "torch.cuda.manual_seed_all(1)#set random seed for all gpus"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-07-25T03:22:47.672428Z",
     "start_time": "2019-07-25T03:22:43.825Z"
    }
   },
   "outputs": [],
   "source": [
    "os.environ['CUDA_VISIBLE_DEVICES'] = '0'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-07-25T03:22:47.674426Z",
     "start_time": "2019-07-25T03:22:43.827Z"
    }
   },
   "outputs": [],
   "source": [
    "if torch.cuda.is_available():\n",
    "    use_cuda = True\n",
    "else:\n",
    "    use_cuda = False\n",
    "use_cuda"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Read Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-07-25T03:22:47.676416Z",
     "start_time": "2019-07-25T03:22:43.830Z"
    }
   },
   "outputs": [],
   "source": [
    "def readdata(filename1, filename2, filename3, filename4, filename5):\n",
    "    userlist = []\n",
    "    with open(filename1, 'r') as f:\n",
    "        content = f.readlines()\n",
    "    for line in content:\n",
    "        line = line.strip()\n",
    "        userlist.append(int(line))\n",
    "    itemlist = []\n",
    "    with open(filename2, 'r') as f:\n",
    "        content = f.readlines()\n",
    "    for line in content:\n",
    "        line = line.strip()\n",
    "        itemlist.append(int(line))\n",
    "    traindata = []\n",
    "    with open(filename3, 'r') as f:\n",
    "        content = f.readlines()\n",
    "    for line in content:\n",
    "        line = line.split('\\t')\n",
    "        user = int(line[0])\n",
    "        item = int(line[1])\n",
    "        rating = float(line[2])\n",
    "        traindata.append((user,item,rating))\n",
    "    validdata = []\n",
    "    with open(filename4, 'r') as f:\n",
    "        content = f.readlines()\n",
    "    for line in content:\n",
    "        line = line.split('\\t')\n",
    "        user = int(line[0])\n",
    "        item = int(line[1])\n",
    "        rating = float(line[2])\n",
    "        validdata.append((user,item,rating))\n",
    "    testdata = []\n",
    "    with open(filename5, 'r') as f:\n",
    "        content = f.readlines()\n",
    "    for line in content:\n",
    "        line = line.split('\\t')\n",
    "        user = int(line[0])\n",
    "        item = int(line[1])\n",
    "        rating = float(line[2])\n",
    "        testdata.append((user,item,rating))\n",
    "    return userlist, itemlist, traindata, validdata, testdata"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-07-25T03:22:47.678410Z",
     "start_time": "2019-07-25T03:22:43.834Z"
    }
   },
   "outputs": [],
   "source": [
    "filename1 = 'data/db.userlist'\n",
    "filename2 = 'data/db.itemlist'\n",
    "filename3 = 'data/db.train.rating'\n",
    "filename4 = 'data/db.valid.rating'\n",
    "filename5 = 'data/db.test.rating'\n",
    "#filename1 = 'data/ht-ml.userlist'\n",
    "#filename2 = 'data/ht-ml.itemlist'\n",
    "#filename3 = 'data/ht-ml.train.rating'\n",
    "#filename4 = 'data/ht-ml.valid.rating'\n",
    "#filename5 = 'data/ht-ml.test.rating'\n",
    "#filename1 = 'data/ml.userlist'\n",
    "#filename2 = 'data/ml.itemlist'\n",
    "#filename3 = 'data/ml.train.rating'\n",
    "#filename4 = 'data/ml.valid.rating'\n",
    "#filename5 = 'data/ml.test.rating'\n",
    "#filename1 = 'data/ciao.userlist'\n",
    "#filename2 = 'data/ciao.itemlist'\n",
    "#filename3 = 'data/ciao.train.rating'\n",
    "#filename4 = 'data/ciao.valid.rating'\n",
    "#filename5 = 'data/ciao.test.rating'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-07-25T03:22:47.680404Z",
     "start_time": "2019-07-25T03:22:43.838Z"
    },
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "userlist, itemlist, traindata, validdata, testdata = readdata(filename1, filename2, filename3, filename4, filename5)  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Utility Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-07-25T03:22:47.682400Z",
     "start_time": "2019-07-25T03:22:43.842Z"
    }
   },
   "outputs": [],
   "source": [
    "def batchtoinput(batch, use_cuda):\n",
    "    users = []\n",
    "    items = []\n",
    "    ratings = []\n",
    "    for example in batch:\n",
    "        users.append(example[0])\n",
    "        items.append(example[1])\n",
    "        ratings.append(example[2])\n",
    "    users = torch.tensor(users, dtype=torch.int64)\n",
    "    items = torch.tensor(items, dtype=torch.int64)\n",
    "    ratings = torch.tensor(ratings, dtype=torch.float32)\n",
    "    if use_cuda:\n",
    "        users = users.cuda()\n",
    "        items = items.cuda()\n",
    "        ratings = ratings.cuda()\n",
    "    return users, items, ratings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-07-25T03:22:47.685392Z",
     "start_time": "2019-07-25T03:22:43.845Z"
    }
   },
   "outputs": [],
   "source": [
    "def getbatches(traindata, batch_size, use_cuda, shuffle):\n",
    "    dataset = traindata.copy()\n",
    "    if shuffle:\n",
    "        random.shuffle(dataset)\n",
    "    for batch_i in range(0,int(np.ceil(len(dataset)/batch_size))):\n",
    "        start_i = batch_i*batch_size\n",
    "        batch = dataset[start_i:start_i+batch_size]\n",
    "        yield batchtoinput(batch, use_cuda)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-07-25T03:22:47.687386Z",
     "start_time": "2019-07-25T03:22:43.848Z"
    }
   },
   "outputs": [],
   "source": [
    "def weights_init(m):\n",
    "    classname = m.__class__.__name__\n",
    "    if classname.find('Linear') != -1:\n",
    "        nn.init.xavier_normal_(m.weight.data)\n",
    "        nn.init.constant_(m.bias.data, 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-07-25T03:22:47.689382Z",
     "start_time": "2019-07-25T03:22:43.853Z"
    }
   },
   "outputs": [],
   "source": [
    "def get_eval(ratlist, predlist, output=False):\n",
    "    mae = np.mean(np.abs(ratlist-predlist))\n",
    "    mse = np.mean(np.square(ratlist-predlist))\n",
    "    if output:\n",
    "        maelist = np.abs(ratlist-predlist)\n",
    "        with open('maelist.dat','w') as f:\n",
    "            i = 0\n",
    "            while i < len(maelist):\n",
    "                f.write(str(maelist[i])+'\\n')\n",
    "                i += 1\n",
    "        mselist = np.square(ratlist-predlist)\n",
    "        with open('mselist.dat','w') as f:\n",
    "            i = 0\n",
    "            while i < len(mselist):\n",
    "                f.write(str(mselist[i])+'\\n')\n",
    "                i += 1        \n",
    "    return  mae, mse"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Train Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-07-25T03:22:47.691381Z",
     "start_time": "2019-07-25T03:22:43.856Z"
    }
   },
   "outputs": [],
   "source": [
    "net = model(len(userlist), len(itemlist))\n",
    "net.apply(weights_init)\n",
    "if use_cuda:\n",
    "    net.cuda()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-07-25T03:22:47.693372Z",
     "start_time": "2019-07-25T03:22:43.860Z"
    }
   },
   "outputs": [],
   "source": [
    "optimizer = optim.Adam(net.parameters(), lr=0.0001, weight_decay=0.001)#for MetaMF"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-07-25T03:22:47.695365Z",
     "start_time": "2019-07-25T03:22:43.863Z"
    }
   },
   "outputs": [],
   "source": [
    "batch_size = 64#for MetaMF\n",
    "epoches = 100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-07-25T03:22:47.698360Z",
     "start_time": "2019-07-25T03:22:43.866Z"
    },
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "print(time.localtime())\n",
    "for epoch in range(epoches):\n",
    "    net.train()#switch to train mode\n",
    "    error = 0\n",
    "    num = 0\n",
    "    for k, (users, items, ratings) in enumerate(getbatches(traindata, batch_size, use_cuda, True)):\n",
    "        optimizer.zero_grad()\n",
    "        pred = net(users, items)\n",
    "        loss = net.loss(pred, ratings)\n",
    "        loss.backward()\n",
    "        nn.utils.clip_grad_norm_(net.parameters(), 5)\n",
    "        optimizer.step()\n",
    "        error += loss.detach().cpu().numpy()*len(users)#loss is averaged\n",
    "        num += len(users)\n",
    "        if (k+1)%1000 == 0:\n",
    "            print(error/num)\n",
    "    print('Epoch {}/{} - Training Loss: {:.3f}'.format(epoch+1,epoches,error/num))\n",
    "    torch.save(net, 'checkpoint/epoch_'+str(epoch+1)+'.model')\n",
    "    net.eval()#switch to test mode\n",
    "    ratlist = []\n",
    "    predlist= []\n",
    "    for k, (users, items, ratings) in enumerate(getbatches(validdata, batch_size, use_cuda, False)):\n",
    "        pred = net(users, items)\n",
    "        predlist.extend(pred.tolist())\n",
    "        ratlist.extend(ratings.tolist())\n",
    "    mae, mse = get_eval(np.array(ratlist), np.array(predlist))\n",
    "    print('MAE: {:.5f}'.format(mae))\n",
    "    print('MSE: {:.5f}'.format(mse))\n",
    "    print(time.localtime())\n",
    "print(time.localtime())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Test Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "net = torch.load('checkpoint/epoch_.model')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "print(time.localtime())\n",
    "net.eval()#switch to test mode\n",
    "ratlist = []\n",
    "predlist= []\n",
    "for k, (users, items, ratings) in enumerate(getbatches(testdata, batch_size, use_cuda, False)):\n",
    "    pred = net(users, items)\n",
    "    predlist.extend(pred.tolist())\n",
    "    ratlist.extend(ratings.tolist())\n",
    "mae, mse = get_eval(np.array(ratlist), np.array(predlist))\n",
    "print('MAE: {:.5f}'.format(mae))\n",
    "print('MSE: {:.5f}'.format(mse))\n",
    "print(time.localtime())"
   ]
  }
 ],
 "metadata": {
  "hide_input": false,
  "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.5.3"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}