NaN.

Solution to Hands-on Assignment: Movie Recommender System using Matrix Factorization[ Edit ]

This is a template solution to Hands-on Assignment: Movie Recommender System using Matrix Factorization. Remember, as we mentioned in the project itself, you should try to bring down the test RMSE to around 0.85-0.90. The code below works, and produces a test RMSE of only about 1.4 which is not good enough. This is the sample output:

TRAINING...
rmse:  1.1268493005030837
rmse:  0.9966966691641564
rmse:  0.9280137338973233
rmse:  0.9024047542871837
rmse:  0.8812355262401679
rmse:  0.8609071335848433
rmse:  0.841338966368842
rmse:  0.8229397240371596
rmse:  0.8059236796648503
rmse:  0.7903639033428491
rmse:  0.7762635756920586
rmse:  0.7635707553165091
rmse:  0.7521906181191182
rmse:  0.7420037415122787
rmse:  0.732882699925961
TESTING...
Test RMSE:  1.4216956127131872

Code

import numpy as np
import pandas as pd
 
pd.set_option('display.width', 1000)
 
###############################################################################
## load data
 
train = pd.read_csv('movielens_100k/train', sep='\t', header=None, names=['user_id', 'movie_id', 'rating', 'timestamp', ])
test  = pd.read_csv('movielens_100k/test', sep='\t', header=None, names=['user_id', 'movie_id', 'rating', 'timestamp', ])
 
movies = pd.read_csv('movielens_100k/movies', sep='|', header=None, names=['movie_id', 'title', 'release_date', 'video_release_date', 'IMDb_URL', 'unknown', 'Action', 'Adventure', 'Animation', 'Children', 'Comedy', 'Crime', 'Documentary', 'Drama', 'Fantasy', 'FilmNoir', 'Horror', 'Musical', 'Mystery', 'Romance', 'SciFi', 'Thriller', 'War', 'Western', ], encoding="latin1")
users  = pd.read_csv('movielens_100k/users', sep='|', header=None, names=['user_id', 'age', 'gender', 'occupation', 'zip_code', ])
 
###############################################################################
## matrix factorization
 
## train
 
# train:init
print("TRAINING...")
nusers = len(users)
nmovies = len(movies)
d = 20 # number of latent dimensions for each user and for each movie
 
U = np.random.rand(nusers, d)
X = np.random.rand(nmovies, d)
U_bias = np.random.rand(nusers)
X_bias = np.random.rand(nmovies)
 
# train: gradient descent
learning_rate = 0.01 # for gradient descent
lmbda = 0.01 # regularization coefficient
tolerance = 0.01 # termination criteria
 
previous_rmse = None
 
while True:
  errors = list()
 
  for ii in range(len(train)):
 
    user_id, movie_id, rating, _ = train.iloc[ii, :] # get the i-th row of the data
 
    #users and movie id's in data are 1-indexed, so:
    user_id, movie_id = user_id-1, movie_id-1
 
    # calculate prediction
    prediction = np.matmul(U[user_id, :], np.transpose(X[movie_id, :])) + U_bias[user_id] + X_bias[movie_id]
 
    # calculate cost
    error = prediction - rating
    cost = np.square(error) # squared error between prediction and rating
    cost += lmbda * np.square(np.linalg.norm(U[user_id, :])) # regularization penalty: norm of U[user_id, :]
    cost += lmbda * np.square(np.linalg.norm(X[movie_id, :])) # regularization penalty: norm of X[movie_id, :]
 
    # calculate gradients
    u_gradient = 2*X[movie_id, :]*error + lmbda*U[user_id, :] # gradients for U[user_id, :]
    x_gradient = 2*U[user_id, :]*error + lmbda*X[movie_id, :]  # gradients for X[movie_id, :]
    u_bias_gradient = error +lmbda*U_bias[user_id] # gradient for U_bias[user_id]
    x_bias_gradient = error + lmbda*X_bias[movie_id] # gradient for X_bias[movie_id]
 
    # update params
    U[user_id, :]  -= learning_rate * u_gradient
    X[movie_id, :] -= learning_rate * x_gradient
    U_bias[user_id]  -= learning_rate * u_bias_gradient
    X_bias[movie_id] -= learning_rate * x_bias_gradient
 
    errors.append(error)
 
  # termination condition
  errors = np.asarray(errors)
  rmse = np.sqrt(np.mean(np.square(errors))) # root mean squared error
  print("rmse: ", rmse)
  if previous_rmse is not None and (previous_rmse - rmse) < tolerance: break
  previous_rmse = rmse
 
## predict
print("TESTING...")
predictions = list()
for ii in range(len(test)):
  user_id, movie_id, rating, _ = test.iloc[ii, :] # get the i-th row of the data
 
  #users and movie id's in data are 1-indexed, so:
  user_id, movie_id = user_id-1, movie_id-1
 
  # calculate prediction (same code as above)
  prediction = np.matmul(U[user_id, :], np.transpose(X[movie_id, :])) + U_bias[user_id] + X_bias[movie_id] # make prediction using U[user_id, :] and X[movie_id, :]
 
  predictions.append(prediction)
 
## evaluate
errors = np.asarray(predictions) - np.asarray(test[['rating']])
test_rmse = np.sqrt(np.mean(np.square(errors)))
print('Test RMSE: ', test_rmse)

Code

Further Reading