def computeRecommendation(new_user):
# Testing
#Take ratings for some questions
for i in range(0, numcourses / 3):
ind = random.randint(0, numcourses - 1)
new_user[0][ind] = random.randint(1, 5)
print new_user
for i, rating in enumerate(new_user[0]):
if rating > 0:
print('Rated {:.0f} for {:s}\n'.format(rating, courseslist[i]))
print new_user.shape
print load_data.Y.shape
# TODO: correct the bug of mismatch of array dimensions on uncommenting
# the following code
# load_data.Y = np.vstack((load_data.Y, new_user))
# load_data.R = np.vstack((load_data.R, (new_user != 0).astype(int)))
# Normalize data and get test data
[
load_data.Y, Y_Mean, load_data.test_data_Y, load_data.test_data_R,
load_data.R
] = normalizeRatings.normalizeRatings(load_data.Y, load_data.R, 0.20)
load_data.numstudents = load_data.Y.shape[0]
print "Training our model: \n Please keep patience \n"
print Y_Mean
output = Model_Trainer.output[-1, :] + Y_Mean.flatten()
outputarg = output.argsort()[::-1]
return output, outputarg, courseslist
data = scipy.io.loadmat('ex8/ex8_movies.mat')
Y = data['Y']
R = data['R'].astype(bool)
# Y is a 1682x943 matrix, containing ratings (1-5) of 1682 movies by
# 943 users
#
# R is a 1682x943 matrix, where R(i,j) = 1 if and only if user j gave a
# rating to movie i
# Add our own ratings to the data matrix
Y = np.column_stack((my_ratings, Y))
R = np.column_stack((my_ratings, R)).astype(bool)
# Normalize Ratings
Ynorm, Ymean = normalizeRatings(Y, R)
# Useful Values
num_users = Y.shape[1]
num_movies = Y.shape[0]
num_features = 10
# Set Initial Parameters (Theta, X)
X = np.random.rand(num_movies, num_features)
Theta = np.random.rand(num_users, num_features)
initial_parameters = np.hstack((X.T.flatten(), Theta.T.flatten()))
# Set Regularization
Lambda = 10
costFunc = lambda p: cofiCostFunc(p, Ynorm, R, num_users, num_movies, num_features, Lambda)[0]
data = loadmat('ex8_movies.mat')
Y = data['Y']
R = data['R']
# Y is a 1682x943 matrix, containing ratings (1-5) of 1682 movies by
# 943 users
# R is a 1682x943 matrix, where R(i,j) = 1 if and only if user j gave a
# rating to movie i
# Add our own ratings to the data matrix
Y = np.hstack((my_ratings, Y))
R = np.hstack((my_ratings != 0, R))
# Normalize Ratings
Ynorm, Ymean = normalizeRatings(Y, R)
# Useful Values
num_users = np.size(Y, 1)
num_movies = np.size(Y, 0)
num_features = 10
# Set Initial Parameters (Theta, X)
X = np.random.randn(num_movies, num_features)
Theta = np.random.randn(num_users, num_features)
initial_parameters = []
initial_parameters.extend(
(list(X.flatten(order='F')) + list(Theta.flatten(order='F'))))
# Set options for using advanced optimizer
mat = scipy.io.loadmat('ex8_movies.mat')
Y = mat["Y"]
R = mat["R"]
# Y is a 1682x943 matrix, containing ratings (1-5) of 1682 movies by
# 943 users
#
# R is a 1682x943 matrix, where R(i,j) = 1 if and only if user j gave a
# rating to movie i
# Add our own ratings to the data matrix
Y = np.column_stack((my_ratings, Y))
R = np.column_stack(((my_ratings != 0).astype(int), R))
# Normalize Ratings
[Ynorm, Ymean] = nr.normalizeRatings(Y, R)
# Useful Values
num_users = Y.shape[1]
num_movies = Y.shape[0]
num_features = 10
# Set Initial Parameters (Theta, X)
X = np.random.randn(num_movies, num_features)
Theta = np.random.randn(num_users, num_features)
initial_parameters = np.concatenate(
(X.reshape(X.size, order='F'), Theta.reshape(Theta.size, order='F')))
# Set options
maxiter = 100
def ex8_cofi():
## Machine Learning Online Class
# Exercise 8 | Anomaly Detection and Collaborative Filtering
#
# Instructions
# ------------
#
# This file contains code that helps you get started on the
# exercise. You will need to complete the following functions:
#
# estimateGaussian.m
# selectThreshold.m
# cofiCostFunc.m
#
# For this exercise, you will not need to change any code in this file,
# or any other files other than those mentioned above.
#
## =============== Part 1: Loading movie ratings dataset ================
# You will start by loading the movie ratings dataset to understand the
# structure of the data.
#
print('Loading movie ratings dataset.\n')
# Load data
mat = scipy.io.loadmat('ex8_movies.mat')
Y = mat['Y']
R = mat['R']
# Y is a 1682x943 matrix, containing ratings (1-5) of 1682 movies on
# 943 users
#
# R is a 1682x943 matrix, where R(i,j) = 1 if and only if user j gave a
# rating to movie i
# From the matrix, we can compute statistics like average rating.
print('Average rating for movie 1 (Toy Story): %f / 5\n' %
np.mean(Y[0, R[0, :] == 1]))
# We can "visualize" the ratings matrix by plotting it with imagesc
plt.imshow(Y)
plt.ylabel('Movies')
plt.xlabel('Users')
plt.savefig('figure1.png')
print('\nProgram paused. Press enter to continue.')
#pause
## ============ Part 2: Collaborative Filtering Cost Function ===========
# You will now implement the cost function for collaborative filtering.
# To help you debug your cost function, we have included set of weights
# that we trained on that. Specifically, you should complete the code in
# cofiCostFunc.m to return J.
# Load pre-trained weights (X, Theta, num_users, num_movies, num_features)
mat = scipy.io.loadmat('ex8_movieParams.mat')
X = mat['X']
Theta = mat['Theta']
num_users = mat['num_users']
num_movies = mat['num_movies']
num_features = mat['num_features']
# Reduce the data set size so that this runs faster
num_users = 4
num_movies = 5
num_features = 3
X = X[:num_movies, :num_features]
Theta = Theta[:num_users, :num_features]
Y = Y[:num_movies, 0:num_users]
R = R[:num_movies, 0:num_users]
# Evaluate cost function
J, _ = cofiCostFunc(np.concatenate([X.ravel(), Theta.ravel()]), Y, R,
num_users, num_movies, num_features, 0)
print(
'Cost at loaded parameters: %f \n(this value should be about 22.22)' %
J)
print('\nProgram paused. Press enter to continue.')
#pause
## ============== Part 3: Collaborative Filtering Gradient ==============
# Once your cost function matches up with ours, you should now implement
# the collaborative filtering gradient function. Specifically, you should
# complete the code in cofiCostFunc.m to return the grad argument.
#
print('\nChecking Gradients (without regularization) ... ')
# Check gradients by running checkNNGradients
checkCostFunction()
print('\nProgram paused. Press enter to continue.')
#pause
## ========= Part 4: Collaborative Filtering Cost Regularization ========
# Now, you should implement regularization for the cost function for
# collaborative filtering. You can implement it by adding the cost of
# regularization to the original cost computation.
#
# Evaluate cost function
J, _ = cofiCostFunc(np.concatenate([X.ravel(), Theta.ravel()]), Y, R,
num_users, num_movies, num_features, 1.5)
print(
'Cost at loaded parameters (lambda = 1.5): %f \n(this value should be about 31.34)'
% J)
print('\nProgram paused. Press enter to continue.\n')
#pause
## ======= Part 5: Collaborative Filtering Gradient Regularization ======
# Once your cost matches up with ours, you should proceed to implement
# regularization for the gradient.
#
#
print('\nChecking Gradients (with regularization) ... ')
# Check gradients by running checkNNGradients
checkCostFunction(1.5)
print('\nProgram paused. Press enter to continue.')
#pause
## ============== Part 6: Entering ratings for a new user ===============
# Before we will train the collaborative filtering model, we will first
# add ratings that correspond to a new user that we just observed. This
# part of the code will also allow you to put in your own ratings for the
# movies in our dataset!
#
movieList = loadMovieList()
# Initialize my ratings
my_ratings = np.zeros(1682)
# Check the file movie_idx.txt for id of each movie in our dataset
# For example, Toy Story (1995) has ID 1, so to rate it "4", you can set
my_ratings[0] = 4
# Or suppose did not enjoy Silence of the Lambs (1991), you can set
my_ratings[97] = 2
# We have selected a few movies we liked / did not like and the ratings we
# gave are as follows:
my_ratings[6] = 3
my_ratings[11] = 5
my_ratings[53] = 4
my_ratings[63] = 5
my_ratings[65] = 3
my_ratings[68] = 5
my_ratings[182] = 4
my_ratings[225] = 5
my_ratings[354] = 5
print('\n\nNew user ratings:')
for i in range(len(my_ratings)):
if my_ratings[i] > 0:
print('Rated %d for %s' % (my_ratings[i], movieList[i]))
#end
print('\nProgram paused. Press enter to continue.')
#pause
## ================== Part 7: Learning Movie Ratings ====================
# Now, you will train the collaborative filtering model on a movie rating
# dataset of 1682 movies and 943 users
#
print('\nTraining collaborative filtering...')
# Load data
mat = scipy.io.loadmat('ex8_movies.mat')
Y = mat['Y']
R = mat['R']
# Y is a 1682x943 matrix, containing ratings (1-5) of 1682 movies by
# 943 users
#
# R is a 1682x943 matrix, where R(i,j) = 1 if and only if user j gave a
# rating to movie i
# Add our own ratings to the data matrix
Y = np.hstack([my_ratings[:, None], Y])
R = np.hstack([(my_ratings > 0)[:, None], R])
# Normalize Ratings
Ynorm, Ymean = normalizeRatings(Y, R)
# Useful Values
num_movies, num_users = Y.shape
num_features = 10
# Set Initial Parameters (Theta, X)
X = np.random.randn(num_movies, num_features)
Theta = np.random.randn(num_users, num_features)
initial_parameters = np.concatenate([X.ravel(), Theta.ravel()])
# Set options for fmincg
options = {'maxiter': 100}
# Set Regularization
lambda_value = 10
res = optimize.minimize(lambda x: cofiCostFunc(
x, Ynorm, R, num_users, num_movies, num_features, lambda_value),
initial_parameters,
method='TNC',
jac=True,
options=options)
theta = res.x
# Unfold the returned theta back into U and W
X = theta[:num_movies * num_features].reshape(num_movies, num_features)
Theta = theta[num_movies * num_features:].reshape(num_users, num_features)
print('Recommender system learning completed.')
print('\nProgram paused. Press enter to continue.')
#pause
## ================== Part 8: Recommendation for you ====================
# After training the model, you can now make recommendations by computing
# the predictions matrix.
#
p = np.dot(X, Theta.T)
my_predictions = p[:, 0] + Ymean
movieList = loadMovieList()
ix = np.argsort(my_predictions)[::-1]
print('\nTop recommendations for you:')
for i in range(10):
j = ix[i]
print('Predicting rating %.1f for movie %s' %
(my_predictions[j], movieList[j]))
#end
print('\n\nOriginal ratings provided:')
for i in range(len(my_ratings)):
if my_ratings[i] > 0:
print('Rated %d for %s' % (my_ratings[i], movieList[i]))
print('Rated {} for {}'.format(my_ratings[i], movie_list[i]))
print('Training collaborative filtering...')
mat_data = sio.loadmat('ex8_movies.mat')
# Y is a 1682x943 matrix, containing ratings (1-5) of 1682 movies on 943 users
Y = mat_data['Y']
# R is a 1682x943 matrix, where R(i,j) = 1 if and only if user j gave a rating to movie i
R = mat_data['R']
# Add our own ratings to the data matrix
Y = np.hstack((my_ratings.reshape(len(movie_list), 1), Y))
R = np.hstack((my_ratings.reshape(len(movie_list), 1) != 0, R))
# Normalize Ratings
Y_norm, Y_mean = normalizeRatings(Y, R)
# Useful Values
num_users = Y.shape[1]
num_movies = Y.shape[0]
num_features = 10
# Set Initial Parameters (Theta, X)
X = np.random.randn(num_movies, num_features)
Theta = np.random.randn(num_users, num_features)
initial_parameters = np.hstack((X.flatten(), Theta.flatten()))
# Set Regularization
l = 10
result = opt.minimize(fun=cofiCostFunc,
mat = scipy.io.loadmat('ex8_movies.mat')
Y = mat["Y"]
R = mat["R"]
# Y is a 1682x943 matrix, containing ratings (1-5) of 1682 movies by
# 943 users
#
# R is a 1682x943 matrix, where R(i,j) = 1 if and only if user j gave a
# rating to movie i
# Add our own ratings to the data matrix
Y = np.column_stack((my_ratings, Y))
R = np.column_stack(((my_ratings != 0).astype(int), R))
# Normalize Ratings
[Ynorm, Ymean] = nr.normalizeRatings(Y, R)
# Useful Values
num_users = Y.shape[1]
num_movies = Y.shape[0]
num_features = 10
# Set Initial Parameters (Theta, X)
X = np.random.randn(num_movies, num_features)
Theta = np.random.randn(num_users, num_features)
initial_parameters = np.concatenate((X.reshape(X.size, order='F'), Theta.reshape(Theta.size, order='F')))
# Set options
maxiter = 100
options = {'disp': True, 'maxiter':maxiter}