if exclude_seen:
scores = self.filter_seen(user_id, scores)
# rank items
ranking = scores.argsort()[::-1]
return ranking[:at]
def filter_seen(self, user_id, scores):
start_pos = self.URM_train.indptr[user_id]
end_pos = self.URM_train.indptr[user_id + 1]
user_profile = self.URM_train.indices[start_pos:end_pos]
scores[user_profile] = -np.inf
return scores
if __name__ == "__main__":
# evaluator = Evaluator()
# evaluator.split_data_randomly()
user_cf_parameters = {"topK": 410, "shrink": 0}
cb = UserCollaborativeFilter
map10 = RunRecommender.run(cb, user_cf_parameters)
return recommended_items[0: at]
def filter_seen(self, user_id, scores):
"""Remove items that are in the user profile from recommendations
:param user_id: array of user ids for which to compute recommendations
:param scores: array containing the scores for each object"""
start_pos = self.URM_train.indptr[user_id]
end_pos = self.URM_train.indptr[user_id + 1]
user_profile = self.URM_train.indices[start_pos:end_pos]
scores[user_profile] = -np.inf
return scores
if __name__ == "__main__":
# Train and test data are now loaded by the helper
weights = {'SSLIM_weight': 0.35630766332989877, 'item_cbf_weight': 0.0016397036630690053, 'item_cf_weight': 0.028077081167200757, 'rp3_weight': 0.6615055983108671}
hybrid_ucficf = HybridSSLIMICFUCFRP3Beta
RunRecommender.run(hybrid_ucficf, weights)
#RunRecommender.evaluate_on_test_set(hybrid_ucficf, weights, Kfold=10, parallelize_evaluation=True)
scores[user_profile] = -np.inf
return scores
if __name__ == "__main__":
# Train and test data are now loaded by the helper
# weights = {"weights": {'AlternatingLeastSquare': 0.09136760425375567, 'ItemCBF': 0.01686781824511765, 'ItemCollaborativeFilter': 0.03454041362675262, 'RP3betaRecommender': 0.8187162817070645, 'SLIMElasticNetRecommender': 0.7756431422518303}}
weights = {
"weights": {
'ItemCBF': 0.013769403495491125,
'ItemCollaborativeFilter': 0.015447034894805844,
'RP3betaRecommender': 0.9945281573130214,
'SLIMElasticNetRecommender': 0.7629862396511091
}
}
# weights = {"weights": {'RP3betaRecommender': 1}}
RunRecommender.run(Hybrid,
weights,
init_params={
"recommenders": [
MultiThreadSLIM_ElasticNet,
ItemCollaborativeFilter, RP3betaRecommender,
ItemCBF
]
})
#RunRecommender.run(Hybrid, weights, init_params={"recommenders": [RP3betaRecommender]})
#RunRecommender.evaluate_on_test_set(hybrid_ucficf, weights, Kfold=10, parallelize_evaluation=True)
return scores
def recommend(self, playlist_id, at=10, exclude_seen=True):
# Compute scores of the recommendation
scores = self.compute_scores(playlist_id)
# Filter to exclude already seen items
if exclude_seen:
scores = self.filter_seen(playlist_id, scores)
recommended_items = np.argsort(scores)
recommended_items = np.flip(recommended_items, axis=0)
return recommended_items[:at]
def filter_seen(self, playlist_id, scores):
start_pos = self.URM.indptr[playlist_id]
end_pos = self.URM.indptr[playlist_id + 1]
user_profile = self.URM.indices[start_pos:end_pos]
scores[user_profile] = -np.inf
return scores
if __name__ == "__main__":
cbf_recommender = CBFRecomender()
evaluator = Evaluator()
evaluator.split_data_randomly()
runner = RunRecommender()
runner.run(cbf_recommender)
item_popularity = (self.URM_CSR > 0).sum(axis=0)
# Squeeze term removes single-dimensional entries from the shape of an array.
item_popularity = np.array(item_popularity).squeeze()
# Ordering the items according to the popularity values
self.popular_items = np.argsort(item_popularity)
# Flip order high to lower
self.popular_items = np.flip(self.popular_items, axis=0)
def recommend(self, playlist_id, at=10, remove_seen = True):
if remove_seen:
unseen_items_mask = np.in1d(self.popular_items, self.URM_CSR[playlist_id].indices, assume_unique=True, invert=True)
unseen_items = self.popular_items[unseen_items_mask]
recommended_items = unseen_items[0:at]
else:
recommended_items = self.popularItems[0:at]
return recommended_items
if __name__ == "__main__":
helper = Helper()
top_popular = TopPopRecommender(helper)
runner = RunRecommender()
runner.run(top_popular)
scores[user_profile] = -np.inf
return scores
if __name__ == "__main__":
# Train and test data are now loaded by the helper
weights = {'SLIM_weight': 0.9852122782782439}
hybrid_als_slim = HybridALSElasticNet
# Evaluation is performed by RunRecommender
# RunRecommender.evaluate_on_validation_set(hybrid_als_slim, weights)
RunRecommender.run(hybrid_als_slim, weights)
from SSLIMElasticNetRecommender import MultiThreadSSLIM_ElasticNet
from Hybrid_User_CBF_Regional_TopPop import HybridUserCBFRegionalTopPop
from UserCollaborativeFilter import UserCollaborativeFilter
from UserCBF import UserCBF
import numpy as np
from utils.run import RunRecommender
from utils.helper import Helper
UCF_parameters = {
'bm_25_norm': True,
'normalize': False,
'shrink': 29,
'similarity': 'cosine',
self.W_sparse = sps.csr_matrix(
(values[:numCells], (rows[:numCells], cols[:numCells])),
shape=(Pui.shape[1], Pui.shape[1]))
if self.normalize_similarity:
self.W_sparse = normalize(self.W_sparse, norm='l1', axis=1)
if self.topK != False:
self.W_sparse = similarityMatrixTopK(self.W_sparse, k=self.topK)
self.W_sparse = check_matrix(self.W_sparse, format='csr')
if __name__ == "__main__":
# opt2 = {'alpha': 1.0007888517936574, 'beta': 0.04055276086709765, 'implicit': True, 'min_rating': 0, 'normalize_similarity': True, 'topK': 26}
# opt ={'alpha': 1.009077614740585, 'beta': 0.029849929646199647, 'implicit': True, 'min_rating': 0, 'normalize_similarity': True, 'topK': 600}
opt_kfold = {
'alpha': 0.29165867718335486,
'beta': 0.20255242992271763,
'topK': 50.0,
'implicit': True,
'min_rating': 0,
'normalize_similarity': True,
'topK': 26
}
# RunRecommender.evaluate_on_validation_set(RP3betaRecommender, opt)
RunRecommender.run(RP3betaRecommender, opt_kfold)
