Python

Sometimes, the installation of the surprise library, which is used to build recommendation systems, faces issues in Jupyter. To avoid any issues, it is advised to use Google Colab for this project.

Let's start by mounting the Google drive on Colab.

Installing surprise library

As this dataset is very large and has 7,824,482 observations, it is not computationally possible to build a model using this. Moreover, many users have only rated a few products and also some products are rated by very few users. Hence, we can reduce the dataset by considering certain logical assumptions.

Here, we will be taking users who have given at least 50 ratings, and the products that have at least 5 ratings, as when we shop online we prefer to have some number of ratings of a product.

Observations: There are 65,290 users who have rated above 50 items that each have at least 5 ratings.

Observations: There are 65,290 observations and 3 columns of data. The rating column is of numeric data type. The other columns are of object data types.

Observations: There are 65,290 observations. Therefore, there are the same amount of observtions than users so there is no missing data and there is only one interaction between a pair of a user and an item.

Observations: There are 65,290 ratings provided by users. The average of the ratings is 4.29 which seems very high. This is probably because people who buy products and are unhappy with them do not rate the product. The minimum rating is 1 and the maximum rating is 5. Furthermore, the median is 5 wich means there are a lot of high ratings.

Observations: The data is positively skewed and regroups a huge majority of 4 and 5 ratings.

• There are 1540 unique users and 5689 products in the dataset.

• The highest number of ratings by a user is 295 which is far from the actual number of products present in the data. We can build a recommendation system to recommend products to users which they have not interacted with.

Observations: In the final data there are 1540 unique users and there are 5689 products. There is a possibility of 1540 * 5689 = 8761060 ratings possible. But we only have 65290 ratings. We can build a recommendations system to recommend products the users have not yet interacted with.

Now that we have explored and prepared the data, let's build the first recommendation system.

We have recommended the top 5 products by using the popularity recommendation system. Now, let's build a recommendation system using collaborative filtering.

In this type of recommendation system, we do not need any information about the users or items. We only need user item interaction data to build a collaborative recommendation system. For example -

1. Ratings provided by users. For example, ratings of books on goodread, movie ratings on imdb, etc.
2. Likes of users on different facebook posts, likes on youtube videos.
3. Use/buying of a product by users. For example, buying different items on e-commerce sites.
4. Reading of articles by readers on various blogs.

Types of Collaborative Filtering

• Similarity/Neighborhood based

  • User-User Similarity Based
  • Item-Item similarity based

• Model based

• Below, we are building similarity-based recommendation systems using cosine similarity and using KNN to find similar users which are the nearest neighbor to the given user.
• We will be using a new library, called surprise, to build the remaining models. Let's first import the necessary classes and functions from this library.

Before building the recommendation systems, let's go over some basic terminologies we are going to use:

Relevant item: An item (product in this case) that is actually rated higher than the threshold rating (here 3.5) is relevant, if the actual rating is below the threshold then it is a non-relevant item.

Recommended item: An item that's predicted rating is higher than the threshold (here 3.5) is a recommended item, if the predicted rating is below the threshold then that product will not be recommended to the user.

False Negative (FN): It is the frequency of relevant items that are not recommended to the user. If the relevant items are not recommended to the user, then the user might not buy the product/item. This would result in the loss of opportunity for the service provider, which they would like to minimize.

False Positive (FP): It is the frequency of recommended items that are actually not relevant. In this case, the recommendation system is not doing a good job of finding and recommending the relevant items to the user. This would result in loss of resources for the service provider, which they would also like to minimize.

Recall: It is the fraction of actually relevant items that are recommended to the user, i.e., if out of 10 relevant products, 6 are recommended to the user then recall is 0.60. Higher the value of recall better is the model. It is one of the metrics to do the performance assessment of classification models.

Precision: It is the fraction of recommended items that are relevant actually, i.e., if out of 10 recommended items, 6 are found relevant by the user then precision is 0.60. The higher the value of precision better is the model. It is one of the metrics to do the performance assessment of classification models.

While making a recommendation system, it becomes customary to look at the performance of the model. In terms of how many recommendations are relevant and vice-versa, below are some most used performance metrics used in the assessment of recommendation systems.

Precision@k - It is the fraction of recommended items that are relevant in top k predictions. The value of k is the number of recommendations to be provided to the user. One can choose a variable number of recommendations to be given to a unique user.

Recall@k - It is the fraction of relevant items that are recommended to the user in top k predictions.

F1-score@k - It is the harmonic mean of Precision@k and Recall@k. When precision@k and recall@k both seem to be important then it is useful to use this metric because it is representative of both of them.

• Below function takes the recommendation model as input and gives the precision@k, recall@k, and F1-score@k for that model.
• To compute precision and recall, top k predictions are taken under consideration for each user.
• We will use the precision and recall to compute the F1-score.

• To compute precision and recall, a threshold of 3.5 and k value of 10 is taken for the recommended and relevant ratings.
• In the present case, precision and recall both need to be optimized as the service provider would like to minimize both the losses discussed above. Hence, the correct performance measure is the F_1 score.

Below we are loading the rating dataset, which is a pandas DataFrame, into a different format called surprise.dataset.DatasetAutoFolds, which is required by this library. To do this, we will be using the classes Reader and Dataset.

• Now, we are ready to build the first baseline similarity-based recommendation system using the cosine similarity.
• KNNBasic is an algorithm that is also associated with the surprise package. It is used to find the desired similar items among a given set of items.

Observations: RMSE is how far are the predicted ratings to the actual ratings. Recall tells us that out of all the relevant products, 85.6% are relevant. F_1 has a high score which tells us that most of the movies recommended were relevant and that most of the relevant movies were recommended.

Let's now predict rating for a user with userId=A3LDPF5FMB782Z and productId=1400501466 as shown below. Here the user has already interacted or watched the product with productId '1400501466' and given a rating of 5 which is denoted by the parameter r_ui.

• The above output shows that the actual rating for this user-item pair is 5, and the predicted rating is 3.40 by this user-user-similarity-based baseline model.

Below is the list of users who have not seen the product with product id "1400501466".

• It can be observed from the above list that user "A34BZM6S9L7QI4" has not seen the product with productId "1400501466" as this user id is not a part of the above list.

Below we are predicting rating for the same userId=A34BZM6S9L7QI4 but for a product which this user has not seen yet i.e. prod_id=1400501466

• The predicted rating for this user is around 4.3 based on this

user-user similarity-based baseline model.

Below, we will be tuning hyperparameters for the KNNBasic algorithms. Let's try to understand some of the hyperparameters of the KNNBasic algorithm:

• k (int) – The (max) number of neighbors to take into account for aggregation. Default is 40.
• min_k (int) – The minimum number of neighbors to take into account for aggregation. If there are not enough neighbors, the prediction is set to the global mean of all ratings. Default is 1.
• sim_options (dict) – A dictionary of options for the similarity measure. And there are four similarity measures available in surprise -
  • cosine
  • msd (default)
  • Pearson
  • Pearson baseline

Once the grid search is complete, we can get the optimal values for each of those hyperparameters as shown above.

Now, let's build the final model by using tuned values of the hyperparameters, which we received by using grid search cross-validation.

• We can observe that after tuning hyperparameters, F_1 score of the tuned model is 0.87, which is slightly better than the baseline model. Along with this, the RMSE of the model has gone down as compared to the model before hyperparameter tuning. Hence, we can say that the model performance has improved slightly after hyperparameter tuning.

Let's now predict the rating for a user with userId = "A3LDPF5FMB782Z", and prod_id = 1400501466 with the optimized model as shown below.

Observations: The predicted rating for both users is around 4.3 based on this user-user-optimized similarity-based baseline model.

We can also find out similar items to a given item or its nearest neighbors based on this KNNBasic algorithm. Below, we are finding the 5 most similar items to the first user in the list with internal id 0, based on the msd distance metric.

Below we will be implementing a function where the input parameters are:

• data: A rating dataset
• user_id: A user id against which we want the recommendations
• top_n: The number of products we want to recommend
• algo: the algorithm we want to use for predicting the ratings
• The output of the function is a set of top_n items recommended for the given user_id based on the given algorithm

While comparing the ratings of two products, it is not only the ratings that describe the likelihood of the user to that product. Along with the rating, the number of users who have seen that product also becomes important to consider. Due to this, we have calculated the "corrected_ratings" for each product. Commonly higher the "rating_count" of a product more it is liked by users. To interpret the above concept, a product rated 4 with rating_count 3 is less liked in comparison to a product rated 3 with a rating count of 50. It has been empirically found that the likelihood of the product is directly proportional to the inverse of the square root of the rating_count of the product.

Note: In the above-corrected rating formula, we can add the quantity 1/np.sqrt(n) instead of subtracting it to get more optimistic predictions. But here we are subtracting this quantity, as there are some products with ratings 5 and we can't have a rating more than 5 for a product.

• Above we have seen similarity-based collaborative filtering where similarity is calculated between users. Now let us look into similarity-based collaborative filtering where similarity is seen between items.

• The baseline model is giving a good F_1 score of ~ 84%. We will try to improve this later by using GridSearchCV by tuning different hyperparameters of this algorithm.

Let's now predict a rating for a user with userId = A3LDPF5FMB782Z and prod_Id = 1400501466 as shown below. Here the user has already interacted or watched the product with productId "1400501466".

• The above output shows that the actual rating for this user-item pair is 5 and the predicted rating is 4.27 by this item-item-similarity-based baseline model.

Below we are predicting rating for the same userId = A34BZM6S9L7QI4 but for a product with which this user has not interacted yet, i.e., prod_id = 1400501466.

As we can see the predicted rating for this user-item pair is good (around 4.3) based on this item-item similarity-based baseline model.

Below we will be tuning hyperparameters for the KNNBasic algorithms.

Once the grid search is complete, we can get the optimal values for each of those hyperparameters as shown above.

Now let's build the final model by using tuned values of the hyperparameters which we received by using grid search cross-validation.

Observations: After changing the hyperparameters, the score of F1 is better than the original model. Furthermore, the score of the RMSE has decreased therefore the model has imporved after the tuning.

Let's us now predict rating for an user with userId = A3LDPF5FMB782Z and for prod_id = 1400501466 with the optimized model as shown below:

Below we are predicting rating for the same userId = A34BZM6S9L7QI4 but for a product with which this user has not interacted before, i.e., prod_id == 1400501466, by using the optimized model as shown below:

• For an unknown product the model is predicting a rating of 4.29.

We can also find out similar items to a given item or its nearest neighbors based on this KNNBasic algorithm. Below we are finding the 5 most similar items to the item with internal id 0 based on the msd distance metric.

• Now as we have seen similarity-based collaborative filtering algorithms, let us now get into model-based collaborative filtering algorithms.

Model-based Collaborative Filtering is a personalized recommendation system, the recommendations are based on the past behavior of the user and it is not dependent on any additional information. We use latent features to find recommendations for each user.

SVD is used to compute the latent features from the user-item matrix. But SVD does not work when we miss values in the user-item matrix.

Observations: The F_1 score for the matrix factorization recommendation system is lower than with the user_user_similarity recommendation system.

• Let's now predict the rating for a user with userId = "A3LDPF5FMB782Z" and prod_id = "1400501466 as shown below.
• Here, the user has already rated the product.

As we can observe, the actual rating for this user-item pair is 5, and the predicted rating is 4.08 by this matrix factorization-based baseline model. It seems like we have under-estimated the rating. We will try to fix this later by tuning the hyperparameters of the model using GridSearchCV.

Below we are predicting rating for the same userId = A34BZM6S9L7QI4 but for a product with which this user has not interacted before, i.e., productId = 1400501466, as shown below:

We can see that the estimated rating for this user-item pair is 4.40 based on this matrix factorization based baseline model.

In SVD, rating is predicted as:

$$\hat{r}_{u i}=\mu+b_{u}+b_{i}+q_{i}^{T} p_{u}$$

If user $u$ is unknown, then the bias $b_{u}$ and the factors $p_{u}$ are assumed to be zero. The same applies for item $i$ with $b_{i}$ and $q_{i}$.

To estimate all the unknown, we minimize the following regularized squared error:

$$\sum_{r_{u i} \in R_{\text {train }}}\left(r_{u i}-\hat{r}_{u i}\right)^{2}+\lambda\left(b_{i}^{2}+b_{u}^{2}+\left\|q_{i}\right\|^{2}+\left\|p_{u}\right\|^{2}\right)$$

The minimization is performed by a very straightforward stochastic gradient descent:

$$\begin{aligned} b_{u} & \leftarrow b_{u}+\gamma\left(e_{u i}-\lambda b_{u}\right) \\ b_{i} & \leftarrow b_{i}+\gamma\left(e_{u i}-\lambda b_{i}\right) \\ p_{u} & \leftarrow p_{u}+\gamma\left(e_{u i} \cdot q_{i}-\lambda p_{u}\right) \\ q_{i} & \leftarrow q_{i}+\gamma\left(e_{u i} \cdot p_{u}-\lambda q_{i}\right) \end{aligned}$$

There are many hyperparameters to tune in this algorithm, you can find a full list of hyperparameters here

Below we will be tuning only three hyperparameters:

• n_epochs: The number of iterations of the SGD algorithm.
• lr_all: The learning rate for all parameters.
• reg_all: The regularization term for all parameters.

Once the grid search is complete, we can get the optimal values for each of those hyperparameters, as shown above.

Now, we will the build final model by using tuned values of the hyperparameters, which we received using grid search cross-validation above.

Observations: Although we adjusted the hyperparameters the value of F_1 has decreased rendering the second model less optimal.

Let's now predict a rating for a user with userId = A3LDPF5FMB782Z and productId = 1400501466 with the optimized model as shown below.

Observations: We can see that the estimated rating for this user-item pair is 4.17 based on this matrix factorization based baseline model with the hyperparamters changed.

Throughout this notebook, we built a recommendation system using different techniques.

• First, we used the Rank-Based technique to find the highest-ranked products.
• Secondly, we used the user-user similarity-based collaborative filtering, which consists of predicting items that a user might like based on the ratings given to an item provided by other users. These other users are similar to the one we are recommending the product to.
• Thirdly, we used the item-item similarity-based collaborative filtering, which consists of predicting items that a user might like based on the rating of similar products rated by that same user.
• Finally, we used the Model-based (matrix factorisation) collaborative filtering.

In order to be sure that we are using the best performing models, we grid searched cross-validation to find the optimal hyper parameters for the data. We have various evaluation systems. Such as the precision@k and recall@k which gives us the F_1 score. We can then choose the better performing model according to the RMSE and F_1 scores.

These methods help us recommend items to users in the most optimal and correct way possible.