1 billion dollars per year. That’s how much Netflix’s Chief Product Officer Neil Hunt estimates the company saves per year thanks to their global recommendation system. No wonder you’ve found yourself searching for how to build a recommendation engine in R! They’re valuable commodities!
From tech giants like Netflix to Amazon to YouTube, enterprises all over the world are recognizing the importance of recommendation engines in order to keep their customer base engaged and their conversions high. And they’re looking for data professionals like you to build them.
Here at Data Mania, we help give data pros a leg up by helping them make (and save) money for the corporations they serve, so they can advance their data career and get the promotion and raise they deserve. We were tired of seeing so many data scientists launch initiatives that flop, and having their superiors fail to see the ROI their projects could bring in.
While you may be a pro at learning all the different algorithms and technologies, finding a clear, consistent way to combine them to increase business profits is where the magic happens (and where most people struggle!). That’s why my team and I embarked on a 6-month AI research crusade to study the most successful, reproducible data projects across the market.
The end product of that expedition? A collection of winning data-strategy case collections to kick off your next profitable data project. Get it inside here ⬇️.
Let’s get started today with helping you build a recommendation engine in R that’s sure to help your company’s customer retention and profitability. First I’m going to provide you a conceptual overview of the topic, and then I’ll show you the exact steps on how to build a recommendation engine in R.
Make sure to stick around to the end for another show-stopper of a recommendation on how to get ahead FAST in your data science career.
Ready? Let’s get started.
KEY CONCEPTS RELATED TO RECOMMENDATION SYSTEMS
Before showing you how to build a recommendation engine in R, let’s get you up-to-speed on the concepts behind how recommendation engines work.
What’s a recommendation engine?
[disclaim]If you’re a developer who’s here just to see how the code works… I understand! CLICK HERE TO SKIP THE INTRO and go straight to where I show you the code for how to build a recommendation engine in R.[/disclaim]
The go-to case study: NetFlix movie recommendationsThe go-to case study for recommendation engines is the NetFlix recommender that I mentioned above. In fact, Netflix runs many layers of recommendations, each operating according to its own unique set of instructions. But it wasn’t until 2009 that Netflix really broke ground with its recommendations, back when it hosted an open competition on Kaggle. In the competition, participants were asked to predict user ratings for new films by using previous user rating data for films they’d already seen. If the predictions made by the engine had a high degree of accuracy, Netflix would select the team’s engine to make recommendations to its users. In the end, a team developed a recommendation algorithm that performed 10% better than NetFlix’s existing algorithm, bagging them a $1 mil in cash (not bad, right?! 💥)….just to give you a general idea of how much these algorithms are worth to Netflix.
First things first: understanding collaborative filteringRecommendation engines use collaborative filtering. Like the name suggests, collaborative filtering uses data from other people (or “users” on the platform) to make its prediction. Collaborative filtering can work a few different ways. One possible way to use a collaborative filtering algorithm could be to ‘filter’ similar purchases users made in the past to generate and then recommend a list of items that go well together in combination. In this example, items that are not frequently purchased together would be excluded from the list, and the engine would make recommendations from a final set of items that have a history of being purchased together.
2 Types of Collaborative Filtering Algorithms – User-based collaborative filtering and Item-Based Collaborative Filtering.I’ll define these in terms of movie recommendation systems, using Netflix again as our trusty example.
A Screen Grab From My LinkedIn Learning Course:
Building a Recommendation System with Python
- User-based collaborative filtering systems: A user-based recommendation engine recommends movies based on what other users with similar profiles have watched and liked in the past. As an example of a user-based recommender, imagine there’s a big movie buff who loves watching movies regularly, usually every Friday evening. He’s an unmarried man and a working professional. A user-based recommender would go in and look up movie recommendations based on what other unmarried, professionnel men who watch movies regularly have liked.
- Item-based collaborative filtering systems: An item-based recommender would make recommendations based on similarities between movies; in other words, it would recommend movies that are similar to ones a user already likes. Say you watched the movie ‘Kung Fu Panda’ and you liked it so much you gave it five stars. A item-based collaborative filtering system would then look into similar movies from the same genre (perhaps animated, fighting, comedy or films with a similar storyline) and then recommend similar movies based on the preference you displayed when giving ‘Kung Fu Panda’ five stars.
In fact, item-based collaborative filtering systems can even make recommendations based on any variety of common elements, like movies about pandas, movies from the same producers, directors, etc…the possibilities are truly endless! In the case of Kung Fu Panda, it’s most likely that ‘Kung Fu Panda 2’ and ‘Kung Fu Panda 3’ will be suggested to the user, followed by other cases.
If only life were that simple
Now that you understand the basics about collaborative filtering algorithms, let’s go ahead and add a little complexity to the discussion. Don’t worry, I’m going to be showing you how to build a recommendation engine in R very soon!
If you really think about it, a user should have to do more than simply watch a movie in order for the film to qualify as being recommendable to other users. After all, the user may have seen the movie and absolutely hated it! If that were the case, recommending the movie to similar users could be a potentially terrible idea.
Instead of just looking at how many times a movie was viewed, we’ve actually got to take into account the rating each user gave the movie (aka; “movie ratings data”). By doing this, we can see what movies similar users have enjoyed and use that data to filter our movie recommendations accordingly. Now, the recommendation will only include the movies which are rated highly by other similar users.
Real-life recommenders that are in-production on ecommerce platforms are usually quite complex. They almost always hybridize the two collaborative techniques we’ve discussed above. These recommendation engines may, for example, suggest a movie based on what other users with similar profiles have enjoyed, and then further order the recommendations based on how similar those movies are to the movie you last watched. My point here is that all recommendation engines all have their own utility in different situations, so decisions about the best logic to use requires data scientists and machine learning engineers alike to use solid reasoning and sound strategy alike when planning initiatives.
The reality is, good implementation and coding skills alone simply isn’t enough to win with data these days. With 85% of data initiatives failing (according to Gartner) it’s time to step up your game and become a data leader to make sure your projects aren’t among those. How? Using data strategy! As a data educator who’s trained over 1 Million workers on data science (through prestigious partnerships with LinkedIn Learning and Wiley & Sons Publishers), I’m ready to tell you what you need to know to reach that next rung up the data career ladder. Get started learning need-to-know data strategy skills here.
Where machine learning fits in
Both recommendation methods we discussed above (user-based collaborative filtering systems and Item-based collaborative filtering systems) can use clustering as the backbone, although there are other machine learning algorithms that may be better suited for the job depending on your project requirements.
Clustering algorithms allow you to group users and items based on similarity, so these are an easy fit when building a recommendation engine. Another way to make recommendations might be to focus on what’s dissimilar between users and/or items. Needless to say, the machine learning algorithms you choose largely depend on the specifics of your unique project.
Don’t forget about the content-based recommenders
Wait! There’s one more type of recommendation system we haven’t gotten around to yet – content-based recommendation systems. Content-based recommenders are an alternative approach you can use when you don’t have a ton of data available. The speed of content-based recommenders, however, largely correlates with the dataset’s size, making them unfit for large datasets.
One advantage to content-based recommenders? You can use them to start recommending newer items that still don’t have user ratings (fixing what’s known as the “cold start” problem). This is helpful for getting new products out in front of your user base, so they can quickly begin to gain traction.
That being said, collaborative filtering systems still have a lot of advantages over content-based recommenders. These advantages include:
- They can handle huge, high-dimensional datasets.
- They can suggest niche items (items popular among only a specific segment of users).
- They can suggest items which may be from a completely different product category altogether.
- Based on the type of data you have, a collaborative filtering system can suggest items purchased by similar users, solely depending upon their ratings for these items.
By now, you should have a good grasp on recommendation engine concepts. It’s the time you’ve all been waiting for – I’m now going to show you how to build a recommendation engine in R!
The coding demonstrationIn the following demo, we’ll use the famous movielens dataset that’s been made available by grouplens research. The dataset consists of 20,000,000 distinct user ratings on about 27,000 movies, and rated by 138,000 users. The data can be downloaded from the website here: https://grouplens.org/datasets/movielens/. This dataset is fairly large, about 190 mb. Luckily, the website also hosts miniature versions of the movie lens data with sizes varying from 100,000 ratings, 1 million ratings and 10 million ratings. Let’s keep it simple by using the 100,000 ratings data, which is only 1 MB. With the download, you get a zipped file containing a readme and movies data, with separate links, tags and ratings files. Here is the link to the dataset used in the demo: http://files.grouplens.org/datasets/movielens/ml-latest-small.zip So, how to build a recommendation engine in R… starting with the reading step in R, let’s read-in all our datasets and build a ratings matrix:
##Demo: How to build a recommendation engine in R ## setwd("C:/Users/User/Desktop/Data-Mania Blog Coding Demos/Recommendation Engine in R") #Read all the datasets movies=read.csv("movies.csv") links=read.csv("links.csv") ratings=read.csv("ratings.csv") tags=read.csv("tags.csv") #Import the reshape2 library. Use the file install.packages(“reshape2”) if the package is not already installed install.packages("reshape2", dependencies=TRUE) install.packages("stringi", dependencies=TRUE) library(stringi) library(reshape2) #Create ratings matrix with rows as users and columns as movies. We don't need timestamp ratingmat = dcast(ratings, userId~movieId, value.var = "rating", na.rm=FALSE) #We can now remove user ids ratingmat = as.matrix(ratingmat[,-1])The recommendation package in R we’ll use is recommenderlab. It provides us a User Based Collaborative Filtering (UBCF) model. For similarity among user ratings, we have a choice to calculate similarity according to the following methods:
- Jaccard similarity
- Cosine similarity
- Pearson similarity
#Uncomment the following line if the package is not installed #install.packages("recommenderlab", dependencies=TRUE) library(recommenderlab)First, we want to reduce the size of our ratings matrix to make computation faster. In my machine, the ratingmat takes up about 46.9 Mbs. This size is due to the large number of zero’s in the matrix (in other words, it’s a “sparse matrix”). Let’s transform into a dense matrix by removing the zero’s.
#Convert ratings matrix to real rating matrx which makes it dense ratingmat = as(ratingmat, "realRatingMatrix")This step immediately reduced the size of the matrix to 1.7 Mbs, in my machine, which is much, much smaller. Now let’s normalize the matrix so that our our recommendations come out unbiased.
#Normalize the ratings matrix ratingmat = normalize(ratingmat)The Recommender() function in the recommenderlab package is the underlying recommendation model we’re using here. [warning]You may want to use the help function for this recommender to learn more about it. To do this, just enter the ‘?Recommender’ command in R.[/warning]
#Create Recommender Model. The parameters are UBCF and Cosine similarity. We take 10 nearest neighbours rec_mod = Recommender(ratingmat, method = "UBCF", param=list(method="Cosine",nn=10))Now that we’ve built our model, let’s make some predictions. Starting with the first user:
#Obtain top 5 recommendations for 1st user entry in dataset Top_5_pred = predict(rec_mod, ratingmat, n=5)At this point, we’ve created recommendations for the first user, but we can’t see them. That’s annoying. To see the predictions our model made, we’ll convert them to a list and print them out:
#Convert the recommendations to a list Top_5_List = as(Top_5_pred, "list") Top_5_List "47" "893" "1769" "2567" "3423"As you can see, we get movie recommendations… but alas, they’re in movieId number format. Let’s take a look at the movie names that correspond to these number. We’ll do this by using the movies dataset. It maps movie id to movie titles.
#Uncomment the following line if the package is not installed #install.packages("dplyr") library(dplyr) #We convert the list to a dataframe and change the column name to movieId Top_5_df=data.frame(Top_5_List) colnames(Top_5_df)="movieId" #Since movieId is of type integer in Movies data, we typecast id in our recommendations as well Top_5_df$movieId=as.numeric(levels(Top_5_df$movieId)) #Merge the movie ids with names to get titles and genres names=left_join(Top_5_df, movies, by="movieId") #Print the titles and genres names movieId title genres 1 1769 Replacement Killers, The (1998) Action|Crime|Thriller 2 2567 EDtv (1999) Comedy 3 3423 School Daze (1988) Drama 4 47 Seven (a.k.a. Se7en) (1995) Mystery|Thriller 5 893 Mother Night (1996) DramaBased on similarity between users, for the first user, our model initially recommends the above movies. In our results, you can see:
- The year that the movie was released.
- The movie genres.
This is just the tip of the proverbial iceberg…Netflix uses more than 27,000 genres to classify its movies. It suggests movies based on user similarities and on movie classifications. Tons of other features (like year, age, and user demographic) are used when making recommendations, so this tutorial really was just the tip of the iceberg when it comes to building functional recommendation systems. Take your knowledge deeper with my LinkedIn Learning course on building recommendation systems. Or maybe you’re ready to go BEYOND learning new languages and implementation techniques. While it’s normal to think learning new data implementation skills is what will help you advance your career and get promoted, it’ll actually just keep you at your current level doing more of the same. If you’re ready to skyrocket your data career and earn more recognition, responsibility and a heftier salary, it’s time you transition from data science to data strategy. Take my client’s word for it 👇🏻👇🏻
Winning With Data: Case Collection was created for the DATA PROFESSIONAL who wants to up-level their career & their company’s results with effective data strategy. Get the exact use cases you need to start planning your company’s next profitable data project 👇🏻