4.49 out of 5
4.49
621 reviews on Udemy

Building Recommender Systems with Machine Learning and AI

Help people discover new products and content with deep learning, neural networks, and machine learning recommendations.
Instructor:
Sundog Education by Frank Kane
4,631 students enrolled
English
Understand and apply user-based and item-based collaborative filtering to recommend items to users
Create recommendations using deep learning at massive scale
Build recommender systems with neural networks and Restricted Boltzmann Machines (RBM's)
Make session-based recommendations with recurrent neural networks and Gated Recurrent Units (GRU)
Build a framework for testing and evaluating recommendation algorithms with Python
Apply the right measurements of a recommender system's success
Build recommender systems with matrix factorization methods such as SVD and SVD++
Apply real-world learnings from Netflix and YouTube to your own recommendation projects
Combine many recommendation algorithms together in hybrid and ensemble approaches
Use Apache Spark to compute recommendations at large scale on a cluster
Use K-Nearest-Neighbors to recommend items to users
Solve the "cold start" problem with content-based recommendations
Understand solutions to common issues with large-scale recommender systems

Learn how to build recommender 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 technologies.

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

  • 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

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!

Getting Started

1
Udemy 101: Getting the Most From This Course
2
[Activity] Install Anaconda, course materials, and create movie recommendations!

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!

3
Course Roadmap

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.

4
Types of Recommenders

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.

5
Understanding You through Implicit and Explicit Ratings

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.

6
Top-N Recommender Architecture

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.

7
[Quiz] Review the basics of recommender systems.

We'll review what we've covered in this section with a quick 4-question quiz, and discuss the answers.

Introduction to Python [Optional]

1
[Activity] The Basics of Python

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.

2
Data Structures in Python

We'll look at using lists, tuples, and dictionaries in Python.

3
Functions in Python

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.

4
[Exercise] Booleans, loops, and a hands-on challenge

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!

Evaluating Recommender Systems

1
Train/Test and Cross Validation

Learn about different testing methodologies for evaluating recommender systems offline, including train/test, K-Fold Cross Validation, and Leave-One-Out cross-validation.

2
Accuracy Metrics (RMSE, MAE)

Learn about Root Mean Squared Error, Mean Absolute Error, and why we use these measures of recommendation prediction accuracy.

3
Top-N Hit Rate - Many Ways

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.

4
Coverage, Diversity, and Novelty

Learn how to measure the coverage of your recommender system, how diverse its results are, and how novel its results are.

5
Churn, Responsiveness, and A/B Tests

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.

6
[Quiz] Review ways to measure your recommender.

In this short quiz, we'll review what we've learned about different ways to measure the qualities and accuracy of your recommender system.

7
[Activity] Walkthrough of RecommenderMetrics.py

Let's walk through this course's Python module for implementing the metrics we've discussed in this section on real recommender systems.

8
[Activity] Walkthrough of TestMetrics.py

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.

9
[Activity] Measure the Performance of SVD Recommendations

After running TestMetrics.py, we'll look at the results for our SVD recommender, and discuss how to interpret them.

A Recommender Engine Framework

1
Our Recommender Engine Architecture

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.

2
[Activity] Recommender Engine Walkthrough, Part 1

In part one of the code walkthrough of our recommender engine, we'll see how it's used, and dive into the Evaluator class.

3
[Activity] Recommender Engine Walkthrough, Part 2

In part two of the walkthrough, we'll dive into the EvaluationData class, and kick off a test with the SVD recommender.

4
[Activity] Review the Results of our Algorithm Evaluation.

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.

Content-Based Filtering

1
Content-Based Recommendations, and the Cosine Similarity Metric

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.

2
K-Nearest-Neighbors and Content Recs

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.

3
[Activity] Producing and Evaluating Content-Based Movie Recommendations

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.

4
[Activity] Bleeding Edge Alert! Mise en Scene Recommendations

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.

5
[Exercise] Dive Deeper into Content-Based Recommendations

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.

Neighborhood-Based Collaborative Filtering

1
Measuring Similarity, and Sparsity

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.

2
Similarity Metrics

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.

3
User-based Collaborative Filtering

We'll illustrate how user-based collaborative filtering works, where we recommend stuff that people similar to you liked.

4
[Activity] User-based Collaborative Filtering, Hands-On

Let's write some code to apply user-based collaborative filtering to the MovieLens data set, run it, and evaluate the results.

5
Item-based Collaborative Filtering

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.

6
[Activity] Item-based Collaborative Filtering, Hands-On

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.

7
[Exercise] Tuning Collaborative Filtering Algorithms

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.

8
[Activity] Evaluating Collaborative Filtering Systems Offline

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.

9
[Exercise] Measure the Hit Rate of Item-Based Collaborative Filtering

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.

10
KNN Recommenders

Learn how the ideas of neighborhood-based collaborative filtering can be applied into frameworks based on rating predictions, with K-Nearest-Neighbor recommenders.

11
[Activity] Running User and Item-Based KNN on MovieLens

Let's use SurpriseLib to quickly run user-based and item-based KNN on our MovieLens data, and evaluate the results.

12
[Exercise] Experiment with different KNN parameters.

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.

13
Bleeding Edge Alert! Translation-Based Recommendations

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.

Matrix Factorization Methods

1
Principal Component Analysis (PCA)

Let's learn how PCA allows us to reduce higher-dimensional data into lower dimensions, which is the first step toward understanding SVD.

2
Singular Value Decomposition

We'll extend PCA to the problem of making movie recommendations, and learn how SVD is just a specific implementation of PCA.

3
[Activity] Running SVD and SVD++ on MovieLens

Let's run SVD and SVD++ on our MovieLens movie ratings data set, and evaluate the results. They're really good!

4
Improving on SVD

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.

5
[Exercise] Tune the hyperparameters on SVD

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.

6
Bleeding Edge Alert! Sparse Linear Methods (SLIM)

We'll cover some exciting research from the University of Minnesota based on matrix factorization.

Introduction to Deep Learning [Optional]

1
Deep Learning Introduction

A quick introduction on what to expect from this section, and who can skip it.

2
Deep Learning Pre-Requisites

We'll cover the concepts of Gradient Descent, Reverse Mode AutoDiff, and Softmax, which you'll need to build deep neural networks.

3
History of Artificial Neural Networks

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.

4
[Activity] Playing with Tensorflow

We'll use the Tensorflow Playground to get a hands-on feel of how deep neural networks operate, and the effects of different topologies.

5
Training Neural Networks

We'll cover the mechanics of different activation functions and optimization functions for neural networks, including ReLU, Adam, RMSProp, and Gradient Descent.

6
Tuning Neural Networks

We'll talk about how to prevent overfitting using techniques such as dropout layers, and how to tune your topology for the best results.

7
Introduction to Tensorflow

We'll walk through an example of using Tensorflow's low-level API to distribute the processing of neural networks using Python.

8
[Activity] Handwriting Recognition with Tensorflow, part 1

In this hands-on activity, we'll implement handwriting recognition on real data using Tensorflow's low-level API. Part 1 of 3.

9
[Activity] Handwriting Recognition with Tensorflow, part 2

In this hands-on activity, we'll implement handwriting recognition on real data using Tensorflow's low-level API. Part 2 of 3.

10
[Activity] Handwriting Recognition with Tensorflow, Part 3

In this hands-on activity, we'll implement handwriting recognition on real data using Tensorflow's low-level API. Part 3 of 3.

11
Introduction to Keras

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.

12
[Activity] Handwriting Recognition with Keras

We'll tackle the same handwriting recognition problem as before, but this time using Keras with much simpler code, and better results.

13
Classifier Patterns with Keras

There are different patterns to use in Keras for multi-class or binary classification problems; we'll talk about how to tackle each.

14
[Exercise] Predict Political Parties of Politicians with Keras

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.

15
Intro to Convolutional Neural Networks (CNN's)

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.

16
CNN Architectures

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.

17
[Activity] Handwriting Recognition with Convolutional Neural Networks (CNNs)

We'll tackle handwriting recognition again, this time using Keras and CNN's for our best results yet. Can you improve upon them?

18
Intro to Recurrent Neural Networks (RNN's)

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.

19
Training Recurrent Neural Networks

Training RNN's involve back-propagating through time, which makes them extra-challenging to work with.

20
[Activity] Sentiment Analysis of Movie Reviews using RNN's and Keras

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.

Deep Learning for Recommender Systems

1
Intro to Deep Learning for Recommenders

We'll introduce the idea of using neural networks to produce recommendations, and explore whether this concept is overkill or not.

2
Restricted Boltzmann Machines (RBM's)

We'll cover a very simple neural network called the Restricted Boltzmann Machine, and show how it can be used to produce recommendations given sparse rating data.

3
[Activity] Recommendations with RBM's, part 1

We'll walk through our implementation of Restricted Boltzmann Machines integrated into our recommender framework. Part 1 of 2.

4
[Activity] Recommendations with RBM's, part 2

We'll walk through our implementation of Restricted Boltzmann Machines integrated into our recommender framework. Part 2 of 2.

5
[Activity] Evaluating the RBM Recommender

We'll run our RBM recommender, and study its results.

6
[Exercise] Tuning Restricted Boltzmann Machines

You're challenged to tune the RBM using GridSearchCV to see if you can improve its results.

7
Exercise Results: Tuning a RBM Recommender

We'll review my results from the previous exercise, so you can compare them against your own.

8
Auto-Encoders for Recommendations: Deep Learning for Recs

We'll learn how to apply modern deep neural networks to recommender systems, and the challenges sparse data creates.

9
[Activity] Recommendations with Deep Neural Networks

We'll walk through our code for producing recommendations with deep learning, and evaluate the results.

10
Clickstream Recommendations with RNN's

We'll introduce "GRU4Rec," a technique that applies recurrent neural networks to the problem of clickstream recommendations.

11
[Exercise] Get GRU4Rec Working on your Desktop

As a more challenging exercise that mimics what you might do in the real world, try and port some older research code into a modern Python and Tensorflow environment, and get it running.

12
Exercise Results: GRU4Rec in Action

We'll review my results from the previous exercise.

13
Bleeding Edge Alert! Deep Factorization Machines

We'll explore DeepFM, which combines the strengths of Factorization Machines and of Deep Neural Networks to produce a hybrid solution that out-performs either technique.

14
More Emerging Tech to Watch

We'll cover a few more "bleeding edge" topics, including Word2Vec, 3D CNN's for session-based recommendations, and feature extraction with CNN's.

Scaling it Up

1
[Activity] Introduction and Installation of Apache Spark

We'll introduce Apache Spark as our first means of "scaling it up," and get it installed on your system if you want to experiment with it.

2
Apache Spark Architecture

We'll explain just enough about how Spark works to let you understand how it distributes its work across a cluster, and the main objects our sample code will use: RDD's and DataFrames.

3
[Activity] Movie Recommendations with Spark, Matrix Factorization, and ALS

We'll start by using Spark's MLLib to generate recommendations with ALS for our ml-100k data set.

4
[Activity] Recommendations from 20 million ratings with Spark

We'll scale things up, and use all of the cores on our local PC to process 20 million ratings and produce top-N recommendations with Apache Spark.

5
Amazon DSSTNE

Amazon open-sourced its recommender engine called DSSTNE, which makes it easy to apply deep neural networks to massive, sparse data sets and produce great recommendations at large scale.

6
DSSTNE in Action

Watch as we use Amazon DSSTNE on an EC2 Ubuntu instance to produce movie recommendations using a deep neural network.

7
Scaling Up DSSTNE

Let's explore how Amazon scaled DSSTNE up, paired with Apache Spark, to process their massive data and produce recommendations for millions of customers.

8
AWS SageMaker and Factorization Machines

Amazon's SageMaker service offers some machine learning algorithms that can be used for recommendations, including factorization machines.

You can view and review the lecture materials indefinitely, like an on-demand channel.
Definitely! If you have an internet connection, courses on Udemy are available on any device at any time. If you don't have an internet connection, some instructors also let their students download course lectures. That's up to the instructor though, so make sure you get on their good side!
4.5
4.5 out of 5
621 Ratings

Detailed Rating

Stars 5
364
Stars 4
195
Stars 3
42
Stars 2
10
Stars 1
11
506f79164577135064e8d97ade09d1d9
30-Day Money-Back Guarantee

Includes

9 hours on-demand video
1 article
Full lifetime access
Access on mobile and TV
Certificate of Completion