def runParameterSearch_Content(recommender_class, URM_train, ICM_object, ICM_name, n_cases=30,
evaluator_validation=None, evaluator_test=None, metric_to_optimize="PRECISION",
output_root_path="result_experiments/", parallelizeKNN=False):
# If directory does not exist, create
if not os.path.exists(output_root_path):
os.makedirs(output_root_path)
##########################################################################################################
this_output_root_path = output_root_path + recommender_class.RECOMMENDER_NAME + "_{}".format(ICM_name)
parameterSearch = BayesianSearch(recommender_class, evaluator_validation=evaluator_validation,
evaluator_test=evaluator_test)
similarity_type_list = ['cosine', 'jaccard', "asymmetric", "dice", "tversky"]
run_KNNCBFRecommender_on_similarity_type_partial = partial(run_KNNCBFRecommender_on_similarity_type,
parameterSearch=parameterSearch,
URM_train=URM_train,
ICM_train=ICM_object,
n_cases=n_cases,
output_root_path=this_output_root_path,
metric_to_optimize=metric_to_optimize)
if parallelizeKNN:
pool = PoolWithSubprocess(processes=int(multiprocessing.cpu_count()), maxtasksperchild=1)
resultList = pool.map(run_KNNCBFRecommender_on_similarity_type_partial, similarity_type_list)
else:
for similarity_type in similarity_type_list:
run_KNNCBFRecommender_on_similarity_type_partial(similarity_type)
def hybrid_repo(is_test):
b = Builder()
ev = Evaluator()
ev.split()
ICM = b.build_ICM()
URM_train, URM_test = train_test_holdout(b.get_URM(), train_perc=0.8)
URM_train, URM_validation = train_test_holdout(URM_train, train_perc=0.9)
from ParameterTuning.AbstractClassSearch import EvaluatorWrapper
from Base.Evaluation.Evaluator import SequentialEvaluator
evaluator_validation = SequentialEvaluator(URM_validation, cutoff_list=[5])
evaluator_test = SequentialEvaluator(URM_test, cutoff_list=[5, 10])
evaluator_validation = EvaluatorWrapper(evaluator_validation)
evaluator_test = EvaluatorWrapper(evaluator_test)
from KNN.ItemKNNCFRecommender import ItemKNNCFRecommender
from ParameterTuning.BayesianSearch import BayesianSearch
recommender_class = ItemKNNCFRecommender
parameterSearch = BayesianSearch(recommender_class,
evaluator_validation=evaluator_validation,
evaluator_test=evaluator_test)
from ParameterTuning.AbstractClassSearch import DictionaryKeys
hyperparamethers_range_dictionary = {}
hyperparamethers_range_dictionary["topK"] = [
5, 10, 20, 50, 100, 150, 200, 300, 400, 500, 600, 700, 800
]
hyperparamethers_range_dictionary["shrink"] = [
0, 10, 50, 100, 200, 300, 500, 1000
]
hyperparamethers_range_dictionary["similarity"] = ["cosine"]
hyperparamethers_range_dictionary["normalize"] = [True, False]
recommenderDictionary = {
DictionaryKeys.CONSTRUCTOR_POSITIONAL_ARGS: [URM_train],
DictionaryKeys.CONSTRUCTOR_KEYWORD_ARGS: {},
DictionaryKeys.FIT_POSITIONAL_ARGS: dict(),
DictionaryKeys.FIT_KEYWORD_ARGS: dict(),
DictionaryKeys.FIT_RANGE_KEYWORD_ARGS:
hyperparamethers_range_dictionary
}
output_root_path = "result_experiments/"
import os
# If directory does not exist, create
if not os.path.exists(output_root_path):
os.makedirs(output_root_path)
output_root_path += recommender_class.RECOMMENDER_NAME
n_cases = 2
metric_to_optimize = "MAP"
best_parameters = parameterSearch.search(recommenderDictionary,
n_cases=n_cases,
output_root_path=output_root_path,
metric=metric_to_optimize)
itemKNNCF = ItemKNNCFRecommender(URM_train)
itemKNNCF.fit(**best_parameters)
from FW_Similarity.CFW_D_Similarity_Linalg import CFW_D_Similarity_Linalg
n_cases = 2
metric_to_optimize = "MAP"
best_parameters_ItemKNNCBF = parameterSearch.search(
recommenderDictionary,
n_cases=n_cases,
output_root_path=output_root_path,
metric=metric_to_optimize)
itemKNNCBF = ItemKNNCBFRecommender(ICM, URM_train)
itemKNNCBF.fit(**best_parameters_ItemKNNCBF)
"""
#_____________________________________________________________________
from ParameterTuning.BayesianSearch import BayesianSearch
from ParameterTuning.AbstractClassSearch import DictionaryKeys
from ParameterTuning.AbstractClassSearch import EvaluatorWrapper
evaluator_validation_tuning = EvaluatorWrapper(evaluator_validation)
evaluator_test_tuning = EvaluatorWrapper(evaluator_test)
recommender_class = CFW_D_Similarity_Linalg
parameterSearch = BayesianSearch(recommender_class,
evaluator_validation=evaluator_validation_tuning,
evaluator_test=evaluator_test_tuning)
hyperparamethers_range_dictionary = {}
hyperparamethers_range_dictionary["topK"] = [5, 10, 20, 50, 100, 150, 200, 300, 400, 500, 600, 700, 800]
hyperparamethers_range_dictionary["add_zeros_quota"] = range(0, 1)
hyperparamethers_range_dictionary["normalize_similarity"] = [True, False]
recommenderDictionary = {DictionaryKeys.CONSTRUCTOR_POSITIONAL_ARGS: [URM_train, ICM, itemKNNCF.W_sparse],
DictionaryKeys.CONSTRUCTOR_KEYWORD_ARGS: {},
DictionaryKeys.FIT_POSITIONAL_ARGS: dict(),
DictionaryKeys.FIT_KEYWORD_ARGS: dict(),
DictionaryKeys.FIT_RANGE_KEYWORD_ARGS: hyperparamethers_range_dictionary}
output_root_path = "result_experiments/"
import os
# If directory does not exist, create
if not os.path.exists(output_root_path):
os.makedirs(output_root_path)
output_root_path += recommender_class.RECOMMENDER_NAME
n_cases = 2
metric_to_optimize = "MAP"
best_parameters_CFW_D = parameterSearch.search(recommenderDictionary,
n_cases=n_cases,
output_root_path=output_root_path,
metric=metric_to_optimize)
CFW_weithing = CFW_D_Similarity_Linalg(URM_train, ICM, itemKNNCF.W_sparse)
CFW_weithing.fit(**best_parameters_CFW_D)
#___________________________________________________________________________________________-
"""
from GraphBased.P3alphaRecommender import P3alphaRecommender
P3alpha = P3alphaRecommender(URM_train)
P3alpha.fit()
from MatrixFactorization.PureSVD import PureSVDRecommender
#pureSVD = PureSVDRecommender(URM_train)
#pureSVD.fit()
rec = HybridRec.HybridRec()
S_UCM = b.get_S_UCM_KNN(b.get_UCM(ev.get_URM_train()), 600)
S_ICM = b.build_S_ICM_knn(b.build_ICM(), 250)
rec.fit(ev.get_URM_train(),
ev.get_target_playlists(),
ev.get_target_tracks(),
ev.num_playlists_to_test,
itemKNNCBF.W_sparse,
itemKNNCF.W_sparse,
P3alpha.W_sparse,
is_test=True,
alfa=0.7,
avg=0.3)
train_df = rec.recommend()
if is_test:
map5 = ev.map5(train_df)
print('Hybrid MAP@10:', map5)
return map5
else:
print('Prediction saved!')
train_df.to_csv(os.path.dirname(os.path.realpath(__file__))[:-19] +
"/all/sub.csv",
sep=',',
index=False)
return 0
#hybridrecommender = ItemKNNSimilarityHybridRecommender(URM_train, itemKNNCF.W_sparse, P3alpha.W_sparse)
#hybridrecommender.fit(alpha=0.5)
#print(evaluator_validation.evaluateRecommender(hybridrecommender))
"""
#evaluator_test = SequentialEvaluator(URM_test, cutoff_list=[10])
evaluator_validation = EvaluatorWrapper(evaluator_validation)
#evaluator_test = EvaluatorWrapper(evaluator_test)
# ------------------------
# Recommender class definition
# ------------------------
recommender_class = ItemKNNCBFRecommender
# ------------------------
# Instanciating BayesianSearch
# ------------------------
parameterSearch = BayesianSearch(recommender_class,
evaluator_validation=evaluator_validation)
# -------------------------------
# Defining parameters dictionnary
# -------------------------------
hyperparamethers_range_dictionary = {}
hyperparamethers_range_dictionary["topK"] = [
5, 10, 20, 50, 100, 150, 200, 300, 400, 500, 600, 700, 800
]
hyperparamethers_range_dictionary["shrink"] = [
0, 10, 50, 100, 200, 300, 500, 1000
]
hyperparamethers_range_dictionary["similarity"] = ["cosine"]
hyperparamethers_range_dictionary["normalize"] = [True, False]
def runParameterSearch_Collaborative(recommender_class,
URM_train,
metric_to_optimize="PRECISION",
evaluator_validation=None,
evaluator_test=None,
evaluator_validation_earlystopping=None,
output_root_path="result_experiments/",
parallelizeKNN=True,
n_cases=30):
"""runParameterSearch_Collaborative use the BayesianSearch class to fin best parameters
:param recommender_class: The name of the class on which you want to optimize parameters
:param URM_train:
:param metric_to_optimize: The metric you want to optimize; "MAP", "Precision"...
:param evaluator_validation:
:param evaluator_test:
:param evaluator_validation_earlystopping:
:param output_root_path:
:param parallelizeKNN:
:param n_cases:
:return:
"""
from ParameterTuning.AbstractClassSearch import DictionaryKeys
# If directory does not exist, create
if not os.path.exists(output_root_path):
os.makedirs(output_root_path)
try:
output_root_path_rec_name = output_root_path + recommender_class.RECOMMENDER_NAME
parameterSearch = BayesianSearch(
recommender_class,
evaluator_validation=evaluator_validation,
evaluator_test=evaluator_test)
if recommender_class in [TopPop, Random]:
recommender = recommender_class(URM_train)
recommender.fit()
output_file = open(
output_root_path_rec_name + "_BayesianSearch.txt", "a")
result_dict, result_baseline = evaluator_validation.evaluateRecommender(
recommender)
output_file.write(
"ParameterSearch: Best result evaluated on URM_validation. Results: {}"
.format(result_baseline))
pickle.dump(
result_dict.copy(),
open(output_root_path_rec_name + "_best_result_validation",
"wb"),
protocol=pickle.HIGHEST_PROTOCOL)
result_dict, result_baseline = evaluator_test.evaluateRecommender(
recommender)
output_file.write(
"ParameterSearch: Best result evaluated on URM_test. Results: {}"
.format(result_baseline))
pickle.dump(result_dict.copy(),
open(output_root_path_rec_name + "_best_result_test",
"wb"),
protocol=pickle.HIGHEST_PROTOCOL)
output_file.close()
return
##########################################################################################################
if recommender_class is UserKNNCFRecommender:
similarity_type_list = [
'cosine', 'jaccard', "asymmetric", "dice", "tversky"
]
run_KNNCFRecommender_on_similarity_type_partial = partial(
run_KNNCFRecommender_on_similarity_type,
parameterSearch=parameterSearch,
URM_train=URM_train,
n_cases=n_cases,
output_root_path=output_root_path_rec_name,
metric_to_optimize=metric_to_optimize)
if parallelizeKNN:
pool = PoolWithSubprocess(processes=int(2), maxtasksperchild=1)
resultList = pool.map(
run_KNNCFRecommender_on_similarity_type_partial,
similarity_type_list)
else:
for similarity_type in similarity_type_list:
run_KNNCFRecommender_on_similarity_type_partial(
similarity_type)
return
##########################################################################################################
if recommender_class is ItemKNNCFRecommender:
similarity_type_list = [
'cosine', 'jaccard', "asymmetric", "dice", "tversky"
]
run_KNNCFRecommender_on_similarity_type_partial = partial(
run_KNNCFRecommender_on_similarity_type,
parameterSearch=parameterSearch,
URM_train=URM_train,
n_cases=n_cases,
output_root_path=output_root_path_rec_name,
metric_to_optimize=metric_to_optimize)
if parallelizeKNN:
pool = PoolWithSubprocess(processes=int(2), maxtasksperchild=1)
resultList = pool.map(
run_KNNCFRecommender_on_similarity_type_partial,
similarity_type_list)
else:
for similarity_type in similarity_type_list:
run_KNNCFRecommender_on_similarity_type_partial(
similarity_type)
return
##########################################################################################################
# if recommender_class is MultiThreadSLIM_RMSE:
#
# hyperparamethers_range_dictionary = {}
# hyperparamethers_range_dictionary["topK"] = [50, 100]
# hyperparamethers_range_dictionary["l1_penalty"] = [1e-2, 1e-3, 1e-4]
# hyperparamethers_range_dictionary["l2_penalty"] = [1e-2, 1e-3, 1e-4]
#
#
# recommenderDictionary = {DictionaryKeys.CONSTRUCTOR_POSITIONAL_ARGS: [URM_train],
# DictionaryKeys.CONSTRUCTOR_KEYWORD_ARGS: {},
# DictionaryKeys.FIT_POSITIONAL_ARGS: dict(),
# DictionaryKeys.FIT_KEYWORD_ARGS: dict(),
# DictionaryKeys.FIT_RANGE_KEYWORD_ARGS: hyperparamethers_range_dictionary}
#
#
##########################################################################################################
if recommender_class is P3alphaRecommender:
hyperparamethers_range_dictionary = {}
hyperparamethers_range_dictionary["topK"] = [
5, 10, 20, 50, 100, 150, 200, 300, 400, 500, 600, 700, 800
]
hyperparamethers_range_dictionary["alpha"] = range(0, 2)
hyperparamethers_range_dictionary["normalize_similarity"] = [
True, False
]
recommenderDictionary = {
DictionaryKeys.CONSTRUCTOR_POSITIONAL_ARGS: [URM_train],
DictionaryKeys.CONSTRUCTOR_KEYWORD_ARGS: {},
DictionaryKeys.FIT_POSITIONAL_ARGS:
dict(),
DictionaryKeys.FIT_KEYWORD_ARGS:
dict(),
DictionaryKeys.FIT_RANGE_KEYWORD_ARGS:
hyperparamethers_range_dictionary
}
##########################################################################################################
if recommender_class is RP3betaRecommender:
hyperparamethers_range_dictionary = {}
hyperparamethers_range_dictionary["topK"] = [
5, 10, 20, 50, 100, 150, 200, 300, 400, 500, 600, 700, 800
]
hyperparamethers_range_dictionary["alpha"] = range(0, 2)
hyperparamethers_range_dictionary["beta"] = range(0, 2)
hyperparamethers_range_dictionary["normalize_similarity"] = [
True, False
]
recommenderDictionary = {
DictionaryKeys.CONSTRUCTOR_POSITIONAL_ARGS: [URM_train],
DictionaryKeys.CONSTRUCTOR_KEYWORD_ARGS: {},
DictionaryKeys.FIT_POSITIONAL_ARGS:
dict(),
DictionaryKeys.FIT_KEYWORD_ARGS:
dict(),
DictionaryKeys.FIT_RANGE_KEYWORD_ARGS:
hyperparamethers_range_dictionary
}
##########################################################################################################
if recommender_class is MatrixFactorization_FunkSVD_Cython:
hyperparamethers_range_dictionary = {}
hyperparamethers_range_dictionary["sgd_mode"] = ["adagrad", "adam"]
#hyperparamethers_range_dictionary["epochs"] = [1, 5, 10, 20, 30, 50, 70, 90, 110]
hyperparamethers_range_dictionary["num_factors"] = [
1, 5, 10, 20, 30, 50, 70, 90, 110
]
hyperparamethers_range_dictionary["reg"] = [0.0, 1e-3, 1e-6, 1e-9]
hyperparamethers_range_dictionary["learning_rate"] = [
1e-2, 1e-3, 1e-4, 1e-5
]
recommenderDictionary = {
DictionaryKeys.CONSTRUCTOR_POSITIONAL_ARGS: [URM_train],
DictionaryKeys.CONSTRUCTOR_KEYWORD_ARGS: {},
DictionaryKeys.FIT_POSITIONAL_ARGS:
dict(),
DictionaryKeys.FIT_KEYWORD_ARGS: {
"validation_every_n": 5,
"stop_on_validation": True,
"evaluator_object": evaluator_validation_earlystopping,
"lower_validatons_allowed": 20,
"validation_metric": metric_to_optimize
},
DictionaryKeys.FIT_RANGE_KEYWORD_ARGS:
hyperparamethers_range_dictionary
}
##########################################################################################################
if recommender_class is MatrixFactorization_BPR_Cython:
hyperparamethers_range_dictionary = {}
hyperparamethers_range_dictionary["sgd_mode"] = ["adagrad", "adam"]
#hyperparamethers_range_dictionary["epochs"] = [1, 5, 10, 20, 30, 50, 70, 90, 110]
hyperparamethers_range_dictionary["num_factors"] = [
1, 5, 10, 20, 30, 50, 70, 90, 110
]
hyperparamethers_range_dictionary["batch_size"] = [1]
hyperparamethers_range_dictionary["positive_reg"] = [
0.0, 1e-3, 1e-6, 1e-9
]
hyperparamethers_range_dictionary["negative_reg"] = [
0.0, 1e-3, 1e-6, 1e-9
]
hyperparamethers_range_dictionary["learning_rate"] = [
1e-2, 1e-3, 1e-4, 1e-5
]
recommenderDictionary = {
DictionaryKeys.CONSTRUCTOR_POSITIONAL_ARGS: [URM_train],
DictionaryKeys.CONSTRUCTOR_KEYWORD_ARGS: {
'positive_threshold': 0
},
DictionaryKeys.FIT_POSITIONAL_ARGS:
dict(),
DictionaryKeys.FIT_KEYWORD_ARGS: {
"validation_every_n": 5,
"stop_on_validation": True,
"evaluator_object": evaluator_validation_earlystopping,
"lower_validatons_allowed": 20,
"validation_metric": metric_to_optimize
},
DictionaryKeys.FIT_RANGE_KEYWORD_ARGS:
hyperparamethers_range_dictionary
}
##########################################################################################################
if recommender_class is PureSVDRecommender:
hyperparamethers_range_dictionary = {}
hyperparamethers_range_dictionary["num_factors"] = list(
range(0, 250, 5))
recommenderDictionary = {
DictionaryKeys.CONSTRUCTOR_POSITIONAL_ARGS: [URM_train],
DictionaryKeys.CONSTRUCTOR_KEYWORD_ARGS: {},
DictionaryKeys.FIT_POSITIONAL_ARGS:
dict(),
DictionaryKeys.FIT_KEYWORD_ARGS: {},
DictionaryKeys.FIT_RANGE_KEYWORD_ARGS:
hyperparamethers_range_dictionary
}
#########################################################################################################
if recommender_class is SLIM_BPR_Cython:
hyperparamethers_range_dictionary = {}
hyperparamethers_range_dictionary["topK"] = [
5, 10, 20, 50, 100, 150, 200, 300, 400, 500, 600, 700, 800
]
#hyperparamethers_range_dictionary["epochs"] = [1, 5, 10, 20, 30, 50, 70, 90, 110]
hyperparamethers_range_dictionary["sgd_mode"] = ["adagrad", "adam"]
hyperparamethers_range_dictionary["lambda_i"] = [
0.0, 1e-3, 1e-6, 1e-9
]
hyperparamethers_range_dictionary["lambda_j"] = [
0.0, 1e-3, 1e-6, 1e-9
]
recommenderDictionary = {
DictionaryKeys.CONSTRUCTOR_POSITIONAL_ARGS: [URM_train],
DictionaryKeys.CONSTRUCTOR_KEYWORD_ARGS: {
'train_with_sparse_weights': True,
'symmetric': True,
'positive_threshold': 0
},
DictionaryKeys.FIT_POSITIONAL_ARGS:
dict(),
DictionaryKeys.FIT_KEYWORD_ARGS: {
"validation_every_n": 5,
"stop_on_validation": True,
"evaluator_object": evaluator_validation_earlystopping,
"lower_validatons_allowed": 10,
"validation_metric": metric_to_optimize
},
DictionaryKeys.FIT_RANGE_KEYWORD_ARGS:
hyperparamethers_range_dictionary
}
##########################################################################################################
if recommender_class is SLIMElasticNetRecommender:
hyperparamethers_range_dictionary = {}
hyperparamethers_range_dictionary["topK"] = [
5, 10, 20, 50, 100, 150, 200, 300, 400, 500, 600, 700, 800
]
hyperparamethers_range_dictionary["l1_penalty"] = [
1.0, 0.0, 1e-2, 1e-4, 1e-6
]
hyperparamethers_range_dictionary["l2_penalty"] = [
100.0, 1.0, 0.0, 1e-2, 1e-4, 1e-6
]
recommenderDictionary = {
DictionaryKeys.CONSTRUCTOR_POSITIONAL_ARGS: [URM_train],
DictionaryKeys.CONSTRUCTOR_KEYWORD_ARGS: {},
DictionaryKeys.FIT_POSITIONAL_ARGS:
dict(),
DictionaryKeys.FIT_KEYWORD_ARGS:
dict(),
DictionaryKeys.FIT_RANGE_KEYWORD_ARGS:
hyperparamethers_range_dictionary
}
##########################################################################################################
if recommender_class is HybridRecommender:
hyperparamethers_range_dictionary = {}
hyperparamethers_range_dictionary["topK"] = [
5, 10, 20, 50, 100, 150, 200, 300, 400, 500, 600, 700, 800
]
hyperparamethers_range_dictionary["l1_penalty"] = [
1.0, 0.0, 1e-2, 1e-4, 1e-6
]
hyperparamethers_range_dictionary["l2_penalty"] = [
100.0, 1.0, 0.0, 1e-2, 1e-4, 1e-6
]
recommenderDictionary = {
DictionaryKeys.CONSTRUCTOR_POSITIONAL_ARGS: [URM_train],
DictionaryKeys.CONSTRUCTOR_KEYWORD_ARGS: {
'Similarities_list': True,
'weights_list': True,
'sparse_weights': True
},
DictionaryKeys.FIT_POSITIONAL_ARGS:
dict(),
DictionaryKeys.FIT_KEYWORD_ARGS:
dict(),
DictionaryKeys.FIT_RANGE_KEYWORD_ARGS:
hyperparamethers_range_dictionary
}
#########################################################################################################
## Final step, after the hyperparameter range has been defined for each type of algorithm
best_parameters = parameterSearch.search(
recommenderDictionary,
n_cases=n_cases,
output_root_path=output_root_path_rec_name,
metric=metric_to_optimize)
except Exception as e:
print("On recommender {} Exception {}".format(recommender_class,
str(e)))
traceback.print_exc()
error_file = open(output_root_path + "ErrorLog.txt", "a")
error_file.write("On recommender {} Exception {}\n".format(
recommender_class, str(e)))
error_file.close()
def runParameterSearch_Collaborative(recommender_class,
URM_train,
ICM_1,
ICM_2,
metric_to_optimize="PRECISION",
evaluator_validation=None,
evaluator_test=None,
evaluator_validation_earlystopping=None,
output_root_path="result_experiments/",
parallelizeKNN=True,
n_cases=100):
from ParameterTuning.AbstractClassSearch import DictionaryKeys
# If directory does not exist, create
if not os.path.exists(output_root_path):
os.makedirs(output_root_path)
try:
output_root_path_rec_name = output_root_path + recommender_class.RECOMMENDER_NAME
parameterSearch = BayesianSearch(
recommender_class,
evaluator_validation=evaluator_validation,
evaluator_test=evaluator_test)
if recommender_class in [TopPop, Random]:
recommender = recommender_class(URM_train)
recommender.fit()
output_file = open(
output_root_path_rec_name + "_BayesianSearch.txt", "a")
result_dict, result_baseline = evaluator_validation.evaluateRecommender(
recommender)
output_file.write(
"ParameterSearch: Best result evaluated on URM_validation. Results: {}"
.format(result_baseline))
pickle.dump(
result_dict.copy(),
open(output_root_path_rec_name + "_best_result_validation",
"wb"),
protocol=pickle.HIGHEST_PROTOCOL)
result_dict, result_baseline = evaluator_test.evaluateRecommender(
recommender)
output_file.write(
"ParameterSearch: Best result evaluated on URM_test. Results: {}"
.format(result_baseline))
pickle.dump(result_dict.copy(),
open(output_root_path_rec_name + "_best_result_test",
"wb"),
protocol=pickle.HIGHEST_PROTOCOL)
output_file.close()
return
##########################################################################################################
if recommender_class is UserKNNCFRecommender:
similarity_type_list = ['cosine']
run_KNNCFRecommender_on_similarity_type_partial = partial(
run_KNNCFRecommender_on_similarity_type,
parameterSearch=parameterSearch,
URM_train=URM_train,
n_cases=n_cases,
output_root_path=output_root_path_rec_name,
metric_to_optimize=metric_to_optimize)
if parallelizeKNN:
pool = PoolWithSubprocess(processes=int(2), maxtasksperchild=1)
resultList = pool.map(
run_KNNCFRecommender_on_similarity_type_partial,
similarity_type_list)
else:
for similarity_type in similarity_type_list:
run_KNNCFRecommender_on_similarity_type_partial(
similarity_type)
return
##########################################################################################################
if recommender_class is ItemKNNCFRecommender:
similarity_type_list = ['cosine']
run_KNNCFRecommender_on_similarity_type_partial = partial(
run_KNNCFRecommender_on_similarity_type,
parameterSearch=parameterSearch,
URM_train=URM_train,
n_cases=n_cases,
output_root_path=output_root_path_rec_name,
metric_to_optimize=metric_to_optimize)
if parallelizeKNN:
pool = PoolWithSubprocess(processes=int(2), maxtasksperchild=1)
resultList = pool.map(
run_KNNCFRecommender_on_similarity_type_partial,
similarity_type_list)
else:
for similarity_type in similarity_type_list:
run_KNNCFRecommender_on_similarity_type_partial(
similarity_type)
return
##########################################################################################################
# if recommender_class is MultiThreadSLIM_RMSE:
#
# hyperparamethers_range_dictionary = {}
# hyperparamethers_range_dictionary["topK"] = [50, 100]
# hyperparamethers_range_dictionary["l1_penalty"] = [1e-2, 1e-3, 1e-4]
# hyperparamethers_range_dictionary["l2_penalty"] = [1e-2, 1e-3, 1e-4]
#
#
# recommenderDictionary = {DictionaryKeys.CONSTRUCTOR_POSITIONAL_ARGS: [URM_train],
# DictionaryKeys.CONSTRUCTOR_KEYWORD_ARGS: {},
# DictionaryKeys.FIT_POSITIONAL_ARGS: dict(),
# DictionaryKeys.FIT_KEYWORD_ARGS: dict(),
# DictionaryKeys.FIT_RANGE_KEYWORD_ARGS: hyperparamethers_range_dictionary}
#
#
##########################################################################################################
if recommender_class is P3alphaRecommender:
hyperparamethers_range_dictionary = {}
hyperparamethers_range_dictionary["topK"] = [
5, 10, 20, 50, 100, 150, 200, 300, 400, 500, 600, 700, 800
]
hyperparamethers_range_dictionary["alpha"] = range(0, 2)
hyperparamethers_range_dictionary["normalize_similarity"] = [
True, False
]
recommenderDictionary = {
DictionaryKeys.CONSTRUCTOR_POSITIONAL_ARGS: [URM_train],
DictionaryKeys.CONSTRUCTOR_KEYWORD_ARGS: {},
DictionaryKeys.FIT_POSITIONAL_ARGS:
dict(),
DictionaryKeys.FIT_KEYWORD_ARGS:
dict(),
DictionaryKeys.FIT_RANGE_KEYWORD_ARGS:
hyperparamethers_range_dictionary
}
##########################################################################################################
if recommender_class is HybridRecommender:
hyperparamethers_range_dictionary = {}
hyperparamethers_range_dictionary["w_itemcf"] = [
x * 0.1 + 1 for x in range(0, 10)
]
hyperparamethers_range_dictionary["w_usercf"] = [
x * 0.1 for x in range(0, 10)
]
hyperparamethers_range_dictionary["w_cbart"] = [
x * 0.1 for x in range(0, 10)
]
hyperparamethers_range_dictionary["w_cbalb"] = [
x * 0.1 for x in range(0, 10)
]
hyperparamethers_range_dictionary["w_slim"] = [
x * 0.1 for x in range(0, 10)
]
#hyperparamethers_range_dictionary["w_svd"] = [x * 0.05 for x in range(0, 20)]
#hyperparamethers_range_dictionary["w_rp3"] = [x * 0.05 for x in range(0, 20)]
item = ItemKNNCFRecommender(URM_train)
user = UserKNNCFRecommender(URM_train)
SLIM = MultiThreadSLIM_ElasticNet(URM_train=URM_train)
item.fit(topK=800, shrink=10, similarity='cosine', normalize=True)
user.fit(topK=70, shrink=22, similarity='cosine', normalize=True)
SLIM.fit(l1_penalty=1e-05,
l2_penalty=0,
positive_only=True,
topK=150,
alpha=0.00415637376180466)
CBArt = ItemKNNCBFRecommender(ICM=ICM_1, URM_train=URM_train)
CBArt.fit(topK=160,
shrink=5,
similarity='cosine',
normalize=True,
feature_weighting="none")
CBAlb = ItemKNNCBFRecommender(ICM=ICM_2, URM_train=URM_train)
CBAlb.fit(topK=160,
shrink=5,
similarity='cosine',
normalize=True,
feature_weighting="none")
recommenderDictionary = {
DictionaryKeys.CONSTRUCTOR_POSITIONAL_ARGS: [URM_train],
DictionaryKeys.CONSTRUCTOR_KEYWORD_ARGS: {},
DictionaryKeys.FIT_POSITIONAL_ARGS:
dict(),
DictionaryKeys.FIT_KEYWORD_ARGS: {
"ICM_Art": ICM_1,
"ICM_Alb": ICM_2,
"item": item,
"user": user,
"SLIM": SLIM,
"CBArt": CBArt,
"CBAlb": CBAlb,
},
DictionaryKeys.FIT_RANGE_KEYWORD_ARGS:
hyperparamethers_range_dictionary
}
##########################################################################################################
if recommender_class is RP3betaRecommender:
hyperparamethers_range_dictionary = {}
hyperparamethers_range_dictionary["topK"] = [
5, 10, 20, 50, 100, 150, 200, 300, 400, 500, 600, 700, 800
]
hyperparamethers_range_dictionary["alpha"] = range(0, 2)
hyperparamethers_range_dictionary["beta"] = range(0, 2)
hyperparamethers_range_dictionary["normalize_similarity"] = [True]
hyperparamethers_range_dictionary["implicit"] = [True]
recommenderDictionary = {
DictionaryKeys.CONSTRUCTOR_POSITIONAL_ARGS: [URM_train],
DictionaryKeys.CONSTRUCTOR_KEYWORD_ARGS: {},
DictionaryKeys.FIT_POSITIONAL_ARGS:
dict(),
DictionaryKeys.FIT_KEYWORD_ARGS:
dict(),
DictionaryKeys.FIT_RANGE_KEYWORD_ARGS:
hyperparamethers_range_dictionary
}
##########################################################################################################
if recommender_class is MatrixFactorization_FunkSVD_Cython:
hyperparamethers_range_dictionary = {}
hyperparamethers_range_dictionary["sgd_mode"] = ["adagrad", "adam"]
# hyperparamethers_range_dictionary["epochs"] = [1, 5, 10, 20, 30, 50, 70, 90, 110]
hyperparamethers_range_dictionary["num_factors"] = range(
100, 1000, 20)
hyperparamethers_range_dictionary["reg"] = [0.0, 1e-3, 1e-6, 1e-9]
hyperparamethers_range_dictionary["learning_rate"] = [
1e-2, 1e-3, 1e-4, 1e-5
]
recommenderDictionary = {
DictionaryKeys.CONSTRUCTOR_POSITIONAL_ARGS: [URM_train],
DictionaryKeys.CONSTRUCTOR_KEYWORD_ARGS: {},
DictionaryKeys.FIT_POSITIONAL_ARGS:
dict(),
DictionaryKeys.FIT_KEYWORD_ARGS: {
"validation_every_n": 5,
"stop_on_validation": True,
"evaluator_object": evaluator_validation_earlystopping,
"lower_validatons_allowed": 20,
"validation_metric": metric_to_optimize
},
DictionaryKeys.FIT_RANGE_KEYWORD_ARGS:
hyperparamethers_range_dictionary
}
##########################################################################################################
if recommender_class is FunkSVD:
hyperparamethers_range_dictionary = {}
# hyperparamethers_range_dictionary["epochs"] = [1, 5, 10, 20, 30, 50, 70, 90, 110]
hyperparamethers_range_dictionary["num_factors"] = range(
100, 1000, 20)
hyperparamethers_range_dictionary["reg"] = [
0.0, 1e-03, 1e-06, 1e-09
]
hyperparamethers_range_dictionary["learning_rate"] = [1e-02, 1e-03]
recommenderDictionary = {
DictionaryKeys.CONSTRUCTOR_POSITIONAL_ARGS: [URM_train],
DictionaryKeys.CONSTRUCTOR_KEYWORD_ARGS: {},
DictionaryKeys.FIT_POSITIONAL_ARGS:
dict(),
DictionaryKeys.FIT_KEYWORD_ARGS:
dict(),
DictionaryKeys.FIT_RANGE_KEYWORD_ARGS:
hyperparamethers_range_dictionary
}
##########################################################################################################
if recommender_class is MatrixFactorization_AsySVD_Cython:
hyperparamethers_range_dictionary = {}
hyperparamethers_range_dictionary["sgd_mode"] = ["adagrad", "adam"]
# hyperparamethers_range_dictionary["epochs"] = [1, 5, 10, 20, 30, 50, 70, 90, 110]
hyperparamethers_range_dictionary["num_factors"] = range(
100, 500, 10)
hyperparamethers_range_dictionary["batch_size"] = [
100, 200, 300, 400
]
hyperparamethers_range_dictionary["positive_reg"] = [
0.0, 1e-3, 1e-6, 1e-9
]
hyperparamethers_range_dictionary["negative_reg"] = [
0.0, 1e-3, 1e-6, 1e-9
]
hyperparamethers_range_dictionary["learning_rate"] = [
1e-2, 1e-3, 1e-4, 1e-5
]
hyperparamethers_range_dictionary["user_reg"] = [
1e-3, 1e-4, 1e-5, 1e-6
]
recommenderDictionary = {
DictionaryKeys.CONSTRUCTOR_POSITIONAL_ARGS: [URM_train],
DictionaryKeys.CONSTRUCTOR_KEYWORD_ARGS: {
'positive_threshold': 1
},
DictionaryKeys.FIT_POSITIONAL_ARGS:
dict(),
DictionaryKeys.FIT_KEYWORD_ARGS: {
"validation_every_n": 5,
"stop_on_validation": True,
"evaluator_object": evaluator_validation_earlystopping,
"lower_validatons_allowed": 20,
"validation_metric": metric_to_optimize
},
DictionaryKeys.FIT_RANGE_KEYWORD_ARGS:
hyperparamethers_range_dictionary
}
##########################################################################################################
if recommender_class is PureSVDRecommender:
hyperparamethers_range_dictionary = {}
hyperparamethers_range_dictionary["num_factors"] = list(
range(0, 250, 5))
recommenderDictionary = {
DictionaryKeys.CONSTRUCTOR_POSITIONAL_ARGS: [URM_train],
DictionaryKeys.CONSTRUCTOR_KEYWORD_ARGS: {},
DictionaryKeys.FIT_POSITIONAL_ARGS:
dict(),
DictionaryKeys.FIT_KEYWORD_ARGS: {},
DictionaryKeys.FIT_RANGE_KEYWORD_ARGS:
hyperparamethers_range_dictionary
}
#########################################################################################################
if recommender_class is SLIM_BPR_Cython:
hyperparamethers_range_dictionary = {}
hyperparamethers_range_dictionary["topK"] = [800, 900, 1000, 1200]
# hyperparamethers_range_dictionary["epochs"] = [1, 5, 10, 20, 30, 50, 70, 90, 110]
hyperparamethers_range_dictionary["sgd_mode"] = ["adagrad"]
hyperparamethers_range_dictionary["lambda_i"] = [1e-6]
hyperparamethers_range_dictionary["lambda_j"] = [1e-9]
hyperparamethers_range_dictionary["learning_rate"] = [
0.01, 0.001, 1e-4, 1e-5, 0.1
]
recommenderDictionary = {
DictionaryKeys.CONSTRUCTOR_POSITIONAL_ARGS: [URM_train],
DictionaryKeys.CONSTRUCTOR_KEYWORD_ARGS: {
'train_with_sparse_weights': True,
'symmetric': True,
'positive_threshold': 1
},
DictionaryKeys.FIT_POSITIONAL_ARGS:
dict(),
DictionaryKeys.FIT_KEYWORD_ARGS: {
"validation_every_n": 10,
"stop_on_validation": True,
"evaluator_object": evaluator_validation_earlystopping,
"lower_validatons_allowed": 3,
"validation_metric": metric_to_optimize
},
DictionaryKeys.FIT_RANGE_KEYWORD_ARGS:
hyperparamethers_range_dictionary
}
##########################################################################################################
if recommender_class is MultiThreadSLIM_ElasticNet:
hyperparamethers_range_dictionary = {}
hyperparamethers_range_dictionary["topK"] = [
3300, 4300, 5300, 6300, 7300
]
hyperparamethers_range_dictionary["l1_penalty"] = [
1e-5, 1e-6, 1e-4, 1e-3
]
hyperparamethers_range_dictionary["l2_penalty"] = [1e-4]
hyperparamethers_range_dictionary["alpha"] = range(0, 1)
recommenderDictionary = {
DictionaryKeys.CONSTRUCTOR_POSITIONAL_ARGS: [URM_train],
DictionaryKeys.CONSTRUCTOR_KEYWORD_ARGS: {},
DictionaryKeys.FIT_POSITIONAL_ARGS:
dict(),
DictionaryKeys.FIT_KEYWORD_ARGS:
dict(),
DictionaryKeys.FIT_RANGE_KEYWORD_ARGS:
hyperparamethers_range_dictionary
}
#########################################################################################################
## Final step, after the hyperparameter range has been defined for each type of algorithm
best_parameters = parameterSearch.search(
recommenderDictionary,
n_cases=n_cases,
output_root_path=output_root_path_rec_name,
metric=metric_to_optimize)
except Exception as e:
print("On recommender {} Exception {}".format(recommender_class,
str(e)))
traceback.print_exc()
error_file = open(output_root_path + "ErrorLog.txt", "a")
error_file.write("On recommender {} Exception {}\n".format(
recommender_class, str(e)))
error_file.close()