baseline_bias_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 BaselineOnly\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('../data/ratings.csv', \n",
    "                        #parse_dates=['timestamp'], \n",
    "                        #date_parser=dateparse\n",
    "                       )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def baseline(rating):\n",
    "    # This is the baseline bias recommendation model.\n",
    "    # For every user, the model will calculate the rating of every movie based on user's average rating and movie's average rating.    \n",
    "    # The function uses surprise package, as our original basline model is extremely time-consuming .\n",
    "    # input:  user rating dataset consist of userId, movieId and rating\n",
    "    # output: the accuracy of the model using RMSE\n",
    " \n",
    "    \"\"\"   ORIGINAL MODEL\n",
    "    # retrieve all users with their avg rating\n",
    "    user_avg_rating = rating.groupby(['userId'])['rating'].mean()\n",
    "    \n",
    "    # retrieve all movies with their avg rating\n",
    "    movie_avg_rating = rating.groupby(['movieId'])['rating'].mean()\n",
    "    \n",
    "    df = pd.DataFrame(user_avg_rating)\n",
    "    \n",
    "    df_T = df.T\n",
    "    x = pd.concat([df_T]*len(movie_avg_rating))\n",
    "    x['mId'] = movie_avg_rating.index\n",
    "    df = x.set_index('mId').T + list(movie_avg_rating)\n",
    "    \n",
    "    return df\"\"\"\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 baseline model. \n",
    "    # since it is a baseline, we set regulation parameters to be 0\n",
    "    bsl_options = {'method': 'als',\n",
    "               'n_epochs': 5,\n",
    "               'reg_u': 0,\n",
    "               'reg_i': 0\n",
    "               }\n",
    "    algo = BaselineOnly(bsl_options=bsl_options)\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",
    "    \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",
    "# randomly select 10% 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": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Estimating biases using als...\n",
      "RMSE: 0.8750\n"
     ]
    }
   ],
   "source": [
    "b_model = baseline(sample_df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Estimating biases using als...\n"
     ]
    }
   ],
   "source": [
    "reader = Reader(rating_scale=(0,5))\n",
    "data = Dataset.load_from_df(sample_df,reader)\n",
    "\n",
    "# set up the baseline model. \n",
    "# since it is a baseline, we set regulation parameters to be 0\n",
    "bsl_options = {'method': 'als',\n",
    "           'n_epochs': 5,\n",
    "           'reg_u': 0,\n",
    "           'reg_i': 0\n",
    "           }\n",
    "algo = BaselineOnly(bsl_options=bsl_options)\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": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "# get dcg for baseline bias model -- 0.8759653479087667 \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)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8759653479087668"
      ]
     },
     "execution_count": 50,
     "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
}