Item_based_CF_model.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "from scipy.sparse import csr_matrix\n",
    "from sklearn.neighbors import NearestNeighbors\n",
    "\n",
    "from surprise import KNNWithMeans\n",
    "from surprise.model_selection import train_test_split\n",
    "from surprise import Dataset, Reader\n",
    "from surprise import accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "rating_dt = pd.read_csv('D:/Columbia/fall 2020/IEOR 4571/HW2/ml-latest/ratings.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Item_basedCF(rating):\n",
    "    ## To perform comparison using the same metric over every model, \n",
    "    ##    we implement the second CF method using surprise package\n",
    "    # This is the Item-based CF model.\n",
    "    # It finds the similar item to user's record and make recommendations base on that\n",
    "    # input:  user rating dataset consist of userId, movieId and rating\n",
    "    # output: the accuracy of the model using RMSE\n",
    "    \n",
    "    # read the pandas dataframe as surprise dataframe\n",
    "    reader = Reader(rating_scale=(0,5))\n",
    "    data = Dataset.load_from_df(rating,reader)\n",
    "    \n",
    "    # set up the kNN model\n",
    "    my_k = 15\n",
    "    my_min_k = 5\n",
    "    my_sim_option = {'name':'pearson',\n",
    "                     'user_based':False}\n",
    "    algo = KNNWithMeans(k = my_k, min_k = my_min_k, sim_option = my_sim_option)\n",
    "    \n",
    "    # split and train the data\n",
    "    trainset, testset = train_test_split(data, test_size=0.25)\n",
    "    predictions = algo.fit(trainset).test(testset)\n",
    "    acc = accuracy.rmse(predictions)\n",
    "    return acc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "user_ids = rating_dt[\"userId\"].unique().tolist() \n",
    "num_all_user = len(user_ids)\n",
    "\n",
    "# randomly select 20% users from rating dataset \n",
    "np.random.seed(123)\n",
    "rand_userid = np.random.choice(user_ids, size = int(num_all_user * 0.1), replace=False)\n",
    "sample_df = rating_dt.loc[rating_dt['userId'].isin(rand_userid)]\n",
    "sample_df = sample_df[['userId','movieId','rating']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Computing the msd similarity matrix...\n",
      "Done computing similarity matrix.\n",
      "RMSE: 0.9098\n"
     ]
    }
   ],
   "source": [
    "kNN_model = Item_basedCF(sample_df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Computing the msd similarity matrix...\n",
      "Done computing similarity matrix.\n"
     ]
    }
   ],
   "source": [
    "# read the pandas dataframe as surprise dataframe\n",
    "reader = Reader(rating_scale=(0,5))\n",
    "data = Dataset.load_from_df(sample_df,reader)\n",
    "\n",
    "# set up the kNN model\n",
    "my_k = 15\n",
    "my_min_k = 5\n",
    "my_sim_option = {'name':'pearson',\n",
    "                 'user_based':False}\n",
    "algo = KNNWithMeans(k = my_k, min_k = my_min_k, sim_option = my_sim_option)\n",
    "\n",
    "# split and train the data\n",
    "trainset, testset = train_test_split(data, test_size=0.25)\n",
    "predictions = algo.fit(trainset).test(testset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# compute dcg for item-based CF  -- 0.9361632672396146\n",
    "np.random.seed(123)\n",
    "userid_random = np.random.choice(user_ids, 100, replace=False)\n",
    "rel_list = []\n",
    "for user in userid_random:\n",
    "    recommended = []\n",
    "    rate = []\n",
    "    for i in predictions:\n",
    "        if i[0] == user and i[3] >= 4.5:\n",
    "            rate.append(i[3])\n",
    "            recommended.append(i[1])\n",
    "        if len(recommended) == 20:\n",
    "            break\n",
    "    indx_sorted = np.flip(np.argsort(rate))\n",
    "    sorted_recommend = np.array(recommended)[indx_sorted]\n",
    "    rated_movie = sample_df.loc[sample_df['userId'] == user].movieId.tolist()\n",
    "    rel = []    \n",
    "    for index, item in enumerate(recommended):\n",
    "        if item in rated_movie:\n",
    "            rel.append(1)\n",
    "        else:\n",
    "            rel.append(0)\n",
    "    rel_list.append(rel)\n",
    "dcg_sum = 0\n",
    "for r in rel_list:\n",
    "    for i, value in enumerate(r):\n",
    "        if value == 1:\n",
    "            dcg_sum += 1/np.log(i+2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9361632672396146"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dcg_sum/100"
   ]
  },
  {
   "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}