def ContentRecs():
""" for this content-based(item) recommender
calculate items' cosine similarity matrix in alg.fit()
I don't test `HitRate` for `topN` recommendation, because here it's impossible to do that. What I recommend by this algorithm are all the movies the user haven't rated.
"""
np.random.seed(0)
random.seed(0)
# loader = True
# Load up common data set for the recommender algorithms
# print(f'call ContentRecs()\nloader = {loader}')
(ml, evaluationData, rankings) = MyDump.LoadMovieLensData(loader)
# Construct an Evaluator to, you know, evaluate them
evaluator = Evaluator(evaluationData, rankings, load=True)
contentKNN = ContentKNNAlgorithm()
evaluator.AddAlgorithm(contentKNN, "ContentKNN")
# Just make random recommendations
Random = NormalPredictor()
evaluator.AddAlgorithm(Random, "Random")
evaluator.Evaluate(False, True) # not topN, able load
# recommend 10(default) items
evaluator.SampleTopNRecs(ml)
def BehaviorBasedCF():
np.random.seed(0)
random.seed(0)
# Load up common data set for the recommender algorithms
(ml, evaluationData, rankings) = MyDump.LoadMovieLensData(loader)
# Construct an Evaluator to, you know, evaluate them
evaluator = Evaluator(evaluationData, rankings, load=True)
# User-based KNN
UserKNN = KNNBasic(sim_options={'name': 'cosine', 'user_based': True})
evaluator.AddAlgorithm(UserKNN, "User KNN")
# Item-based KNN
ItemKNN = KNNBasic(sim_options={'name': 'cosine', 'user_based': False})
evaluator.AddAlgorithm(ItemKNN, "Item KNN")
# Just make random recommendations
Random = NormalPredictor()
evaluator.AddAlgorithm(Random, "Random")
evaluator.Evaluate(
False
) # load is also False, cause simsMatrix needs to be loaded; I haven't figured it out.
evaluator.SampleTopNRecs(ml)
def AutoRec():
np.random.seed(0)
random.seed(0)
ml, evaluationData, rankings = MyDump.LoadMovieLensData(loader)
evaluator = Evaluator(evaluationData, rankings, loader)
myAutoRec = RBMAlgorithm()
evaluator.AddAlgorithm(myAutoRec, "AutoRec")
Random = NormalPredictor()
evaluator.AddAlgorithm(Random, "Random")
evaluator.Evaluate(doTopN=False, load=loader)
evaluator.SampleTopNRecs(ml, loader)
def CompareSVDRandom():
np.random.seed(0)
random.seed(0)
# loader = True
start_t = time.time()
# Load up common data set for the recommender algorithms
# (evaluationData, rankings) = LoadMovieLensData()
# MyDump.Save('ratingsDataset', data = evaluationData, verbose = 1)
# MyDump.Save('rankings', data = rankings, verbose = 1)
# _,_,evaluationData = MyDump.Load('ratingsDataset', 1)
# _,_,rankings = MyDump.Load('rankings',1)
# if evaluationData == None or rankings == None:
# (_, evaluationData, rankings) = MyDump.LoadMovieLensData() # meat
# MyDump.Save('ratingsDataset', data = evaluationData, verbose = 1)
# MyDump.Save('rankings', data = rankings, verbose = 1)
_, evaluationData, rankings = MyDump.LoadMovieLensData(loader)
print(
f'------time consumption: {time.time() - start_t} for LoadMovieLensData()'
)
start_t = time.time()
# Construct an Evaluator to, you know, evaluate them
evaluator = Evaluator(dataset=evaluationData,
rankings=rankings,
load=loader)
print(
f'------time consumption: {time.time() - start_t} for create an evaluator instance'
)
start_t = time.time()
# Throw in an SVD recommender
SVDAlgorithm = SVD(random_state=10)
evaluator.AddAlgorithm(SVDAlgorithm, "SVD")
# Just make random recommendations
Random = NormalPredictor()
evaluator.AddAlgorithm(Random, "Random")
start_t = time.time()
evaluator.Evaluate(True, loader) # doTopN, loader
print(
f'------time consumption: {time.time() - start_t} for evaluator.Evaluate()'
)
start_t = time.time()
def MF():
""" the idea behind is math, latent features
implementation is simple out of library source
"""
np.random.seed(0)
random.seed(0)
ml, evaluationData, rankings = MyDump.LoadMovieLensData(loader)
evaluator = Evaluator(evaluationData, rankings, loader)
mySVD = SVD(random_state=10)
evaluator.AddAlgorithm(mySVD, "SVD") # the same with before
mySVDpp = SVDpp(random_state=10)
evaluator.AddAlgorithm(mySVDpp, "SVDpp")
Random = NormalPredictor()
evaluator.AddAlgorithm(Random, "Random")
evaluator.Evaluate(doTopN=False, load=loader)
evaluator.SampleTopNRecs(ml, loader)
def RBMtest():
np.random.seed(0)
random.seed(0)
ml, evaluationData, rankings = MyDump.LoadMovieLensData(loader)
# Construct an Evaluator to, you know, evaluate them
evaluator = Evaluator(evaluationData, rankings, loader)
# RBM
# able to tune by trying more parameter combination
myRBM = RBMAlgorithm(epochs=20)
evaluator.AddAlgorithm(myRBM, "RBM")
Random = NormalPredictor()
evaluator.AddAlgorithm(Random, "Random")
evaluator.Evaluate(doTopN=False, load=loader)
evaluator.SampleTopNRecs(ml, loader)
def contentGive(id):
np.random.seed(0)
random.seed(0)
# Load up common data set for the recommender algorithms
(ml, evaluationData, rankings) = LoadMovieLensData()
# Construct an Evaluator to, you know, evaluate them
evaluator = Evaluator(evaluationData, rankings)
contentKNN = ContentKNNAlgorithm()
evaluator.AddAlgorithm(contentKNN, "ContentKNN")
# Just make random recommendations
Random = NormalPredictor()
evaluator.AddAlgorithm(Random, "Random")
evaluator.Evaluate(False)
evaluator.SampleTopNRecs(ml, id)
def contentf(self):
# Load up common data set for the recommender algorithms
(ml, evaluationData, rankings) = self.LoadNovieLensData()
# Construct an Evaluator to, you know, evaluate them
evaluator = Evaluator(evaluationData, rankings)
contentKNN = ContentKNNAlgorithm()
evaluator.AddAlgorithm(contentKNN, "ContentKNN")
# Just make random recommendations
#Random = NormalPredictor()
#evaluator.AddAlgorithm(Random, "Random")
evaluator.Evaluate(False)
evaluator.SampleTopNRecs(ml)
def LoadMovieLensData():
ml = MovieLens()
print("Loading movie ratings...")
data = ml.loadMovieLensLatestSmall()
print(
"\nComputing movie popularity ranks so we can measure novelty later..."
)
rankings = ml.getPopularityRanks()
return (data, rankings)
np.random.seed(0) # to make sure the same result for each run.
random.seed(0)
# Load up common data set for the recommender algorithms
(evaluationData, rankings) = LoadMovieLensData()
# Construct an Evaluator to, you know, evaluate them
evaluator = Evaluator(evaluationData, rankings)
# Throw in an SVD recommender
SVDAlgorithm = SVD(random_state=10)
evaluator.AddAlgorithm(SVDAlgorithm, "SVD")
# Just make random recommendations
Random = NormalPredictor()
evaluator.AddAlgorithm(Random, "Random")
# Fight!
evaluator.Evaluate(True)
ml.actualizarRatings()
print("Loading movie ratings...")
data = ml.loadMovieLensLatestSmall()
print(
"\nComputing movie popularity ranks so we can measure novelty later..."
)
rankings = ml.getPopularityRanks()
return (ml, data, rankings)
np.random.seed(0)
random.seed(0)
# Load up common data set for the recommender algorithms
(ml, evaluationData, rankings) = LoadMovieLensData()
# Construct an Evaluator to, you know, evaluate them
evaluator = Evaluator(evaluationData, rankings)
contentKNN = ContentKNNAlgorithm()
evaluator.AddAlgorithm(contentKNN, "ContentKNN")
# Just make random recommendations
#Random = NormalPredictor()
#evaluator.AddAlgorithm(Random, "Random")
#evaluator.Evaluate(True)
recomendations = evaluator.globalRecommendation()
print("get_top_n")
evaluator.get_top_n(recomendations)
#evaluator.SampleTopNRecs(ml,268,10)
ml = MovieLens()
print(BeginGREEN + "Loading movie ratings..." + EndGREEN)
data = ml.loadMovieLensLatestSmall()
print(
BeginGREEN +
"Computing movie popularity ranks so we can measure novelty later..." +
EndGREEN)
rankings = ml.getPopularityRanks()
return (data, rankings)
np.random.seed(0)
random.seed(0)
# Load up common data set for the recommender algorithms
(evaluationData, rankings) = LoadMovieLensData()
# Construct an Evaluator
evaluator = Evaluator(evaluationData, rankings)
# Throw in an SVD recommender
SVDAlgorithm = SVD(random_state=10)
evaluator.AddAlgorithm(SVDAlgorithm, BeginBgBLUE + "SVD" + EndBgBLUE)
# Just make random recommendations
Random = NormalPredictor()
evaluator.AddAlgorithm(Random, BeginBgBLUE + "Random" + EndBgBLUE)
# Fight!
evaluator.Evaluate(True)
def loadMovieLensData():
ml = MovieLens()
print("Loading Movie ratings...")
data = ml.loadMovieLensLatestSmall()
print(
"\nComputing movie popularity ranks so we can measure novelty later..."
)
rankings = ml.getPopularityRanks()
return (ml, data, rankings)
np.random.seed(0)
random.seed(0)
(ml, evaluationData, rankings) = loadMovieLensData()
evaluator = Evaluator(evaluationData, rankings)
SimpleRBM = RBMAlgorithm(epochs=60)
SimpleAutoRec = AutoRecAlgorithm(epochs=100)
Hybrid = HybridAlgorithm([SimpleRBM, SimpleAutoRec], [0.5, 0.5])
evaluator.AddAlgorithm(SimpleRBM, "RBM")
evaluator.AddAlgorithm(SimpleAutoRec, "Auto Encoder")
evaluator.AddAlgorithm(Hybrid, "Hybrid")
evaluator.Evaluate(False)
evaluator.SampleTopNRecs(ml)
rankings = ml.getPopularityRanks()
return (ml, data, rankings)
np.random.seed(0)
random.seed(0)
# Load up common data set for the recommender algorithms
(ml, evaluationData, rankings) = LoadMovieLensData()
# Construct an Evaluator to, you know, evaluate them
evaluator = Evaluator(evaluationData, rankings)
# SVD
SVD = SVD()
evaluator.AddAlgorithm(SVD, "SVD")
# Fight!
evaluator.Evaluate(False)
# userratings = ml.getUserRatings(1)
# print(userratings)
# recommendation = evaluator.SampleTopNRecs(ml, 1)
# print(recommendation)
@app.route('/user/<id>', methods=['GET'])
def test(id=85):
print(f"id={id}")
result = {
'userRating': ml.getUserRatings(int(id)),
)
rankings = ml.getPopularityRanks()
return (ml, data, rankings)
np.random.seed(0)
random.seed(0)
# Load up common data set for the recommender algorithms
(ml, evaluationData, rankings) = LoadMovieLensData()
# Construct an Evaluator to, you know, evaluate them
evaluator = Evaluator(evaluationData, rankings)
#Simple RBM
SimpleRBM = RBMAlgorithm(epochs=40)
#Content
ContentKNN = ContentKNNAlgorithm()
#Combine them
Hybrid = HybridAlgorithm([SimpleRBM, ContentKNN], [0.5, 0.5])
evaluator.AddAlgorithm(SimpleRBM, "RBM")
evaluator.AddAlgorithm(ContentKNN, "ContentKNN")
evaluator.AddAlgorithm(Hybrid, "Hybrid")
# Fight!
evaluator.Evaluate(False)
evaluator.SampleTopNRecs(ml)
def LoadMovieLensData():
ml = MovieLens()
print("Loading movie ratings...")
data = ml.loadMovieLensLatestSmall()
print(
"\nComputing movie popularity ranks so we can measure novelty later..."
)
rankings = ml.getPopularityRanks()
return (ml, data, rankings)
np.random.seed(0)
random.seed(0)
# Load up common data set for the recommender algorithms
(ml, evaluationData, rankings) = LoadMovieLensData()
# Construct an Evaluator to, you know, evaluate them
evaluator = Evaluator(evaluationData, rankings)
contentKNN = ContentKNNAlgorithm()
evaluator.AddAlgorithm(contentKNN, "ContentKNN")
# Just make random recommendations
Random = NormalPredictor()
evaluator.AddAlgorithm(Random, "Random")
evaluator.Evaluate(False)
evaluator.SampleTopNRecs(ml)
rankings = ml.getPopularityRanks()
return (ml, data, rankings)
np.random.seed(0)
random.seed(0)
# Load up common data set for the recommender algorithms
(ml, evaluationData, rankings) = LoadMovieLensData()
t0 = time()
evaluator = Evaluator(evaluationData, rankings)
#Content-based
ContentKNN = ContentBasedAlgorithm()
evaluator.AddAlgorithm(ContentKNN, "ContentBased")
#User-Based
sim_options_user = {'name': 'cosine', 'user_based': True}
userKNN = KNNBasic(sim_options=sim_options_user)
evaluator.AddAlgorithm(userKNN, "UserBased")
#Item-Based
sim_options_item = {'name': 'cosine', 'user_based': False}
itemKNN = KNNBasic(sim_options=sim_options_item)
evaluator.AddAlgorithm(itemKNN, "ItemBased")
# SVD
SVD = SVD()
evaluator.AddAlgorithm(SVD, "SVD")
print("Loading movie ratings...")
data = ml.loadMovieLensLatestSmall()
print(
"\nComputing movie popularity ranks so we can measure novelty later..."
)
rankings = ml.getPopularityRanks()
return (ml, data, rankings)
np.random.seed(0)
random.seed(0)
# Load up common data set for the recommender algorithms
(ml, evaluationData, rankings) = LoadMovieLensData()
# Construct an Evaluator to, you know, evaluate them
evaluator = Evaluator(evaluationData, rankings)
#RBM
RBM = RBMAlgorithm(epochs=20)
evaluator.AddAlgorithm(RBM, "RBM")
# Just make random recommendations
Random = NormalPredictor()
evaluator.AddAlgorithm(Random, "Random")
# Fight!
evaluator.Evaluate(True)
evaluator.SampleTopNRecs(ml)
)
rankings = ml.getPopularityRanks()
return (ml, data, rankings)
np.random.seed(0)
random.seed(0)
# Load up common data set for the recommender algorithms
(ml, evaluationData, rankings) = LoadPCData()
# Construct an Evaluator to, you know, evaluate them
evaluator = Evaluator(evaluationData, rankings)
# User-based KNN
UserKNN = KNNBasic(sim_options={'name': 'pearson', 'user_based': True})
evaluator.AddAlgorithm(UserKNN, "User KNN")
# Item-based KNN
ItemKNN = KNNBasic(sim_options={'name': 'pearson', 'user_based': False})
evaluator.AddAlgorithm(ItemKNN, "Item KNN")
# Just make random recommendations
Random = NormalPredictor()
evaluator.AddAlgorithm(Random, "Random")
# Fight!
evaluator.Evaluate(False)
evaluator.SampleTopNRecs(ml)
param_grid = {'hiddenDim': [20, 10], 'learningRate': [0.1, 0.01]}
gs = GridSearchCV(RBMAlgorithm, param_grid, measures=['rmse', 'mae'], cv=3)
gs.fit(evaluationData)
# best RMSE score
print("Best RMSE score attained: ", gs.best_score['rmse'])
# combination of parameters that gave the best RMSE score
print(gs.best_params['rmse'])
# Construct an Evaluator to, you know, evaluate them
evaluator = Evaluator(evaluationData, rankings)
params = gs.best_params['rmse']
RBMtuned = RBMAlgorithm(hiddenDim=params['hiddenDim'],
learningRate=params['learningRate'])
evaluator.AddAlgorithm(RBMtuned, "RBM - Tuned")
RBMUntuned = RBMAlgorithm()
evaluator.AddAlgorithm(RBMUntuned, "RBM - Untuned")
# Just make random recommendations
Random = NormalPredictor()
evaluator.AddAlgorithm(Random, "Random")
# Fight!
evaluator.Evaluate(False)
evaluator.SampleTopNRecs(ml)
def loadMovieLensData():
ml = MovieLens()
print("Loading Movie ratings...")
data = ml.loadMovieLensLatestSmall()
print(
"\nComputing movie popularity ranks so we can measure novelty later..."
)
rankings = ml.getPopularityRanks()
return (ml, data, rankings)
np.random.seed(0)
random.seed(0)
(ml, evaluationData, rankings) = loadMovieLensData()
evaluator = Evaluator(evaluationData, rankings)
SimpleRBM = RBMAlgorithm(epochs=60)
SVD = SVD(n_epochs=30)
Hybrid = HybridAlgorithm([SimpleRBM, SVD], [0.5, 0.5])
evaluator.AddAlgorithm(SimpleRBM, "RBM")
evaluator.AddAlgorithm(SVD, "SVD")
evaluator.AddAlgorithm(Hybrid, "Hybrid")
evaluator.Evaluate(False)
evaluator.SampleTopNRecs(ml)
import numpy as np
np.random.seed(0)
random.seed(0)
def LoadMovieLensData():
ml = MovieLens()
print('Loading movie ratings..')
data = ml.loadMovieLensDataset()
#Compute movie popularity ranks to measure novelty
rankings = ml.getPopularityRanks()
return (ml,data,rankings)
#Load the common data set for the recommender algorithms
(ml,evaluationData,rankings) = LoadMovieLensData()
#create an evaluator which is an object of Evaluator class
evaluator = Evaluator(evaluationData,rankings)
#Item-Based KNN
t0=time()
sim_options_item = {'name':'cosine','user_based':False}
itemKNN = KNNBasic(sim_options = sim_options_item)
evaluator.AddAlgorithm(itemKNN,"ItemBased")
evaluator.Evaluate(True)
evaluator.SampleTopNRecs(ml)
tt=time()-t0
print("Item based CF Model trained in %s seconds" % round(tt,3))
def LoadMovieLensData():
ml = MovieLens()
print("Loading movie ratings...")
data = ml.loadMovieLensLatestSmall()
print(
"\nComputing movie popularity ranks so we can measure novelty later..."
)
rankings = ml.getPopularityRanks()
return (ml, data, rankings)
np.random.seed(0)
random.seed(0)
# Load up common data set for the recommender algorithms
(ml, evaluationData, rankings) = LoadMovieLensData()
# Construct an Evaluator to, you know, evaluate them
evaluator = Evaluator(evaluationData, rankings)
# User-based KNN
UserKNN = KNNBasic(sim_options={
'name': 'pearson_baseline',
'user_based': True,
'shrinkage': 0
})
evaluator.AddAlgorithm(UserKNN, "User KNN")
recomendations = evaluator.globalRecommendation()
evaluator.get_top_n(recomendations)
print("Loading movie ratings...")
data = ml.loadMovieLensLatestSmall()
print(
"\nComputing movie popularity ranks so we can measure novelty later..."
)
rankings = ml.getPopularityRanks()
return (ml, data, rankings)
np.random.seed(0)
random.seed(0)
# Load up common data set for the recommender algorithms
(ml, evaluationData, rankings) = LoadMovieLensData()
# Construct an Evaluator to, you know, evaluate them
evaluator = Evaluator(evaluationData, rankings)
#Autoencoder
AutoRec = AutoRecAlgorithm()
evaluator.AddAlgorithm(AutoRec, "AutoRec")
# Just make random recommendations
Random = NormalPredictor()
evaluator.AddAlgorithm(Random, "Random")
# Fight!
evaluator.Evaluate(True)
evaluator.SampleTopNRecs(ml)
data = ml.loadMovieLensLatestSmall()
print("\nComputing movie popularity ranks so we can measure novelty later...")
rankings = ml.getPopularityRanks()
return (ml, data, rankings)
np.random.seed(0)
random.seed(0)
# Load up common data set for the recommender algorithms
(ml, evaluationData, rankings) = LoadMovieLensData()
# Construct an Evaluator to, you know, evaluate them
evaluator = Evaluator(evaluationData, rankings)
#Content
ContentKNN = ContentKNNAlgorithm()
# SVD++
SVDPlusPlus = SVDpp()
evaluator.AddAlgorithm(SVDPlusPlus, "SVD++")
#Combine them
Hybrid = HybridAlgorithm([SVDPlusPlus, ContentKNN], [0.5, 0.5])
evaluator.AddAlgorithm(SVDPlusPlus, "SVD++")
evaluator.AddAlgorithm(ContentKNN, "ContentKNN")
evaluator.AddAlgorithm(Hybrid, "Hybrid")
evaluator.Evaluate(True)
param_grid = {'n_epochs': [20, 30], 'lr_all': [0.005, 0.010],
'n_factors': [50, 100]}
gs = GridSearchCV(SVD, param_grid, measures=['rmse', 'mae'], cv=3)
gs.fit(evaluationData)
# best RMSE score
print("Best RMSE score attained: ", gs.best_score['rmse'])
# combination of parameters that gave the best RMSE score
print(gs.best_params['rmse'])
# Construct an Evaluator to, you know, evaluate them
evaluator = Evaluator(evaluationData, rankings)
params = gs.best_params['rmse']
SVDtuned = SVD(n_epochs = params['n_epochs'], lr_all = params['lr_all'], n_factors = params['n_factors'])
evaluator.AddAlgorithm(SVDtuned, "SVD - Tuned")
SVDUntuned = SVD()
evaluator.AddAlgorithm(SVDUntuned, "SVD - Untuned")
# Just make random recommendations
Random = NormalPredictor()
evaluator.AddAlgorithm(Random, "Random")
# Fight!
evaluator.Evaluate(False)
evaluator.SampleTopNRecs(ml)
print("searching for the best parameters for svd...")
param_grid = {
'n_epochs': [14, 14],
'lr_all': [0.005, 0.005],
'n_factors': [10, 5]
}
gs = GridSearchCV(SVD, param_grid, measures=['rmse', 'mae'], cv=3)
gs.fit(evaluationData)
print("Best RMSE score attained: ", gs.best_score['rmse'])
# combination of parameters that gave the best RMSE score
print("Best parameters: ", gs.best_params['rmse'])
evaluator = Evaluator(evaluationData, rankings)
params = gs.best_params['rmse']
SVDtuned = SVD(n_epochs=params['n_epochs'],
lr_all=params['lr_all'],
n_factors=params['n_factors'])
evaluator.AddAlgorithm(SVDtuned, "SVD - Tuned")
SVDUntuned = SVD()
evaluator.AddAlgorithm(SVDUntuned, "SVD - Untuned")
evaluator.Evaluate(True)
evaluator.SampleTopNRecs(ml)
return (ml, data, rankings)
np.random.seed(0)
random.seed(0)
# Load up common data set for the recommender algorithms
(ml, evaluationData, rankings) = LoadMovieLensData()
# Construct an Evaluator to, you know, evaluate them
evaluator = Evaluator(evaluationData, rankings)
###### KNNBasic
# User-based KNN
UserKNN1 = KNNBasic(sim_options={'name': 'cosine', 'user_based': True})
evaluator.AddAlgorithm(UserKNN1, "User KNNBasic")
# Item-based KNN
ItemKNN1 = KNNBasic(sim_options={'name': 'cosine', 'user_based': False})
evaluator.AddAlgorithm(ItemKNN1, "Item KNNBasic")
###############
###### KNNWithZScore
# User-based KNN
UserKNN2 = KNNWithZScore(sim_options={'name': 'cosine', 'user_based': True})
evaluator.AddAlgorithm(UserKNN2, "User KNNWithZScore")
# Item-based KNN
ItemKNN2 = KNNWithZScore(sim_options={'name': 'cosine', 'user_based': False})
evaluator.AddAlgorithm(ItemKNN2, "Item KNNWithZScore")
###############
###### KNNWithMeans
# User-based KNN
UserKNN3 = KNNWithMeans(sim_options={'name': 'cosine', 'user_based': True})
np.random.seed(0)
random.seed(0)
# Load up common data set for the recommender algorithms
(ml, evaluationData, rankings) = LoadMovieLensData()
# Construct an Evaluator to, you know, evaluate them
evaluator = Evaluator(evaluationData, rankings)
# Just make random recommendations
Random = NormalPredictor()
#Content
ContentKNN = ContentBasedAlgorithm()
#Combine them
Hybrid = HybridAlgorithm([Random, ContentKNN], [0.5, 0.5])
t0=time()
evaluator.AddAlgorithm(Random, "Random")
evaluator.AddAlgorithm(ContentKNN, "ContentKNN")
evaluator.AddAlgorithm(Hybrid, "Hybrid")
evaluator.Evaluate(False)
evaluator.SampleTopNRecs(ml)
tt=time()-t0
print("time to run %s secs" % round(tt,3))
)
rankings = ml.getPopularityRanks()
return (ml, data, rankings)
np.random.seed(0)
random.seed(0)
# Load up common data set for the recommender algorithms
(ml, evaluationData, rankings) = LoadMovieLensData()
# Construct an Evaluator to, you know, evaluate them
evaluator = Evaluator(evaluationData, rankings)
# SVD
SVD = SVD()
evaluator.AddAlgorithm(SVD, "SVD")
# SVD++
SVDPlusPlus = SVDpp()
evaluator.AddAlgorithm(SVDPlusPlus, "SVD++")
# Just make random recommendations
Random = NormalPredictor()
evaluator.AddAlgorithm(Random, "Random")
# Fight!
evaluator.Evaluate(False)
evaluator.SampleTopNRecs(ml)
import numpy as np
from time import time
np.random.seed(0)
random.seed(0)
def LoadMovieLensData():
ml = MovieLens()
print('Loading movie ratings..')
data = ml.loadMovieLensDataset()
#Compute movie popularity ranks to measure novelty
rankings = ml.getPopularityRanks()
return (ml, data, rankings)
# Load up common data set for the recommender algorithms
(ml, evaluationData, rankings) = LoadMovieLensData()
evaluator = Evaluator(evaluationData, rankings)
# SVD++
SVDPlusPlus = SVDpp()
evaluator.AddAlgorithm(SVDPlusPlus, "SVD++")
t0 = time()
evaluator.Evaluate(True)
evaluator.SampleTopNRecs(ml)
tt = time() - t0
print("SVDpp Algorithm in %s seconds" % round(tt, 3))
