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)
