Recommendation System.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "RangeIndex: 242124 entries, 0 to 242123\n",
      "Data columns (total 4 columns):\n",
      "user        242124 non-null int64\n",
      "item        242124 non-null int64\n",
      "qty         242124 non-null int64\n",
      "datetime    242124 non-null datetime64[ns]\n",
      "dtypes: datetime64[ns](1), int64(3)\n",
      "memory usage: 7.4 MB\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style>\n",
       "    .dataframe thead tr:only-child th {\n",
       "        text-align: right;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: left;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>user</th>\n",
       "      <th>item</th>\n",
       "      <th>qty</th>\n",
       "      <th>datetime</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>32011003635952</td>\n",
       "      <td>16198</td>\n",
       "      <td>1</td>\n",
       "      <td>2014-01-01 00:39:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>32009100468450</td>\n",
       "      <td>18107</td>\n",
       "      <td>4</td>\n",
       "      <td>2014-01-01 01:07:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>32013007873699</td>\n",
       "      <td>13612</td>\n",
       "      <td>2</td>\n",
       "      <td>2014-01-01 07:00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>32011004803503</td>\n",
       "      <td>42496</td>\n",
       "      <td>1</td>\n",
       "      <td>2014-01-01 07:06:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>32011004221857</td>\n",
       "      <td>8875</td>\n",
       "      <td>4</td>\n",
       "      <td>2014-01-01 07:09:00</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             user   item  qty            datetime\n",
       "0  32011003635952  16198    1 2014-01-01 00:39:00\n",
       "1  32009100468450  18107    4 2014-01-01 01:07:00\n",
       "2  32013007873699  13612    2 2014-01-01 07:00:00\n",
       "3  32011004803503  42496    1 2014-01-01 07:06:00\n",
       "4  32011004221857   8875    4 2014-01-01 07:09:00"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import random\n",
    "import functools\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import scipy\n",
    "from scipy.sparse import coo_matrix\n",
    "from sklearn.preprocessing import label_binarize\n",
    "import implicit\n",
    "import matplotlib.pyplot as plt\n",
    "import warnings\n",
    "\n",
    "warnings.filterwarnings('ignore')\n",
    "%matplotlib inline\n",
    "np.random.seed(41)\n",
    "\n",
    "data = pd.read_csv('rs.csv')\n",
    "del data['Unnamed: 0']\n",
    "data['datetime'] = pd.to_datetime(data['datetime'], format='%Y%m%d %H:%M:%S')\n",
    "N, D = data.shape\n",
    "\n",
    "data.info()\n",
    "data.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Without temporal effect, implement top-k recommendation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train size = 169487, test size = 72637.\n"
     ]
    }
   ],
   "source": [
    "TEST_SIZE = 0.3\n",
    "data_nt = data[['user', 'item', 'qty']] # _nt stands for no temporality\n",
    "\n",
    "# map each artist and user to a unique numeric value\n",
    "data_nt['user'] = data_nt['user'].astype(\"category\")\n",
    "data_nt['item'] = data_nt['item'].astype(\"category\")\n",
    "data_nt['qty'] = data['qty'].astype(float)\n",
    "\n",
    "#train test set split\n",
    "train_nt = data_nt.sample(frac=1-TEST_SIZE)\n",
    "test_nt = data_nt.drop(train_nt.index)\n",
    "print('train size = {}, test size = {}.'.format(len(train_nt), len(test_nt)))\n",
    "\n",
    "# get mapping from category to code for user\n",
    "#             from code to category for item\n",
    "m_u = list(zip(data_nt['user'], data_nt['user'].cat.codes))\n",
    "mapping_user = {}\n",
    "for cat, code in m_u:\n",
    "    mapping_user[cat] = code\n",
    "m_i = list(zip(data_nt['item'], data_nt['item'].cat.codes))\n",
    "mapping_item = {}\n",
    "for cat, code in m_i:\n",
    "    mapping_item[code] = cat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "fold interval:  [array([    0,     1,     2, ..., 33895, 33896, 33897])\n",
      " array([33898, 33899, 33900, ..., 67793, 67794, 67795])\n",
      " array([ 67796,  67797,  67798, ..., 101690, 101691, 101692])\n",
      " array([101693, 101694, 101695, ..., 135587, 135588, 135589])\n",
      " array([135590, 135591, 135592, ..., 169484, 169485, 169486])]\n",
      "Shape of user-item matrix = (2000, 1000).\n",
      "0th accuracy: 0.020237182134639212\n",
      "Shape of user-item matrix = (2000, 1000).\n",
      "1th accuracy: 0.02159419434774913\n",
      "Shape of user-item matrix = (2000, 1000).\n",
      "2th accuracy: 0.021388323450452842\n",
      "Shape of user-item matrix = (2000, 1000).\n",
      "3th accuracy: 0.021358822314659114\n",
      "Shape of user-item matrix = (2000, 1000).\n",
      "4th accuracy: 0.02085730300616574\n"
     ]
    }
   ],
   "source": [
    "#split train into K fold\n",
    "FACTOR_NUMBER = 50\n",
    "RECOMMENDATION_NUMBER = 10\n",
    "KFOLD = 5\n",
    "fold_interval = np.array(np.array_split(np.arange(len(train_nt)), KFOLD))\n",
    "print('fold interval: ', fold_interval)\n",
    "         \n",
    "# initialize a model\n",
    "model = implicit.als.AlternatingLeastSquares(factors=FACTOR_NUMBER)\n",
    "\n",
    "for i in range(KFOLD):\n",
    "    train_idx = np.concatenate(fold_interval[np.arange(KFOLD)!=i])    \n",
    "    train_val_nt = train_nt.iloc[train_idx, :]\n",
    "    \n",
    "        \n",
    "    # create a sparse matrix of all the artist/user/play triples\n",
    "    qtys = coo_matrix((train_val_nt['qty'], \n",
    "                   (train_val_nt['item'].cat.codes, \n",
    "                    train_val_nt['user'].cat.codes)))\n",
    "    \n",
    "    # train the model on a sparse matrix of item/user/confidence weights\n",
    "    model.fit(qtys)\n",
    "    user_items = qtys.T.tocsr()\n",
    "    print('Shape of user-item matrix = {}.'.format(user_items.toarray().shape))\n",
    "    \n",
    "    # validation, recommend items for a user\n",
    "    val_idx = np.concatenate(fold_interval[np.arange(KFOLD)==i])    \n",
    "    val_nt = train_nt.iloc[val_idx, :]\n",
    "    \n",
    "    # transform validation userid to train_val userid\n",
    "    correct_count = 0    \n",
    "    for index in val_nt.index:\n",
    "        userid = val_nt.loc[index, 'user']\n",
    "        itemid = val_nt.loc[index, 'item']\n",
    "        recommendations = model.recommend(mapping_user[userid], user_items, N=RECOMMENDATION_NUMBER)\n",
    "        if itemid in [mapping_item[item] for item, score in recommendations]:\n",
    "            correct_count += 1\n",
    "    \n",
    "    print('{}th accuracy: {}'.format(i, correct_count/len(val_nt)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shape of user-item matrix = (2000, 1000).\n",
      "4th accuracy: 0.01786968074122004\n"
     ]
    }
   ],
   "source": [
    "# Test\n",
    "# create a sparse matrix of all the artist/user/play triples\n",
    "qtys = coo_matrix((train_nt['qty'], \n",
    "               (train_nt['item'].cat.codes, \n",
    "                train_nt['user'].cat.codes)))\n",
    "\n",
    "# train the model on a sparse matrix of item/user/confidence weights\n",
    "model.fit(qtys)\n",
    "user_items = qtys.T.tocsr()\n",
    "print('Shape of user-item matrix = {}.'.format(user_items.toarray().shape))\n",
    "\n",
    "# transform validation userid to train_val userid\n",
    "correct_count = 0    \n",
    "for index in test_nt.index:\n",
    "    userid = test_nt.loc[index, 'user']\n",
    "    itemid = test_nt.loc[index, 'item']\n",
    "    recommendations = model.recommend(mapping_user[userid], user_items, N=RECOMMENDATION_NUMBER)\n",
    "    if itemid in [mapping_item[item] for item, score in recommendations]:\n",
    "        correct_count += 1\n",
    "\n",
    "print('{}th accuracy: {}'.format(i, correct_count/len(test_nt)))"
   ]
  }
 ],
 "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}