SlopeOneRecommendationSystem .ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Importing the important Libraries\n",
    "import pandas as pd\n",
    "import math\n",
    "from surprise import Reader, Dataset, evaluate\n",
    "import os\n",
    "import random\n",
    "from surprise import SlopeOne\n",
    "from sklearn.utils import shuffle\n",
    "from sklearn.model_selection import train_test_split"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#Setting the path for file\n",
    "os.chdir(\"C:/Users/Swati Arora/Data Science using Python/Movie Recommender System- Pybots/Data\")\n",
    "file_path = os.path.expanduser(\"C:/Users/Swati Arora/Data Science using Python/Movie Recommender System- Pybots/Data\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:1: ParserWarning: Falling back to the 'python' engine because the 'c' engine does not support regex separators (separators > 1 char and different from '\\s+' are interpreted as regex); you can avoid this warning by specifying engine='python'.\n",
      "  \"\"\"Entry point for launching an IPython kernel.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Index(['UserID', 'MovieID', 'Rating', 'Timestamp'], dtype='object')"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = pd.read_csv('ratings.dat',sep='::', encoding='latin-1',names=['UserID','MovieID','Rating','Timestamp'])\n",
    "df.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#shuffling the dataset to randomly select the userid for test and train data\n",
    "df = shuffle(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#Dividing the data ino test and train\n",
    "train, test = train_test_split(df, test_size=0.1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8999999000208956"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(train)/len(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#Writing the test and train data into a CSV file.\n",
    "test.to_csv(\"Test_dataset.csv\",sep=',')\n",
    "train.to_csv(\"Train_dataset.csv\",sep=',')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# A reader is still needed but only the rating_scale param is requiered.\n",
    "reader = Reader(rating_scale=(1, 5))\n",
    "# Coverting the pandas data frame to slop one specific alogrith format.\n",
    "data = Dataset.load_from_df(train[['UserID','MovieID','Rating']], reader)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#Initializing the slopeone alogorithm for model building\n",
    "algo=SlopeOne()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Retrieve the trainset.\n",
    "trainset = data.build_full_trainset()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#train the Model\n",
    "algo.train(trainset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#Testing the model on train set\n",
    "x=test\n",
    "x.index = pd.RangeIndex(len(x.index))\n",
    "x=x.drop('Timestamp',axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#Using the trained model to predict results for test Data set\n",
    "x['Pred_rating']=1\n",
    "for i in range(0,len(test)):\n",
    "    userid=x.iloc[i]['UserID']\n",
    "    itemid=x.iloc[i]['MovieID']\n",
    "    actual_rating=x.iloc[i]['Rating']\n",
    "    x.iloc[[i],[3]]=algo.predict(userid, itemid, actual_rating).est"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x.to_csv(\"Predicted_rating.csv\",sep=',')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#Calculating RMSE & MAE\n",
    "RMSE=0\n",
    "MAE=0\n",
    "for i in range(0,len(x)):\n",
    "    RMSE=RMSE+math.pow((x.iloc[i]['Pred_rating']-x.iloc[i]['Rating']),2)\n",
    "    MAE=MAE+abs(x.iloc[i]['Pred_rating']-x.iloc[i]['Rating'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RMSE: 0.0028630170261709676\n",
      "MAE: 0.713873523791\n"
     ]
    }
   ],
   "source": [
    "RMSE=math.sqrt(RMSE)/len(x)\n",
    "MAE=MAE/len(x)\n",
    "print(\"RMSE:\", RMSE)\n",
    "print(\"MAE:\",MAE)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Evaluating RMSE, MAE of algorithm SlopeOne.\n",
      "\n",
      "------------\n",
      "Fold 1\n",
      "RMSE: 0.9079\n",
      "MAE:  0.7153\n",
      "------------\n",
      "Fold 2\n",
      "RMSE: 0.9096\n",
      "MAE:  0.7165\n",
      "------------\n",
      "Fold 3\n",
      "RMSE: 0.9095\n",
      "MAE:  0.7167\n",
      "------------\n",
      "------------\n",
      "Mean RMSE: 0.9090\n",
      "Mean MAE : 0.7162\n",
      "------------\n",
      "------------\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "CaseInsensitiveDefaultDict(list,\n",
       "                           {'mae': [0.71527449137032351,\n",
       "                             0.71648387400934732,\n",
       "                             0.71674540997237546],\n",
       "                            'rmse': [0.90785426887076948,\n",
       "                             0.90962945384021454,\n",
       "                             0.9094537748391921]})"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Applying K-Fold to find best model\n",
    "# Split data into 5 folds\n",
    "data.split(n_folds=3)\n",
    "algo = SlopeOne()\n",
    "evaluate(algo, data, measures=['RMSE', 'MAE'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Recommending Top Five Movies to a random user:\n",
    "i=random.randrange(0, len(df), 1)\n",
    "i=df.iloc[i]['UserID']\n",
    "user=df[(df.UserID)==i]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:1: ParserWarning: Falling back to the 'python' engine because the 'c' engine does not support regex separators (separators > 1 char and different from '\\s+' are interpreted as regex); you can avoid this warning by specifying engine='python'.\n",
      "  \"\"\"Entry point for launching an IPython kernel.\n"
     ]
    }
   ],
   "source": [
    "movies=pd.read_csv('movies.dat',sep='::',encoding='ANSI',names=['MovieID','Title','Genres'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#Merging user rating data with movie data to identify which movies user has not wtached\n",
    "user_movies=pd.merge(movies,user,left_on='MovieID',right_on='MovieID',how='left')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "user_movies=user_movies[pd.isnull(user_movies['Rating'])]\n",
    "user_movies['UserID']=i\n",
    "user_movies=user_movies.drop('Timestamp',axis=1)\n",
    "user_movies=user_movies.drop('Genres',axis=1)\n",
    "user_movies.index = pd.RangeIndex(len(user_movies.index))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#Recommending top five movies\n",
    "y=user_movies\n",
    "for i in range(0,len(y)):\n",
    "    userid=y.iloc[i]['UserID']\n",
    "    itemid=y.iloc[i]['MovieID']\n",
    "    actual_rating=y.iloc[i]['Rating']\n",
    "    y.iloc[[i],[3]]=algo.predict(userid, itemid, actual_rating).est"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Top 5 Recommended movies For User: 601\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>MovieID</th>\n",
       "      <th>Title</th>\n",
       "      <th>UserID</th>\n",
       "      <th>Rating</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>502</th>\n",
       "      <td>572</td>\n",
       "      <td>Foreign Student (1994)</td>\n",
       "      <td>601</td>\n",
       "      <td>5.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2971</th>\n",
       "      <td>3382</td>\n",
       "      <td>Song of Freedom (1936)</td>\n",
       "      <td>601</td>\n",
       "      <td>5.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2913</th>\n",
       "      <td>3323</td>\n",
       "      <td>Chain of Fools (2000)</td>\n",
       "      <td>601</td>\n",
       "      <td>5.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>577</th>\n",
       "      <td>657</td>\n",
       "      <td>Yankee Zulu (1994)</td>\n",
       "      <td>601</td>\n",
       "      <td>5.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>508</th>\n",
       "      <td>578</td>\n",
       "      <td>Hour of the Pig, The (1993)</td>\n",
       "      <td>601</td>\n",
       "      <td>5.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      MovieID                        Title  UserID  Rating\n",
       "502       572       Foreign Student (1994)     601     5.0\n",
       "2971     3382       Song of Freedom (1936)     601     5.0\n",
       "2913     3323        Chain of Fools (2000)     601     5.0\n",
       "577       657           Yankee Zulu (1994)     601     5.0\n",
       "508       578  Hour of the Pig, The (1993)     601     5.0"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Sorting the movies for a particular user on the basis of their rating.\n",
    "y=y.sort_values(['Rating'],ascending=[0])\n",
    "print(\"Top 5 Recommended movies For User:\",y.iloc[0]['UserID'])\n",
    "y.head(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "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.6.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}