Hello, and welcome!
In this video, we will show you how to build a collaborative filtering based recommendation
system using a Restricted Boltzmann Machine, and the TensorFlow library.
To recommend items, this system will find users that are similar to each other based
on their item ratings.
Let's download the datasets that we'll use for our application, and extract the contents
into an accessible directory.
The datasets were acquired by GroupLens, and they contain movies, users, and movie ratings
by these users.
Next we'll import the necessary libraries.
TensorFlow and Numpy will be used for the RBM model, and Pandas will allow us to easily
manipulate our datasets.
Now we'll load the data into our program.
The .dat files containing our data are similar to CSV files, but instead of using the comma
character to separate entries, it uses two colon characters instead.
To accommodate this, we can simply call the "read csv"
function with an additional sep="::".
Our datasets don't have any headers so we'll also add in the parameter "header=None".
We just imported and displayed the movie dataset, so let's do the same for the ratings.
Our "movies_df"
variable contains a dataframe that stores a movie's unique ID number, title, and genres.
Our "ratings_df"
variable stores a unique User ID number, an ID for movies that the user has watched, and
the user's rating for the movie.
Let's now rename the columns in these dataframes to something more intuitive.
Here are our final datasets.
Now let?s take a look at our RBM model.
A Restricted Boltzmann Machine has two layers of neurons: the visible input layer, and the
hidden layer.
The hidden layer is used to learn features from the information fed through the input
layer.
For our model, the input is going to contain "X"
neurons, where "X" is the number of movies in our dataset.
Each of these neurons will possess a normalized rating value ranging from 0 to 1.
0 means that a user has not watched that movie, and the closer the value is to 1, the more
the user likes the movie that the neuron's representing.
These values will be extracted and normalized from the ratings dataset.
Let's format the datasets so that they conform to the RBM's structure.
To begin, let's see how many movies we have, and if the movie IDs correspond to that value.
Notice that we have 3883 movies, while our ID's vary from 1 to 3952.
Due to this, we won't be able to index movies through their ID since we would get memory
indexing errors.
So instead we can create a column that shows what spot in our list that particular movie is in.
Now let's merge the ratings dataframe into the movies one so we can have the List Index
values in both dataframes.
We're also going to drop the Timestamp, Title, and Genres columns since we won't be needing
them to make recommendations.
Now, we can start formatting the data into input for the RBM.
We're going to store the normalized user ratings into a list of lists called "trX".
Let's build our RBM with Tensorflow.
After choosing the number of hidden layers, we create placeholder variables for the visible
layer biases, hidden layer biases, and weights that connect the hidden layer with the visible layer.
We arbitrarily use 20 units in our hidden layer.
Next we create the visible and hidden layer units.
For the activation functions, we?ll use the"nonlinear tf.sigmoid" and "tf.relu" functions.
Now we set the RBM training parameters and functions.
And set the error function, which will be Mean Absolute Error.
We also have to initialize our variables.
Thankfully, NumPy has a "zeros function" for this.
We'll train the RBM for 15 epochs.
Each epoch uses 10 batches with size 100.
After training, we'll print out a graph with the error by epoch.
With our model trained, we can finally predict movies that an arbitrarily selected user might like.
This can be done by feeding the user's watched movie preferences into the RBM
and then reconstructing the input.
The values that the RBM gives us will estimate the user's preferences for movies that he
hasn't watched, based on the preferences of the users that the RBM was trained on.
To find the 20 most recommended movies for our mock user, we can sort by the scores that
our model provided.
Feel free to modify the parameters like the number of hidden units or the loss functions.
These parameters have an impact on run time and performance.
By now, you should understand how to implement a basic recommendation system using an RBM
and the TensorFlow library.
Thank you for watching this video.