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))