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)