}
if __name__ == '__main__':
### step 3 : storing the results of every iteration
bayes_trials = Trials()
MAX_EVALS = 100
# Optimize
best = fmin(fn=objective,
space=item_cbf_space,
algo=hp.tpe.suggest,
max_evals=MAX_EVALS,
trials=bayes_trials,
verbose=True,
points_to_evaluate={
"topK": 1,
"shrink": 13,
"similarity": "cosine",
"normalize": True
})
### best will the return the the best hyperparameter set
params = space_eval(item_cbf_space, best)
print("Best parameters:", params)
RunRecommender.evaluate_on_test_set(ItemCBF,
params,
Kfold=4,
parallel_fit=True)
space=search_space,
algo=hp.tpe.suggest,
max_evals=MAX_EVALS,
trials=bayes_trials,
verbose=True,
points_to_evaluate=opt_eval)
params = space_eval(search_space, best)
### best will the return the the best hyperparameter set
print("Best parameters:")
print(params)
params["topK"] = int(params["topK"])
### best will the return the the best hyperparameter set
params = space_eval(search_space, best)
print("############### Best parameters ###############")
print(params)
print("############### Test set performance ###############")
RunRecommender.evaluate_on_test_set(AlternatingLeastSquare,
params,
parallel_fit=False,
Kfold=N_K_FOLD,
parallelize_evaluation=True,
user_group="warm")
computer_sleep(verbose=False)
'topK': 56
}
# RunRecommender.evaluate_on_validation_set(RP3betaRecommender, opt)
# Optimize
best = fmin(fn=objective,
space=als_space,
algo=hp.tpe.suggest,
max_evals=MAX_EVALS,
trials=bayes_trials,
verbose=True,
points_to_evaluate=[opt])
### best will the return the the best hyperparameter set
best = space_eval(als_space, best)
print("############### Best parameters ###############")
print(best)
RunRecommender.evaluate_on_test_set(RP3betaRecommender,
best,
Kfold=N_KFOLD,
parallelize_evaluation=True,
user_group="warm")
computer_sleep(verbose=False)
"""
MAP to beat: .03581871259565834 val
.041 test
"""
if exclude_seen:
unseen_items_mask = np.in1d(self.popular_items,
self.URM_CSR[user_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.popular_items[0:at]
return recommended_items
if __name__ == "__main__":
# evaluator = Evaluator()
# evaluator.split_data_randomly_2()
top_popular = TopPopRecommender
map10 = RunRecommender.evaluate_on_test_set(top_popular, {},
Kfold=4,
parallel_fit=True,
user_group="cold")
#print('{0:.128f}'.format(map10))
print(map10)
if __name__ == '__main__':
### step 3 : storing the results of every iteration
bayes_trials = Trials()
# Optimize
best = fmin(fn=objective,
space=slim_bpr_space,
algo=hp.tpe.suggest,
max_evals=MAX_EVALS,
trials=bayes_trials,
verbose=True)
### best will the return the the best hyperparameter set
params = space_eval(slim_bpr_space, best)
params["topK"] = int(params["topK"])
params["batch_size"] = int(params["batch_size"])
params["random_seed"] = 1234
params["epochs"] = 30
print("############### Best parameters ###############")
print(params)
RunRecommender.evaluate_on_test_set(SLIM_BPR_Cython,
params,
Kfold=N_KFOLD,
parallelize_evaluation=False,
user_group="warm")
'item_cbf_weight': 0.037666643326618406,
'item_cf_weight': 0.014294955186782246,
'rp3_weight': 0.9314974601074552
}
# Optimize
best = fmin(fn=objective,
space=search_space,
algo=hp.tpe.suggest,
max_evals=MAX_EVALS,
trials=bayes_trials,
verbose=True,
points_to_evaluate=[opt, new_opt, last_opt])
best = space_eval(search_space, best)
# best will the return the the best hyperparameter set
print("\n############## Best Parameters ##############\n")
print(best, "\n\nEvaluating on test set now...")
RunRecommender.evaluate_on_test_set(HybridElasticNetICFUCFRP3Beta,
best,
Kfold=N_KFOLD)
####################################################
# Test Map to beat 0.05112213282549001 #
# MAP-10 score: 0.05107393648464094 on kfold, k = 4#
####################################################
# {'SLIM_weight': 0.7989266787188458, 'item_cbf_weight': 0.03258554983815878, 'item_cf_weight': 0.0077609799300920445, 'rp3_weight': 0.6740989817682256}
"topK": hp.hp.quniform('topK', 0, 1000, 5),
"shrink": hp.hp.uniformint('shrink', 0, 50),
"bm_25_norm": hp.hp.choice('bm_25_norm', [True, False]),
"normalize": hp.hp.choice('normalize', [True, False]),
"similarity": hp.hp.choice('similarity', ["cosine", "jaccard", "dice"])
}
if __name__ == '__main__':
### step 3 : storing the results of every iteration
bayes_trials = Trials()
MAX_EVALS = 100
item_cf_parameters = {'shrink': 46.0, 'similarity': "jaccard", 'topK': 8}
# Optimize
best = fmin(fn=objective, space=search_space, algo=hp.tpe.suggest,
max_evals=MAX_EVALS, trials=bayes_trials, verbose=True, points_to_evaluate=item_cf_parameters)
params = space_eval(search_space, best)
### best will the return the the best hyperparameter set
print("Best parameters:")
print(params)
params["topK"] = int(params["topK"])
RunRecommender.evaluate_on_test_set(ItemCollaborativeFilter, best, parallel_fit=False, Kfold=N_K_FOLD, parallelize_evaluation=True )
# last_opt = {'SSLIM_weight': 0.8737840927419455, 'item_cbf_weight': 0.037666643326618406, 'item_cf_weight': 0.014294955186782246, 'rp3_weight': 0.9314974601074552, 'user_cbf_weight': 0, 'user_cf_weight': 0}
#
opt = {'AlternatingLeastSquare': 0.07611985905191196, 'ItemCBF': 0.017561491230314447, 'ItemCollaborativeFilter': 0.0341817493248531, 'RP3betaRecommender': 0.9713719890744753, 'SLIMElasticNetRecommender': 0.9974897962716185, 'SLIM_BPR_Recommender': 0.8633266021278376}
# Optimize
best = fmin(fn=objective, space=search_space, algo=hp.tpe.suggest,
max_evals=MAX_EVALS, trials=bayes_trials, verbose=True, points_to_evaluate=[opt])
best = space_eval(search_space, best)
# best will the return the the best hyperparameter set
print("\n############## Best Parameters ##############\n")
print(best, "\n\nEvaluating on test set now...")
RunRecommender.evaluate_on_test_set(Hybrid, {"weights": best}, Kfold=N_KFOLD,
init_params={"recommenders": [MultiThreadSLIM_ElasticNet, RP3betaRecommender, ItemCBF, AlternatingLeastSquare, SLIM_BPR_Cython]},
parallelize_evaluation=False,
parallel_fit=False)
computer_sleep(verbose=False)
####################################################
# Test Map to beat 0.05112213282549001 #
# MAP-10 score: 0.05107393648464094 on kfold, k = 4#
####################################################
new_best = {'ItemCBF': 0.013769403495491125, 'ItemCollaborativeFilter': 0.015447034894805844, 'RP3betaRecommender': 0.9945281573130214, 'SLIMElasticNetRecommender': 0.7629862396511091}
# {'SLIM_weight': 0.7989266787188458, 'item_cbf_weight': 0.03258554983815878, 'item_cf_weight': 0.0077609799300920445, 'rp3_weight': 0.6740989817682256}
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__':
new_params_cosine = {
'normalize': False,
'shrink': 50,
'suppress_interactions': False,
'topK': 540,
'top_pop_weight': 0.0020283643469209793
}
params_test_bm_25 = {'bm_25_norm': True}
RunRecommender.evaluate_on_test_set(HybridUserCBFRegionalTopPop, {},
Kfold=10,
user_group="cold",
parallelize_evaluation=True,
parallel_fit=False)
RunRecommender.evaluate_on_test_set(HybridUserCBFRegionalTopPop,
new_params_cosine,
Kfold=10,
user_group="cold",
parallelize_evaluation=True,
parallel_fit=False)
loss = - RunRecommender.evaluate_on_validation_set(UserCollaborativeFilter, params, Kfold=N_K_FOLD, parallel_fit=False, parallelize_evaluation=True, user_group="warm")
return loss
search_space = {
"topK": hp.hp.quniform('topK', 0, 1000, 5),
"shrink": hp.hp.uniformint('shrink', 0, 50),
"bm_25_norm": hp.hp.choice('bm_25_norm', [True, False]),
"normalize": hp.hp.choice('normalize', [True, False]),
"similarity": hp.hp.choice('similarity', ["cosine", "jaccard", "dice"])
}
if __name__ == '__main__':
### step 3 : storing the results of every iteration
bayes_trials = Trials()
MAX_EVALS = 100
# Optimize
best = fmin(fn=objective, space=search_space, algo=hp.tpe.suggest,
max_evals=MAX_EVALS, trials=bayes_trials, verbose=True, points_to_evaluate=[])
### best will the return the the best hyperparameter set
params = space_eval(search_space, best)
print("############### Best parameters ###############")
params["topK"] = int(params["topK"])
print(params)
print("############### Test set performance ###############")
RunRecommender.evaluate_on_test_set(UserCollaborativeFilter, params, parallel_fit=False, Kfold=N_K_FOLD, parallelize_evaluation=True, user_group="warm")
"top_pop_weight": 0.02139131367609725,
"topK": 765,
"shrink": 6,
"normalize": True,
"similarity": "jaccard",
"suppress_interactions": False
}
# Optimize
best = fmin(fn=objective,
space=user_cbf_space,
algo=hp.tpe.suggest,
max_evals=MAX_EVALS,
trials=bayes_trials,
verbose=True,
points_to_evaluate=[previous, last])
### best will the return the the best hyperparameter set
print(best)
params = space_eval(user_cbf_space, best)
print(params)
params["topK"] = int(params["topK"])
print("############### Performance on test set #################")
MAP = RunRecommender.evaluate_on_test_set(HybridUserCBFRegionalTopPop,
params,
Kfold=10,
user_group="cold",
parallel_fit=False,
parallelize_evaluation=True)
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_2()
ubcbf = UserCBF
params = {
'normalize': True,
'shrink': 1.0,
'similarity': "dice",
'suppress_interactions': True,
'topK': 93 * 5
}
# ubcbf.helper.split_ucm_region()
RunRecommender.evaluate_on_test_set(ubcbf,
params,
user_group="cold",
parallel_fit=True,
Kfold=4)
# print('{0:.128f}'.format(map10))
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 = {
'SLIM_weight': 0.9313349587356776,
'als_weight': 0.7463720610782647,
'item_cf_weight': 0.335817947135043
}
hybrid_ucficf = HybridALSElasticNetCF
# Evaluation is performed by RunRecommender
RunRecommender.evaluate_on_test_set(hybrid_ucficf, weights)
# RunRecommender.run(hybrid_ucficf, weights)
# Compute scores of the recommendation
scores = self.compute_scores(user_id)
# Filter to exclude already seen items
if exclude_seen:
scores = self.filter_seen(user_id, scores)
recommended_items = np.argsort(scores)
recommended_items = np.flip(recommended_items, axis=0)
return recommended_items[: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.split_data_randomly()
parameters = {"topK": 4, "shrink": 8}
cbf_recommender = AssetCBF
RunRecommender.evaluate_on_test_set(cbf_recommender, parameters)
# RunRecommender.run(cbf_recommender)
def objective(params):
print("Current parameters:")
print(params)
loss = -RunRecommender.evaluate_on_test_set(PureSVDRecommender, params)
return loss
: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 = {'SLIM_weight': 0.8950096358670148, 'item_cbf_weight': 0.034234727663263104, 'item_cf_weight': 0.011497379340447589, 'rp3_weight': 0.8894480634395567}
#weights2 = {'SLIM_weight': 0.8525330515257261, 'item_cbf_weight': 0.03013686377319209, 'item_cf_weight': 0.01129668459365759, 'rp3_weight': 0.9360587800999112}
weights = {'SLIM_weight': 0.8737840927419455, 'item_cbf_weight': 0.037666643326618406, 'item_cf_weight': 0.014294955186782246, 'rp3_weight': 0.9314974601074552}
hybrid_ucficf = HybridElasticNetICFUCFRP3Beta
# Evaluation is performed by RunRecommender
# RunRecommender.evaluate_on_test_set(hybrid_ucficf, weights)
RunRecommender.evaluate_on_test_set(hybrid_ucficf, weights, Kfold=4, parallelize_evaluation=True)
#RunRecommender.evaluate_on_validation_set(hybrid_ucficf, weights)
RunRecommender.run(hybrid_ucficf, weights)
from SLIM_BPR.Cython.SLIM_BPR_Cython import SLIM_BPR_Cython
from utils.run import RunRecommender
recommender = SLIM_BPR_Cython
RunRecommender.evaluate_on_test_set(SLIM_BPR_Cython, {})
loss = - RunRecommender.evaluate_on_validation_set(UserCBF, params, Kfold=4, user_group="cold")
return loss
user_cbf_space = {
"topK": hp.hp.choice('topK', np.arange(0, 500, 5)),
"shrink": hp.hp.uniformint('shrink', 0, 50),
"similarity": hp.hp.choice('similarity', ["cosine", "adjusted", "asymmetric", "pearson", "jaccard", "dice", "tversky", "tanimoto"]),
"suppress_interactions": hp.hp.choice('suppress_interactions', [True, False]),
"normalize": hp.hp.choice('normalize', [True, False])
}
if __name__ == '__main__':
### step 3 : storing the results of every iteration
bayes_trials = Trials()
MAX_EVALS = 100
previous = {'normalize': True, 'shrink': 5, 'similarity': "cosine", 'suppress_interactions': False, 'topK': 200}
last = {'normalize': True, 'shrink': 1.0, 'similarity': "dice", 'suppress_interactions': True, 'topK': 93*5}
# Optimize
best = fmin(fn=objective, space=user_cbf_space, algo=hp.tpe.suggest,
max_evals=MAX_EVALS, trials=bayes_trials, verbose=True, points_to_evaluate=[previous, last])
### best will the return the the best hyperparameter set
print(best)
MAP = RunRecommender.evaluate_on_test_set(UserCBF, best, Kfold=4, user_group="cold")
def recommend(self, user_id, at=10, exclude_seen=True):
scores = self.compute_scores(user_id)
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__":
from utils.run import RunRecommender
cb = ItemCollaborativeFilter
map10 = RunRecommender.evaluate_on_test_set(cb, {})
return loss
item_cbf_space = {
"topK": hp.hp.choice('topK', np.arange(0, 500, 5)),
"shrink": hp.hp.uniformint('shrink', 0, 50),
"similarity": hp.hp.choice('similarity', ["cosine", "jaccard", "dice"]),
"bm_25_normalization": hp.hp.choice('bm_25_normalization', [True, False]),
"normalize": hp.hp.choice('normalize', [True, False])
}
if __name__ == '__main__':
### step 3 : storing the results of every iteration
bayes_trials = Trials()
MAX_EVALS = 100
# Optimize
best = fmin(fn=objective, space=item_cbf_space, algo=hp.tpe.suggest,
max_evals=MAX_EVALS, trials=bayes_trials, verbose=True)
### best will the return the the best hyperparameter set
params = space_eval(item_cbf_space, best)
print('################### Best parameters ######################')
print("Parameters:", params)
print('################### Performance on Test set ######################')
RunRecommender.evaluate_on_test_set(UserCBF, params, Kfold=N_FOLD, parallelize_evaluation=True, user_group="warm")
def objective(params):
print("Current parameters:")
print(params)
loss = -RunRecommender.evaluate_on_test_set(MF_MSE_PyTorch, params)
return loss
