In this paper we describe rrecsys, an open source extension package in R for rapid prototyping and intuitive assessment of recommender system algorithms. Due to its wide variety of implemented packages and functionalities, R language represents a popular choice for many tasks in Data Analysis. This package replicates the most popular collaborative filtering algorithms for rating and binary data and we compare results with the Java-based LensKit implementation for the purpose of benchmarking the implementation. Therefore this work can also be seen as a contribution in the context of replication of algorithm implementations and reproduction of evaluation results. Users can easily tune available implementations or develop their own algorithms and assess them according to the standard methodology for offline evaluation. Thus this package should represent an easily accessible environment for research and teaching purposes in the field of recommender systems.
R represents a popular choice in Data Analytics and Machine Learning. The software has low setup cost and contains a large selection of packages and functionalities to enhance and prototype algorithms with compact code and good visualization tools. Thus R represents a suitable environment for exploring the field of recommender systems. Therefore we present and contribute a novel R package that reproduces several of the most popular recommender algorithms for Likert scaled as well as binary rating values. The functionality of this framework is mainly focused on prototyping and educational purposes due to the compact code representation and the interactive way of invoking and visualizing results in R. We took advantage of the large selection of packages in R to implement the algorithms included in our package. We achieve competing performance due to highly vectorized and mixed R/C++ implementations.
We therefore introduce rrecsys [1,2] by presenting a general overview of the implemented algorithms and the evaluation methodology. A few code examples are included in an appendix. Furthermore, we proceed by comparing results of rrecsys with those of the Lenskit library. We also include evidence on runtime performance that document the efficient implementation of algorithms in R.
rrecsys has a modular structure as well as includes expansion capabilities. The core of the package includes the implementation of several popular algorithms, an evaluation component and a couple of auxiliary parts for data analysis and convergence detection. Next we concisely describe the included algorithms.
Baseline and Popularity: The included baseline predictors are the global mean rating (Global Average), item's mean rating (Item Average), user's mean ratings (User Average) as well as an unpersonalized Most Popular method that determines item popularity based on the total number of (positive) ratings.
Item Based K-nearest neighbors: Given a target user and her positively rated items, the algorithm will identify the k-most similar items for each target a and will rank them according to aggregated similarities with the different targets as described by Sarwar et al. [14]. For similarity measures we develop the cosine similarity and the adjusted cosine similarity.
Items a and b are considered as rating vectors a and b in the user space. Cosine similarity measures the cosine angle between those vectors:
The adjusted cosine similarity is computed by offsetting the user average on each co-rated pair on two item vectors. If I a and I b is the set of users that rated correspondingly item a and b the adjusted cosine similarity is measured as:
Where R u is the average rating of user u, computed as:
Where I u is the set of items rated by user u.
Once similarities among all items are computed a neighborhood might be formed by choosing the items with the highest similarity value. Prediction over a target user u and item a are calculated as the weighted sum [14].
User Based K-nearest neighbors: Herlocker et al. [7] proposed the algorithm that finds similarities among users instead among items. In our implementation we consider the cosine similarity and the Pearson correlation.
User u and v are considered as rating vectors u and v in the item space. Cosine similarity measures the cosine angle between those vectors using Formula 1
Instead the Pearson correlation is measured by offsetting the user average on co-rated pairs among the user vectors:
Where R u and R v are correspondingly the average ratings of user u and user v, computed like in Formula 3.
Once similarities among all items are computed a neighborhood might be formed by choosing the items with the highest similarity value. Prediction over a target user u and item a are calculated as the weighted sum [14]:
Weighted Slope One: proposed by Lemire et al [10] performs prediction for a missing rating rui for user u on item i as the following average:
The average deviation rating dev ij between co-rated items is defined by:
Where c ij is the number of co-rated items between items i and j and r ui is an existing rating for user u on item i. The Weighted Slope One takes into account both, information from users who rated the same item and the number of observed ratings. Simon Funk's SVD: Matrix factorization methods are used in recommender systems to derive a set of latent factors, from the user × item rating matrix, to characterize both users and items by this vector of factors. The useritem interaction are modeled as inner product of the latent factors space [4]. Accordingly each item i will be associated with a vector of factors V i , and each user u is associated with a vector of factors U u . An approximation of the rating of a user u on an item i can be derived as the inner product of their factor vectors:
Where µ is the overall average rating and b u and b i indicate the deviation due to user u and item i from the mean rating.
The U(user) and V(item) factor matrices are cropped to k features and initialized at small values. Each feature is trained until convergence (where convergence specifying the number of updates to be computed on a feature before considering it converged, it can be either chosen by the user or calculated automatically by the package). On each loop the algorithm predicts Rui , calculates the error and the factors are updated as follows:
The attribute λ represents the learning rate, while γ corresponds to the regularization term.
In addition, the following two algorithms address the One Class Collaborative Filtering problem (OCCF).
Bayesian Personalized Ranking: The algorithm has been introduced by [12]. It turns the OCCF into a ranking problem by implicitly assuming that users prefer items they have already interacted with another time. Instead of applying rating prediction techniques, BPR ranks candidate items for a user without calculating a "virtual" rating. The overall goal of the algorithm is to find a personalized total ranking > u ⊂ I 2 for any user u ∈ U sers and pairs of items (i, j) ∈ I 2 that meet the properties of a total order (totality, anti-symmetry, transitivity).
Weighted Alternated Least Squares: We compute a low-rank approximation matrix R = ( Rij ) m×n = U * V T , where U and V are the usual feature matrix cropped to k features as introduced by [11]. Weighted low-rank aims to determine R such that minimizes the Frobenius loss of the following objective function:
The regularization term weighted by λ is added to prevent over-fitting. The expression . F denotes the Frobenius norm. The alternated least square algorithms optimization process solves partial derivatives of L with respect to each entry U and V , ∂L(U,V ) ∂Ui = 0 with fixed V and ∂L(U,V ) ∂Vj = 0 with fixed U , to compute U i and V i . Then U and V are initialized with random Gaussian numbers with mean zero and small standard deviation and are updated until convergence. The matrix W = (W ij ) m×n ∈ R m×n + is a non-negative weight matrix that assigns confidence values to observations (hence the name weighted ALS).
The library is currently distributing two different methodologies for computing the top-N recommendation. The first is the Highest Predicted Ratings (HPR), which proposes a sorted list based on the highest computed rating values by an algorithm. The second method is the Most Frequent (MF), that determines the top-N list based on the most frequent items available in the neighborhood of an user or item. This methodology is known to produce better performance than HPR [9,15].
The evaluation module is based on the k-fold cross-validation method. A stratified random selection procedure is applied when dividing the rated items of each user into k folds such that each user is uniformly represented in each fold, i.e. the number of ratings of each user in any fold differs at most by one. For k-fold cross validation each of the k disjunct fractions of the ratings are used k − 1 times for training (i.e. ⊂ R train ) and once for testing (i.e. ⊂ R test ). Practically, ratings in R test are set as missing in the original dataset and predictions/recommendations are compared to R test to compute the performance measures.
We included the most popular performance metrics according to the survey in [8]. These are mean absolute error(MAE), root mean squared error(RMSE), Precision, Recall, F1, True and False Positives, True and False Negatives, normalized discounted cumulative gain (NDCG), rank score, area under the ROC curve (AUC) and catalog coverage [5].
In this Section, we compare our rrecsys library with the popular Lenskit [3] Java library.
In Figure 1, we compare both libraries in terms of RMSE and MAE, using 5-fold cross validation. Lenskit and rrecsys were configured both with the same algorithms and evaluation methodology. We used the MovieLens100K dataset [6] for these experiments as the purpose is not only the results per se, but to demonstrate the reproducibility of the results derived from LensKit.
For the experiments in Figure 1 on the FunkSVD, we have tuned its parameters as follows, the latent space is set to 100 features, the learning rate is set to 0.001, the regularization term is set to 0.015. In the case of the item based k-nearest neighbor algorithm, we have set the number of nearest neighbors to 100, and adjusted cosine similarity is the similarity measure. In the case of the user-based k-nearest neighbor algorithm, we have set the number of nearest neighbors to 100, and used Pearson as similarity measure.
As shown in Figure 1, all the reported results demonstrate our ability to clearly reproduce and replicate the same results with those of Lenskit in terms of both RMSE and MAE while other libraries failed to do so [13]. The insignificant differences with LensKit are the result of a random distribution of items in the k-folds. Since BPR and wALS are not implemented in LensKit it is impossible for us to compare results.
In Table 1 we show the performance of rrecsys based on the latest implementations with R/C++ code on the MovieLens100K dataset running on the same machine. It is noticeable that rrecsys performs similarly to LensKit. We compared only optimized algorithms. In future we will provide optimized implementation of more state of the art algorithms.
In this Section, we introduce an executable script in R for running some of the functionalities of rrecsys in order to demonstrate its intuitive use. Please notice that due to space limitations in this paper we do not describe all commands in detail. The library is distributed with a full range of vignettes and a manual describing all available functionalities1 . The package is loaded on the Comprehensive R Archive Network (CRAN), therefore download, installation and loading of the package requires the execution of the following two functions: install.packages("rrecsys"); library(rrecsys)
Once the package is loaded the dataset MovieLens Latest 2 will be available within the environment. A setup of the data is required to define possible limits and the structure of the dataset. Users can explore the dataset by checking the number of ratings, its sparsity or even by modifying it to contain a specific number of ratings for each item\user. The following code shows how to train a model (e.g., ub10) on an algorithm (e.g., UBKNN), which can be used for either rating prediction (e.g., p) or item recommendation (e.g., rHPR and rMF). ub10 <-rrecsys(smallmlLatest, "UBKNN", neigh = 10, simFunct = 1) p <-predict(ub10) rHPR <-recommendHPR(ub10, topN = 10) #pt is the positive threshold for recommending an item. rMF <-recommendMF(ub10, topN = 10, pt = 3)
The following code shows how we generate the k-folds. Same fold distribution can be used to evaluate different algorithms.
folds <-evalModel(smallmlLatest, folds = 2) #Recommendation evaluation. evalRec(folds, "UBKNN", topN = 10, goodRating = 3, simFunct = 2, recAlg = 1)
The output of the evaluation function looks like as follows:
This paper contributed a recently released package for prototyping and interactively demonstrating recommendation algorithms in R. It comes with a nice range of implemented standard algorithms for Likert scaled and binary ratings. Reported results demonstrate that it reproduces results of the Java-based Lenskit toolkit. Thus it remains to hope that this effort will be of use for the field of recommender systems and the large R user community.