Building Recommender Systems with Machine Learning and AI

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.

We'll look at using lists, tuples, and dictionaries 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.

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!

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

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.

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

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.

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

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

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

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.

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

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

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.

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.

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.

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.

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.

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.

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.

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

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.

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.

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.

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.

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.

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

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

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.

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.

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

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.

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.

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

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

We'll cover the concepts of Gradient Descent, Reverse Mode AutoDiff, and Softmax, which you'll need to build deep 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.

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

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

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

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

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

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

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.

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

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

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.

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.

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.

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

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.

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

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.

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

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

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

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

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

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

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

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

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

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.

We'll review my results from the previous exercise.

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.

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

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.

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.

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

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.

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

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

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

Watch as I use SageMaker from a cloud-hosted Notebook to pre-process the MovieLens 1-million-rating data set, train and save a Factorization Machine model, and deploy the model for making real-time predictions for movie recommendations.

A huge number of commercial SAAS offerings have emerged to offer easy-to-use recommender systems out of the box, and there are many open-source offerings that allow you to develop recommender systems at scale at as low a level as you want. We'll cover some of the more popular ones, and enumerate the rest.

The specifics of how you deploy a recommender system into production will depend on the environment you're working within, but we'll cover some high-level architectures to consider and some of the technologies you might employ.