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 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 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 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)
) 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)
# 'Anger': "Family Musical Comedy", # 'Depressing': "Drama Biography", # "Confusing": 'Thriller Fantasy Crime', # "Inspring": "Biography Documentary Sport War", # "Thrilling": "Horror Mystery" } for mood, c in moods.items(): print(mood, c) # Load up common data set for the recommender algorithms (ml, evaluationData, rankings) = LoadMovieLensData(c) print("Searching for best parameters...") 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) evaluator = Evaluator(evaluationData, rankings, list(ml.movieID_to_name.keys())) 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") print("--------------------------------\n") filename = mood + ".sav" evaluator.SampleTopNRecs(ml, filename) print("--------------------------------\n\n")
def LoadData(): movielens = MovieLensData() print( "Loading all ratings and computing popularity ranks from Movie Lens..." ) data = movielens.loadMovieLens() ranks = movielens.computePopularity() return (movielens, data, ranks) (movielens, data_evaluation, ranks) = LoadData() evaluator = Evaluator(data_evaluation, ranks) ContentBased = ContentFiltering() itemKNN = KNNBasic(sim_options={'name': 'cosine', 'user_based': False}, k=15) Hybrid = HybridAlgorithm([ContentBased, itemKNN], [0.75, 0.25]) # print("Computing content-based similarity based on Genre, Year and Mise En Scene similarity") evaluator.AddAlgorithm(ContentBased, "Content Based Filtering") evaluator.AddAlgorithm(itemKNN, "Item-Based Collaborative Filtering") evaluator.AddAlgorithm(Hybrid, "Hybrid") evaluator.Evaluate(True) evaluator.SampleTopNRecs(movielens)
from surprise import NormalPredictor from Evaluator import Evaluator import random import numpy as np def LoadGoodBooksData(): gb = GoodBooks() data = gb.loadGoodBooksLatestSmall() rankings = gb.getPopularityRanks() return (gb, data, rankings) np.random.seed(0) random.seed(0) # Links to the GoodBooks.py class -- loads in our dataset (gb, evaluationData, rankings) = LoadGoodBooksData() # Constructs an evaluator evaluator = Evaluator(evaluationData, rankings) # SVD SVD = SVD() evaluator.AddAlgorithm(SVD, "SVD") # Fight! evaluator.Evaluate(False) evaluator.SampleTopNRecs(gb, testSubject=15)
'n_epochs': [10, 30], 'lr_all': [0.005, 0.010], 'n_factors': [50, 90] } gs = GridSearchCV(KNNBasic, 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'] KNNBasictuned = KNNBasic(n_epochs=params['n_epochs'], lr_all=params['lr_all'], n_factors=params['n_factors']) evaluator.AddAlgorithm(KNNBasictuned, "KNN - Tuned") KNNBasicUntuned = KNNBasic() evaluator.AddAlgorithm(KNNBasicUntuned, "KNN - Untuned") # Evaluating all algorithms evaluator.Evaluate(False) evaluator.SampleTopNRecs(ml, testSubject=85, k=10)
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(gb)