yuan-daja-daql-ss18-project.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "################################################ READ ME #################################################################\n",
    "\n",
    "# There are 4 classes: Load(), Plot(), BLRS(), and ALS()\n",
    "\n",
    "# Load() -- has the function to load the data\n",
    "# Plot() -- has the functions to plot the data statistics \n",
    "# BLRS() -- implements the basic item-item collaborative filtering recommender system\n",
    "# ALS()  -- implements the advanced recommender systems that uses alternating least squares \n",
    "\n",
    "# IMPORTANT: you must run the cells with the classes in order to view the results from the examples\n",
    "\n",
    "##########################################################################################################################\n",
    "\n",
    "# The cell under the Plot() class outputs the plots corresponding to the data\n",
    "# The cell under the BLRS() class outputs examples showing that the functions in the class works\n",
    "# The cell under the ALS() class outputs examples showing that the functions in the class works\n",
    "# The last cell implements the evaluation system and outputs the resulsts\n",
    "\n",
    "# TO USE THE FUNCTIONS: Read the comments and see the examples to enter the correct arguments for the functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "############################### RUN THIS CELL TO IMPORT THE LIBRARIES AND LOAD DATA ######################################\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd \n",
    "from scipy.sparse import csr_matrix\n",
    "from matplotlib import pyplot as plt\n",
    "import csv\n",
    "from scipy.spatial.distance import pdist, squareform\n",
    "from scipy.sparse import csr_matrix, issparse \n",
    "import scipy.sparse as sp\n",
    "from random import sample\n",
    "\n",
    "class Load: \n",
    "        # Load the data file\n",
    "    def loadRatings(self, df):\n",
    "        df = pd.read_csv(df,  sep=',', header=None)         \n",
    "        df.columns = ['user_id', 'item_id', 'rating', 'timestamp']    # column labels\n",
    "       \n",
    "        return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "####################################### PLOTS FOR DATA ANALYSIS ##########################################################\n",
    "\n",
    "class Plot:\n",
    "            \n",
    "    # Plot ratings with respect to items\n",
    "    def plotRatingItems(self):\n",
    "        dfPlot = pd.read_csv('ratings_Electronics_50.csv', header = None)\n",
    "        dfPlot[1].value_counts().hist(bins=100, range=[1,30])\n",
    "        plt.ylabel('Counts')\n",
    "        plt.xlabel('#Ratings')\n",
    "        plt.title('Ratings w.r.t. Items')\n",
    "        plt.show()\n",
    "    \n",
    "    # plot ratings with respect to users\n",
    "    def plotRatingUsers(self):\n",
    "        dfPlot = pd.read_csv('ratings_Electronics_50.csv', header = None)\n",
    "        dfPlot[0].value_counts().hist(bins=500)\n",
    "        plt.ylabel('Counts')\n",
    "        plt.xlabel('#Ratings')\n",
    "        plt.title('Ratings w.r.t. Users')\n",
    "        plt.show()\n",
    "    \n",
    "    # Calculate the minimum, maximum, median, average number and standard deviation of ratings per user and per item\n",
    "    # Show the results for users and items in a boxplot\n",
    "    # To see the numerical values uncomment the print statements\n",
    "    def boxPlot(self, df):\n",
    "        #print('The minimun rating for each user is:')\n",
    "        dfMinUser = df.groupby(['user_id'])['rating'].min()\n",
    "        #print(dfMinUser)\n",
    "        #print('The minimun rating for each item is:')\n",
    "        dfMinItem = df.groupby(['item_id'])['rating'].min()\n",
    "        #print(dfMinItem)\n",
    "        #print('The maximum rating for each user is:')\n",
    "        dfMaxUser = df.groupby(['user_id'])['rating'].max()\n",
    "        #print(dfMaxUser)\n",
    "        #print('The maximum rating for each item is:')\n",
    "        dfMaxItem = df.groupby(['item_id'])['rating'].min()\n",
    "        #print(dfMaxItem)\n",
    "        #print('The median rating for each user is:')\n",
    "        dfMedUser = df.groupby(['user_id'])['rating'].median()\n",
    "        #print(dfMedUser)\n",
    "        #print('The median rating for each item is:')\n",
    "        dfMedItem = df.groupby(['item_id'])['rating'].median()\n",
    "        #print(dfMedItem)\n",
    "        #print('The average of rating for each user is:')\n",
    "        dfAvgUser = df.groupby(['user_id'])['rating'].mean()\n",
    "        #print(dfAvgUser)\n",
    "        #print('The average of rating for each item is:')\n",
    "        dfAvgItem = df.groupby(['item_id'])['rating'].mean()\n",
    "        #print(dfAvgItem)\n",
    "        #print('The standart deviation of rating for each user is:')\n",
    "        dfStdUser = df.groupby(['user_id'])['rating'].std()\n",
    "        #print(dfStdUser)\n",
    "        #print('The standart deviation of rating for each item is:')\n",
    "        dfStdItem = df.groupby(['item_id'])['rating'].std()\n",
    "        #print(dfStdItem)\n",
    "        \n",
    "        #Show the results for users in a boxplot\n",
    "        #Create a new dataframe that contains the min, max, med, avg and std for each user as calculated in the previous question\n",
    "        userDataFrame = pd.DataFrame(\n",
    "            {\n",
    "             'min': dfMinUser,\n",
    "             'max': dfMaxUser,\n",
    "             'med': dfMaxUser,\n",
    "             'avg': dfAvgUser,\n",
    "             'std': dfStdUser\n",
    "            })\n",
    "\n",
    "        userDataFrame.boxplot()\n",
    "        plt.title('Boxplot for Users Statistics')\n",
    "        plt.show()\n",
    "        \n",
    "        #Show the results for items in a boxplot\n",
    "        #Create a new dataframe that contains the min, max, med, avg and std for each item as calculated in the previous question\n",
    "        itemDataFrame = pd.DataFrame(\n",
    "            {\n",
    "             'min': dfMinItem,\n",
    "             'max': dfMaxItem,\n",
    "             'med': dfMaxItem,\n",
    "             'avg': dfAvgItem,\n",
    "             'std': dfStdItem\n",
    "            })\n",
    "\n",
    "        itemDataFrame.boxplot()\n",
    "        plt.title('Boxplot for Items Statistics')\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#################################################### PLOTS EXAMPLE #######################################################\n",
    "\n",
    "# Call Load class\n",
    "l = Load()\n",
    "# load the data\n",
    "df = l.loadRatings('ratings_Electronics_50.csv')\n",
    "\n",
    "# Call Plot class\n",
    "p = Plot()\n",
    "\n",
    "# Plot of ratings w.r.t. items\n",
    "p.plotRatingItems()\n",
    "# Plot of ratings w.r.t. users\n",
    "p.plotRatingUsers()\n",
    "# Box plot\n",
    "p.boxPlot(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "############################ THIS CELL CONTAINS THE CODE FOR THE BLRS RECOMMENDER SYSTEM ################################\n",
    "############################ AND THE FUNCTION TO COMPUTE THE SPARSITY OF THE DATA #######################################\n",
    "\n",
    "# Implement a basic Item-to-Item Collaborative Filtering Recommender System\n",
    "class BLRS:\n",
    "    \n",
    "    # Call this function to see the number of users and items in the data\n",
    "    def get_users_items(self, df):     \n",
    "        users_items = df.groupby(by=['user_id','item_id']).apply(lambda x: 1).to_dict() \n",
    "        n_users = df.user_id.unique().shape[0]\n",
    "        n_items = df.item_id.unique().shape[0]\n",
    "        \n",
    "        print('Number of users = ' + str(n_users) + ' | Number of items = ' + str(n_items))\n",
    "\n",
    "    # Construct the rating matrix from data\n",
    "    def buildRatingM(self, df):\n",
    "         \n",
    "        users_items = df.groupby(by=['user_id','item_id']).apply(lambda x: 1).to_dict() \n",
    "        self.n_users = df.user_id.unique().shape[0]\n",
    "        self.n_items = df.item_id.unique().shape[0]\n",
    "\n",
    "        # Build Rating matrix\n",
    "        row, col = zip(*(users_items.keys())) #row-> users,  col-> items\n",
    "        self.map_u = dict(zip(df['user_id'].unique(),range(self.n_users)))     # user dict: keys are the userID and values are the indexes\n",
    "        self.map_i = dict(zip(df['item_id'].unique(),range(self.n_items)))     # item dict: keys are the itemID and values are the indexes\n",
    "        row_idx = [self.map_u[u] for u in row]\n",
    "        col_idx = [self.map_i[i] for i in col]\n",
    "        ratings = df['rating'].tolist()\n",
    "        data = np.array(ratings, dtype=np.float32)\n",
    "        # Create the rating matrix where the rows corresponds the users and the columns corresponds the items\n",
    "        # the values of the matrix are the ratings with respect to users and items\n",
    "        ratingM = csr_matrix((data, (row_idx, col_idx)), shape=(self.n_users,self.n_items))   \n",
    "        \n",
    "        return ratingM\n",
    "    \n",
    "    # Get the average rating per user\n",
    "    def avgR(self, df):\n",
    "        \n",
    "        # Get the rating matrix\n",
    "        ratingM = self.buildRatingM(df)\n",
    "        \n",
    "        tot = np.array(ratingM.sum(axis=1).squeeze())[0]    # Sum of ratings\n",
    "        cts = np.diff(ratingM.indptr)    # Total number of non-zero ratings\n",
    "        mu = tot/cts    # Average rating per user\n",
    "        \n",
    "        # Returns an array of the average ratings per user \n",
    "        # where the indexes corresponds to the user index in the rating matrix\n",
    "        return mu   \n",
    "    \n",
    "    # Computes the similiarity matrix\n",
    "    def simM(self, df):\n",
    "        \n",
    "        # Get the rating matrix\n",
    "        ratingM = self.buildRatingM(df)\n",
    "        \n",
    "        # Get the average rating per user\n",
    "        mu = self.avgR(df)\n",
    "\n",
    "        # Construct mean-adjusted matrix\n",
    "        # When subtract the rating matrix by the matrix of mu\n",
    "        # the unknown rating which is represented as zero is not subtracted \n",
    "        # Make sure the rating doesn’t become a negative number but remains zero instead\n",
    "        d = sp.diags(mu, 0)\n",
    "        d = d.todense()\n",
    "        b = ratingM.copy()\n",
    "        b.data = np.ones_like(b.data)\n",
    "        b = b.todense()\n",
    "\n",
    "        mean_adjusted = ratingM - d*b\n",
    "\n",
    "        # Construct similarity matrix\n",
    "        sim_matrix = 1 -squareform(pdist(mean_adjusted.T, 'cosine'))\n",
    "        \n",
    "        # For items with only ratings of 0, the denominator will be 0\n",
    "        # the division by the norm will result in NaN.\n",
    "        # We change the NaN values to 0 for sorting purposes in the rating prediction step\n",
    "        sim_matrix[np.isnan(sim_matrix)] = 0\n",
    "        \n",
    "        return sim_matrix\n",
    "    \n",
    "    # Computes the sparsity of the rating matrix\n",
    "    def sparsity(self):\n",
    "        \n",
    "        # Get rating matrix\n",
    "        ratingM = self.buildRatingM(df)\n",
    "        ratingM_array = ratingM.toarray()\n",
    "        \n",
    "        # Get the unique counts of ratings (0 to 5: 0 meaning an unrated item)\n",
    "        unique, counts = np.unique(ratingM_array, return_counts=True)\n",
    "        # Get the number of unrated items\n",
    "        unknown_ratings = counts[0]\n",
    "        unknown_ratings = float(unknown_ratings)\n",
    "        # Compute the sparsity of the matrix\n",
    "        sparsity = (unknown_ratings/(self.n_users*self.n_items))*100\n",
    "        sparsity = float(str(round(sparsity, 2)))\n",
    "\n",
    "        print(\"The Sparsity of the Rating Matrix is: \" + str(sparsity) + \"%\")\n",
    "        \n",
    "\n",
    "    # Predict the rating given a user and item        \n",
    "    def predictRating(self, userID, itemID, df): \n",
    "        \n",
    "        # Get rating matrix\n",
    "        ratingM = self.buildRatingM(df)\n",
    "        ratingM_array = ratingM.toarray()\n",
    "        \n",
    "        # Get similarity matrix\n",
    "        sim_matrix = self.simM(df)\n",
    "\n",
    "        user_idx = self.map_u.get(userID)  # Get the row corresponding to the user\n",
    "        item_idx = self.map_i.get(itemID)  # Get the col corresponding to item\n",
    "\n",
    "        if ratingM_array[user_idx, item_idx] != 0:  # If the given user rated the given item\n",
    "            print(\"The user has already rated this item!\")\n",
    "        else:\n",
    "            v = sim_matrix[:,item_idx]   # Simalarity vector: get the column in the sim_matrix corresponding to the given item\n",
    "            v = v[v >= 0]                # Disregard the similarities that are negative\n",
    "            item_num = np.argsort(v)     # Sort the index of the similarity vector\n",
    "            item_num = item_num[::-1]    # Descending order\n",
    "            item_num = item_num[1:51]    # For L = 50 : Pick the most similar 50 items \n",
    "                                         # Disregard the first element because the similarity is 1: the item compared to itself\n",
    "            v = sorted(v)                # Sort the similarity vector\n",
    "            v = v[::-1]                  # Descending order\n",
    "            v = v[1:51]                  # For L = 50: Pick the most similar 50 items\n",
    "\n",
    "            item_rating = []\n",
    "\n",
    "            for k in range(0,50):\n",
    "                item_rating.append(ratingM_array[user_idx, item_num[k]])    # list of ratings corresponding to the 50 most similar items\n",
    "\n",
    "            dot_p = np.dot(v, item_rating)     # Compute the dot product of the similarities of items and the item ratings\n",
    "            sim_sum = sum(np.absolute(v))      # Absolute value of the sum of similarities\n",
    "            pred = dot_p/sim_sum               # Compute the prediction for the given item\n",
    "            \n",
    "            pred = float(str(round(pred, 2)))  # Round the rating\n",
    "\n",
    "            print('The predicted rating of user: ' + str(userID) + ' for item: ' + str(itemID) + ' is ' + str(pred))\n",
    "            \n",
    "    # Given a user compute the top K recommendations provided by the predicted ratings\n",
    "    def predictTopKRecommendations(self, userID, k, df):\n",
    "        \n",
    "        # Get rating matrix\n",
    "        ratingM = self.buildRatingM(df)\n",
    "        ratingM_array = ratingM.toarray()\n",
    "        \n",
    "        # Get sim matrix\n",
    "        sim_matrix = self.simM(df)\n",
    "        \n",
    "        \n",
    "        user_idx = self.map_u.get(userID)      # Get row index of user\n",
    "        unrated_items = []\n",
    "        \n",
    "\n",
    "        user_row = ratingM_array[user_idx,:]  # Get the ratings of given user\n",
    "\n",
    "        user_row = user_row.astype(int)   # Convert ratings to integer\n",
    "\n",
    "        for i in range(len(user_row)):    \n",
    "            if user_row[i] == 0:\n",
    "                unrated_items.append(i)   # Vector of the index of the unrated items\n",
    "\n",
    "        v = []\n",
    "        item_idx = []\n",
    "        w =[]\n",
    "\n",
    "\n",
    "        for i in unrated_items:\n",
    "            v.append(sim_matrix[:,i])     # Get the ratings from the sim_matrix with the index of unrated items\n",
    "            \n",
    "        # Disregard negative similarities\n",
    "        for i in range(len(v)):\n",
    "            v[i] = v[i][v[i] >= 0] \n",
    "\n",
    "        for i in range(len(v)):\n",
    "            item_idx.append(v[i].argsort()[::-1][:51])    # For L = 50, get 50 most similar items and sort the similarities by index\n",
    "            w.append(sorted(v[i], reverse=True)[:51])     # Sort similarities, get 50 most similar items\n",
    "\n",
    "        item_idx = np.delete(item_idx, [0], axis=1)       # Delete the first element of the vector where the similarity is compared with the item itself\n",
    "        w = np.delete(w, [0], axis=1)\n",
    "\n",
    "        item_ratings = []\n",
    "\n",
    "        for i in range(len(item_idx)):\n",
    "            item_ratings.append([])\n",
    "            for j in range(0,50):\n",
    "                item_ratings[i].append(ratingM_array[user_idx, item_idx[i][j]])   # Get the ratings of the most similar items by the user        \n",
    "\n",
    "        dot_p = []\n",
    "        sim_sum = []   \n",
    "\n",
    "        for i in range(len(item_idx)):\n",
    "            dot_p.append(np.dot(w[i], item_ratings[i]))   # Compute dot product\n",
    "            sim_sum.append(sum(w[i]))                     # Compute sum of similarities\n",
    "\n",
    "        dot_p = np.array(dot_p)\n",
    "        sim_sum = np.array(sim_sum)  \n",
    "\n",
    "\n",
    "        pred = dot_p/sim_sum                              # Compute predictions\n",
    "\n",
    "        pred[np.isnan(pred)] = 0                          # Change NaN predictions to zero\n",
    "        \n",
    "    \n",
    "        for i in range(len(item_idx)):\n",
    "            pred[i] = float(str(round(pred[i], 2)))       # Round predicitons\n",
    "\n",
    "        pred = np.array(pred)\n",
    "\n",
    "        result = np.vstack((unrated_items, pred))         # Contrust a matrix where the 1st row is the unrated items \n",
    "                                                          # and the 2nd row is the predictions corresponding to the unrated items\n",
    "\n",
    "        result = result[:,result[1,:].argsort()[::-1]]    # Sort the predictions in desc. order\n",
    "\n",
    "        u_i = result[0,:]                                 # Vector of unrated items after sorting\n",
    "        u_i = u_i.astype(int)\n",
    "\n",
    "        # Get the item labels from dict for the unrated items \n",
    "        item_list = []\n",
    "        for i in range(len(u_i)):\n",
    "            for key, value in self.map_i.items():\n",
    "                if value == u_i[i]:\n",
    "                    it = key\n",
    "                    item_list.append(it)\n",
    "\n",
    "        u_pred = result[1,:]                              # Vector of predictions after sorting\n",
    "\n",
    "        \n",
    "        i_list = []\n",
    "        p_list =[]\n",
    "\n",
    "        for i in range(0,k):\n",
    "            i_list.append(item_list[i])    # List of top k recommendation items\n",
    "            p_list.append(u_pred[i])       # List of predictions with respect to the top k recommendation items\n",
    "        \n",
    "        return (i_list, p_list)\n",
    "    \n",
    "    # Print the top k recommendations for a given user    \n",
    "    def printTopK(self, userID, k, df):\n",
    "        \n",
    "        # Get the top k recommendation items and their predicted ratings\n",
    "        item_rating = self.predictTopKRecommendations(userID, k, df)\n",
    "        \n",
    "        print('Top ' + str(k) + ' recommendations for user ' + str(userID) + ' : ')\n",
    "        print(\" \")\n",
    "\n",
    "        for i in range(0,k):\n",
    "            \n",
    "            print(str(i+1) + '. Item ' + str(item_rating[0][i]) + ' with Predicated Rating of ' + str(item_rating[1][i]))\n",
    "            \n",
    "    # Compute the number of relavent items for each user         \n",
    "    def revItems(self, userID, k, df):\n",
    "        \n",
    "        # Get the average ratings for all users\n",
    "        mu = self.avgR(df)\n",
    "    \n",
    "        # Get row index of user\n",
    "        user_idx = self.map_u.get(userID)      \n",
    "        \n",
    "        # Get the average rating for the given user\n",
    "        avg_rating = mu[user_idx]\n",
    "        \n",
    "        # Get the top 10 items\n",
    "        item_rating = self.predictTopKRecommendations(userID, k, df)    \n",
    "        \n",
    "        rev_items = []\n",
    "        \n",
    "        for i in range(0, k):\n",
    "            # If the predicted rating of an item is greater than the average rating of the user\n",
    "            if np.any(item_rating[1][i] > mu):\n",
    "                # Add it to the list of relavent items\n",
    "                rev_items.append(i)\n",
    " \n",
    "        # Get the number of relavent items in the list\n",
    "        num_rev = len(rev_items)\n",
    "        \n",
    "        return(num_rev)\n",
    "    \n",
    "    # Compute Precision M = 10:       \n",
    "    def precision(self, users, M, df):\n",
    "        \n",
    "        # Get the number of users\n",
    "        \n",
    "        num_users = len(users)\n",
    "        \n",
    "        num_users = float(num_users)\n",
    "        \n",
    "        num_rev = []\n",
    "        \n",
    "        # Get the number of relavent items for each user\n",
    "        for i in range(len(users)):\n",
    "            num_rev.append(self.revItems(users[i], M, df))\n",
    "        \n",
    "        # Divide the number of relavent items of each user by M = 10\n",
    "        a = [i/M for i in num_rev]\n",
    "        # Sum the result for all users\n",
    "        sum_rev = sum(a)\n",
    "        # Compute the precision, M = 10 \n",
    "        prec = (1/(num_users)) * sum_rev\n",
    "        prec = float(str(round(prec, 2)))\n",
    "        \n",
    "        # Print result\n",
    "        print('Precision@10 for BLRS is ' + str(prec))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " ---------------------------------------------------------------------------- \n",
      "\n",
      "The rating matrix: \n",
      "\n",
      "[[5. 5. 5. ... 0. 0. 0.]\n",
      " [0. 0. 0. ... 0. 0. 0.]\n",
      " [0. 0. 0. ... 0. 0. 0.]\n",
      " ...\n",
      " [0. 0. 0. ... 4. 5. 5.]\n",
      " [0. 0. 0. ... 0. 0. 0.]\n",
      " [0. 0. 0. ... 0. 0. 0.]]\n",
      "\n",
      " ---------------------------------------------------------------------------- \n",
      "\n",
      "Number of users = 1542 | Number of items = 48190\n",
      "\n",
      " ---------------------------------------------------------------------------- \n",
      "\n",
      "The Sparsity of the Rating Matrix is: 99.83%\n",
      "\n",
      " ---------------------------------------------------------------------------- \n",
      "\n",
      "BLRS RECOMMENDER SYSTEM RESULTS:\n",
      " \n",
      "The similarity matrix: \n",
      "\n",
      "[[ 1.  1.  1. ...  0.  0.  0.]\n",
      " [ 1.  1.  1. ...  0.  0.  0.]\n",
      " [ 1.  1.  1. ...  0.  0.  0.]\n",
      " ...\n",
      " [ 0.  0.  0. ...  1.  1. -1.]\n",
      " [ 0.  0.  0. ...  1.  1. -1.]\n",
      " [ 0.  0.  0. ... -1. -1.  1.]]\n",
      "\n",
      " ---------------------------------------------------------------------------- \n",
      "\n",
      "The predicted rating of user: A28I5UM0FT3I6T for item: B000OFSN4G is 3.22\n",
      " \n",
      "The user has already rated this item!\n",
      "\n",
      " ---------------------------------------------------------------------------- \n",
      "\n",
      "Top 5 recommendations for user A28I5UM0FT3I6T : \n",
      " \n",
      "1. Item B003UI62AG with Predicated Rating of 3.76\n",
      "2. Item B002VR6A9K with Predicated Rating of 3.73\n",
      "3. Item B004GF1PC2 with Predicated Rating of 3.36\n",
      "4. Item B002TPL260 with Predicated Rating of 3.22\n",
      "5. Item B002SGATH8 with Predicated Rating of 3.22\n",
      "\n",
      " ---------------------------------------------------------------------------- \n",
      "\n",
      "The number of relavent items for userID A28I5UM0FT3I6T is: 0\n",
      "\n",
      " ---------------------------------------------------------------------------- \n",
      "\n"
     ]
    }
   ],
   "source": [
    "####################################### EXAMPLES OF THE RESULTS OF RUNNING BLRS ##########################################\n",
    "\n",
    "# Call Load class\n",
    "l = Load()\n",
    "# Load the data by inserting the name of the file (ex:'ratings_Electronics_50.csv')\n",
    "df = l.loadRatings('ratings_Electronics_50.csv')\n",
    "\n",
    "# Call the BLRS class\n",
    "d = BLRS()\n",
    "\n",
    "# Get the rating matrix by calling the function buildRatingM\n",
    "# The arugument is the data (ex: df)\n",
    "rating_matrix = d.buildRatingM(df).toarray()\n",
    "print(\"\\n ---------------------------------------------------------------------------- \\n\")\n",
    "print(\"The rating matrix: \\n\")\n",
    "print(rating_matrix)\n",
    "\n",
    "# Get the number of users and items of the data (df)\n",
    "print(\"\\n ---------------------------------------------------------------------------- \\n\")\n",
    "d.get_users_items(df)\n",
    "print(\"\\n ---------------------------------------------------------------------------- \\n\")\n",
    "\n",
    "\n",
    "# Get the sparsity of the data\n",
    "d.sparsity()\n",
    "print(\"\\n ---------------------------------------------------------------------------- \\n\")\n",
    "\n",
    "# For the purpose of faster computation time, we reduced the data to the first 5000 rows\n",
    "df = df[:5000]\n",
    "\n",
    "print(\"BLRS RECOMMENDER SYSTEM RESULTS:\")\n",
    "print(\" \")\n",
    "# Get the similarity matrix by calling the function simM\n",
    "# The arugument is the  data (ex: df)\n",
    "sim_mat = d.simM(df)\n",
    "print(\"The similarity matrix: \\n\")\n",
    "print(sim_mat)\n",
    "\n",
    "print(\"\\n ---------------------------------------------------------------------------- \\n\")\n",
    "####################################### Examples of results of the predictRating function ################################\n",
    "\n",
    "# Get the predicted ratings\n",
    "# The first argument is the userID (ex: 'A12LH2100CKQO)\n",
    "# The second argument is the itemID (ex: 'B000OFSN4G')\n",
    "# The last arguement is the data (ex: df)\n",
    "d.predictRating('A28I5UM0FT3I6T','B000OFSN4G', df)\n",
    "# Example of the result when the user has already rated the item\n",
    "print(\" \")\n",
    "d.predictRating('A12LH2100CKQO','B0002AOQ9O', df)\n",
    "print(\"\\n ---------------------------------------------------------------------------- \\n\")\n",
    "\n",
    "\n",
    "############################### Example of the result of the top k recommendations for a given user ######################\n",
    "\n",
    "# The first argument is the userID (ex: 'A12LH2100CKQO')\n",
    "# The second argument is k (ex: top 5)\n",
    "# The third arguement is the data (ex: df)\n",
    "d.printTopK('A28I5UM0FT3I6T', 5, df)\n",
    "print(\"\\n ---------------------------------------------------------------------------- \\n\")\n",
    "\n",
    "##########################################################################################################################\n",
    "\n",
    "# Get the number of relavent items for a given user\n",
    "\n",
    "r = d.revItems('A28I5UM0FT3I6T', 5, df)\n",
    "print(\"The number of relavent items for userID A28I5UM0FT3I6T is: \" + str(r))\n",
    "print(\"\\n ---------------------------------------------------------------------------- \\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "################################## THIS CELL CONTAINS THE CODE FOR THE ALS RECOMMENDER SYSTEM ############################\n",
    "\n",
    "class ALS():\n",
    "\n",
    "    # Construct the rating matrix from data\n",
    "    def buildRatingM(self, df):\n",
    "         \n",
    "        users_items = df.groupby(by=['user_id','item_id']).apply(lambda x: 1).to_dict() \n",
    "        self.n_users = df.user_id.unique().shape[0]\n",
    "        self.n_items = df.item_id.unique().shape[0]\n",
    "\n",
    "        # Build Rating matrix\n",
    "        row, col = zip(*(users_items.keys())) #row-> users,  col-> items\n",
    "        self.map_u = dict(zip(df['user_id'].unique(),range(self.n_users)))     # user dict: keys are the userID and values are the indexes\n",
    "        self.map_i = dict(zip(df['item_id'].unique(),range(self.n_items)))     # item dict: keys are the itemID and values are the indexes\n",
    "        row_idx = [self.map_u[u] for u in row]\n",
    "        col_idx = [self.map_i[i] for i in col]\n",
    "        ratings = df['rating'].tolist()\n",
    "        data = np.array(ratings, dtype=np.float32)\n",
    "        # Create the rating matrix where the rows corresponds the users and the columns corresponds the items\n",
    "        # the values of the matrix are the ratings with respect to users and items\n",
    "        ratingM = csr_matrix((data, (row_idx, col_idx)), shape=(self.n_users,self.n_items))   \n",
    "        \n",
    "        return ratingM\n",
    "    \n",
    "    # Get the average rating per user\n",
    "    def avgR(self, df):\n",
    "        \n",
    "        # Get the rating matrix\n",
    "        ratingM = self.buildRatingM(df)\n",
    "        \n",
    "        tot = np.array(ratingM.sum(axis=1).squeeze())[0]    # Sum of ratings\n",
    "        cts = np.diff(ratingM.indptr)    # Total number of non-zero ratings\n",
    "        mu = tot/cts    # Average rating per user\n",
    "        \n",
    "        # Returns an array of the average ratings per user \n",
    "        # where the indexes corresponds to the user index in the rating matrix\n",
    "        return mu   \n",
    "\n",
    "    #A function that implements AlS algorithm with U-V matrix decompositon\n",
    "    def runALS(self, df): \n",
    "        Q = self.buildRatingM(df) #User-Item Matrix with ratings \n",
    "        Q = Q.toarray()\n",
    "        #Replace the items that are rated with a 1 and the items that are not rated with 0, so that we have a binary matrix\n",
    "        W = Q>0.5\n",
    "        # User-Item Matrix with 1 if there is a rating or 0 if not\n",
    "        W[W == True] = 1\n",
    "        W[W == False] = 0\n",
    "        # To be consistent with our Q matrix\n",
    "        W = W.astype(np.float64, copy=False)\n",
    "    \n",
    "        \n",
    "        #The implementation of the AlS algorithm with U-V matrix decompositon\n",
    "        #In order to observe how each parameter works and how it influences the result of the algorithm we calculate the MSE.\n",
    "        #We print it after each iteration so that we see if the error decreases and after what point it start to encrease or\n",
    "        #not change anymore so that we can stop the iterations. To help the visualisaton we also plot the error.\n",
    "        lambdA = 0.1 #Regularization parameter\n",
    "        nFactors = 3 #How many factors each of user and item matrix will consider\n",
    "        n, m = Q.shape\n",
    "        nIterations = 20 #How many times to run algorithm\n",
    "        #Iitialize the user and item vectors with random values\n",
    "        Users = 5 * np.random.rand(n, nFactors)\n",
    "        Items = 5 * np.random.rand(nFactors, m)\n",
    "        \n",
    "        #print( \"Initiating \")\n",
    "\n",
    "        # A function to calculate the MSE\n",
    "        def get_error(Q, Users, Items, W):\n",
    "             # This calculates the MSE of nonzero elements\n",
    "            return np.sum((W * (Q - np.dot(Users, Items))) ** 2) / np.sum(W)\n",
    "\n",
    "    #Initialise the list of errors to be printed at the end for observational reasons\n",
    "        MSE_List = []\n",
    "    #Running the iterations for the ALS algorithm\n",
    "        #print (\"Starting Iterations\")\n",
    "        #The iteration steps of the ALS algorithm with respect to users and items \n",
    "        for iter in range(nIterations):\n",
    "            for i, Ri in enumerate(W):\n",
    "                Users[i] = np.linalg.solve(np.dot(Items, np.dot(np.diag(Ri), Items.T)) + lambdA * np.eye(nFactors), np.dot(Items, np.dot(np.diag(Ri), Q[i].T))).T\n",
    "            #print (\"Error after solving for User Matrix:\", get_error(Q, Users, Items, W))\n",
    "\n",
    "            for j, Rj in enumerate(W.T):\n",
    "                Items[:,j] = np.linalg.solve(np.dot(Users.T, np.dot(np.diag(Rj), Users)) + lambdA * np.eye(nFactors), np.dot(Users.T, np.dot(np.diag(Rj), Q[:, j])))\n",
    "            #print (\"Error after solving for Item Matrix:\", get_error(Q, Users, Items, W))\n",
    "\n",
    "            MSE_List.append(get_error(Q, Users, Items, W))\n",
    "            #print ('%sth iteration is complete...' % iter)\n",
    "\n",
    "        #print (MSE_List)\n",
    "    #     fig = plt.figure()\n",
    "    #     ax = fig.add_subplot(111)\n",
    "    #     plt.plot(range(1, len(MSE_List) + 1), MSE_List); plt.ylabel('Error'); plt.xlabel('Iteration')\n",
    "    #     plt.title('Python Implementation MSE by Iteration \\n with %d users and %d items' % Q.shape);\n",
    "    #     #plt.savefig('Python MSE Graph.pdf', format='pdf')\n",
    "        #plt.show()\n",
    "\n",
    "    #Calculating the prediction matrix as the dot product of the Users and Items arrays \n",
    "        PMatrix = np.dot(Users, Items)\n",
    "        \n",
    "        return PMatrix\n",
    "\n",
    "    # Given an user and item, compute the predicted rating for the item\n",
    "    def predictRatingALS(self, u, i, df):\n",
    "        \n",
    "        # Get rating matrix\n",
    "        matrix = self.buildRatingM(df)\n",
    "        \n",
    "        # Get prediction matrix\n",
    "        pred_matrix = self.runALS(df)\n",
    "\n",
    "        u_idx = self.map_u.get(u)  # Get the row corresponding to the user\n",
    "        i_idx = self.map_i.get(i)  # Get the col corresponding to item\n",
    "\n",
    "        # If the user has already rated the item\n",
    "        if matrix[u_idx, i_idx] !=0:\n",
    "            print(\"User rated this item already!\")\n",
    "        else:\n",
    "            # Get the predicted rating from the prediction matrix\n",
    "            pred = pred_matrix[u_idx, i_idx]\n",
    "            pred = float(str(round(pred, 2)))\n",
    "\n",
    "            print('The predicted rating of user: ' + str(u) + ' for item: ' + str(i) + ' is ' + str(pred))\n",
    "\n",
    "    # Get the top k items recommended to a user \n",
    "    def predictTopKRecommendationsALS(self, u, k, df):\n",
    "        \n",
    "        # Get rating matrix\n",
    "        ratingM = self.buildRatingM(df)     \n",
    "        ratingM_array = ratingM.toarray()\n",
    "        \n",
    "        # Get predicition matrix\n",
    "        predMatrix = self.runALS(df)\n",
    "        \n",
    "        # get the\n",
    "        u_idx = self.map_u.get(u)\n",
    "\n",
    "        unrated_items = []\n",
    "        \n",
    "        # Get the unrated items\n",
    "        for i in range(ratingM_array.shape[1]):\n",
    "            if ratingM_array[u_idx, i] == 0:\n",
    "                unrated_items.append(i)    # item idx\n",
    "\n",
    "        item_pred = []\n",
    "\n",
    "        # Get the predicted ratings for the unrated items\n",
    "        for i in range(len(unrated_items)):\n",
    "            item_pred.append(predMatrix[u_idx, i])\n",
    "\n",
    "        # Construct a matrix where the 1st row is the unrated items \n",
    "        # and the 2nd row is the predictions corresponding to the unrated items\n",
    "        result = np.vstack((unrated_items, item_pred))        \n",
    "        result = result[:,result[1,:].argsort()[::-1]]    # Sort the predictions in desc. order\n",
    "\n",
    "        # Vector of unrated items after sorting\n",
    "        u_i = result[0,:]                                 \n",
    "        u_i = u_i.astype(int)\n",
    "\n",
    "        # Vector of predictions after sorting\n",
    "        u_pred = result[1,:]                              \n",
    "\n",
    "        for i in range(len(u_pred)):\n",
    "            u_pred[i] = float(str(round(u_pred[i], 2))) \n",
    "\n",
    "        item_list = []\n",
    "\n",
    "        # Get the itemID for the items\n",
    "        for i in range(len(u_i)):\n",
    "            for key, value in self.map_i.items():\n",
    "                if value == u_i[i]:\n",
    "                    it = key\n",
    "                    item_list.append(it)\n",
    "        \n",
    "        i_list = []\n",
    "        p_list =[]\n",
    "        \n",
    "        for i in range(0,k):\n",
    "            \n",
    "            i_list.append(item_list[i])    # List of top k items\n",
    "            p_list.append(u_pred[i])       # List of corresponding predicted ratings\n",
    "        \n",
    "        return (i_list, p_list)\n",
    "        \n",
    "    # Print the top k recommendations given a user\n",
    "    def printTopKALS(self, userID, k, df):\n",
    "        \n",
    "        # Get the top k items and predicted ratings\n",
    "        item_rating = self. predictTopKRecommendationsALS(userID, k, df)\n",
    "        \n",
    "        \n",
    "        print('Top ' + str(k) + ' recommendations for user ' + str(userID) + ' : ')\n",
    "        print(\" \")\n",
    "        \n",
    "        for i in range(0,k):\n",
    "            print(str(i+1) + '. Item ' + str(item_rating[0][i]) + ' with Predicated Rating of ' + str(item_rating[1][i]))\n",
    "         \n",
    "    # Get the number of relavent items per user    \n",
    "    def revItemsALS(self, userID, k, df):\n",
    "        \n",
    "        # Get the average rating of all users\n",
    "        mu = self.avgR(df)\n",
    "        \n",
    "        # Get row index of user\n",
    "        user_idx = self.map_u.get(userID)      \n",
    "        \n",
    "        # Get the average rating of the given user\n",
    "        avg_rating = mu[user_idx]\n",
    "        \n",
    "        # Compute the top k recommendations for the given user\n",
    "        item_rating = self.predictTopKRecommendationsALS(userID, k, df)    \n",
    "        \n",
    "        rev_items = []\n",
    "    \n",
    "        # If the predicted rating is greater than the average rating of the user add it to a list\n",
    "        for i in range(0, k):\n",
    "            if np.any(item_rating[1][i] > mu):\n",
    "                rev_items.append(i)\n",
    "                \n",
    "        # Get the number of relavent items in the list        \n",
    "        num_rev = len(rev_items)\n",
    "        \n",
    "        return(num_rev)\n",
    "         \n",
    "    #Precision M = 10, top 10 items\n",
    "    def precisionALS(self, users, M, df):\n",
    "        \n",
    "        # Get the number of users in the data\n",
    "        num_users = len(users)\n",
    "        \n",
    "        num_users = float(num_users)\n",
    "        \n",
    "        num_rev = []\n",
    "\n",
    "        # Get the number of relavent items for each user\n",
    "        for i in range(len(users)):\n",
    "            num_rev.append(self.revItemsALS(users[i], M, df))\n",
    "            \n",
    "        # Divide the number of relavent items for each user by M = 10\n",
    "        a = [i/M for i in num_rev]\n",
    "        # Sum the result\n",
    "        sum_rev = sum(a)\n",
    "        \n",
    "        # Compute the precision\n",
    "        prec = (1/(num_users)) * sum_rev\n",
    "        prec = float(str(round(prec, 2)))\n",
    "        \n",
    "        print('Precision@10 for ALS is ' + str(prec))      "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " ---------------------------------------------------------------------------- \n",
      "\n",
      "ALS RECOMMENDER SYSTEM RESULTS:\n",
      " \n",
      "The prediction matrix: \n",
      "\n",
      "[[ 2.93763344  3.91684458  1.95842229 ...  0.11955581  0.47822323\n",
      "   0.59777903]\n",
      " [ 1.39335638  1.8578085   0.92890425 ...  0.93286444  3.73145777\n",
      "   4.66432221]\n",
      " [ 0.1079477   0.14393027  0.07196514 ...  0.96514505  3.8605802\n",
      "   4.82572526]\n",
      " ...\n",
      " [ 1.45615052  1.94153402  0.97076701 ...  0.8384589   3.3538356\n",
      "   4.19229451]\n",
      " [ 2.62742169  3.50322892  1.75161446 ... -0.12975131 -0.51900522\n",
      "  -0.64875653]\n",
      " [ 0.35504667  0.47339556  0.23669778 ...  0.97899914  3.91599657\n",
      "   4.89499571]]\n",
      "\n",
      " ---------------------------------------------------------------------------- \n",
      "\n",
      "The predicted rating of user: A28I5UM0FT3I6T for item: B000OFSN4G is -0.5\n",
      " \n",
      "User rated this item already!\n",
      "\n",
      " ---------------------------------------------------------------------------- \n",
      "\n",
      "Top 5 recommendations for user A1ZVFCPHCWFV71 : \n",
      " \n",
      "1. Item B00AVST4GM with Predicated Rating of 8.39\n",
      "2. Item B00CGY4JBY with Predicated Rating of 7.3\n",
      "3. Item B007WTAJTO with Predicated Rating of 7.23\n",
      "4. Item B000WIK61I with Predicated Rating of 7.03\n",
      "5. Item B00DQZOD8Q with Predicated Rating of 7.03\n",
      "\n",
      " ---------------------------------------------------------------------------- \n",
      "\n",
      "The number of relavent items for userID A28I5UM0FT3I6T is: 5\n",
      "\n",
      " ---------------------------------------------------------------------------- \n",
      "\n"
     ]
    }
   ],
   "source": [
    "######################################### EXAMPLES OF THE RESULTS OF RUNNING ALS ########################################\n",
    "\n",
    "# Call Load class\n",
    "l = Load()\n",
    "# Load the data by inserting the name of the file (ex:'ratings_Electronics_50.csv')\n",
    "df = l.loadRatings('ratings_Electronics_50.csv')\n",
    "# For the purpose of faster computation time, we reduced the data to the first 5000 rows\n",
    "df = df[:5000]\n",
    "\n",
    "# Call the BLRS class\n",
    "a = ALS()\n",
    "\n",
    "print(\"\\n ---------------------------------------------------------------------------- \\n\")\n",
    "print(\"ALS RECOMMENDER SYSTEM RESULTS:\")\n",
    "print(\" \")\n",
    "# Get the prediction matrix with the predicted ratings\n",
    "# The argument is the data (ex: df)\n",
    "pred_matrix = a.runALS(df)\n",
    "print(\"The prediction matrix: \\n\")\n",
    "print(pred_matrix)\n",
    "print(\"\\n ---------------------------------------------------------------------------- \\n\")\n",
    "\n",
    "\n",
    "################################### Examples of results of the predictRatingALS function ################################\n",
    "\n",
    "# Get the predicted ratings\n",
    "# The first argument is the userID (ex: 'A12LH2100CKQO)\n",
    "# The second argument is the itemID (ex: 'B00008A6CC')\n",
    "# The last arguement is the data (ex: df)\n",
    "a.predictRatingALS('A28I5UM0FT3I6T','B000OFSN4G', df)\n",
    "# Example of the result when the user has already rated the item\n",
    "print(\" \")\n",
    "a.predictRatingALS('A12LH2100CKQO','B0002AOQ9O', df)\n",
    "print(\"\\n ---------------------------------------------------------------------------- \\n\")\n",
    "\n",
    "\n",
    "############################### Example of the result of the top k recommendations for a given user ######################\n",
    "\n",
    "# The first argument is the userID (ex: 'A12LH2100CKQO')\n",
    "# The second argument is k (ex: top 5)\n",
    "# The third arguement is the data (ex: df)\n",
    "a.printTopKALS('A1ZVFCPHCWFV71', 5, df)\n",
    "print(\"\\n ---------------------------------------------------------------------------- \\n\")\n",
    "\n",
    "##########################################################################################################################\n",
    "\n",
    "# Get the number of relavent items for a given user\n",
    "\n",
    "r = a.revItemsALS('A12LH2100CKQO', 5, df)\n",
    "print(\"The number of relavent items for userID A28I5UM0FT3I6T is: \" + str(r))\n",
    "print(\"\\n ---------------------------------------------------------------------------- \\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "####################################### EVALUATION SYSTEM (EvaS) RESULTS #################################################\n",
    "\n",
    "# load folds 1 to 4\n",
    "df1 = pd.read_csv('ratings_Electronics_50_fold1.csv', sep=',', header=None)\n",
    "df2 = pd.read_csv('ratings_Electronics_50_fold2.csv', sep=',', header=None)\n",
    "df3 = pd.read_csv('ratings_Electronics_50_fold3.csv', sep=',', header=None)\n",
    "df4 = pd.read_csv('ratings_Electronics_50_fold4.csv', sep=',', header=None)\n",
    "frames = [df1, df2, df3, df4]\n",
    "# Combines the folds into training data\n",
    "df_train = pd.concat(frames)\n",
    "df_train.columns = ['user_id', 'item_id', 'rating', 'timestamp', 'fold']\n",
    "# For the purpose of faster computation time, we reduced the data to the first 2000 rows\n",
    "df_train = df_train[:2000]\n",
    "\n",
    "# load fold 5 into test data\n",
    "df_test = pd.read_csv('ratings_Electronics_50_fold5.csv', sep=',', header=None)\n",
    "df_test.columns = ['user_id', 'item_id', 'rating', 'timestamp', 'fold']\n",
    "\n",
    "# Find the users that appear in both the training and test data\n",
    "df_user_train = df_train['user_id']\n",
    "df_user_train = df_user_train.drop_duplicates()\n",
    "df_user_test = df_test['user_id']\n",
    "df_user_test = df_user_test.drop_duplicates()\n",
    "f = [df_user_train, df_user_test]\n",
    "\n",
    "users = pd.concat(f)\n",
    "\n",
    "# Find the duplicated users in both training and test data and store the results in a new dataframe\n",
    "users = users[users.duplicated(keep=False)]\n",
    "\n",
    "# create random index\n",
    "rindex =  np.array(sample(range(len(users)), 10))\n",
    "\n",
    "# get 10 random users from the datadrame users\n",
    "users = users.iloc[rindex]\n",
    "users = np.array(users)\n",
    "\n",
    "########################################## EXAMPLES TO EVALUATE BLRS ####################################################\n",
    "\n",
    "# Call BLRS class\n",
    "b = BLRS()\n",
    "\n",
    "print(\"\\n ---------------------------------------------------------------------------- \\n\")\n",
    "print(\"EvaS--BLRS Results: \\n\")\n",
    "\n",
    "# Get the top 10 recommendations for each of the 10 random users\n",
    "for i in range(len(users)):\n",
    "    b.printTopK(users[i], 10, df_train)\n",
    "    print(\" \")\n",
    "    \n",
    "print(\"\\n ---------------------------------------------------------------------------- \\n\")\n",
    "# Get precision@10 for the BLRS   \n",
    "b.precision(users, 10, df_train)\n",
    "\n",
    "########################################## EXAMPLES TO EVALUATE ALS ####################################################\n",
    "\n",
    "# Call ALS class\n",
    "\n",
    "a = ALS()\n",
    "\n",
    "print(\"\\n ---------------------------------------------------------------------------- \\n\")\n",
    "print(\"EvaS--ALS Results: \\n\")\n",
    "\n",
    "# Get the top 10 recommendations for each of the 10 random users\n",
    "for i in range(len(users)):\n",
    "    a.printTopKALS(users[i], 10, df_train)\n",
    "    print(\" \")\n",
    "    \n",
    "print(\"\\n ---------------------------------------------------------------------------- \\n\")\n",
    "# Get precision@10 for the ALS   \n",
    "a.precisionALS(users, 10, df_train)\n",
    "\n",
    "\n",
    "\n",
    "      "
   ]
  }
 ],
 "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.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}