Collaborative Filtering based Recommender Systems for Implicit Feedback Data
Different Flavors of Recommenders
At a highlevel, Recommender systems work based on two different strategies (or a hybrid of the two) for recommending content.
 Collaborative Filtering: Algorithms that use usage data, such as explicit or implicit feedback from the user.
 Contentbased Filtering: Algorithms that use content metadata and user profile. For example, a movie can be profiled based on its genre, IMDb ratings, boxoffice sales, etc., and a user can be profile based on their demographic information or their answers to an onboarding survey.
So, while collaborative filtering needs much feedback from the users to work properly, contentbased filtering needs good descriptions of the items.
Challenges With Using Explicit Data
Broadly speaking, the usage data can be either an explicit or implicit signal from the user. Explicit feedback is likely the most accurate input for the recommender system because it is pure information provided by the user about their preference for certain content. This feedback is usually collected using controls such as upvote/downvote buttons or star ratings.
Despite their flaws, explicit feedback is used by a vast majority of recommender systems probably thanks to the convenience of using such an input.
However, explicit feedback is not always available and often lacks nuances. Not everyone who purchases a product on Amazon or watches a movie on Netflix likes to leave feedback, people might rate a product lower because of their bad experience with an Amazon delivery agent, and someone might rate a movie higher not because of the content of the movie but simply because they liked the movie’s cover art.
Explicit feedback collection is not even possible for products like movies or shows broadcasted on television. Similarly, a platform may not have a feedback system with 0 or negative ratings, so if you don’t like a product, the lowest rating you can give to it might still be a 1star. This dilutes how strongly you may dislike the product, and for the recommender system, it means that the dataset lacks substantial evidence on which products consumers dislike.
Despite their flaws, explicit feedback is used by a large number of recommender systems probably thanks to the convenience of using such an input. The missing information is simply considered as empty cells in a sparse matrix input and is omitted from the analysis. Using explicit signals requires additional boosting algorithms to get user feedback on new content because collaborative filtering will not be able to recommend the new content until someone rates it (also known as the cold start problem).
Building a Recommender System Using Explicit Feedback
Before we talk about using implicit signals, let’s implement a collaborative filtering based recommender system using explicit signals. We will implement a matrix factorization based algorithm using NumPy’s SVD ^{1} on MovieLens 100K dataset ^{2}. This dataset contains 100,000 ratings given by 943 users for 1682 movies, with each user having rated at least 20 movies.
Quick Notes on How Matrix Factorization Works
We start with a U
x M
rating matrix (943x1682 for our dataset) where each value $r_{ui}$ represents the rating given by user u
for a movie i
. We then divide this matrix into two much smaller matrices such that we approximately get the same U
x M
matrix back if we multiply the two new matrices together. Basically, we compress a highdimensional sparse input matrix to a lowdimensional dense matrix space because this generalization leads to a better understanding of the data. Refer to Yehuda Koren’s paper to read more about how the matrix factorization technique is used for recommender systems ^{3}. To learn how SVD works, refer to Jeremy Kun’s article on Math ∩ Programming ^{4}.
By splitting this matrix into lower dimensions (factors), we represent each user as well as each movie by a 50dimensional dense vector.
To recommend movies similar to a given movie, we can compute the dot product (cosine similarity) between that movie and other movies and take the closest candidates as the output. Alternatively, we can compute the dot product of a user vector u
and an item vector i
to get the predicted score and sort all unrated items’ predicted score for a given user to get the list of recommended items for a user.
Python Implementation


Code is also available on this GitHub Gist.
Challenges With Using Implicit Data
Implicit user feedback includes purchase history, browsing history, search patterns, impressions, clicks, or even mouse movements. While with explicit feedback, the user specifies the degree of positive or negative preference for an item, we do not have the same symmetry with implicit feedback. For example, a user might not have read a book either because they didn’t like the book or they didn’t know about the book or the book wasn’t available in their region, or maybe its cost was prohibitive for the user.
Focusing on only the gathered implicit signals means that we could end up focusing heavily on positive signals. So we also have to address the missing data because a lot of negative feedback might exist there. This unfortunately also means that we may no longer have a sparse matrix and we may not be able to use computeefficient sparsitybased algorithmic optimizations.
Implicit feedback is also inherently noisy. A user might have purchased an item in the past only to give it away as a gift, someone might have “watched” a 2+ hour long movie in a theatre, but they might have been asleep throughout it, a user might have missed watching a tv show because there was a live sports event at the same time.
Preference vs Confidence
One way to think about the difference between the two feedback types is that the explicit feedback indicates user preference, whereas the implicit feedback numerical value indicates confidence. For example, using the count of the number of times the user has watched a show does not indicates a higher preference, but it tells us about the confidence we have in a certain observation. A onetime event might be caused by various reasons that have nothing to do with user preferences. However, a recurring event is more likely to reflect the user’s opinion.
Building a Recommender System Using Implicit Feedback
The most common collaborative filtering algorithms are either neighborhoodbased or latent factor models.
 Neighborhood models, such as clustering or topN, find the closest users or closest items to generate recommendations. But with implicit data, they do not make a distinction between user preferences and the confidence we might have in those preferences.
 Factorization models, uncover latent features that explain observed ratings. We already saw an example of a factorization method using explicit data in the previous section. Most of the research in this domain use explicit feedback datasets and model the observed ratings directly as shown below:
Parameters in the above equation are often learned through stochastic gradient descent.
Work done by Hu et. al divides raw observation $r_{ui}$ into two separate magnitudes with distinct interpretations: preference ($p_{ui}$) and confidence levels ($c_{ui}$).
Hu et. al.^{5} in their seminal paper (Winner of the 2017 IEEE ICDM 10Year HighestImpact Paper Award) described an implicit feedback based factorization model idea that gained a lot of popularity. First, they formalized the notion of preference and confidence. Preference $p_{ui}$ is indicated using a binary variable that is 1 for all nonzero and positive $r_{ui}$ values, and is 0 otherwise (when u
never consumed i
).
$p_{ui} = \begin{cases} 1 & r_{ui}>0\ 0 & r_{ui}=0 \end{cases}$
$r_{ui}$ indicates the observations for user actions, for example $r_{ui}$ = 0.7 could indicate that the user u
watched 70% of the movie i
. If $r_{ui}$ grows, so does our confidence that the user indeed likes the item. Hence the confidence $c_{ui}$ in observing $p_{ui}$ is defined as $1 + \alpha r_{ui}$. This varying level of confidence gracefully handles the noisy implicit feedback issues described previously. Also, the missing values ($p_{ui} = 0$) will have low corresponding confidence.
Similar to the leastsquares model for explicit feedback, our goal is to find a vector $x_{u}$ (user factor) for each user u
and vector $y_{i}$ (item factor) for each item i
that will factor respective user and item preferences. In other words, preferences are assumed to be the inner products: $p_{ui} = x_{u}^{T}y_{i}$. Hence the cost function becomes:
Note that the cost function now contains $m \times n$ terms where m
and n
are the dimensions of the rating matrix. As this number can easily reach a few billion, the author proposed a clever modification to the alternating least squares method (as opposed to using stochastic gradient descent). The algorithm alternates between recomputing user factors and item factors and each step is guaranteed to lower the value of the cost function. Basically $x_{u}$ can be minimized to: $x_{u} = (Y^{T} C^{u}Y + \lambda I)^{1} Y^{T} C^{u} p(u)$, which can be further sped up by computing $Y^{T} C^{u}Y$ as $Y^{T}Y + Y^{T}(C^{u}I)Y$. Similar we calculate $y_{i}$ as $(X^{T} C^{i}X + \lambda I)^{1} X^{T} C^{i} p(i)$. A slight modification to this calculation also allows for explainable recommendations. Refer to their paper for further details^{5}.
Implementing Implicit Feedback Recommender in Python
To implement a recommender based on the above idea, we will use the Last.fm 360K dataset ^{6}, and the Python implementation based on Ben Frederickson’s implicit Python package^{7}.


Code is also available on this GitHub Gist.
Summary
In this article, I discussed defining characteristics of explicit and implicit feedback along with their respective shortcomings. Next, I went over one of the most popular research on a factor model which is specially tailored for implicit feedback recommenders. We also implemented factorizationbased recommender systems in Python for both explicit and implicit datasets.
References

https://numpy.org/doc/stable/reference/generated/numpy.linalg.svd.html ↩︎

Y. Koren, R. Bell and C. Volinsky, “Matrix Factorization Techniques for Recommender Systems,” in Computer, vol. 42, no. 8, pp. 3037, Aug. 2009, doi: 10.1109/MC.2009.263. https://datajobs.com/datasciencerepo/RecommenderSystems[Netflix].pdf ↩︎

https://jeremykun.com/2016/04/18/singularvaluedecompositionpart1perspectivesonlinearalgebra/ ↩︎

Hu, Yifan & Koren, Yehuda & Volinsky, Chris. (2008). Collaborative Filtering for Implicit Feedback Datasets. Proceedings  IEEE International Conference on Data Mining, ICDM. 263272. 10.1109/ICDM.2008.22. ↩︎ ↩︎