def make_recs(self, _id, _id_type='movie', rec_num=5):
'''
given a user id or a movie that an individual likes to make recommendations.
Input:
_id - the user/movie id you want to predect for
_id_type - the id _id_type
rec_num - how many recommendation you want to provide
Output:
rec_names - (array) a list or numpy array of recommended movies by name
'''
rec_ids = create_ranked_df(self.movies, self.ratings_mat)
if _id_type == 'user':
if _id in self.ratings_mat.index:
ind = np.where(self.ratings_mat.index == _id)[0][0]
preds = np.dot(self.user_mat[ind, :], self.movie_mat)
rec_inds = np.argsort(preds)[0 - rec_num:]
rec_ids = self.ratings_mat.columns[rec_inds]
rec_names = rf.get_movie_names(rec_ids)
else:
rec_names = rf.popular_recommendations(_id, rec_num, rec_ids)
else:
rec_ids = rf.find_similar_movies(_id)
rec_names = rf.get_movie_names(rec_ids)
return rec_names
def make_recommendations(self, _id, dot_prod, _id_type='movie', rec_num=5):
if _id_type == 'user':
if _id in self.user_ids_series:
message = 'Glad to see you again! recommended for you:\n'
idx = np.where(self.user_ids_series == _id)[0][0]
# predict items
# take the dot product of that row and the V matrix
preds = np.dot(self.user_mat[idx, :], self.item_mat)
# pull the top items according to the prediction
indices = preds.argsort()[-rec_num:][::-1]
rec_ids = self.items_ids_series[indices]
rec_names = rf.get_item_names(rec_ids, self.df_items,
self.item_id_colname,
self.item_name_colname)
else:
message = "Hey, you are new here, this is for you:\n"
# if we don't have this user, give just top ratings back
rec_names = rf.popular_recommendations(_id, self.ranked_items,
rec_num)
else:
if _id in self.items_ids_series:
message = 'Similar items for this rated item:\n'
rec_names = (list(
rf.find_similar_items(_id, self.df_items,
self.item_name_colname,
dot_prod))[:rec_num])
else:
print("Please update the database with this item")
return rec_ids, rec_names, message
def make_recs(self, _id, _id_type='movie', rec_num=5):
"""
given a user id or a movie that an individual likes
make recommendations
INPUT:
_id - either a user or movie id (int)
_id_type - "movie" or "user" (str)
rec_num - number of recommendations to return (int)
OUTPUT:
rec_ids - (array) a list or numpy array of recommended movies by id
rec_names - (array) a list or numpy array of recommended movies by name
"""
# if the user is available from the matrix factorization data,
# I will use this and rank movies based on the predicted values
# For use with user indexing
val_users = self.train_data_df.index
rec_ids, rec_names = None, None
if _id_type == 'user':
if _id in self.train_data_df.index:
# Get the index of which row the user is in for use in U matrix
idx = np.where(val_users == _id)[0][0]
# take the dot product of that row and the V matrix
preds = np.dot(self.user_mat[idx, :], self.movie_mat)
# pull the top movies according to the prediction
indices = preds.argsort()[-rec_num:][::-1] # indices
rec_ids = self.train_data_df.columns[indices]
rec_names = rf.get_movie_names(rec_ids, self.movies)
else:
# if we don't have this user, give just top ratings back
rec_names = rf.popular_recommendations(_id, rec_num,
self.ranked_movies)
print(
"Because this user wasn't in our database, we are giving back the top movie "
"recommendations for all users.")
# Find similar movies if it is a movie that is passed
else:
if _id in self.train_data_df.columns:
rec_names = list(rf.find_similar_movies(_id,
self.movies))[:rec_num]
else:
print(
"That movie doesn't exist in our database. Sorry, we don't have any recommendations for you."
)
return rec_ids, rec_names
def make_recs(self, _id, _id_type='movie', rec_num=5):
'''
given a user id or a movie that an individual likes
make recommendations
INPUT:
_id - either a user or movie id (int)
_id_type - "movie" or "user" (str) (defult 'movie')
rec_num - number of recommendations to return (int) (defult 5)
OUTPUT:
rec_ids - (array) a list or numpy array of recommended movies by id
rec_names - (array) a list or numpy array of recommended movies by name
'''
if _id_type == 'movie':
try:
rec_names = rf.find_similar_movies(_id, self.movies)[:rec_num]
rec_ids = self.movies[self.movies['movie'].isin(
rec_names)]['movie_id'].values[:rec_num]
except:
print('movie not in dataset')
rec_ids, rec_names = None, None
else:
if _id in self.train_data_df.index:
# find row in user_mat
user = np.where(self.train_data_df.index == _id)[0][0]
# preidct rateing on user with all movies
pre = np.dot(self.user_mat[user, :], self.movie_mat)
# get movies indices of top rec_num records
indices = np.argsort(pre)[::-1][:rec_num]
# get movie ids with index
rec_ids = self.train_data_df.columns[indices].values
# get movie names
rec_names = rf.get_movie_names(rec_ids, self.movies)
else:
rec_names = rf.popular_recommendations(_id, rec_num,
self.ranked_movies)
rec_ids = self.movies[self.movies['movie'].isin(
rec_names)]['movie_id'].values[:rec_num]
print(
"Because this user wasn't in our database, we are giving back the top movie recommendations for all users."
)
return rec_ids, rec_names
def make_recommendations(self, _id, _id_type='movie', rec_num=5):
"""
given a user id or a movie that an individual likes
make recommendations
"""
rec_ids, rec_names = None, None
if _id_type == 'user':
if _id in self.user_ids_series:
# Get the index of which row the user is in for use in U matrix
idx = np.where(self.user_ids_series == _id)[0][0]
# take the dot product of that row and the V matrix
preds = np.dot(self.user_matrix[idx, :], self.movie_matrix)
# pull the top movies according to the prediction
indices = preds.argsort()[-rec_num:][::-1] #indices
rec_ids = self.movie_ids_series[indices]
rec_names = rf.get_movie_names(rec_ids, self.movies)
else:
# if we don't have this user, give just top ratings back
rec_names = rf.popular_recommendations(_id, rec_num,
self.ranked_movies)
print(
"Because this user wasn't in our database, we are giving back the top movie recommendations for all users. (Cold Start Problem)"
)
# Find similar movies if it is a movie that is passed
else:
if _id in self.movie_ids_series:
rec_names = list(rf.find_similar_movies(_id,
self.movies))[:rec_num]
else:
print(
"That movie doesn't exist in our database. Sorry, we don't have any recommendations for you."
)
return rec_ids, rec_names
def make_recs(self,_id, _id_type='user', rec_num=5):
'''
INPUT:
_id - either a user or movie id (int)
_id_type - "movie" or "user" (str)
rec_num - number of recommendations to return (int)
OUTPUT:
recs - (array) a list or numpy array of recommended movies like the
given movie, or recs for a user_id given
'''
rec_ids, rec_names = None, None
if _id_type == 'user':
if _id in self.user_ids_series:
# Get the index of which row the user is in for use in U matrix
idx = np.where(self.user_ids_series == _id)[0][0]
# take the dot product of that row and the V matrix
preds = np.dot(self.user_mat[idx,:],self.movie_mat)
# pull the top movies according to the prediction
indices = preds.argsort()[-rec_num:][::-1] #indices
rec_ids = self.user_item_df.columns[indices]
rec_names = rf.get_movie_names(rec_ids, self.movies)
else:
# if we don't have this user, give just top ratings back
rec_names = rf.popular_recommendations(_id, rec_num, self.ranked_movies)
# Find similar movies if it is a movie that is passed
else:
if _id in self.movie_ids_series:
rec_names = list(rf.find_similar_movies(_id, self.movies))[:rec_num]
else:
print("That movie doesn't exist in our database. Sorry, we don't have any recommendations for you.")
return rec_ids, rec_names
def make_recommendations(self,
_id,
dot_prod_user,
tfidf_matrix,
_id_type='item',
rec_num=5):
"""
This function make recommendations for a particular user or a
particular item regarding the value that you've putted in
the _id_type argument.
If you choose _id_type='user':
the _id argument will be considered as a user id and the
recommendation is given using matrix factorization if the user
has already rated some movies before. If the user is a new user
the recommendation is given using the most popular movies in
the data (Ranked based recommendation).
If you choose _id_type='item':
the _id argument will be considered as a item id and the
recommendation is given using similarity between movies if the
item exist in the data (Content Based Recommendation).
If the item is not present in the data (so no information
about the genre, years, ect.) it will return a message to
update the data with this item.
Input:
- _id: either a user or item id (int)
- dot_prod_user: the dot product matrix computed by your own
to find similar users
- _id_type: either 'user' or 'item', Default:'item' (str)
- rec_num: number of recommendation that you want
Default:5 (int)
Output:
- recommendation ids
- recommendation names
- and a personalized message
"""
if _id_type == 'user':
if _id in self.user_ids_series:
message = 'Glad to see you again! recommended for you:\n'
idx = np.where(self.user_ids_series == _id)[0][0]
# predict items
# take the dot product of that row and the V matrix
preds = np.dot(self.user_mat[idx, :], self.item_mat)
# pull the top items according to the prediction
indices = preds.argsort()[-rec_num:][::-1]
rec_ids = self.items_ids_series[indices]
rec_names = rf.get_item_names(rec_ids, self.df_items,
self.item_id_colname,
self.item_name_colname)
rec_user_user_ids = rf.find_similar_user(
_id, self.df_reviews, self.user_id_colname, dot_prod_user)
rec_user_item_names = rf.user_user_cf(rec_user_user_ids,
self.user_item_df,
self.df_reviews,
self.item_id_colname,
self.item_name_colname)
else:
message = "Hey, you are new here, this is for you:\n"
# if we don't have this user, give just top ratings back
rec_ids = rf.popular_recommendations(_id, self.ranked_items,
self.item_id_colname,
rec_num)
rec_names = rf.get_item_names(rec_ids, self.df_items,
self.item_id_colname,
self.item_name_colname)
rec_user_user_ids = None
rec_user_item_names = None
else:
if _id in self.items_ids_series:
name_item_for_message = rf.get_item_names(
[_id], self.df_items, self.item_id_colname,
self.item_name_colname)
message = (f"Similar items for id:{_id}, corresponding to "
f"{name_item_for_message[0]}:\n")
rec_ids = (rf.find_similar_items(_id, self.df_items,
self.item_id_colname,
tfidf_matrix))[:rec_num]
rec_names = rf.get_item_names(rec_ids, self.df_items,
self.item_id_colname,
self.item_name_colname)
rec_user_user_ids = None
rec_user_item_names = None
else:
message = (
"We can't make recommendation for this item, please make"
"sure the data was updated with this item.\n")
rec_ids = None
rec_names = None
rec_user_user_ids = None
rec_user_item_names = None
return rec_ids, rec_names, message, rec_user_user_ids, rec_user_item_names
def make_recommendations(self, _id, _id_type='item', rec_num=5, latent_features=12, learning_rate=0.001, iters=10):
"""
This function make recommendations for a particular user or a
particular item regarding the value that you've putted in
the _id_type argument.
If you choose _id_type='user':
the _id argument will be considered as a user id and the
recommendation is given using matrix factorization if the user
has already rated some movies before. If the user is a new user
the recommendation is given using the most popular movies in
the data (Ranked based recommendation).
If you choose _id_type='item':
the _id argument will be considered as a item id and the
recommendation is given using similarity between movies if the
item exist in the data (Content Based Recommendation).
If the item is not present in the data (so no information
about the genre, years, ect.) it will return a message to
update the data with this item.
Input:
- _id: either a user or item id (int)
- dot_prod_user: the dot product matrix computed by your own
to find similar users
- _id_type: either 'user' or 'item', Default:'item' (str)
- rec_num: number of recommendation that you want
Default:5 (int)
Output:
- recommendation ids
- recommendation names
- and a personalized message
"""
self.latent_features = latent_features
self.learning_rate = learning_rate
self.iters = iters
user_item_reset = self.user_item_grouped.reset_index()
self.user_ids = user_item_reset[self.user_id_colname].unique()
current_user = (
user_item_reset[user_item_reset[self.user_id_colname] == _id]
)
current_user = (
current_user.groupby([self.user_id_colname,
self.item_id_colname])[self.rating_col_name].max()
)
current_user_item_df = current_user.unstack()
self.current_user_item_df = current_user_item_df
self.user_item_mat = np.array(self.current_user_item_df)
# Set up some useful values for later
self.n_users = self.user_item_mat.shape[0]
self.n_items = self.user_item_mat.shape[1]
self.num_ratings = np.count_nonzero(~np.isnan(self.user_item_mat))
self.user_ids_series = np.array(user_item_reset[self.user_id_colname].unique())
self.items_ids_series = np.array(user_item_reset[self.item_id_colname].unique())
print('Train data with Funk Singular Value Decomposition...')
#### FunkSVD ####
# initialize the user and item matrices with random values
user_mat = np.random.rand(self.n_users, self.latent_features)
item_mat = np.random.rand(self.latent_features, self.n_items)
sse_accum = 0
print("Iterations \t\t Mean Squared Error ")
for iteration in range(self.iters):
old_sse = sse_accum
sse_accum = 0
for i in range(self.n_users):
for j in range(self.n_items):
# if the rating exists (so we train only on non-missval)
if self.user_item_mat[i, j] > 0:
# compute the error as the actual minus the dot
# product of the user and item latent features
diff = (
self.user_item_mat[i, j]
- np.dot(user_mat[i, :], item_mat[:, j])
)
# Keep track of the sum of squared errors for the
# matrix
sse_accum += diff**2
for k in range(self.latent_features):
user_mat[i, k] += (
self.learning_rate * (2*diff*item_mat[k, j])
)
item_mat[k, j] += (
self.learning_rate * (2*diff*user_mat[i, k])
)
print(f"\t{iteration+1} \t\t {sse_accum/self.num_ratings} ")
self.mse=sse_accum/self.num_ratings
# Create ranked items
self.ranked_items = rf.ranked_df(self.df_reviews,
self.item_id_colname,
self.rating_col_name,
self.date_col_name)
if _id in self.user_ids_series:
message = 'Glad to see you again! recommended for you:\n'
idx = np.where(self.user_ids_series == _id)[0][0]
# predict items
# take the dot product of that row and the V matrix
preds = np.dot(user_mat[idx,:],item_mat)
# pull the top items according to the prediction
indices = preds.argsort()[-rec_num:][::-1]
rec_ids = self.items_ids_series[indices]
rec_names = rf.get_item_names(rec_ids,
self.df_items,
self.item_id_colname,
self.item_name_colname)
else:
message = "Hey, you are new here, this is for you:\n"
# if we don't have this user, give just top ratings back
rec_ids = rf.popular_recommendations(_id,
self.ranked_items,
self.item_id_colname,
rec_num)
rec_names = rf.get_item_names(rec_ids,
self.df_items,
self.item_id_colname,
self.item_name_colname)
return rec_ids, rec_names, message
