Building Recommender Systems with Machine Learning and AI
- Descripción
- Currículum
- Reseñas
Updated with Tensorflow Recommenders (TFRS) and Generative Adversarial Networks for recommendations (GANs)
Learn how to build machine learning recommendation systems from one of Amazon’s pioneers in the field. Frank Kane spent over nine years at Amazon, where he managed and led the development of many of Amazon’s personalized product recommendation systems.
You’ve seen automated recommendations everywhere – on Netflix’s home page, on YouTube, and on Amazon as these machine learning algorithms learn about your unique interests, and show the best products or content for you as an individual. These technologies have become central to the largest, most prestigious tech employers out there, and by understanding how they work, you’ll become very valuable to them.
We’ll cover tried and true recommendation algorithms based on neighborhood-based collaborative filtering, and work our way up to more modern techniques including matrix factorization and even deep learning with artificial neural networks. Along the way, you’ll learn from Frank’s extensive industry experience to understand the real-world challenges you’ll encounter when applying these algorithms at large scale and with real-world data.
Recommender systems are complex; don’t enroll in this course expecting a learn-to-code type of format. There’s no recipe to follow on how to make a recommender system; you need to understand the different algorithms and how to choose when to apply each one for a given situation. We assume you already know how to code.
However, this course is very hands-on; you’ll develop your own framework for evaluating and combining many different recommendation algorithms together, and you’ll even build your own neural networks using Tensorflow to generate recommendations from real-world movie ratings from real people. We’ll cover:
-
Building a recommendation engine
-
Evaluating recommender systems
-
Content-based filtering using item attributes
-
Neighborhood-based collaborative filtering with user-based, item-based, and KNN CF
-
Model-based methods including matrix factorization and SVD
-
Applying deep learning, AI, and artificial neural networks to recommendations
-
Using the latest frameworks from Tensorflow (TFRS) and Amazon Personalize.
-
Session-based recommendations with recursive neural networks
-
Scaling to massive data sets with Apache Spark machine learning, Amazon DSSTNE deep learning, and AWS SageMaker with factorization machines
-
Real-world challenges and solutions with recommender systems
-
Case studies from YouTube and Netflix
-
Building hybrid, ensemble recommenders
-
“Bleeding edge alerts” covering the latest research in the field of recommender systems
This comprehensive course takes you all the way from the early days of collaborative filtering, to bleeding-edge applications of deep neural networks and modern machine learning techniques for recommending the best items to every individual user.
The coding exercises in this course use the Python programming language. We include an intro to Python if you’re new to it, but you’ll need some prior programming experience in order to use this course successfully. We also include a short introduction to deep learning if you are new to the field of artificial intelligence, but you’ll need to be able to understand new computer algorithms.
High-quality, hand-edited English closed captions are included to help you follow along.
I hope to see you in the course soon!

-
1Udemy 101: Getting the Most From This CourseVideo lesson
-
2Important noteText lesson
-
3Note: Alternate dataset download locationText lesson
-
4[Activity] Install Anaconda, course materials, and create movie recommendations!Video lesson
After a brief introduction to the course, we'll dive right in and install what you need: Anaconda (your Python development environment,) the course materials, and the MovieLens data set of 100,00 real movie ratings from real people. We'll then run a quick example to generate movie recommendations using the SVD algorithm, to make sure it all works!
-
5Course RoadmapVideo lesson
We'll just lay out the structure of the course so you know what to expect later on (and when you'll start writing some code of your own!) Also, we'll provide advice on how to navigate this course depending on your prior experience.
-
6What Is a Recommender System?Video lesson
The phrase "recommender system" is a more general-sounding term than it really is. Let's briefly clarify what a recommender system is - and more importantly, what it is not.
-
7Types of RecommendersVideo lesson
There are many different flavors of recommender systems, and you encounter them every day. Let's review some of the applications of recommender systems in the real world.
-
8Understanding You through Implicit and Explicit RatingsVideo lesson
How do recommender systems learn about your individual tastes and preferences? We'll explain how both explicit ratings and implicit ratings work, and the strengths and weaknesses of both.
-
9Top-N Recommender ArchitectureVideo lesson
Most real-world recommender systems are "Top-N" systems, that produce a list of top results to individuals. There are a couple of main architectural approaches to building them, which we'll review here.
-
10[Quiz] Review the basics of recommender systems.Video lesson
We'll review what we've covered in this section with a quick 4-question quiz, and discuss the answers.
-
11[Activity] The Basics of PythonVideo lesson
After installing Jupyter Notebook, we'll cover the basics of what's different about Python, including its use of white-space. We'll dissect a simple function to get a feel of what Python code looks like.
-
12Data Structures in PythonVideo lesson
We'll look at using lists, tuples, and dictionaries in Python.
-
13Functions in PythonVideo lesson
We'll see how to define a function in Python, and how Python lets you pass functions to other functions. We'll also look at a simple example of a Lambda function.
-
14[Exercise] Booleans, loops, and a hands-on challengeVideo lesson
We'll look at how Boolean expressions work in Python as well as loops. Then, we'll give you a challenge to write a simple Python function on your own!
-
15Train/Test and Cross ValidationVideo lesson
Learn about different testing methodologies for evaluating recommender systems offline, including train/test, K-Fold Cross Validation, and Leave-One-Out cross-validation.
-
16Accuracy Metrics (RMSE, MAE)Video lesson
Learn about Root Mean Squared Error, Mean Absolute Error, and why we use these measures of recommendation prediction accuracy.
-
17Top-N Hit Rate - Many WaysVideo lesson
Learn about several ways to measure the accuracy of top-N recommenders, including hit rate, cumulative hit rate, average reciprocal hit rank, rating hit rate, and more.
-
18Coverage, Diversity, and NoveltyVideo lesson
Learn how to measure the coverage of your recommender system, how diverse its results are, and how novel its results are.
-
19Churn, Responsiveness, and A/B TestsVideo lesson
Measure how often your recommendations change (churn,) how quickly they respond to new data (responsiveness,) and why no metric matters more than the results of real, online A/B tests. We'll also talk about perceived quality, where you explicitly ask your users to rate your recommendations.
-
20[Quiz] Review ways to measure your recommender.Video lesson
In this short quiz, we'll review what we've learned about different ways to measure the qualities and accuracy of your recommender system.
-
21[Activity] Walkthrough of RecommenderMetrics.pyVideo lesson
Let's walk through this course's Python module for implementing the metrics we've discussed in this section on real recommender systems.
-
22[Activity] Walkthrough of TestMetrics.pyVideo lesson
We'll walk through our sample code to apply our RecommenderMetrics module to a real SVD recommender using real MovieLens rating data, and measure its performance in many different ways.
-
23[Activity] Measure the Performance of SVD RecommendationsVideo lesson
After running TestMetrics.py, we'll look at the results for our SVD recommender, and discuss how to interpret them.
-
24Our Recommender Engine ArchitectureVideo lesson
Let's review the architecture of our recommender engine framework, which will let us easy implement, test, and compare different algorithms throughout the rest of this course.
-
25[Activity] Recommender Engine Walkthrough, Part 1Video lesson
In part one of the code walkthrough of our recommender engine, we'll see how it's used, and dive into the Evaluator class.
-
26[Activity] Recommender Engine Walkthrough, Part 2Video lesson
In part two of the walkthrough, we'll dive into the EvaluationData class, and kick off a test with the SVD recommender.
-
27[Activity] Review the Results of our Algorithm Evaluation.Video lesson
Wrapping up our review of our recommender system architecture, we'll look at the results of using our framework to evaluate the SVD algorithm, and interpret them.
-
28Content-Based Recommendations, and the Cosine Similarity MetricVideo lesson
We'll talk about how content-based recommendations work, and introduce the cosine similarity metric. Cosine scores will be used throughout the course, and understanding their mathematical basis is important.
-
29K-Nearest-Neighbors and Content RecsVideo lesson
We'll cover how to factor time into our content-based recs, and how the concept of KNN will allow us to make rating predictions just based on similarity scores based on genres and release dates.
-
30[Activity] Producing and Evaluating Content-Based Movie RecommendationsVideo lesson
We'll look at some code for producing movie recommendations based on their genres and years, and evaluate the results using the MovieLens data set.
-
31A Note on Using Implicit Ratings.Video lesson
A common point of confusion is how to use implicit ratings, such as purchase or click data, with the algorithms we're talking about. It's pretty simple, but let's cover it here.
-
32[Activity] Bleeding Edge Alert! Mise en Scene RecommendationsVideo lesson
In our first "bleeding edge alert," we'll examine the use of Mise en Scene data for providing additional content-based information to our recommendations. And, we'll turn the idea into code, and evaluate the results.
-
33[Exercise] Dive Deeper into Content-Based RecommendationsVideo lesson
In two different hands-on exercises, dive into which content attributes provide the best recommendations - and try augmenting our content-based recommendations using popularity data.
-
34Measuring Similarity, and SparsityVideo lesson
Similarity between users or items is at the heart of all neighborhood-based approaches; we'll discuss how similarity measures fit into our architecture, and the effect data sparsity has on it.
-
35Similarity MetricsVideo lesson
We'll cover different ways of measuring similarity, including cosine, adjusted cosine, Pearson, Spearman, Jaccard, and more - and how to know when to use each one.
-
36User-based Collaborative FilteringVideo lesson
We'll illustrate how user-based collaborative filtering works, where we recommend stuff that people similar to you liked.
-
37[Activity] User-based Collaborative Filtering, Hands-OnVideo lesson
Let's write some code to apply user-based collaborative filtering to the MovieLens data set, run it, and evaluate the results.
-
38Item-based Collaborative FilteringVideo lesson
We'll talk about the advantages of flipping user-based collaborative filtering on its head, to give us item-based collaborative filtering - and how it works.
-
39[Activity] Item-based Collaborative Filtering, Hands-OnVideo lesson
Let's write, run, and evaluate some code to apply item-based collaborative filtering to generate recommendations from the MovieLens data set, and compare it to user-based CF.
-
40[Exercise] Tuning Collaborative Filtering AlgorithmsVideo lesson
In this exercise, you're challenged to improve upon the user-based and item-based collaborative filtering algorithms we presented, by tweaking the way candidate generation works.
-
41[Activity] Evaluating Collaborative Filtering Systems OfflineVideo lesson
Since collaborative filtering does not make rating predictions, evaluating it offline is challenging - but we can test it with hit rate metrics, and leave-one-out cross validation. Which we'll do, in this activity.
-
42[Exercise] Measure the Hit Rate of Item-Based Collaborative FilteringVideo lesson
In the previous activity, we measured the hit rate of a user-based collaborative filtering system. Your challenge is to do the same for an item-based system.
-
43KNN RecommendersVideo lesson
Learn how the ideas of neighborhood-based collaborative filtering can be applied into frameworks based on rating predictions, with K-Nearest-Neighbor recommenders.
-
44[Activity] Running User and Item-Based KNN on MovieLensVideo lesson
Let's use SurpriseLib to quickly run user-based and item-based KNN on our MovieLens data, and evaluate the results.
-
45[Exercise] Experiment with different KNN parameters.Video lesson
Try different similarity measures to see if you can improve on the results of KNN - and we'll talk about why this is so challenging.
-
46Bleeding Edge Alert! Translation-Based RecommendationsVideo lesson
In our next "bleeding edge alert," we'll discuss Translation-Based Recommendations - an idea unveiled in the 2017 RecSys conference for recommending sequences of events, based on vectors in item similarity space.
-
47Principal Component Analysis (PCA)Video lesson
Let's learn how PCA allows us to reduce higher-dimensional data into lower dimensions, which is the first step toward understanding SVD.
-
48Singular Value DecompositionVideo lesson
We'll extend PCA to the problem of making movie recommendations, and learn how SVD is just a specific implementation of PCA.
-
49[Activity] Running SVD and SVD++ on MovieLensVideo lesson
Let's run SVD and SVD++ on our MovieLens movie ratings data set, and evaluate the results. They're really good!
-
50Improving on SVDVideo lesson
We'll talk about some variants and extensions to SVD that have emerged, and the importance of hyperparameter tuning on SVD, as well as how to tune parameters in SurpriseLib using the GridSearchCV class.
-
51[Exercise] Tune the hyperparameters on SVDVideo lesson
Have a go at modifying our SVD bake-off code to find the optimal values of the various hyperparameters for SVD, and see if it makes a difference in the results.
-
52Bleeding Edge Alert! Sparse Linear Methods (SLIM)Video lesson
We'll cover some exciting research from the University of Minnesota based on matrix factorization.
-
53Deep Learning IntroductionVideo lesson
A quick introduction on what to expect from this section, and who can skip it.
-
54Deep Learning Pre-RequisitesVideo lesson
We'll cover the concepts of Gradient Descent, Reverse Mode AutoDiff, and Softmax, which you'll need to build deep neural networks.
-
55History of Artificial Neural NetworksVideo lesson
We'll cover the evolution of neural networks from their origin in the 1940's, all the way up to the architecture of modern deep neural networks.
-
56[Activity] Playing with TensorflowVideo lesson
We'll use the Tensorflow Playground to get a hands-on feel of how deep neural networks operate, and the effects of different topologies.
-
57Training Neural NetworksVideo lesson
We'll cover the mechanics of different activation functions and optimization functions for neural networks, including ReLU, Adam, RMSProp, and Gradient Descent.
-
58Tuning Neural NetworksVideo lesson
We'll talk about how to prevent overfitting using techniques such as dropout layers, and how to tune your topology for the best results.
-
59Activation Functions: More DepthVideo lesson
-
60Introduction to TensorflowVideo lesson
We'll walk through an example of using Tensorflow's low-level API to distribute the processing of neural networks using Python.
-
61Important Tensorflow setup note!Text lesson
-
62[Activity] Handwriting Recognition with Tensorflow, part 1Video lesson
In this hands-on activity, we'll implement handwriting recognition on real data using Tensorflow's low-level API. Part 1 of 3.
-
63[Activity] Handwriting Recognition with Tensorflow, part 2Video lesson
In this hands-on activity, we'll implement handwriting recognition on real data using Tensorflow's low-level API. Part 2 of 3.
-
64Introduction to KerasVideo lesson
Keras is a higher-level API that makes developing deep neural networks with Tensorflow a lot easier. We'll explain how it works and how to use it.
-
65[Activity] Handwriting Recognition with KerasVideo lesson
We'll tackle the same handwriting recognition problem as before, but this time using Keras with much simpler code, and better results.
-
66Classifier Patterns with KerasVideo lesson
There are different patterns to use in Keras for multi-class or binary classification problems; we'll talk about how to tackle each.
-
67[Exercise] Predict Political Parties of Politicians with KerasVideo lesson
As an exercise challenge, develop your own neural network using Keras to predict the political parties of politicians, based just on their votes on 16 different issues.
-
68Intro to Convolutional Neural Networks (CNN's)Video lesson
We'll talk about how your brain's visual cortex recognizes images seen by your eyes, and how the same approach inspires artificial convolutional neural networks.
-
69CNN ArchitecturesVideo lesson
The topology of CNN's can get complicated, and there are several variations of them you can choose from for certain problems, including LeNet, GoogLeNet, and ResNet.
-
70[Activity] Handwriting Recognition with Convolutional Neural Networks (CNNs)Video lesson
We'll tackle handwriting recognition again, this time using Keras and CNN's for our best results yet. Can you improve upon them?
-
71Intro to Recurrent Neural Networks (RNN's)Video lesson
Recurrent Neural Networks are appropriate for sequences of information, such as time series data, natural language, or music. We'll dive into how they work and some variations of them.
-
72Training Recurrent Neural NetworksVideo lesson
Training RNN's involve back-propagating through time, which makes them extra-challenging to work with.
-
73[Activity] Sentiment Analysis of Movie Reviews using RNN's and KerasVideo lesson
We'll wrap up our intro to deep learning by applying RNN's to the problem of sentiment analysis, which can be modeled as a sequence-to-vector learning problem.
-
74Tuning Neural NetworksVideo lesson
-
75Neural Network Regularization TechniquesVideo lesson
-
76Generative Adversarial Networks (GAN's)Video lesson
-
77GAN's in ActionVideo lesson
-
78[Activity] Generating images of clothing with Generative Adversarial NetworksVideo lesson
