def read_data_split_and_search():
"""
This function provides a simple example on how to tune parameters of a given algorithm
The BayesianSearch object will save:
- A .txt file with all the cases explored and the recommendation quality
- A _best_model file which contains the trained model and can be loaded with recommender.load_model()
- A _best_parameter file which contains a dictionary with all the fit parameters, it can be passed to recommender.fit(**_best_parameter)
- A _best_result_validation file which contains a dictionary with the results of the best solution on the validation
- A _best_result_test file which contains a dictionary with the results, on the test set, of the best solution chosen using the validation set
"""
dataReader = Movielens10MReader()
URM_train = dataReader.get_URM_train()
URM_validation = dataReader.get_URM_validation()
URM_test = dataReader.get_URM_test()
output_folder_path = "result_experiments/"
# If directory does not exist, create
if not os.path.exists(output_folder_path):
os.makedirs(output_folder_path)
collaborative_algorithm_list = [
Random, TopPop, P3alphaRecommender, RP3betaRecommender,
ItemKNNCFRecommender, UserKNNCFRecommender,
MatrixFactorization_BPR_Cython, MatrixFactorization_FunkSVD_Cython,
PureSVDRecommender, SLIM_BPR_Cython, SLIMElasticNetRecommender
]
from Base.Evaluation.Evaluator import SequentialEvaluator
evaluator_validation = SequentialEvaluator(URM_validation, cutoff_list=[5])
evaluator_test = SequentialEvaluator(URM_test, cutoff_list=[5, 10])
runParameterSearch_Collaborative_partial = partial(
runParameterSearch_Collaborative,
URM_train=URM_train,
metric_to_optimize="MAP",
n_cases=20,
evaluator_validation_earlystopping=evaluator_validation,
evaluator_validation=evaluator_validation,
evaluator_test=evaluator_test,
output_folder_path=output_folder_path)
# pool = multiprocessing.Pool(processes=int(multiprocessing.cpu_count()), maxtasksperchild=1)
# resultList = pool.map(runParameterSearch_Collaborative_partial, collaborative_algorithm_list)
for recommender_class in collaborative_algorithm_list:
try:
runParameterSearch_Collaborative_partial(recommender_class)
except Exception as e:
print("On recommender {} Exception {}".format(
recommender_class, str(e)))
traceback.print_exc()
def evaluateRecommendations(self,
URM_test,
at=5,
minRatingsPerUser=1,
exclude_seen=True,
filterCustomItems=np.array([], dtype=np.int),
filterCustomUsers=np.array([], dtype=np.int)):
"""
Speed info:
- Sparse weighgs: batch mode is 2x faster than sequential
- Dense weighgts: batch and sequential speed are equivalent
:param URM_test: URM to be used for testing
:param at: 5 Length of the recommended items
:param minRatingsPerUser: 1 Users with less than this number of interactions will not be evaluated
:param exclude_seen: True Whether to remove already seen items from the recommended items
:param mode: 'sequential', 'parallel', 'batch'
:param filterTopPop: False or decimal number Percentage of items to be removed from recommended list and testing interactions
:param filterCustomItems: Array, default empty Items ID to NOT take into account when recommending
:param filterCustomUsers: Array, default empty Users ID to NOT take into account when recommending
:return:
"""
import warnings
warnings.warn(
"DEPRECATED! Use Base.Evaluation.SequentialEvaluator.evaluateRecommendations()",
DeprecationWarning)
from Base.Evaluation.Evaluator import SequentialEvaluator
evaluator = SequentialEvaluator(URM_test, [at],
exclude_seen=exclude_seen,
minRatingsPerUser=minRatingsPerUser,
ignore_items=filterCustomItems,
ignore_users=filterCustomUsers)
results_run, results_run_string = evaluator.evaluateRecommender(self)
results_run = results_run[at]
results_run_lowercase = {}
for key in results_run.keys():
results_run_lowercase[key.lower()] = results_run[key]
return results_run_lowercase
def fit(self, alpha):
evaluator_MF = SequentialEvaluator(URM_test_list=self._URM_test, cutoff_list=[10])
#bprmf = MatrixFactorization_Cython(self._URM_train,
# positive_threshold=0,
# algorithm="MF_BPR",
# )
# self.MF_BPRW, self.MF_BPRH = bprmf.fit(epochs=200,
# num_factors=5,
# batch_size=1,
# sgd_mode='adagrad'
# )
#print(evaluator_MF.evaluateRecommender(bprmf))
self.bpr_WII = SLIM_BPR_Cython(self._URM_train, positive_threshold=0, symmetric=True).fit(epochs=10,
topK=200,
batch_size=200,
sgd_mode='adagrad',
learning_rate=1e-2)
self.bpr_WUU = SLIM_BPR_Cython(self._URM_train.T, positive_threshold=0).fit(epochs=10,
topK=200,
batch_size=200,
sgd_mode='adagrad',
learning_rate=1e-2)
print(self.bpr_WII)
print("\n \n max bprII: {0}".format(self.bpr_WII.max()))
print(self.bpr_WII)
print("\n \n max bprUU: {0}".format(self.bpr_WUU.max()))
self._similarity_matrixUU = Cosine_Similarity(self._URM_train.T,
topK=200,
shrink=15,
normalize=True,
mode='cosine').compute_similarity()
print("\n \n max uu: {0}".format(self._similarity_matrixUU.max()))
# self._similarity_matrixII = Cosine_Similarity(self._URM_train.tocsc(),
# topK=200,
# shrink=10,
# normalize=True,
# mode='cosine').compute_similarity()
# print("\n \n max II: {0}".format(self._similarity_matrixII.max()))
self._similarity_matrixCBF = Cosine_Similarity(self._ICM.T,
topK=10,
shrink=10,
normalize=True,
mode='cosine').compute_similarity()
# print(self._similarity_matrixII)
self.latent_x, self.latent_y = (IALS_numpy()).fit(self._URM_train)
print(self.latent_x.dot(self.latent_y.T))
print("\n \n max IALS: {0}".format(self.latent_x.dot(self.latent_y.T).max()))
def fit(self,
epochs=300,
batch_size=1000,
num_factors=10,
learning_rate=0.01,
sgd_mode='sgd',
user_reg=0.0,
positive_reg=0.0,
negative_reg=0.0,
stop_on_validation=False,
lower_validatons_allowed=5,
validation_metric="MAP",
evaluator_object=None,
validation_every_n=5):
self.num_factors = num_factors
self.sgd_mode = sgd_mode
self.batch_size = batch_size
self.learning_rate = learning_rate
if evaluator_object is None and stop_on_validation:
evaluator_object = SequentialEvaluator(self.URM_validation, [5])
# Import compiled module
from MatrixFactorization.Cython.MatrixFactorization_Cython_Epoch import MatrixFactorization_Cython_Epoch
if self.algorithm == "FUNK_SVD":
self.cythonEpoch = MatrixFactorization_Cython_Epoch(
self.URM_train,
algorithm=self.algorithm,
n_factors=self.num_factors,
learning_rate=learning_rate,
batch_size=1,
sgd_mode=sgd_mode,
user_reg=user_reg,
positive_reg=positive_reg,
negative_reg=0.0)
elif self.algorithm == "ASY_SVD":
self.cythonEpoch = MatrixFactorization_Cython_Epoch(
self.URM_train,
algorithm=self.algorithm,
n_factors=self.num_factors,
learning_rate=learning_rate,
batch_size=1,
sgd_mode=sgd_mode,
user_reg=user_reg,
positive_reg=positive_reg,
negative_reg=0.0)
elif self.algorithm == "MF_BPR":
# Select only positive interactions
URM_train_positive = self.URM_train.copy()
URM_train_positive.data = URM_train_positive.data >= self.positive_threshold
URM_train_positive.eliminate_zeros()
assert URM_train_positive.nnz > 0, "MatrixFactorization_Cython: URM_train_positive is empty, positive threshold is too high"
self.cythonEpoch = MatrixFactorization_Cython_Epoch(
URM_train_positive,
algorithm=self.algorithm,
n_factors=self.num_factors,
learning_rate=learning_rate,
batch_size=1,
sgd_mode=sgd_mode,
user_reg=user_reg,
positive_reg=positive_reg,
negative_reg=negative_reg)
self._train_with_early_stopping(epochs,
validation_every_n,
stop_on_validation,
validation_metric,
lower_validatons_allowed,
evaluator_object,
algorithm_name=self.algorithm)
self.W = self.W_best
self.H = self.H_best
sys.stdout.flush()
URM_test = data.get_URM_test()
print("URM_train shape : {}".format(URM_train.shape))
print("URM_test shape : {}".format(URM_test.shape))
print("ICM shape : {}".format(ICM.shape))
print("Dimensions")
print(URM_train.shape)
print(URM_test.shape)
# ------------------------
# Instanciating Evaluators
# ------------------------
evaluator_test = SequentialEvaluator(URM_test, cutoff_list=[10])
#evaluator_test = SequentialEvaluator(URM_test, cutoff_list=[10])
evaluator_test = EvaluatorWrapper(evaluator_test)
#evaluator_test = EvaluatorWrapper(evaluator_test)
# ------------------------
# Recommender class definition
# ------------------------
# ------------------------
# Generating lists of weights to evaluate
# ------------------------
#alpha_list = np.arange(0.1, 1.0, 0.1)
alpha_list = np.arange(0.0, 1.05, 0.05)
from Base.Evaluation.Evaluator import SequentialEvaluator
from SLIM_BPR.Cython.SLIM_BPR_Cython import SLIM_BPR_Cython
from refactored_code.utils import load_random_urms, load_icm
if __name__ == '__main__':
urm_train, urm_test = load_random_urms()
icm = load_icm(0.7, 0.3, 0.5)
slim = SLIM_BPR_Cython(urm_train, positive_threshold=0,
symmetric=True).fit(epochs=10,
topK=300,
batch_size=500,
sgd_mode='adagrad',
learning_rate=1e-4)
evaluator_MF = SequentialEvaluator(urm_test, cutoff_list=[10])
print(evaluator_MF.evaluateRecommender(slim))
recommenderDictionary = {
DictionaryKeys.CONSTRUCTOR_POSITIONAL_ARGS: [train_data],
DictionaryKeys.CONSTRUCTOR_KEYWORD_ARGS: {
'URM_validation': buildURMMatrix(test_data)
},
DictionaryKeys.FIT_POSITIONAL_ARGS: dict(),
DictionaryKeys.FIT_KEYWORD_ARGS: {
"playlist_ids": target_data['playlist_id'],
"validation_every_n": 5,
"stop_on_validation": True,
"lower_validatons_allowed": 5
},
DictionaryKeys.FIT_RANGE_KEYWORD_ARGS: hyperparamethers_range_dictionary
}
evaluator_validation = SequentialEvaluator(buildURMMatrix(test_data),
cutoff_list=[10])
evaluator_validation = EvaluatorWrapper(evaluator_validation)
parameterSearch = BayesianSearch(SLIM_BPR_Cython, evaluator_validation)
n_cases = 2
metric_to_optimize = "MAP"
output_root_path = "output/"
best_parameters = parameterSearch.search(recommenderDictionary,
n_cases=n_cases,
output_root_path=output_root_path,
metric=metric_to_optimize)
def fit(self,
epochs=300,
logFile=None,
batch_size=1000,
lambda_i=0.0,
lambda_j=0.0,
learning_rate=1e-4,
topK=200,
sgd_mode='adagrad',
gamma=0.995,
beta_1=0.9,
beta_2=0.999,
stop_on_validation=False,
lower_validatons_allowed=5,
validation_metric="MAP",
evaluator_object=None,
validation_every_n=1):
# Import compiled module
from SLIM_BPR.Cython.SLIM_BPR_Cython_Epoch import SLIM_BPR_Cython_Epoch
# Select only positive interactions
URM_train_positive = self.URM_train.copy()
URM_train_positive.data = URM_train_positive.data >= self.positive_threshold
URM_train_positive.eliminate_zeros()
self.sgd_mode = sgd_mode
self.epochs = epochs
self.cythonEpoch = SLIM_BPR_Cython_Epoch(
self.URM_mask,
train_with_sparse_weights=self.train_with_sparse_weights,
final_model_sparse_weights=self.sparse_weights,
topK=topK,
learning_rate=learning_rate,
li_reg=lambda_i,
lj_reg=lambda_j,
batch_size=1,
symmetric=self.symmetric,
sgd_mode=sgd_mode,
gamma=gamma,
beta_1=beta_1,
beta_2=beta_2)
if (topK != False and topK < 1):
raise ValueError(
"TopK not valid. Acceptable values are either False or a positive integer value. Provided value was '{}'"
.format(topK))
self.topK = topK
if validation_every_n is not None:
self.validation_every_n = validation_every_n
else:
self.validation_every_n = np.inf
if evaluator_object is None and stop_on_validation:
evaluator_object = SequentialEvaluator(self.URM_validation, [5])
self.batch_size = batch_size
self.lambda_i = lambda_i
self.lambda_j = lambda_j
self.learning_rate = learning_rate
self._train_with_early_stopping(epochs,
validation_every_n,
stop_on_validation,
validation_metric,
lower_validatons_allowed,
evaluator_object,
algorithm_name=self.RECOMMENDER_NAME)
self.get_S_incremental_and_set_W()
sys.stdout.flush()
ICM = data.get_ICM()
URM_train = data.get_URM_train()
URM_test = data.get_URM_test()
print("URM_train shape : {}".format(URM_train.shape))
print("URM_test shape : {}".format(URM_test.shape))
print("ICM shape : {}".format(ICM.shape))
#URM_train, URM_validation, URM_test = split_train_validation_test(URM, [0.8, 0.1, 0.1])
# ------------------------
# Instanciating Evaluators
# ------------------------
evaluator_validation = SequentialEvaluator(URM_test, cutoff_list=[10])
#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
# ------------------------
def fit(self,
epochs=300,
logFile=None,
batch_size=1000,
lambda_i=0.1,
lambda_j=0.1,
learning_rate=1e-3,
topK=200,
sgd_mode='adagrad',
gamma=0.995,
beta_1=0.9,
beta_2=0.999,
stop_on_validation=False,
lower_validatons_allowed=2,
validation_metric="MAP",
evaluator_object=None,
validation_every_n=50,
old_similarity_matrix=None,
force_compute_sim=True):
'''
:param epochs: max number of epochs
:param logFile:
:param batch_size:
:param lambda_i: first regualrizer
:param lambda_j: second regualrizer
:param learning_rate:
:param topK:
:param sgd_mode:
:param gamma:
:param beta_1:
:param beta_2:
:param stop_on_validation: should I stop after some validations?
:param lower_validatons_allowed: stop after n validations that worse the previous one
:param validation_metric:
:param evaluator_object:
:param validation_every_n: how often do validations?
:param old_similarity_matrix: if you want to start from a fixed similarity matrix
:param force_compute_sim:
:return:
'''
self.lambda_i = lambda_i
self.lambda_j = lambda_j
self.learning_rate = learning_rate
self.topK = topK
self.epochs = epochs
if not force_compute_sim:
found = True
try:
with open(
os.path.join(
"IntermediateComputations", "SLIM_BPR",
"totURM={}_topK={}_lambdai={}_lambdaj={}_lr={}_epochs={}.pkl"
.format(str(len(self.URM_train.data)),
str(self.topK), str(self.lambda_i),
str(self.lambda_j),
str(self.learning_rate),
str(self.epochs))), 'rb') as handle:
(W_sparse_new) = pickle.load(handle)
except FileNotFoundError:
found = False
if found:
self.W_sparse = W_sparse_new
print("Saved SLIM Matrix Used!")
return
if evaluator_object is None and stop_on_validation:
print("Creating evaluator object for SLIM BPR")
evaluator_object = SequentialEvaluator(self.URM_validation,
self.URM_train)
# Import compiled module
from SLIM_BPR.Cython.SLIM_BPR_Cython_Epoch import SLIM_BPR_Cython_Epoch
# Select only positive interactions
URM_train_positive = self.URM_train.copy()
URM_train_positive.data = URM_train_positive.data >= self.positive_threshold
URM_train_positive.eliminate_zeros()
self.sgd_mode = sgd_mode
self.epochs = epochs
self.cythonEpoch = SLIM_BPR_Cython_Epoch(
self.URM_mask,
old_similarity=old_similarity_matrix,
train_with_sparse_weights=self.train_with_sparse_weights,
final_model_sparse_weights=self.sparse_weights,
topK=topK,
learning_rate=learning_rate,
li_reg=lambda_i,
lj_reg=lambda_j,
batch_size=1,
symmetric=self.symmetric, # di default è simmetrica
sgd_mode=sgd_mode,
gamma=gamma,
beta_1=beta_1,
beta_2=beta_2)
if topK != False and topK < 1:
raise ValueError(
"TopK not valid. Acceptable values are either False or a positive integer value. Provided value was '{}'"
.format(topK))
self.topK = topK
if validation_every_n is not None:
self.validation_every_n = validation_every_n
else:
self.validation_every_n = np.inf
self.batch_size = batch_size
self.lambda_i = lambda_i
self.lambda_j = lambda_j
self.learning_rate = learning_rate
self._train_with_early_stopping(epochs,
validation_every_n,
stop_on_validation,
validation_metric,
lower_validatons_allowed,
evaluator_object,
algorithm_name=self.RECOMMENDER_NAME)
self.get_S_incremental_and_set_W()
# self.normalized_SLIM()
with open(
os.path.join(
"IntermediateComputations", "SLIM_BPR",
"totURM={}_topK={}_lambdai={}_lambdaj={}_lr={}_epochs={}.pkl"
.format(str(len(self.URM_train.data)), str(self.topK),
str(self.lambda_i), str(self.lambda_j),
str(self.learning_rate), str(self.epochs))),
'wb') as handle:
pickle.dump(self.W_sparse,
handle,
protocol=pickle.HIGHEST_PROTOCOL)
sys.stdout.flush()
def fit(self, epochs=30, batch_size = 128, num_factors=10,
learning_rate = 0.001,
stop_on_validation = False, lower_validatons_allowed = 5, validation_metric = "MAP",
evaluator_object = None, validation_every_n = 1, use_cuda = True):
if evaluator_object is None and self.URM_validation is not None:
from Base.Evaluation.Evaluator import SequentialEvaluator
evaluator_object = SequentialEvaluator(self.URM_validation, [10])
self.n_factors = num_factors
# Select only positive interactions
URM_train_positive = self.URM_train.copy()
URM_train_positive.data = URM_train_positive.data >= self.positive_threshold
URM_train_positive.eliminate_zeros()
self.batch_size = batch_size
self.learning_rate = learning_rate
########################################################################################################
#
# SETUP PYTORCH MODEL AND DATA READER
#
########################################################################################################
if use_cuda and torch.cuda.is_available():
self.device = torch.device('cuda')
print("MF_MSE_PyTorch: Using CUDA")
else:
self.device = torch.device('cpu')
print("MF_MSE_PyTorch: Using CPU")
from MatrixFactorization.PyTorch.MF_MSE_PyTorch_model import MF_MSE_PyTorch_model, DatasetIterator_URM
n_users, n_items = self.URM_train.shape
self.pyTorchModel = MF_MSE_PyTorch_model(n_users, n_items, self.n_factors).to(self.device)
#Choose loss
self.lossFunction = torch.nn.MSELoss(size_average=False)
#self.lossFunction = torch.nn.BCELoss(size_average=False)
self.optimizer = torch.optim.Adagrad(self.pyTorchModel.parameters(), lr = self.learning_rate)
dataset_iterator = DatasetIterator_URM(self.URM_train)
self.train_data_loader = DataLoader(dataset = dataset_iterator,
batch_size = self.batch_size,
shuffle = True,
#num_workers = 2,
)
########################################################################################################
self._train_with_early_stopping(epochs, validation_every_n, stop_on_validation,
validation_metric, lower_validatons_allowed, evaluator_object,
algorithm_name = "MF_MSE_PyTorch")
self.W = self.W_best.copy()
self.H = self.H_best.copy()
sys.stdout.flush()
dataReader = dataReader()
#URM_train = dataReader.get_URM_train()
URM_train = dataReader.get_URM_complete()
URM_validation = dataReader.get_URM_validation()
URM_test = dataReader.get_URM_test()
ICM_Art = dataReader.get_ICM_Art()
ICM_Alb = dataReader.get_ICM_Alb()
recommender_list = [HybridRecommender]
from Base.Evaluation.Evaluator import SequentialEvaluator
evaluator = SequentialEvaluator(URM_test, [10], exclude_seen=True)
evaluatorValid = SequentialEvaluator(URM_validation, [10],
exclude_seen=True)
output_root_path = "result_experiments/"
# If directory does not exist, create
if not os.path.exists(output_root_path):
os.makedirs(output_root_path)
logFile = open(output_root_path + "result_all_algorithms.txt", "a")
for recommender_class in recommender_list:
try:
def read_data_split_and_search():
"""
This function provides a simple example on how to tune parameters of a given algorithm
The BayesianSearch object will save:
- A .txt file with all the cases explored and the recommendation quality
- A _best_model file which contains the trained model and can be loaded with recommender.load_model()
- A _best_parameter file which contains a dictionary with all the fit parameters, it can be passed to recommender.fit(**_best_parameter)
- A _best_result_validation file which contains a dictionary with the results of the best solution on the validation
- A _best_result_test file which contains a dictionary with the results, on the test set, of the best solution chosen using the validation set
"""
data = dataReader()
URM_train = data.get_URM_train()
URM_validation = data.get_URM_validation()
URM_test = data.get_URM_test()
ICM_alb = data.ICM_Alb
ICM_art = data.ICM_Art
output_root_path = "result_experiments/"
# If directory does not exist, create
if not os.path.exists(output_root_path):
os.makedirs(output_root_path)
collaborative_algorithm_list = [HybridRecommender]
from ParameterTuning.AbstractClassSearch import EvaluatorWrapper
from Base.Evaluation.Evaluator import SequentialEvaluator
evaluator_validation_earlystopping = SequentialEvaluator(URM_validation,
cutoff_list=[10])
evaluator_test = SequentialEvaluator(URM_test, cutoff_list=[10])
evaluator_validation = EvaluatorWrapper(evaluator_validation_earlystopping)
evaluator_test = EvaluatorWrapper(evaluator_test)
runParameterSearch_Collaborative_partial = partial(
runParameterSearch_Collaborative,
URM_train=URM_train,
ICM_1=ICM_art,
ICM_2=ICM_alb,
metric_to_optimize="MAP",
evaluator_validation_earlystopping=evaluator_validation_earlystopping,
evaluator_validation=evaluator_validation,
evaluator_test=evaluator_test,
output_root_path=output_root_path)
# pool = multiprocessing.Pool(processes=int(multiprocessing.cpu_count()), maxtasksperchild=1)
# resultList = pool.map(runParameterSearch_Collaborative_partial, collaborative_algorithm_list)
for recommender_class in collaborative_algorithm_list:
try:
runParameterSearch_Collaborative_partial(recommender_class)
except Exception as e:
print("On recommender {} Exception {}".format(
recommender_class, str(e)))
traceback.print_exc()
dataReader = Movielens10MReader()
URM_train = dataReader.get_URM_train()
URM_validation = dataReader.get_URM_validation()
URM_test = dataReader.get_URM_test()
recommender_list = [
Random, TopPop, P3alphaRecommender, RP3betaRecommender,
ItemKNNCFRecommender, UserKNNCFRecommender,
MatrixFactorization_BPR_Cython, MatrixFactorization_FunkSVD_Cython,
PureSVDRecommender, SLIM_BPR_Cython, SLIMElasticNetRecommender
]
from Base.Evaluation.Evaluator import SequentialEvaluator
evaluator = SequentialEvaluator(URM_test, [5, 20], exclude_seen=True)
output_root_path = "result_experiments/"
# If directory does not exist, create
if not os.path.exists(output_root_path):
os.makedirs(output_root_path)
logFile = open(output_root_path + "result_all_algorithms.txt", "a")
for recommender_class in recommender_list:
try:
print("Algorithm: {}".format(recommender_class))
algo = SlopeOne()
trainset = data.build_full_trainset()
algo.fit(trainset)'''
URM_test = dataReader.get_URM_test()
URM_validation = dataReader.get_URM_validation()
ICM_Art = dataReader.get_ICM_Art()
ICM_Alb = dataReader.get_ICM_Alb()
recommender_list = [HybridRecommender]
from Base.Evaluation.Evaluator import SequentialEvaluator
evaluator = SequentialEvaluator(URM_test, [10], exclude_seen=True)
evaluatorValid = SequentialEvaluator(URM_validation, [10],
exclude_seen=True)
output_root_path = "result_experiments/"
# If directory does not exist, create
if not os.path.exists(output_root_path):
os.makedirs(output_root_path)
logFile = open(output_root_path + "result_all_algorithms.txt", "a")
for recommender_class in recommender_list:
try:
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))
"""
def run():
evaluate_algorithm = True
delete_old_computations = False
slim_after_hybrid = False
# delete_previous_intermediate_computations()
# if not evaluate_algorithm:
# delete_previous_intermediate_computations()
# else:
# print("ATTENTION: old intermediate computations kept, pay attention if running with all_train")
# delete_previous_intermediate_computations()
filename = "hybrid_ICB_ICF_UCF_IALS_SLIM_ELASTIC_local_081962.csv"
dataReader = RS_Data_Loader(all_train=not evaluate_algorithm)
URM_train = dataReader.get_URM_train()
URM_PageRank_train = dataReader.get_page_rank_URM()
URM_validation = dataReader.get_URM_validation()
URM_test = dataReader.get_URM_test()
ICM = dataReader.get_ICM()
UCM_tfidf = dataReader.get_tfidf_artists()
# _ = dataReader.get_tfidf_album()
recommender_list1 = [
# Random,
# TopPop,
ItemKNNCBFRecommender,
# UserKNNCBRecommender,
ItemKNNCFRecommender,
UserKNNCFRecommender,
# P3alphaRecommender,
# RP3betaRecommender,
# MatrixFactorization_BPR_Cython,
# MatrixFactorization_FunkSVD_Cython,
IALS_numpy,
SLIM_BPR_Cython,
# ItemKNNCFRecommenderFAKESLIM,
# PureSVDRecommender,
SLIMElasticNetRecommender
]
from Base.Evaluation.Evaluator import SequentialEvaluator
evaluator = SequentialEvaluator(URM_test, URM_train, exclude_seen=True)
output_root_path = "result_experiments/"
# If directory does not exist, create
if not os.path.exists(output_root_path):
os.makedirs(output_root_path)
logFile = open(output_root_path + "result_all_algorithms.txt", "a")
try:
recommender_class = HybridRecommender
print("Algorithm: {}".format(recommender_class))
'''
Our optimal run
'''
recommender_list = recommender_list1 # + recommender_list2 # + recommender_list3
onPop = False
# On pop it used to choose if have dynamic weights for
recommender = recommender_class(URM_train,
ICM,
recommender_list,
URM_PageRank_train=URM_PageRank_train,
dynamic=False,
UCM_train=UCM_tfidf,
URM_validation=URM_validation,
onPop=onPop)
recommender.fit(
**{
"topK": [10, 181, 82, -1, 761, 490],
"shrink": [8, 0, 3, -1, -1, -1],
"pop": [280],
"weights": [
0.47412263345597117, 1.3864620551711606,
0.6224999770898935, 1.5498327677561246, 0.1993692779443738,
2.113324096784624
],
"final_weights": [1, 1],
"force_compute_sim":
False, # not evaluate_algorithm,
"feature_weighting_index":
0,
"epochs":
150,
'lambda_i': [0.0],
'lambda_j': [1.0153577332223556e-08],
'SLIM_lr': [0.1],
'alphaP3': [0.4121720883248633],
'alphaRP3': [0.8582865731462926],
'betaRP': [0.2814208416833668],
'l1_ratio':
3.020408163265306e-06,
'alpha':
0.0014681984611695231,
'tfidf': [True],
"weights_to_dweights":
-1,
"IALS_num_factors":
290,
"IALS_reg":
0.001,
"IALS_iters":
6,
"IALS_scaling":
'log',
"IALS_alpha":
40,
"filter_top_pop_len":
0
})
print("TEST")
print("Starting Evaluations...")
# to indicate if plotting for lenght or for pop
results_run, results_run_string, target_recommendations = evaluator.evaluateRecommender(
recommender, plot_stats=False, onPop=onPop)
print("Algorithm: {}, results: \n{}".format(
[rec.RECOMMENDER_NAME for rec in recommender.recommender_list],
results_run_string))
logFile.write("Algorithm: {}, results: \n{} time: {}".format(
[rec.RECOMMENDER_NAME for rec in recommender.recommender_list],
results_run_string, time.time()))
logFile.flush()
if not evaluate_algorithm:
target_playlist = dataReader.get_target_playlist()
md.assign_recomendations_to_correct_playlist(
target_playlist, target_recommendations)
md.make_CSV_file(target_playlist, filename)
print('File {} created!'.format(filename))
except Exception as e:
traceback.print_exc()
logFile.write("Algorithm: {} - Exception: {}\n".format(
recommender_class, str(e)))
logFile.flush()
# https://mmprj.github.io/mtrm_dataset/index
dataSplitter = DataSplitter_Warm_k_fold(dataReader)
dataSplitter.load_data()
# Each URM is a scipy.sparse matrix of shape |users|x|items|
URM_train, URM_validation, URM_test = dataSplitter.get_holdout_split()
# The ICM is a scipy.sparse matrix of shape |items|x|features|
ICM = dataSplitter.get_ICM_from_name("ICM_genre")
# This contains the items to be ignored during the evaluation step
# In a cold items setting this should contain the indices of the warm items
ignore_items = []
evaluator_validation = SequentialEvaluator(URM_validation,
cutoff_list=[5],
ignore_items=ignore_items)
evaluator_test = SequentialEvaluator(URM_test,
cutoff_list=[5],
ignore_items=ignore_items)
# This is used by the ML model of CFeCBF to perform early stopping and may be omitted.
# ICM_target allows to set a different ICM for this validation step, providing flexibility in including
# features present in either validation or test but not in train
evaluator_validation_earlystopping = EvaluatorCFW_D_wrapper(
evaluator_validation, ICM_target=ICM, model_to_use="incremental")
# We compute the similarity matrix resulting from a RP3beta recommender
# Note that we have not included the code for parameter tuning, which should be done
cf_parameters = {
from KNN.ItemKNNCBFRecommender import ItemKNNCBFRecommender
from KNN.UserKNNCFRecommender import UserKNNCFRecommender
from ParameterTuning.AbstractClassSearch import writeLog
from data_splitter import train_test_holdout
import itertools
data = Data()
URM = data.get_URM()
ICM = data.get_ICM()
URM_train, URM_test = train_test_holdout(URM, train_perc=0.8)
print("Shape : {}".format(URM_train.__sizeof__()))
evaluator_test = SequentialEvaluator(URM_test, cutoff_list=[10])
evaluator_test = EvaluatorWrapper(evaluator_test)
output_root_path = "result_experiments/"
filename = P3alphaRecommender.RECOMMENDER_NAME \
+ ItemKNNCBFRecommender.RECOMMENDER_NAME \
+ ItemKNNCFRecommender.RECOMMENDER_NAME \
+ "hybrid_opt"
output_root_path += filename
output_file = open(output_root_path, "a")
P3alpha = P3alphaRecommender(URM_train)
P3alpha.fit(topK=100, alpha=0.7905462550621185, implicit=True, normalize_similarity=True)
# print("-------------------")
def fit(self,
epochs=5000,
batch_size=1000,
num_factors=80,
learning_rate=0.001,
sgd_mode='adagrad',
user_reg=0.0,
positive_reg=0.01,
negative_reg=0.01,
stop_on_validation=False,
lower_validatons_allowed=5,
validation_metric="MAP",
evaluator_object=None,
validation_every_n=5,
force_compute_sim=True):
if not force_compute_sim:
found = True
try:
with open(
os.path.join("IntermediateComputations",
"MFMatrix.pkl"), 'rb') as handle:
(W_new, H_new) = pickle.load(handle)
except FileNotFoundError:
found = False
if found:
self.W = W_new
self.H = H_new
print("Saved MF Matrix Used!")
return
self.num_factors = num_factors
self.sgd_mode = sgd_mode
self.batch_size = batch_size
self.learning_rate = learning_rate
if evaluator_object is None and stop_on_validation:
evaluator_object = SequentialEvaluator(self.URM_validation, [10])
# Import compiled module
from MatrixFactorization.Cython.MatrixFactorization_Cython_Epoch import MatrixFactorization_Cython_Epoch
if self.algorithm == "FUNK_SVD":
self.cythonEpoch = MatrixFactorization_Cython_Epoch(
self.URM_train,
algorithm=self.algorithm,
n_factors=self.num_factors,
learning_rate=learning_rate,
batch_size=1,
sgd_mode=sgd_mode,
user_reg=user_reg,
positive_reg=positive_reg,
negative_reg=0.0)
elif self.algorithm == "ASY_SVD":
self.cythonEpoch = MatrixFactorization_Cython_Epoch(
self.URM_train,
algorithm=self.algorithm,
n_factors=self.num_factors,
learning_rate=learning_rate,
batch_size=32,
sgd_mode=sgd_mode,
user_reg=user_reg,
positive_reg=positive_reg,
negative_reg=0.0)
elif self.algorithm == "MF_BPR":
# Select only positive interactions
URM_train_positive = self.URM_train.copy()
URM_train_positive.data = URM_train_positive.data >= self.positive_threshold
URM_train_positive.eliminate_zeros()
assert URM_train_positive.nnz > 0, "MatrixFactorization_Cython: URM_train_positive is empty, positive threshold is too high"
self.cythonEpoch = MatrixFactorization_Cython_Epoch(
URM_train_positive,
algorithm=self.algorithm,
n_factors=self.num_factors,
learning_rate=learning_rate,
batch_size=batch_size,
sgd_mode=sgd_mode,
user_reg=user_reg,
positive_reg=positive_reg,
negative_reg=negative_reg)
self._train_with_early_stopping(epochs,
validation_every_n,
stop_on_validation,
validation_metric,
lower_validatons_allowed,
evaluator_object,
algorithm_name=self.algorithm)
self.W = self.W_best
self.H = self.H_best
with open(os.path.join("IntermediateComputations", "MFMatrix.pkl"),
'wb') as handle:
pickle.dump((self.W, self.H),
handle,
protocol=pickle.HIGHEST_PROTOCOL)
sys.stdout.flush()
#
# d_best = [[0.4, 0.03863232277574469, 0.008527738266632112, 0.2560912624445676, 0.7851755932819731,
# 0.4112843940329439],
# [0.2, 0.012499871230102988, 0.020242981888115352, 0.9969708006657074, 0.9999132876156388,
# 0.6888103295594851],
# [0.2, 0.10389111810225915, 0.14839466129917822, 0.866992903043857, 0.07010619211847613,
# 0.5873532658846817]]
# BEST RESULT : d_weights = [[0.5, 0.5, 0], [0.4, 0.4, 0.2], [0, 0.8, 0.2], [0, 0.5, 0.5]]
# Dynamics for Hybrid with Top_N. usefull for testing where each recommender works better
# d_weights = [[2, 4, 0], [1, 4, 5], [0, 2, 8]]
from Base.Evaluation.Evaluator import SequentialEvaluator
evaluator = SequentialEvaluator(URM_test, URM_train, exclude_seen=True)
output_root_path = "result_experiments/"
# If directory does not exist, create
if not os.path.exists(output_root_path):
os.makedirs(output_root_path)
logFile = open(output_root_path + "result_all_algorithms.txt", "a")
transfer_learning = False
if transfer_learning:
recommender_IB = ItemKNNCFRecommender(URM_train)
recommender_IB.fit(200, 15)
transfer_matrix = recommender_IB.W_sparse
else:
def run():
evaluate_algorithm = False
delete_old_computations = False
slim_after_hybrid = False
# delete_previous_intermediate_computations()
# if not evaluate_algorithm:
# delete_previous_intermediate_computations()
# else:
# print("ATTENTION: old intermediate computations kept, pay attention if running with all_train")
# delete_previous_intermediate_computations()
filename = "hybrid_ICB_ICF_UCF_SLIM_ELASTIC_local_08052.csv"
dataReader = RS_Data_Loader(all_train=not evaluate_algorithm)
URM_train = dataReader.get_URM_train()
URM_PageRank_train = dataReader.get_page_rank_URM()
URM_validation = dataReader.get_URM_validation()
URM_test = dataReader.get_URM_test()
ICM = dataReader.get_ICM()
UCM_tfidf = dataReader.get_tfidf_artists()
# _ = dataReader.get_tfidf_album()
recommender_list1 = [
# Random,
# TopPop,
ItemKNNCBFRecommender,
# UserKNNCBRecommender,
ItemKNNCFRecommender,
UserKNNCFRecommender,
# P3alphaRecommender,
# RP3betaRecommender,
# MatrixFactorization_BPR_Cython,
# MatrixFactorization_FunkSVD_Cython,
SLIM_BPR_Cython,
# ItemKNNCFRecommenderFAKESLIM,
# PureSVDRecommender,
SLIMElasticNetRecommender
]
# ITEM CB, ITEM CF, USER CF, RP3BETA, PURE SVD
recommender_list2 = [
# Random,
# TopPop,
ItemKNNCBFRecommender,
# UserKNNCBRecommender,
# ItemKNNCFPageRankRecommender,
ItemKNNCFRecommender,
UserKNNCFRecommender,
# P3alphaRecommender,
# RP3betaRecommender,
# MatrixFactorization_BPR_Cython,
# MatrixFactorization_FunkSVD_Cython,
SLIM_BPR_Cython,
SLIMElasticNetRecommender
# PureSVDRecommender
]
from Base.Evaluation.Evaluator import SequentialEvaluator
evaluator = SequentialEvaluator(URM_test, URM_train, exclude_seen=True)
output_root_path = "result_experiments/"
# If directory does not exist, create
if not os.path.exists(output_root_path):
os.makedirs(output_root_path)
logFile = open(output_root_path + "result_all_algorithms.txt", "a")
try:
recommender_class = HybridRecommender
print("Algorithm: {}".format(recommender_class))
'''
Our optimal run
'''
recommender_list = recommender_list1 # + recommender_list2 # + recommender_list3
onPop = False
# On pop it used to choose if have dynamic weights for
recommender = recommender_class(URM_train, ICM, recommender_list, URM_PageRank_train=URM_PageRank_train,
dynamic=False, UCM_train=UCM_tfidf,
URM_validation=URM_validation, onPop=onPop)
lambda_i = 0.1
lambda_j = 0.05
old_similrity_matrix = None
num_factors = 395
l1_ratio = 1e-06
# Variabili secondo intervallo
alphaRP3_2 = 0.9223827655310622
betaRP3_2 = 0.2213306613226453
num_factors_2 = 391
recommender.fit(**
{
"topK": [10, 33, 160, 761, 490],
"shrink": [8, 26, 2, -1, -1],
"pop": [280],
"weights": [0.33804686720093335, 1.3092081994688194, 0.642288869881126, 0.18883962446529368,
1.9317211019160747],
"final_weights": [1, 1],
"force_compute_sim": False, # not evaluate_algorithm,
"feature_weighting_index": 0,
"epochs": 150,
'lambda_i': [0.0], 'lambda_j': [1.0153577332223556e-08], 'SLIM_lr': [0.1],
'alphaP3': [0.4121720883248633],
'alphaRP3': [0.8582865731462926],
'betaRP': [0.2814208416833668],
'l1_ratio': 3.020408163265306e-06,
'alpha': 0.0014681984611695231,
'tfidf': [True],
"weights_to_dweights": -1,
"filter_top_pop_len": 0})
print("TEST")
print("Starting Evaluations...")
# to indicate if plotting for lenght or for pop
results_run, results_run_string, target_recommendations = evaluator.evaluateRecommender(recommender,
plot_stats=False,
onPop=onPop)
print("Algorithm: {}, results: \n{}".format([rec.RECOMMENDER_NAME for rec in recommender.recommender_list],
results_run_string))
logFile.write("Algorithm: {}, results: \n{} time: {}".format(
[rec.RECOMMENDER_NAME for rec in recommender.recommender_list], results_run_string, time.time()))
logFile.flush()
if not evaluate_algorithm:
target_playlist = dataReader.get_target_playlist()
md.assign_recomendations_to_correct_playlist(target_playlist, target_recommendations)
md.make_CSV_file(target_playlist, filename)
print('File {} created!'.format(filename))
except Exception as e:
traceback.print_exc()
logFile.write("Algorithm: {} - Exception: {}\n".format(recommender_class, str(e)))
logFile.flush()
evaluate_algorithm = True
slim_after_hybrid = False
# delete_previous_intermediate_computations()
filename = "hybrid_UserContentMatrix"
dataReader = RS_Data_Loader(top10k=True, all_train=not evaluate_algorithm)
URM_train = dataReader.get_URM_train()
URM_validation = dataReader.get_URM_validation()
URM_test = dataReader.get_URM_test()
from Base.Evaluation.Evaluator import SequentialEvaluator
evaluator = SequentialEvaluator(URM_test, URM_train, exclude_seen=True)
with open(
os.path.join("IntermediateComputations",
"Clusterization_Kmeans_3.pkl"), 'rb') as handle:
clusters = pickle.load(handle)
cl_0_ind = []
cl_1_ind = []
cl_2_ind = []
for elem in clusters:
if elem == 0:
cl_0_ind.append(elem)
elif elem == 1:
cl_1_ind.append(elem)
else:
def run():
evaluate_algorithm = True
delete_old_computations = False
slim_after_hybrid = False
# delete_previous_intermediate_computations()
# if not evaluate_algorithm:
# delete_previous_intermediate_computations()
# else:
# print("ATTENTION: old intermediate computations kept, pay attention if running with all_train")
# delete_previous_intermediate_computations()
filename = "hybrid_ICB_ICF_UCF_SLIM_ELASTIC_local_08052.csv"
dataReader = RS_Data_Loader(all_train=not evaluate_algorithm)
URM_train = dataReader.get_URM_train()
URM_PageRank_train = dataReader.get_page_rank_URM()
URM_validation = dataReader.get_URM_validation()
URM_test = dataReader.get_URM_test()
ICM = dataReader.get_ICM()
UCM_tfidf = dataReader.get_tfidf_artists()
# _ = dataReader.get_tfidf_album()
recommender_list1 = [
# Random,
# TopPop,
ItemKNNCBFRecommender,
# UserKNNCBRecommender,
ItemKNNCFRecommender,
UserKNNCFRecommender,
# P3alphaRecommender,
# RP3betaRecommender,
# MatrixFactorization_BPR_Cython,
# MatrixFactorization_FunkSVD_Cython,
SLIM_BPR_Cython,
# ItemKNNCFRecommenderFAKESLIM,
# PureSVDRecommender,
SLIMElasticNetRecommender
]
# ITEM CB, ITEM CF, USER CF, RP3BETA, PURE SVD
recommender_list2 = [
# Random,
# TopPop,
ItemKNNCBFRecommender,
# UserKNNCBRecommender,
ItemKNNCFRecommender,
UserKNNCFRecommender,
# P3alphaRecommender,
# RP3betaRecommender,
# MatrixFactorization_BPR_Cython,
# MatrixFactorization_FunkSVD_Cython,
SLIM_BPR_Cython,
# ItemKNNCFRecommenderFAKESLIM,
# PureSVDRecommender,
SLIMElasticNetRecommender
]
from Base.Evaluation.Evaluator import SequentialEvaluator
evaluator = SequentialEvaluator(URM_test, URM_train, exclude_seen=True)
output_root_path = "result_experiments/"
# If directory does not exist, create
if not os.path.exists(output_root_path):
os.makedirs(output_root_path)
logFile = open(output_root_path + "result_all_algorithms.txt", "a")
try:
recommender_class = HybridRecommender
print("Algorithm: {}".format(recommender_class))
'''
Our optimal run
'''
recommender_list = recommender_list1 + recommender_list2 # + recommender_list3
d_weights = [
[0.5469789514168496, 1.5598358421050373, 1.1505851198615593, 0.2540023047558251, 0.9403502151872645] + [
0] * len(recommender_list2),
[0] * len(recommender_list1) + [0.5205017325111618, 1.6831295912149837, 1.6560707664775454,
0.3144197724407203, 1.9912784665282535]
]
onPop = False
# On pop it used to choose if have dynamic weights for
recommender = recommender_class(URM_train, ICM, recommender_list, URM_PageRank_train=URM_PageRank_train,
dynamic=True, UCM_train=UCM_tfidf, d_weights=d_weights,
URM_validation=URM_validation, onPop=onPop)
recommender.fit(**
{
"topK": [10, 33, 160, 761, 490] + [10, 33, 160, 761, 490],
"shrink": [8, 26, 2, -1, -1] + [8, 26, 2, -1, -1],
"pop": [30],
"weights": [1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
"final_weights": [1, 1],
"force_compute_sim": False, # not evaluate_algorithm,
"feature_weighting_index": [0, 0],
"epochs": 150,
'lambda_i': [0.0, 0.0], 'lambda_j': [1.0153577332223556e-08, 1.0153577332223556e-08],
'SLIM_lr': [0.1, 0.1],
'alphaP3': [0.4121720883248633],
'alphaRP3': [0.8582865731462926],
'betaRP': [0.2814208416833668],
'l1_ratio': [3.020408163265306e-06, 3.020408163265306e-06],
'alpha': [0.0014681984611695231, 0.0014681984611695231],
'tfidf': [True, True],
"weights_to_dweights": -1,
"filter_top_pop_len": 0})
print("TEST")
print("Starting Evaluations...")
# to indicate if plotting for lenght or for pop
results_run, results_run_string, target_recommendations = evaluator.evaluateRecommender(recommender,
plot_stats=True,
onPop=onPop)
print("Algorithm: {}, results: \n{}".format([rec.RECOMMENDER_NAME for rec in recommender.recommender_list],
results_run_string))
logFile.write("Algorithm: {}, results: \n{} time: {} \n".format(
[rec.RECOMMENDER_NAME for rec in recommender.recommender_list], results_run_string, time.time()))
logFile.flush()
if not evaluate_algorithm:
target_playlist = dataReader.get_target_playlist()
md.assign_recomendations_to_correct_playlist(target_playlist, target_recommendations)
md.make_CSV_file(target_playlist, filename)
print('File {} created!'.format(filename))
except Exception as e:
traceback.print_exc()
logFile.write("Algorithm: {} - Exception: {}\n".format(recommender_class, str(e)))
logFile.flush()
