def __init__(self, urm_train):
super(HybridNorm3Recommender, self).__init__(urm_train)
urm_train = check_matrix(urm_train.copy(), 'csr')
self.num_users = urm_train.shape[0]
# recommender_1 = HybridGenRecommender(urm_train)
# recommender_1.fit()
recommender_1 = RP3betaRecommender(urm_train)
recommender_1.fit(topK=16,
alpha=0.03374950051351756,
beta=0.24087176329409027,
normalize_similarity=True)
recommender_3 = UserKNNCFRecommender(urm_train)
recommender_3.fit(shrink=2, topK=600, normalize=True)
recommender_2 = ItemKNNCFRecommender(urm_train)
recommender_2.fit(topK=5,
shrink=500,
feature_weighting='BM25',
similarity='tversky',
normalize=False,
tversky_alpha=0.0,
tversky_beta=1.0)
self.recommender_1 = recommender_1
self.recommender_2 = recommender_2
self.recommender_3 = recommender_3
class Hybrid002AlphaRecommender(BaseRecommender):
"""Hybrid000AlphaRecommender recommender"""
RECOMMENDER_NAME = "Hybrid002AlphaRecommender"
def __init__(self, URM_train, UCM, cold_users, warm_users):
super(Hybrid002AlphaRecommender, self).__init__(URM_train)
self.warm_recommender = UserKNNCFRecommender(URM_train)
self.cold_recommender = UserKNNCBFRecommender(UCM, URM_train)
self.cold_users = cold_users
self.warm_users = warm_users
def fit(self, random_seed=42, topK=14000, shrink=2):
self.warm_recommender.fit(topK=topK,
shrink=shrink,
feature_weighting="BM25")
self.cold_recommender.fit(topK=topK,
shrink=shrink,
feature_weighting="BM25")
def recommend(self,
user_id_array,
cutoff=None,
remove_seen_flag=True,
items_to_compute=None,
remove_top_pop_flag=False,
remove_CustomItems_flag=False,
return_scores=False):
if user_id_array in self.warm_users:
return self.warm_recommender.recommend(user_id_array,
cutoff=cutoff)
if user_id_array in self.cold_users:
return self.cold_recommender.recommend(user_id_array,
cutoff=cutoff)
def fit(self,
threshold_sim=0.5,
threshold_count=5,
topK=50,
shrink=100,
similarity='cosine',
normalize=True,
feature_weighting="none",
**similarity_args):
user_cf = UserKNNCFRecommender(self.URM_train)
user_cf.fit(topK=topK,
shrink=shrink,
similarity=similarity,
normalize=normalize,
feature_weighting=feature_weighting,
**similarity_args)
new_URM = VirtualNearestNeighbor.newAugmentUMR(
URM_train=self.URM_train,
W_sparse=user_cf.W_sparse,
threshold_interactions=threshold_count,
threshold_similarity=threshold_sim)
new_item_cf = ItemKNNCFRecommender(new_URM)
new_item_cf.fit(topK=topK,
shrink=shrink,
similarity=similarity,
normalize=normalize,
feature_weighting=feature_weighting,
**similarity_args)
self.W_sparse = new_item_cf.W_sparse
class Hybrid102AlphaRecommender(BaseRecommender):
"""Hybrid102AlphaRecommender recommender"""
RECOMMENDER_NAME = "Hybrid102AlphaRecommender"
def __init__(self, data: DataObject):
super(Hybrid102AlphaRecommender, self).__init__(data.urm_train)
self.data = data
self.rec1 = UserKNNCFRecommender(data.urm_train)
self.rec1.fit(topK=1000, shrink=4500, similarity="cosine", feature_weighting="TF-IDF")
self.rec2 = ItemKNNCFRecommender(data.urm_train)
self.rec2.fit(topK=2000, shrink=800, similarity="cosine", feature_weighting="TF-IDF")
self.rec3 = SLIM_BPR_Cython(data.urm_train)
self.rec3.fit(epochs=120, topK=800, lambda_i=0.1, lambda_j=0.1, learning_rate=0.0001)
self.rec4 = RP3betaRecommender(data.urm_train)
self.rec4.fit(topK=30, alpha=0.21, beta=0.25)
target_users = data.urm_train_users_by_type[2][1]
self.target_users = target_users
self.hybrid_rec = Hybrid1CXAlphaRecommender(data, recommenders=[self.rec1, self.rec2, self.rec3],
recommended_users=target_users, max_cutoff=30)
def fit(self):
weights1 = np.array([[0.37625119, 0.43193487, 0.17444842, 0.16197883, 0.18204363,
0.17016599, 0.14983434, 0.11938279, 0.09980418, 0.1147748,
0.12762677, 0.08689066, 0.09533745, 0.10492991, 0.097475,
0.05278562, 0.05244627, 0.0602501, 0.06743845, 0.06145589,
0.07008017, 0.07410305, 0.07170746, 0.04231058, 0.04493697,
0.02516579, 0.0176046, 0.01360429, 0., 0.],
[0.55298149, 0.27456885, 0.2278579, 0.25095311, 0.24721051,
0.09937549, 0.09209609, 0.07158969, 0.07174988, 0.08251237,
0.09157335, 0.10530935, 0.1106961, 0.12150468, 0.12001527,
0.10052318, 0.09536568, 0.10770821, 0.08553278, 0.06198749,
0.05708056, 0.05176975, 0.05953521, 0.05567152, 0.06083775,
0.02776653, 0.02663699, 0.01181728, 0.01168978, 0.],
[0.25041731, 0.15536414, 0.16953122, 0.17164006, 0.11443169,
0.11873982, 0.07100542, 0.06452205, 0.06123626, 0.06430055,
0.06311274, 0.05618836, 0.05331187, 0.04611177, 0.04239514,
0.03824963, 0.04398116, 0.04738213, 0.04862799, 0.03962175,
0.04556502, 0.04738956, 0.054498, 0.0626727, 0.04973429,
0.03219802, 0.03227312, 0.0307041, 0.03396853, 0.],
[1., 0.5538608, 0.44692181, 0.20321725, 0.22012478,
0.1873366, 0.14329206, 0.09783222, 0.10765581, 0.10658318,
0.12257066, 0.13699397, 0.15743225, 0.12181424, 0.13897041,
0.08672218, 0.09188654, 0.05170634, 0.04459521, 0.04785834,
0.05248675, 0.06035977, 0.06733202, 0.06760871, 0.07775002,
0.0720465, 0.05977294, 0.04260028, 0.00546561, 0.0055422]])
self.hybrid_rec.weights = weights1
def recommend(self, user_id_array, cutoff=None, remove_seen_flag=True, items_to_compute=None,
remove_top_pop_flag=False, remove_CustomItems_flag=False, return_scores=False):
if user_id_array in self.target_users:
return self.hybrid_rec.recommend(user_id_array=user_id_array, cutoff=cutoff)
else:
return []
def __init__(self, urm_train, eurm=False):
super(HybridNorm2Recommender, self).__init__(urm_train)
self.data_folder = Path(__file__).parent.parent.absolute()
self.eurm = eurm
self.num_users = urm_train.shape[0]
urm_train = check_matrix(urm_train.copy(), 'csr')
recommender_2 = ItemKNNCFRecommender(urm_train)
recommender_2.fit(topK=5, shrink=500, feature_weighting='BM25', similarity='tversky', normalize=False, tversky_alpha=0.0, tversky_beta=1.0)
recommender_3 = UserKNNCFRecommender(urm_train)
recommender_3.fit(shrink=2, topK=600, normalize=True)
# recommender_3 = UserKNNCFRecommender(urm_train)
# recommender_3.fit(topK=697, shrink=1000, feature_weighting='TF-IDF', similarity='tversky', normalize=False,
# tversky_alpha=1.0, tversky_beta=1.0)
recommender_4 = RP3betaRecommender(urm_train)
recommender_4.fit(topK=16, alpha=0.03374950051351756, beta=0.24087176329409027, normalize_similarity=True)
recommender_5 = SLIM_BPR_Cython(urm_train)
recommender_5.fit(lambda_i=0.0926694015, lambda_j=0.001697250, learning_rate=0.002391, epochs=65, topK=200)
recommender_6 = ALSRecommender(urm_train)
recommender_6.fit(alpha=5, iterations=40, reg=0.3)
self.recommender_2 = recommender_2
self.recommender_3 = recommender_3
self.recommender_4 = recommender_4
self.recommender_5 = recommender_5
self.recommender_6 = recommender_6
if self.eurm:
self.score_matrix_1 = sps.load_npz(self.data_folder / 'Data/icm_sparse.npz')
self.score_matrix_2 = self.recommender_2._compute_item_matrix_score(np.arange(self.num_users))
self.score_matrix_3 = self.recommender_3._compute_item_matrix_score(np.arange(self.num_users))
self.score_matrix_4 = self.recommender_4._compute_item_matrix_score(np.arange(self.num_users))
self.score_matrix_5 = self.recommender_5._compute_item_matrix_score(np.arange(self.num_users))
self.score_matrix_6 = self.recommender_6._compute_item_score(np.arange(self.num_users))
self.score_matrix_7 = sps.load_npz(self.data_folder / 'Data/ucm_sparse.npz')
self.score_matrix_1 = normalize(self.score_matrix_1, norm='l2', axis=1)
self.score_matrix_2 = normalize(self.score_matrix_2, norm='l2', axis=1)
self.score_matrix_3 = normalize(self.score_matrix_3, norm='l2', axis=1)
self.score_matrix_4 = normalize(self.score_matrix_4, norm='l2', axis=1)
self.score_matrix_5 = normalize(self.score_matrix_5, norm='l2', axis=1)
self.score_matrix_6 = normalize(self.score_matrix_6, norm='l2', axis=1)
self.score_matrix_7 = normalize(self.score_matrix_7, norm='l2', axis=1)
def __init__(self, data: DataObject):
super(Hybrid102AlphaRecommender, self).__init__(data.urm_train)
self.data = data
self.rec1 = UserKNNCFRecommender(data.urm_train)
self.rec1.fit(topK=1000, shrink=4500, similarity="cosine", feature_weighting="TF-IDF")
self.rec2 = ItemKNNCFRecommender(data.urm_train)
self.rec2.fit(topK=2000, shrink=800, similarity="cosine", feature_weighting="TF-IDF")
self.rec3 = SLIM_BPR_Cython(data.urm_train)
self.rec3.fit(epochs=120, topK=800, lambda_i=0.1, lambda_j=0.1, learning_rate=0.0001)
self.rec4 = RP3betaRecommender(data.urm_train)
self.rec4.fit(topK=30, alpha=0.21, beta=0.25)
target_users = data.urm_train_users_by_type[2][1]
self.target_users = target_users
self.hybrid_rec = Hybrid1CXAlphaRecommender(data, recommenders=[self.rec1, self.rec2, self.rec3],
recommended_users=target_users, max_cutoff=30)
def __init__(self, urm_train):
super(HybridNorm1Recommender, self).__init__(urm_train)
self.num_users = urm_train.shape[0]
urm_train = check_matrix(urm_train.copy(), 'csr')
recommender_1 = HybridGen2Recommender(urm_train)
recommender_1.fit()
recommender_2 = ItemKNNCFRecommender(urm_train)
recommender_2.fit(topK=5,
shrink=500,
feature_weighting='BM25',
similarity='tversky',
normalize=False,
tversky_alpha=0.0,
tversky_beta=1.0)
recommender_3 = UserKNNCFRecommender(urm_train)
recommender_3.fit(topK=697,
shrink=1000,
feature_weighting='TF-IDF',
similarity='tversky',
normalize=False,
tversky_alpha=1.0,
tversky_beta=1.0)
recommender_4 = RP3betaRecommender(urm_train)
recommender_4.fit(topK=16,
alpha=0.03374950051351756,
beta=0.24087176329409027,
normalize_similarity=True)
recommmender_5 = SLIM_BPR_Cython(urm_train)
recommmender_5.fit(lambda_i=0.0926694015,
lambda_j=0.001697250,
learning_rate=0.002391,
epochs=65,
topK=200)
recommender_6 = ALSRecommender(urm_train)
recommender_6.fit(alpha=5, iterations=40, reg=0.3)
self.recommender_1 = recommender_1
self.recommender_2 = recommender_2
self.recommender_3 = recommender_3
self.recommender_4 = recommender_4
self.recommender_5 = recommmender_5
self.recommender_6 = recommender_6
def __init__(self,
URM_train,
ICM_train,
submission=False,
verbose=True,
seed=1205):
super(LinearHybrid002, self).__init__(URM_train, verbose=verbose)
self.URM_train = URM_train
self.ICM_train = ICM_train
# seed 1205: 'topK': 190, 'shrink': 0, 'similarity': 'cosine', 'normalize': True
self.__rec1 = UserKNNCFRecommender(URM_train, verbose=False)
self.__rec1_params = {
'topK': 190,
'shrink': 0,
'similarity': 'cosine',
'normalize': True
}
# seed 1205: 'topK': 100, 'shrink': 1000, 'similarity': 'asymmetric', 'normalize': True, 'asymmetric_alpha': 0.0
self.__rec2 = ItemKNNCFRecommender(URM_train, verbose=False)
self.__rec2_params = {
'topK': 100,
'shrink': 1000,
'similarity': 'asymmetric',
'normalize': True,
'asymmetric_alpha': 0.0
}
# seed 1205: 'topK': 205, 'shrink': 1000, 'similarity': 'cosine', 'normalize': True, 'feature_weighting': 'BM25'
self.__rec3 = ItemKNNCBFRecommender(URM_train,
ICM_train,
verbose=False)
self.__rec3_params = {
'topK': 205,
'shrink': 1000,
'similarity': 'cosine',
'normalize': True,
'feature_weighting': 'BM25'
}
self.__a = self.__b = self.__c = None
self.seed = seed
self.__submission = submission
def __init__(self,
URM_train,
ICM_train,
submission=False,
verbose=True,
seed=1205):
super(LinearHybrid008, self).__init__(URM_train, verbose=verbose)
self.URM_train = URM_train
self.ICM_train = ICM_train
self.__rec1 = SSLIMElasticNet(URM_train, ICM_train, verbose=False)
self.__rec1_params = {
'beta': 0.4849594591575789,
'topK': 1000,
'l1_ratio': 1e-05,
'alpha': 0.001
}
self.__rec2 = ItemKNNCBFRecommender(URM_train,
ICM_train,
verbose=False)
self.__rec2_params = {
'topK': 65,
'shrink': 0,
'similarity': 'dice',
'normalize': True
}
self.__rec3 = UserKNNCFRecommender(URM_train, verbose=False)
self.__rec3_params = {
'topK': 190,
'shrink': 0,
'similarity': 'cosine',
'normalize': True
}
self.__a = self.__b = self.__c = None
self.seed = seed
self.__submission = submission
def trial_boost_user(data):
rec1 = UserKNNCFRecommender(data.urm_train)
rec2 = NewUserKNNAgeRecommender(data)
rec3 = UserKNNCFRecommender(data.urm_train)
rec1.fit(topK=500, shrink=1000, similarity='cosine', feature_weighting='TF-IDF')
rec2.set_similarity([1])
rec2.fit(topK=0)
for alpha in [0.999990, 0.999995, 0.999999]:
print("alpha:" + str(alpha))
rec3.W_sparse = alpha * rec1.W_sparse + (1 - alpha) * rec2.W_sparse
total_evaluation(rec3)
def eval(self, *args):
# Input parameters
topK = args[0][0]
shrink = args[0][1]
similarity = args[0][2]
normalize = args[0][3]
feature_weighting = args[0][4]
# Text used for csv file
input_as_string = f"topK={topK} - shrink={shrink} - similarity={similarity} - normalize={normalize} - " \
f"feature_weighting={feature_weighting}"
recommender_name = "Item CF"
# Creating the recommenders (parallel fit and evaluation)
recs = [
UserKNNCFRecommender(data.urm_train) for data in self.dataset_list
]
pairs = zip(recs, self.dataset_list)
results = Parallel(n_jobs=parallelism)(
delayed(parallel_fit_and_eval_job)
(rec, data, topK, shrink, similarity, normalize, feature_weighting)
for rec, data in pairs)
# Computing the average MAP
map_per_type = np.array(results).mean(axis=0)
# Storing the information on file
f = open(self.filename_csv, "a+")
map_as_string = " ".join([str(x) + "," for x in map_per_type])
f.write(f"{recommender_name}, {input_as_string}, {map_as_string}\n")
f.flush()
f.close()
# The MAP value that should be optimized
optimized_map = map_per_type[self.type_of_user]
# Printing stuffs
current_time = time.time()
print(
f"run : {self.counter} - computed in {current_time - self.timer} seconds"
)
print(f"\tparameters : {input_as_string}")
print(f"\tmap : {optimized_map}\n")
self.counter += 1
self.timer = current_time
return -optimized_map
def __init__(self, URM_train, ICM_all, verbose=True):
super(UserWiseHybrid001, self).__init__(URM_train, verbose=verbose)
self.URM_train = URM_train
self.ICM_all = ICM_all
# range and recommender definition ---> element structure: ( (start, end), recommender, fit_args* )
self.__recommender_segmentation = [
((0, 1), TopPop(URM_train), {}),
((1, 25), P3alphaRecommender(URM_train),
{'topK': 729, 'alpha': 0.4104229220476686, 'normalize_similarity': False}),
((25, 50), RP3betaRecommender(URM_train),
{'topK': 939, 'alpha': 0.6073516078011799, 'beta': 0.002238854541773972, 'normalize_similarity': False}),
((50, 100), UserKNNCFRecommender(URM_train),
{'topK': 90, 'shrink': 77, 'similarity': 'cosine', 'normalize': True}),
((100, 200), RP3betaRecommender(URM_train),
{'topK': 1000, 'alpha': 0.32110178834628456, 'beta': 0.0, 'normalize_similarity': True}),
((200, -1), SLIM_BPR_Cython(URM_train),
{'topK': 120, 'epochs': 20, 'symmetric': True, 'sgd_mode': 'adam', 'lambda_i': 0.01, 'lambda_j': 1e-05, 'learning_rate': 0.0001}),
]
self.__loaded = {}
for f_range, _, _ in self.__recommender_segmentation:
self.__loaded[f_range] = False
class LinearHybrid003(BaseItemSimilarityMatrixRecommender):
RECOMMENDER_NAME = "LinearHybrid003"
# set the seed equal to the one of the parameter search!!!!
def __init__(self,
URM_train,
ICM_train,
submission=False,
verbose=True,
seed=1205):
super(LinearHybrid003, self).__init__(URM_train, verbose=verbose)
self.URM_train = URM_train
self.ICM_train = ICM_train
# seed 1205: 'topK': 190, 'shrink': 0, 'similarity': 'cosine', 'normalize': True
self.__rec1 = UserKNNCFRecommender(URM_train, verbose=False)
self.__rec1_params = {
'topK': 190,
'shrink': 0,
'similarity': 'cosine',
'normalize': True
}
self.__rec2 = P3alphaRecommender(URM_train, verbose=False)
self.__rec2_params = {
'topK': 131,
'alpha': 0.33660811631883863,
'normalize_similarity': False
}
# seed 1205: 'topK': 205, 'shrink': 1000, 'similarity': 'cosine', 'normalize': True, 'feature_weighting': 'BM25'
self.__rec3 = ItemKNNCBFRecommender(URM_train,
ICM_train,
verbose=False)
self.__rec3_params = {
'topK': 205,
'shrink': 1000,
'similarity': 'cosine',
'normalize': True,
'feature_weighting': 'BM25'
}
self.__a = self.__b = self.__c = None
self.seed = seed
self.__submission = submission
def fit(self, alpha=0.5, l1_ratio=0.5):
self.__a = alpha * l1_ratio
self.__b = alpha - self.__a
self.__c = 1 - self.__a - self.__b
if not self.__submission:
try:
self.__rec1.load_model(
f'stored_recommenders/seed_{str(self.seed)}_{self.__rec1.RECOMMENDER_NAME}/',
f'best_for_{self.RECOMMENDER_NAME}')
print(f"{self.__rec1.RECOMMENDER_NAME} loaded.")
except:
print(f"Fitting {self.__rec1.RECOMMENDER_NAME} ...")
self.__rec1.fit(**self.__rec1_params)
print(f"done.")
self.__rec1.save_model(
f'stored_recommenders/seed_{str(self.seed)}_{self.__rec1.RECOMMENDER_NAME}/',
f'best_for_{self.RECOMMENDER_NAME}')
try:
self.__rec2.load_model(
f'stored_recommenders/seed_{str(self.seed)}_{self.__rec2.RECOMMENDER_NAME}/',
f'best_for_{self.RECOMMENDER_NAME}')
print(f"{self.__rec2.RECOMMENDER_NAME} loaded.")
except:
print(f"Fitting {self.__rec2.RECOMMENDER_NAME} ...")
self.__rec2.fit(**self.__rec2_params)
print(f"done.")
self.__rec2.save_model(
f'stored_recommenders/seed_{str(self.seed)}_{self.__rec2.RECOMMENDER_NAME}/',
f'best_for_{self.RECOMMENDER_NAME}')
try:
self.__rec3.load_model(
f'stored_recommenders/seed_{str(self.seed)}_{self.__rec3.RECOMMENDER_NAME}/',
f'best_for_{self.RECOMMENDER_NAME}')
print(f"{self.__rec3.RECOMMENDER_NAME} loaded.")
except:
print(f"Fitting {self.__rec3.RECOMMENDER_NAME} ...")
self.__rec3.fit(**self.__rec3_params)
print(f"done.")
self.__rec3.save_model(
f'stored_recommenders/seed_{str(self.seed)}_{self.__rec3.RECOMMENDER_NAME}/',
f'best_for_{self.RECOMMENDER_NAME}')
else:
self.__rec1.fit(**self.__rec1_params)
self.__rec2.fit(**self.__rec2_params)
self.__rec3.fit(**self.__rec3_params)
def _compute_item_score(self, user_id_array, items_to_compute=None):
item_weights_1 = self.__rec1._compute_item_score(user_id_array)
item_weights_2 = self.__rec2._compute_item_score(user_id_array)
item_weights_3 = self.__rec3._compute_item_score(user_id_array)
item_weights = item_weights_1 * self.__a + item_weights_2 * self.__b + item_weights_3 * self.__c
return item_weights
def save_model(self, folder_path, file_name=None):
if file_name is None:
file_name = self.RECOMMENDER_NAME
self._print("Saving model in file '{}'".format(folder_path +
file_name))
dataIO = DataIO(folder_path=folder_path)
dataIO.save_data(file_name=file_name, data_dict_to_save={})
self._print("Saving complete")
def __init__(self, URM_train, ICM_train, submission=False, verbose=True, seed=1205):
super(UserWiseHybrid008, self).__init__(URM_train, verbose=verbose)
recommenders = {
'rp3b': RP3betaRecommender(URM_train),
'p3a': P3alphaRecommender(URM_train),
'sen': SLIMElasticNetRecommender(URM_train),
'sbpr': SLIM_BPR_Cython(URM_train),
'icb': ItemKNNCBFRecommender(URM_train,ICM_train),
'icf': ItemKNNCFRecommender(URM_train),
'ucf': UserKNNCFRecommender(URM_train)
}
#print("Fitting rp3b...")
#params = {'topK': 1000, 'alpha': 0.38192761611274967, 'beta': 0.0, 'normalize_similarity': False}
#recommenders['rp3b'].fit(**params)
#print("done.")
print("Fitting p3a...")
params = {'topK': 131, 'alpha': 0.33660811631883863, 'normalize_similarity': False}
recommenders['p3a'].fit(**params)
print("done.")
print("Fitting sen...")
params = {'topK': 992, 'l1_ratio': 0.004065081925341167, 'alpha': 0.003725005053334143}
recommenders['sen'].fit(**params)
print("done.")
print("Fitting sbpr...")
params = {'topK': 979, 'epochs': 130, 'symmetric': False, 'sgd_mode': 'adam', 'lambda_i': 0.004947329669424629,
'lambda_j': 1.1534760845071758e-05, 'learning_rate': 0.0001}
recommenders['sbpr'].fit(**params)
print("done.")
print("Fitting icb...")
params = {'topK': 65, 'shrink': 0, 'similarity': 'dice', 'normalize': True}
recommenders['icb'].fit(**params)
print("done.")
print("Fitting icf...")
params = {'topK': 55, 'shrink': 1000, 'similarity': 'asymmetric', 'normalize': True, 'asymmetric_alpha': 0.0}
recommenders['icf'].fit(**params)
print("done.")
print("Fitting ucf...")
params = {'topK': 190, 'shrink': 0, 'similarity': 'cosine', 'normalize': True}
recommenders['ucf'].fit(**params)
print("done.")
self.__recommender_segmentation = [
((0,6), HiddenRecommender(URM_train, ICM_train, [
recommenders['p3a'],
recommenders['ucf'],
recommenders['icb']
], submission=submission, verbose=verbose, seed=seed),
{'alpha': 0.3987236515679141, 'l1_ratio': 0.15489605895390016}),
((6,16), HiddenRecommender(URM_train, ICM_train, [
recommenders['ucf'],
recommenders['icb'],
recommenders['sen']
], submission=submission, verbose=verbose, seed=seed),
{'alpha': 0.33535858857401674, 'l1_ratio': 0.4046400351885727}),
((16,-1), HiddenRecommender(URM_train, ICM_train, [
recommenders['icb'],
recommenders['sen'],
recommenders['sbpr']
], submission=submission, verbose=verbose, seed=seed),
{'alpha': 0.7321778261479165, 'l1_ratio': 0.15333729621089734}),
]
from FeatureWeighting.User_CFW_D_Similarity_Linalg import User_CFW_D_Similarity_Linalg
from Hybrid.HybridNorm3Recommender import HybridNorm3Recommender
from MatrixFactorization.ALSRecommender import ALSRecommender
from MatrixFactorization.BPRRecommender import BPRRecommender
import similaripy as sim
data = DataManager()
urm_train = data.get_urm()
urm_train, urm_test = split_train_leave_k_out_user_wise(data.get_urm(),
temperature='normal')
urm_train, urm_valid = split_train_leave_k_out_user_wise(urm_train,
temperature='valid2')
urm_train_warm = data.create_test_warm_users(urm_train, threshold=10)
urm_test_warm = data.create_test_warm_users(urm_test, threshold=10)
evaluator_test_warm = EvaluatorHoldout(urm_test_warm, cutoff_list=[10])
recommender = UserKNNCFRecommender(urm_train)
recommender.fit(shrink=2, topK=600, normalize=True)
recommender_warm = UserKNNCFRecommender(urm_train_warm)
recommender_warm.fit(shrink=2, topK=500, normalize=True)
result, str_result = evaluator_test_warm.evaluateRecommender(recommender)
print('The Map of test of urm normal is : {}'.format(result[10]['MAP']))
result, str_result = evaluator_test_warm.evaluateRecommender(recommender_warm)
print('The Map of test of urm warm is : {}'.format(result[10]['MAP']))
print('URM_train.shape:', URM_train.shape)
print('URM_test.shape:', URM_test.shape)
print('URM_validation.shape:', URM_validation.shape)
print('number_of_users:', number_of_users)
print('number_of_items:', number_of_items)
# test(URM_train, 267)
cutoff = 5
print_statistics(URM_train)
CMN_wrapper_train = CMN_RecommenderWrapper(URM_train)
user_KNNCF_Recommender = UserKNNCFRecommender(URM_train)
item_KNNCF_Recommender = ItemKNNCFRecommender(URM_train)
rp3_beta_Recommender = RP3betaRecommender(URM_train)
evaluator_negative_item_sample = EvaluatorNegativeItemSample(
URM_test, URM_test_negative, cutoff_list=[5, 10])
CMN_wrapper_train.loadModel('result_experiments/SIGIR/CMN_pinterest/',
'CMN_RecommenderWrapper_best_model')
d, s = evaluator_negative_item_sample.evaluateRecommender(CMN_wrapper_train)
print('CMN_wrapper_train')
print(s)
user_KNNCF_Recommender.loadModel('result_experiments/SIGIR/CMN_pinterest/',
'UserKNNCFRecommender_cosine_best_model')
d, s = evaluator_negative_item_sample.evaluateRecommender(
URM_train, URM_test = split_train_in_two_percentage_global_sample(URM_all, train_percentage=0.90, seed=seed)
evaluator_test = EvaluatorHoldout(URM_test, cutoff_list=[10])
sslim = SSLIMElasticNet(URM_train, ICM_all, verbose=False)
sslim_params = {'beta': 0.4849594591575789, 'topK': 1000, 'l1_ratio': 1e-05, 'alpha': 0.001}
try:
sslim.load_model(f'stored_recommenders/seed_1205_S-SLIMElasticNet/', 'for_notebook_analysis')
print(f"{sslim.RECOMMENDER_NAME} loaded.")
except:
print(f"Fitting {sslim.RECOMMENDER_NAME} ...")
sslim.fit(**sslim_params)
print(f"done.")
sslim.save_model(f'stored_recommenders/seed_{str(seed)}_{sslim.RECOMMENDER_NAME}/', 'for_notebook_analysis')
ucf = UserKNNCFRecommender(URM_train, verbose=False)
ucf_params = {'topK': 190, 'shrink': 0, 'similarity': 'cosine', 'normalize': True}
try:
ucf.load_model(f'stored_recommenders/seed_{str(seed)}_{ucf.RECOMMENDER_NAME}/', 'for_notebook_analysis')
print(f"{ucf.RECOMMENDER_NAME} loaded.")
except:
print(f"Fitting {ucf.RECOMMENDER_NAME} ...")
ucf.fit(**ucf_params)
print(f"done.")
ucf.save_model(f'stored_recommenders/seed_{str(seed)}_{ucf.RECOMMENDER_NAME}/', 'for_notebook_analysis')
icb = ItemKNNCBFRecommender(URM_train, ICM_all, verbose=False)
icb_params = {'topK': 65, 'shrink': 0, 'similarity': 'dice', 'normalize': True}
try:
icb.load_model(f'stored_recommenders/seed_{str(seed)}_{icb.RECOMMENDER_NAME}/', 'for_notebook_analysis')
# recommenderELASTIC.save_model('model/', file_name='SLIM_ElasticNet_max')
recommenderELASTIC.load_model('model/',
file_name='SLIM_ElasticNet_l1ratio_0_5')
# recommenderAlphaGRAPH = P3alphaRecommender(URM_all)
# recommenderAlphaGRAPH.fit(topK=10, alpha=0.41, implicit=True, normalize_similarity=True)
recommenderBetaGRAPH = RP3betaRecommender(URM_all)
recommenderBetaGRAPH.fit(topK=54,
implicit=True,
normalize_similarity=True,
alpha=1e-6,
beta=0.2,
min_rating=0)
recommenderUserKNN = UserKNNCFRecommender(URM_all)
recommenderUserKNN.fit(topK=550,
shrink=0,
similarity='jaccard',
normalize=True)
recommenderIALS = IALSRecommender(URM_all)
# recommenderIALS.fit(epochs=200, alpha=1, reg=1e-4)
# recommenderIALS.save_model('model/', file_name='IALS_1_200_max')
recommenderIALS.load_model('model/', file_name='IALS_1_200_max')
recommenderUserCBF = UserKNNCBFRecommender(URM_all, UCM_all)
recommenderUserCBF.fit(topK=3000,
shrink=10,
similarity='cosine',
normalize=True)
class LinearOverMerged001(BaseItemSimilarityMatrixRecommender):
RECOMMENDER_NAME = "LinearOverMerged001"
# set the seed equal to the one of the parameter search!!!!
def __init__(self,
URM_train,
ICM_train,
submission=False,
verbose=True,
seed=1205):
super(LinearOverMerged001, self).__init__(URM_train, verbose=verbose)
self.URM_train = URM_train
self.ICM_train = ICM_train
self.__submission = submission
self.__rec1 = UserKNNCFRecommender(URM_train, verbose=False)
self.__rec1_params = {
'topK': 190,
'shrink': 0,
'similarity': 'cosine',
'normalize': True
}
self.seed = seed
icb = ItemKNNCBFRecommender(URM_train, ICM_train, verbose=False)
icb_params = {
'topK': 65,
'shrink': 0,
'similarity': 'dice',
'normalize': True
}
rp3b = RP3betaRecommender(URM_train, verbose=False)
rp3b_params = {
'topK': 1000,
'alpha': 0.38192761611274967,
'beta': 0.0,
'normalize_similarity': False
}
sen = SLIMElasticNetRecommender(URM_train, verbose=False)
sen_params = {
'topK': 992,
'l1_ratio': 0.004065081925341167,
'alpha': 0.003725005053334143
}
if not self.__submission:
try:
icb.load_model(
f'stored_recommenders/seed_{str(self.seed)}_{icb.RECOMMENDER_NAME}/',
f'best_for_{self.RECOMMENDER_NAME}')
print(f"{icb.RECOMMENDER_NAME} loaded.")
except:
print(f"Fitting {icb.RECOMMENDER_NAME} ...")
icb.fit(**icb_params)
print(f"done.")
icb.save_model(
f'stored_recommenders/seed_{str(self.seed)}_{icb.RECOMMENDER_NAME}/',
f'best_for_{self.RECOMMENDER_NAME}')
try:
rp3b.load_model(
f'stored_recommenders/seed_{str(self.seed)}_{rp3b.RECOMMENDER_NAME}/',
f'best_for_{self.RECOMMENDER_NAME}')
print(f"{rp3b.RECOMMENDER_NAME} loaded.")
except:
print(f"Fitting {rp3b.RECOMMENDER_NAME} ...")
rp3b.fit(**rp3b_params)
print(f"done.")
rp3b.save_model(
f'stored_recommenders/seed_{str(self.seed)}_{rp3b.RECOMMENDER_NAME}/',
f'best_for_{self.RECOMMENDER_NAME}')
try:
sen.load_model(
f'stored_recommenders/seed_{str(self.seed)}_{sen.RECOMMENDER_NAME}/',
f'best_for_{self.RECOMMENDER_NAME}')
print(f"{sen.RECOMMENDER_NAME} loaded.")
except:
print(f"Fitting {sen.RECOMMENDER_NAME} ...")
sen.fit(**sen_params)
print(f"done.")
sen.save_model(
f'stored_recommenders/seed_{str(self.seed)}_{sen.RECOMMENDER_NAME}/',
f'best_for_{self.RECOMMENDER_NAME}')
else:
icb.fit(**icb_params)
rp3b.fit(**rp3b_params)
sen.fit(**sen_params)
self.__rec2 = HiddenMergedRecommender(URM_train,
ICM_train, [icb, rp3b, sen],
verbose=False)
self.__rec2_params = {
'alpha': 0.6355738550417837,
'l1_ratio': 0.6617849709204384,
'topK': 538
}
self.__a = self.__b = None
def fit(self, alpha=0.5):
self.__a = alpha
self.__b = 1 - alpha
if not self.__submission:
try:
self.__rec1.load_model(
f'stored_recommenders/seed_{str(self.seed)}_{self.__rec1.RECOMMENDER_NAME}/',
f'best_for_{self.RECOMMENDER_NAME}')
print(f"{self.__rec1.RECOMMENDER_NAME} loaded.")
except:
print(f"Fitting {self.__rec1.RECOMMENDER_NAME} ...")
self.__rec1.fit(**self.__rec1_params)
print(f"done.")
self.__rec1.save_model(
f'stored_recommenders/seed_{str(self.seed)}_{self.__rec1.RECOMMENDER_NAME}/',
f'best_for_{self.RECOMMENDER_NAME}')
else:
self.__rec1.fit(**self.__rec1_params)
self.__rec2.fit(**self.__rec2_params)
def _compute_item_score(self, user_id_array, items_to_compute=None):
item_weights_1 = self.__rec1._compute_item_score(user_id_array)
item_weights_2 = self.__rec2._compute_item_score(user_id_array)
item_weights = item_weights_1 * self.__a + item_weights_2 * self.__b
return item_weights
def save_model(self, folder_path, file_name=None):
if file_name is None:
file_name = self.RECOMMENDER_NAME
self._print("Saving model in file '{}'".format(folder_path +
file_name))
dataIO = DataIO(folder_path=folder_path)
dataIO.save_data(file_name=file_name, data_dict_to_save={})
self._print("Saving complete")
def __init__(self,
URM_train,
ICM_train,
submission=False,
verbose=True,
seed=1205):
super(LinearOverMerged001, self).__init__(URM_train, verbose=verbose)
self.URM_train = URM_train
self.ICM_train = ICM_train
self.__submission = submission
self.__rec1 = UserKNNCFRecommender(URM_train, verbose=False)
self.__rec1_params = {
'topK': 190,
'shrink': 0,
'similarity': 'cosine',
'normalize': True
}
self.seed = seed
icb = ItemKNNCBFRecommender(URM_train, ICM_train, verbose=False)
icb_params = {
'topK': 65,
'shrink': 0,
'similarity': 'dice',
'normalize': True
}
rp3b = RP3betaRecommender(URM_train, verbose=False)
rp3b_params = {
'topK': 1000,
'alpha': 0.38192761611274967,
'beta': 0.0,
'normalize_similarity': False
}
sen = SLIMElasticNetRecommender(URM_train, verbose=False)
sen_params = {
'topK': 992,
'l1_ratio': 0.004065081925341167,
'alpha': 0.003725005053334143
}
if not self.__submission:
try:
icb.load_model(
f'stored_recommenders/seed_{str(self.seed)}_{icb.RECOMMENDER_NAME}/',
f'best_for_{self.RECOMMENDER_NAME}')
print(f"{icb.RECOMMENDER_NAME} loaded.")
except:
print(f"Fitting {icb.RECOMMENDER_NAME} ...")
icb.fit(**icb_params)
print(f"done.")
icb.save_model(
f'stored_recommenders/seed_{str(self.seed)}_{icb.RECOMMENDER_NAME}/',
f'best_for_{self.RECOMMENDER_NAME}')
try:
rp3b.load_model(
f'stored_recommenders/seed_{str(self.seed)}_{rp3b.RECOMMENDER_NAME}/',
f'best_for_{self.RECOMMENDER_NAME}')
print(f"{rp3b.RECOMMENDER_NAME} loaded.")
except:
print(f"Fitting {rp3b.RECOMMENDER_NAME} ...")
rp3b.fit(**rp3b_params)
print(f"done.")
rp3b.save_model(
f'stored_recommenders/seed_{str(self.seed)}_{rp3b.RECOMMENDER_NAME}/',
f'best_for_{self.RECOMMENDER_NAME}')
try:
sen.load_model(
f'stored_recommenders/seed_{str(self.seed)}_{sen.RECOMMENDER_NAME}/',
f'best_for_{self.RECOMMENDER_NAME}')
print(f"{sen.RECOMMENDER_NAME} loaded.")
except:
print(f"Fitting {sen.RECOMMENDER_NAME} ...")
sen.fit(**sen_params)
print(f"done.")
sen.save_model(
f'stored_recommenders/seed_{str(self.seed)}_{sen.RECOMMENDER_NAME}/',
f'best_for_{self.RECOMMENDER_NAME}')
else:
icb.fit(**icb_params)
rp3b.fit(**rp3b_params)
sen.fit(**sen_params)
self.__rec2 = HiddenMergedRecommender(URM_train,
ICM_train, [icb, rp3b, sen],
verbose=False)
self.__rec2_params = {
'alpha': 0.6355738550417837,
'l1_ratio': 0.6617849709204384,
'topK': 538
}
self.__a = self.__b = None
class LinearHybrid008(BaseItemSimilarityMatrixRecommender):
RECOMMENDER_NAME = "LinearHybrid008"
# set the seed equal to the one of the parameter search!!!!
def __init__(self,
URM_train,
ICM_train,
submission=False,
verbose=True,
seed=1205):
super(LinearHybrid008, self).__init__(URM_train, verbose=verbose)
self.URM_train = URM_train
self.ICM_train = ICM_train
self.__rec1 = SSLIMElasticNet(URM_train, ICM_train, verbose=False)
self.__rec1_params = {
'beta': 0.4849594591575789,
'topK': 1000,
'l1_ratio': 1e-05,
'alpha': 0.001
}
self.__rec2 = ItemKNNCBFRecommender(URM_train,
ICM_train,
verbose=False)
self.__rec2_params = {
'topK': 65,
'shrink': 0,
'similarity': 'dice',
'normalize': True
}
self.__rec3 = UserKNNCFRecommender(URM_train, verbose=False)
self.__rec3_params = {
'topK': 190,
'shrink': 0,
'similarity': 'cosine',
'normalize': True
}
self.__a = self.__b = self.__c = None
self.seed = seed
self.__submission = submission
def fit(self, alpha=0.5, l1_ratio=0.5):
self.__a = alpha * l1_ratio
self.__b = alpha - self.__a
self.__c = 1 - self.__a - self.__b
if not self.__submission:
try:
self.__rec1.load_model(
f'stored_recommenders/seed_{str(self.seed)}_{self.__rec1.RECOMMENDER_NAME}/',
f'best_for_{self.RECOMMENDER_NAME}')
print(f"{self.__rec1.RECOMMENDER_NAME} loaded.")
except:
print(f"Fitting {self.__rec1.RECOMMENDER_NAME} ...")
self.__rec1.fit(**self.__rec1_params)
print(f"done.")
self.__rec1.save_model(
f'stored_recommenders/seed_{str(self.seed)}_{self.__rec1.RECOMMENDER_NAME}/',
f'best_for_{self.RECOMMENDER_NAME}')
try:
self.__rec2.load_model(
f'stored_recommenders/seed_{str(self.seed)}_{self.__rec2.RECOMMENDER_NAME}/',
f'best_for_{self.RECOMMENDER_NAME}')
print(f"{self.__rec2.RECOMMENDER_NAME} loaded.")
except:
print(f"Fitting {self.__rec2.RECOMMENDER_NAME} ...")
self.__rec2.fit(**self.__rec2_params)
print(f"done.")
self.__rec2.save_model(
f'stored_recommenders/seed_{str(self.seed)}_{self.__rec2.RECOMMENDER_NAME}/',
f'best_for_{self.RECOMMENDER_NAME}')
try:
self.__rec3.load_model(
f'stored_recommenders/seed_{str(self.seed)}_{self.__rec3.RECOMMENDER_NAME}/',
f'best_for_{self.RECOMMENDER_NAME}')
print(f"{self.__rec3.RECOMMENDER_NAME} loaded.")
except:
print(f"Fitting {self.__rec3.RECOMMENDER_NAME} ...")
self.__rec3.fit(**self.__rec3_params)
print(f"done.")
self.__rec3.save_model(
f'stored_recommenders/seed_{str(self.seed)}_{self.__rec3.RECOMMENDER_NAME}/',
f'best_for_{self.RECOMMENDER_NAME}')
else:
self.__rec1.fit(**self.__rec1_params)
self.__rec2.fit(**self.__rec2_params)
self.__rec3.fit(**self.__rec3_params)
def _compute_item_score(self, user_id_array, items_to_compute=None):
item_weights_1 = self.__rec1._compute_item_score(user_id_array)
item_weights_2 = self.__rec2._compute_item_score(user_id_array)
item_weights_3 = self.__rec3._compute_item_score(user_id_array)
# normalization
item_weights_1_max = item_weights_1.max()
item_weights_2_max = item_weights_2.max()
item_weights_3_max = item_weights_3.max()
if not item_weights_1_max == 0:
item_weights_1 /= item_weights_1_max
if not item_weights_2_max == 0:
item_weights_2 /= item_weights_2_max
if not item_weights_3_max == 0:
item_weights_3 /= item_weights_3_max
item_weights = item_weights_1 * self.__a + item_weights_2 * self.__b + item_weights_3 * self.__c
return item_weights
def save_model(self, folder_path, file_name=None):
if file_name is None:
file_name = self.RECOMMENDER_NAME
self._print("Saving model in file '{}'".format(folder_path +
file_name))
dataIO = DataIO(folder_path=folder_path)
dataIO.save_data(file_name=file_name, data_dict_to_save={})
self._print("Saving complete")
def fit(self,
topK=None,
shrink=None,
weights=None,
pop=None,
weights1=None,
weights2=None,
weights3=None,
weights4=None,
weights5=None,
weights6=None,
weights7=None,
weights8=None,
pop1=None,
pop2=None,
similarity='cosine',
normalize=True,
final_weights=None,
final_weights1=None,
final_weights2=None,
old_similarity_matrix=None,
epochs=1,
top1=None,
shrink1=None,
force_compute_sim=False,
weights_to_dweights=-1,
**similarity_args):
if topK is None: # IT MEANS THAT I'M TESTING ONE RECOMMENDER ON A SPECIIFC INTERVAL
topK = [top1]
shrink = [shrink1]
if self.weights is None:
if weights1 is not None:
weights = [
weights1, weights2, weights3, weights4, weights5, weights6,
weights7, weights8
]
weights = [x for x in weights if x is not None]
self.weights = weights
if self.pop is None:
if pop is None:
pop = [pop1, pop2]
pop = [x for x in pop if x is not None]
self.pop = pop
if weights_to_dweights != -1:
self.d_weights[weights_to_dweights] = self.weights
assert self.weights is not None, "Weights Are None!"
assert len(self.recommender_list) == len(
self.weights
), "Weights: {} and recommender list: {} have different lenghts".format(
len(self.weights), len(self.recommender_list))
assert len(topK) == len(shrink) == len(self.recommender_list), "Knns, Shrinks and recommender list have " \
"different lenghts "
self.normalize = normalize
self.topK = topK
self.shrink = shrink
self.gradients = [0] * self.recommender_number
self.MAE = 0
p3counter = 0
rp3bcounter = 0
slim_counter = 0
factorCounter = 0
for knn, shrink, recommender in zip(topK, shrink,
self.recommender_list):
if recommender.__class__ is SLIM_BPR_Cython:
if "lambda_i" in list(similarity_args.keys()
): # lambda i and j provided in args
if type(similarity_args["lambda_i"]) is not list:
similarity_args["lambda_i"] = [
similarity_args["lambda_i"]
]
similarity_args["lambda_j"] = [
similarity_args["lambda_j"]
]
recommender.fit(
old_similarity_matrix=old_similarity_matrix,
epochs=epochs,
force_compute_sim=force_compute_sim,
topK=knn,
lambda_i=similarity_args["lambda_i"][slim_counter],
lambda_j=similarity_args["lambda_j"][slim_counter])
else:
recommender.fit(
old_similarity_matrix=old_similarity_matrix,
epochs=epochs,
force_compute_sim=force_compute_sim,
topK=knn)
slim_counter += 1
elif recommender.__class__ in [
MatrixFactorization_BPR_Cython,
MatrixFactorization_FunkSVD_Cython,
MatrixFactorization_AsySVD_Cython
]:
recommender.fit(epochs=epochs,
force_compute_sim=force_compute_sim)
elif recommender.__class__ in [SLIMElasticNetRecommender]:
recommender.fit(topK=knn,
l1_ratio=similarity_args["l1_ratio"],
force_compute_sim=force_compute_sim)
elif recommender.__class__ in [PureSVDRecommender]:
recommender.fit(
num_factors=similarity_args["num_factors"][factorCounter],
force_compute_sim=force_compute_sim)
factorCounter += 1
elif recommender.__class__ in [P3alphaRecommender]:
if type(similarity_args["alphaP3"]) is not list:
similarity_args["alphaP3"] = [similarity_args["alphaP3"]]
recommender.fit(topK=knn,
alpha=similarity_args["alphaP3"][p3counter],
min_rating=0,
implicit=True,
normalize_similarity=True,
force_compute_sim=force_compute_sim)
p3counter += 1
elif recommender.__class__ in [RP3betaRecommender]:
recommender.fit(alpha=similarity_args["alphaRP3"][rp3bcounter],
beta=similarity_args["betaRP"][rp3bcounter],
min_rating=0,
topK=knn,
implicit=True,
normalize_similarity=True,
force_compute_sim=force_compute_sim)
rp3bcounter += 1
elif recommender.__class__ in [ItemKNNCBFRecommender]:
recommender.fit(knn,
shrink,
force_compute_sim=force_compute_sim,
feature_weighting_index=similarity_args[
"feature_weighting_index"])
else: # ItemCF, UserCF, ItemCBF, UserCBF
recommender.fit(knn,
shrink,
force_compute_sim=force_compute_sim)
print("Recommender list before: {}".format(self.recommender_list))
self.W_sparse20 = csr_matrix(([], ([], [])), shape=(20635, 20635))
self.W_sparse50 = csr_matrix(([], ([], [])), shape=(50446, 50446))
to_delete = []
for index, recommender in enumerate(self.recommender_list):
try:
self.W_sparse20 += self.weights[index] * recommender.W_sparse
to_delete.append(recommender)
print("Recommender {} is summed in W_sparse20".format(
recommender))
continue
except:
# the recommender doesn't have a W sparse matrix of that shape
a = 1
try:
self.W_sparse50 += self.weights[index] * recommender.W_sparse
to_delete.append(recommender)
print("Recommender {} is summed in W_sparse50".format(
recommender))
continue
except:
# the recommender doesn't have a W sparse matrix of that shape
a = 1
# remove recommenders that already has the similarity merged
self.recommender_list = [
x for x in self.recommender_list if x not in to_delete
]
print("Recommender list after: {}".format(self.recommender_list))
new_item_recommender = ItemKNNCFRecommender(self.URM_train)
new_item_recommender.W_sparse = self.W_sparse20
self.recommender_list.append(new_item_recommender)
new_user_recommender = UserKNNCFRecommender(self.URM_train)
new_user_recommender.W_sparse = self.W_sparse50
self.recommender_list.append(new_user_recommender)
print("Recommender list final: {}".format(self.recommender_list))
if final_weights is None:
self.final_weights = [final_weights1, final_weights2]
else:
self.final_weights = final_weights
assert len(final_weights) == len(
self.recommender_list
), "Lunghezza di final weights e dei reccomender rimasti è diversa. Sono rimasti {} recommender con i final weight di lunghezza {}".format(
len(self.recommender_list), len(final_weights))
def __init__(self, URM_train, UCM, cold_users, warm_users):
super(Hybrid002AlphaRecommender, self).__init__(URM_train)
self.warm_recommender = UserKNNCFRecommender(URM_train)
self.cold_recommender = UserKNNCBFRecommender(UCM, URM_train)
self.cold_users = cold_users
self.warm_users = warm_users
(trackCol, artistIdCol))) # sparse matrix ROW: track_id COLUMN: artist_id
matTrack_Artist = matTrack_Artist.tocsr()
# matTrack_Dur = sps.coo_matrix(((np.ones(numTrack, dtype=int)), (trackCol, durSecCol))) #sparse matrix ROW: track_id COLUMN: duration_sec
# matTrack_Dur = matTrack_Dur.tocsr()
# NUOVA AGGIUNTA
reader = dataReader()
URM_train = reader.mat_complete
ICM_Art = matTrack_Artist
ICM_Alb = matTrack_Album
recommender = HybridRecommender(URM_train)
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)
recommender.fit(ICM_Art,
ICM_Alb,
item=item,
user=user,
SLIM=SLIM,
w_itemcf=1.1,
w_usercf=0.6,
recommenderELASTIC = SLIMElasticNetRecommender(URM_train)
# recommenderELASTIC.fit(topK=10)
# recommenderELASTIC.save_model('model/', file_name='SLIM_ElasticNet')
recommenderELASTIC.load_model('model/', file_name='SLIM_ElasticNet_train')
# recommenderAlphaGRAPH = P3alphaRecommender(URM_train)
# recommenderAlphaGRAPH.fit(topK=10, alpha=0.22, implicit=True, normalize_similarity=True)
recommenderBetaGRAPH = RP3betaRecommender(URM_train)
recommenderBetaGRAPH.fit(topK=10,
implicit=True,
normalize_similarity=True,
alpha=0.41,
beta=0.049)
recommederUserKNN = UserKNNCFRecommender(URM_train)
recommederUserKNN.fit(topK=10, shrink=15, similarity='jaccard')
# Create BayesianSearch object
recommender_class = ItemKNNScoresHybridRecommender
parameterSearch = SearchBayesianSkopt(
recommender_class,
evaluator_validation=evaluator_validation,
evaluator_test=evaluator_test)
# weight_list = [0.1, 0.15, 0.2, 0.25, 0.3, 0.35, 0.4, 0.45, 0.5, 0.55, 0.6, 0.65, 0.7, 0.8, 0.9]
weight_list = [
0.1, 0.3, 0.5, 0.7, 1, 1.5, 2, 2.5, 3, 3.5, 4, 4.5, 5, 5.5, 6, 7, 8, 9,
10
]
def __init__(self,
URM_train,
ICM_train,
submission=False,
verbose=True,
seed=1205):
super(UserWiseHybrid005, self).__init__(URM_train, verbose=verbose)
recommenders = {
'rp3b': RP3betaRecommender(URM_train),
'p3a': P3alphaRecommender(URM_train),
'sen': SLIMElasticNetRecommender(URM_train),
'sbpr': SLIM_BPR_Cython(URM_train),
'icb': ItemKNNCBFRecommender(URM_train, ICM_train),
'icf': ItemKNNCFRecommender(URM_train),
'ucf': UserKNNCFRecommender(URM_train)
}
print("Fitting rp3b...")
params = {
'topK': 1000,
'alpha': 0.38192761611274967,
'beta': 0.0,
'normalize_similarity': False
}
recommenders['rp3b'].fit(**params)
print("done.")
print("Fitting p3a...")
params = {
'topK': 131,
'alpha': 0.33660811631883863,
'normalize_similarity': False
}
recommenders['p3a'].fit(**params)
print("done.")
print("Fitting sen...")
params = {
'topK': 992,
'l1_ratio': 0.004065081925341167,
'alpha': 0.003725005053334143
}
recommenders['sen'].fit(**params)
print("done.")
#print("Fitting sbpr...")
#params = {'topK': 979, 'epochs': 130, 'symmetric': False, 'sgd_mode': 'adam', 'lambda_i': 0.004947329669424629,
# 'lambda_j': 1.1534760845071758e-05, 'learning_rate': 0.0001}
#recommenders['sbpr'].fit(**params)
print("done.")
print("Fitting icb...")
params = {
'topK': 65,
'shrink': 0,
'similarity': 'dice',
'normalize': True
}
recommenders['icb'].fit(**params)
print("done.")
print("Fitting icf...")
params = {
'topK': 55,
'shrink': 1000,
'similarity': 'asymmetric',
'normalize': True,
'asymmetric_alpha': 0.0
}
recommenders['icf'].fit(**params)
print("done.")
print("Fitting ucf...")
params = {
'topK': 190,
'shrink': 0,
'similarity': 'cosine',
'normalize': True
}
recommenders['ucf'].fit(**params)
print("done.")
self.__recommender_segmentation = [
((0, 3),
HiddenRecommender(URM_train,
ICM_train, [
recommenders['rp3b'], recommenders['icf'],
recommenders['icb']
],
submission=submission,
verbose=verbose,
seed=seed), {
'alpha': 0.4577946628581237,
'l1_ratio': 0.7434539743766688
}),
((3, 5),
HiddenRecommender(URM_train,
ICM_train, [
recommenders['p3a'], recommenders['ucf'],
recommenders['icb']
],
submission=submission,
verbose=verbose,
seed=seed), {
'alpha': 0.3987236515679141,
'l1_ratio': 0.15489605895390016
}),
((5, 10),
HiddenRecommender(URM_train,
ICM_train, [
recommenders['rp3b'], recommenders['icb'],
recommenders['sen']
],
submission=submission,
verbose=verbose,
seed=seed), {
'alpha': 1.0,
'l1_ratio': 0.3951763029766836
}),
((10, 17),
HiddenRecommender(URM_train,
ICM_train, [
recommenders['p3a'], recommenders['icb'],
recommenders['sen']
],
submission=submission,
verbose=verbose,
seed=seed), {
'alpha': 0.9999772418587548,
'l1_ratio': 0.28511052552468436
}),
((17, 30),
HiddenRecommender(URM_train,
ICM_train, [
recommenders['icf'], recommenders['icb'],
recommenders['sen']
],
submission=submission,
verbose=verbose,
seed=seed), {
'alpha': 0.21686976560272436,
'l1_ratio': 0.4598014054291886
}),
((30, 100),
HiddenRecommender(URM_train,
ICM_train, [
recommenders['ucf'], recommenders['icb'],
recommenders['sen']
],
submission=submission,
verbose=verbose,
seed=seed), {
'alpha': 0.33535858857401674,
'l1_ratio': 0.4046400351885727
}),
((100, 200),
HiddenRecommender(URM_train,
ICM_train, [
recommenders['icf'], recommenders['icb'],
recommenders['sen']
],
submission=submission,
verbose=verbose,
seed=seed), {
'alpha': 0.21686976560272436,
'l1_ratio': 0.4598014054291886
}),
((200, -1),
HiddenRecommender(URM_train,
ICM_train, [
recommenders['p3a'], recommenders['icb'],
recommenders['sen']
],
submission=submission,
verbose=verbose,
seed=seed), {
'alpha': 0.9999772418587548,
'l1_ratio': 0.28511052552468436
}),
]
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("-------------------")
# print("--P3alpha fitted---")
# print("-------------------")
UserBased = UserKNNCFRecommender(URM_train)
UserBased.fit(topK=300, shrink=200)
ContentBased = ItemKNNCBFRecommender(ICM, URM_train)
ContentBased.fit(topK=50, shrink=100)
# print("-------------------")
# print("--KNNCBF fitted---")
# print("-------------------")
ItemKNNCF = ItemKNNCFRecommender(URM_train)
ItemKNNCF.fit(topK=300, shrink=100)
# print("-------------------")
# print("---KNNCF fitted----")
# print("-------------------")
PureSVD = PureSVDRecommender(URM_train)
PureSVD.fit(num_factors=240)
# print("-------------------")
def __init__(self,
URM_train,
ICM_train,
submission=False,
verbose=True,
seed=1205):
super(UserWiseHybrid009, self).__init__(URM_train, verbose=verbose)
recommenders = {
'rp3b': RP3betaRecommender(URM_train),
'p3a': P3alphaRecommender(URM_train),
'sen': SLIMElasticNetRecommender(URM_train),
'sbpr': SLIM_BPR_Cython(URM_train),
'icb': ItemKNNCBFRecommender(URM_train, ICM_train),
'icf': ItemKNNCFRecommender(URM_train),
'ucf': UserKNNCFRecommender(URM_train),
'sslim': SSLIMElasticNet(URM_train, ICM_train)
}
params = {
'topK': 1000,
'alpha': 0.38192761611274967,
'beta': 0.0,
'normalize_similarity': False
}
try:
recommenders['rp3b'].load_model(
f'stored_recommenders/seed_{str(seed)}_hybrid_sub/',
f'{recommenders["rp3b"].RECOMMENDER_NAME}_for_sub')
print(f"{recommenders['rp3b'].RECOMMENDER_NAME} loaded.")
except:
print(f"Fitting {recommenders['rp3b'].RECOMMENDER_NAME} ...")
recommenders['rp3b'].fit(**params)
recommenders['rp3b'].save_model(
f'stored_recommenders/seed_{str(seed)}_hybrid_sub/',
f'{recommenders["rp3b"].RECOMMENDER_NAME}_for_sub')
print(f"done.")
params = {
'topK': 131,
'alpha': 0.33660811631883863,
'normalize_similarity': False
}
try:
recommenders['p3a'].load_model(
f'stored_recommenders/seed_{str(seed)}_hybrid_sub/',
f'{recommenders["p3a"].RECOMMENDER_NAME}_for_sub')
print(f"{recommenders['p3a'].RECOMMENDER_NAME} loaded.")
except:
print(f"Fitting {recommenders['p3a'].RECOMMENDER_NAME} ...")
recommenders['p3a'].fit(**params)
recommenders['p3a'].save_model(
f'stored_recommenders/seed_{str(seed)}_hybrid_sub/',
f'{recommenders["p3a"].RECOMMENDER_NAME}_for_sub')
print(f"done.")
params = {
'topK': 992,
'l1_ratio': 0.004065081925341167,
'alpha': 0.003725005053334143
}
try:
recommenders['sen'].load_model(
f'stored_recommenders/seed_{str(seed)}_hybrid_sub/',
f'{recommenders["sen"].RECOMMENDER_NAME}_for_sub')
print(f"{recommenders['sen'].RECOMMENDER_NAME} loaded.")
except:
print(f"Fitting {recommenders['sen'].RECOMMENDER_NAME} ...")
recommenders['sen'].fit(**params)
recommenders['sen'].save_model(
f'stored_recommenders/seed_{str(seed)}_hybrid_sub/',
f'{recommenders["sen"].RECOMMENDER_NAME}_for_sub')
print(f"done.")
params = {
'topK': 979,
'epochs': 130,
'symmetric': False,
'sgd_mode': 'adam',
'lambda_i': 0.004947329669424629,
'lambda_j': 1.1534760845071758e-05,
'learning_rate': 0.0001
}
try:
recommenders['sbpr'].load_model(
f'stored_recommenders/seed_{str(seed)}_hybrid_sub/',
f'{recommenders["sbpr"].RECOMMENDER_NAME}_for_sub')
print(f"{recommenders['sbpr'].RECOMMENDER_NAME} loaded.")
except:
print(f"Fitting {recommenders['sbpr'].RECOMMENDER_NAME} ...")
recommenders['sbpr'].fit(**params)
recommenders['sbpr'].save_model(
f'stored_recommenders/seed_{str(seed)}_hybrid_sub/',
f'{recommenders["sbpr"].RECOMMENDER_NAME}_for_sub')
print(f"done.")
params = {
'topK': 65,
'shrink': 0,
'similarity': 'dice',
'normalize': True
}
try:
recommenders['icb'].load_model(
f'stored_recommenders/seed_{str(seed)}_hybrid_sub/',
f'{recommenders["icb"].RECOMMENDER_NAME}_for_sub')
print(f"{recommenders['icb'].RECOMMENDER_NAME} loaded.")
except:
print(f"Fitting {recommenders['icb'].RECOMMENDER_NAME} ...")
recommenders['icb'].fit(**params)
recommenders['icb'].save_model(
f'stored_recommenders/seed_{str(seed)}_hybrid_sub/',
f'{recommenders["icb"].RECOMMENDER_NAME}_for_sub')
print(f"done.")
params = {
'topK': 55,
'shrink': 1000,
'similarity': 'asymmetric',
'normalize': True,
'asymmetric_alpha': 0.0
}
try:
recommenders['icf'].load_model(
f'stored_recommenders/seed_{str(seed)}_hybrid_sub/',
f'{recommenders["icf"].RECOMMENDER_NAME}_for_sub')
print(f"{recommenders['icf'].RECOMMENDER_NAME} loaded.")
except:
print(f"Fitting {recommenders['icf'].RECOMMENDER_NAME} ...")
recommenders['icf'].fit(**params)
recommenders['icf'].save_model(
f'stored_recommenders/seed_{str(seed)}_hybrid_sub/',
f'{recommenders["icf"].RECOMMENDER_NAME}_for_sub')
print(f"done.")
params = {
'topK': 190,
'shrink': 0,
'similarity': 'cosine',
'normalize': True
}
try:
recommenders['ucf'].load_model(
f'stored_recommenders/seed_{str(seed)}_hybrid_sub/',
f'{recommenders["ucf"].RECOMMENDER_NAME}_for_sub')
print(f"{recommenders['ucf'].RECOMMENDER_NAME} loaded.")
except:
print(f"Fitting {recommenders['ucf'].RECOMMENDER_NAME} ...")
recommenders['ucf'].fit(**params)
recommenders['ucf'].save_model(
f'stored_recommenders/seed_{str(seed)}_hybrid_sub/',
f'{recommenders["ucf"].RECOMMENDER_NAME}_for_sub')
print(f"done.")
params = {
'beta': 0.4849594591575789,
'topK': 1000,
'l1_ratio': 1e-05,
'alpha': 0.001
}
try:
recommenders['sslim'].load_model(
f'stored_recommenders/seed_{str(seed)}_hybrid_sub/',
f'{recommenders["sslim"].RECOMMENDER_NAME}_for_sub')
print(f"{recommenders['sslim'].RECOMMENDER_NAME} loaded.")
except:
print(f"Fitting {recommenders['sslim'].RECOMMENDER_NAME} ...")
recommenders['sslim'].fit(**params)
recommenders['sslim'].save_model(
f'stored_recommenders/seed_{str(seed)}_hybrid_sub/',
f'{recommenders["sslim"].RECOMMENDER_NAME}_for_sub')
print(f"done.")
self.__recommender_segmentation = [
((0, 3),
HiddenMergedRecommender(
URM_train,
ICM_train, [
recommenders['rp3b'], recommenders['icb'],
recommenders['icf']
],
submission=submission,
verbose=verbose,
seed=seed), {
'alpha': 0.7276553525851246,
'l1_ratio': 0.6891035546237165,
'topK': 1000
}),
((3, 5),
HiddenLinearRecommender(
URM_train,
ICM_train, [
recommenders['sslim'], recommenders['p3a'],
recommenders['icb']
],
submission=submission,
verbose=verbose,
seed=seed), {
'alpha': 0.9847198829156348,
'l1_ratio': 0.9996962519963414
}),
((5, 10),
HiddenLinearRecommender(
URM_train,
ICM_train, [
recommenders['icb'], recommenders['rp3b'],
recommenders['sen']
],
submission=submission,
verbose=verbose,
seed=seed), {
'alpha': 0.9949623682515907,
'l1_ratio': 0.007879399002699851
}),
((10, 17),
HiddenLinearRecommender(
URM_train,
ICM_train, [
recommenders['sslim'], recommenders['icb'],
recommenders['ucf']
],
submission=submission,
verbose=verbose,
seed=seed), {
'alpha': 0.6461624491197696,
'l1_ratio': 0.7617220099582368
}),
((17, 30),
HiddenLinearRecommender(
URM_train,
ICM_train, [
recommenders['sslim'], recommenders['p3a'],
recommenders['icb']
],
submission=submission,
verbose=verbose,
seed=seed), {
'alpha': 0.8416340030829476,
'l1_ratio': 0.6651408407090509
}),
((30, 100),
HiddenLinearRecommender(
URM_train,
ICM_train, [
recommenders['sslim'], recommenders['icb'],
recommenders['icf']
],
submission=submission,
verbose=verbose,
seed=seed), {
'alpha': 0.996772013761913,
'l1_ratio': 0.7831508517025596
}),
((100, 200),
HiddenLinearRecommender(
URM_train,
ICM_train, [
recommenders['sslim'], recommenders['rp3b'],
recommenders['icb']
],
submission=submission,
verbose=verbose,
seed=seed), {
'alpha': 0.8416340030829476,
'l1_ratio': 0.6651408407090509
}),
((200, -1),
HiddenMergedRecommender(
URM_train,
ICM_train, [
recommenders['sslim'], recommenders['p3a'],
recommenders['icb']
],
submission=submission,
verbose=verbose,
seed=seed), {
'alpha': 0.859343616443417,
'l1_ratio': 0.8995038091652459,
'topK': 900
}),
]
def __init__(self, urm_train, eurm=False):
super(HybridNormOrigRecommender, self).__init__(urm_train)
self.data_folder = Path(__file__).parent.parent.absolute()
self.eurm = eurm
self.num_users = urm_train.shape[0]
data = DataManager()
urm_train = check_matrix(urm_train.copy(), 'csr')
icm_price, icm_asset, icm_sub, icm_all = data.get_icm()
ucm_age, ucm_region, ucm_all = data.get_ucm()
recommender_1 = ItemKNNCBFRecommender(urm_train, icm_all)
recommender_1.fit(shrink=40, topK=20, feature_weighting='BM25')
recommender_7 = UserKNNCBFRecommender(urm_train, ucm_all)
recommender_7.fit(shrink=1777,
topK=1998,
similarity='tversky',
feature_weighting='BM25',
tversky_alpha=0.1604953616,
tversky_beta=0.9862348646)
# recommender_1 = HybridGenRecommender(urm_train, eurm=self.eurm)
# recommender_1.fit()
# recommender_2 = ItemKNNCFRecommender(urm_train)
# recommender_2.fit(shrink=30, topK=20)
recommender_2 = ItemKNNCFRecommender(urm_train)
recommender_2.fit(topK=5,
shrink=500,
feature_weighting='BM25',
similarity='tversky',
normalize=False,
tversky_alpha=0.0,
tversky_beta=1.0)
recommender_3 = UserKNNCFRecommender(urm_train)
recommender_3.fit(shrink=2, topK=600, normalize=True)
# recommender_3 = UserKNNCFRecommender(urm_train)
# recommender_3.fit(topK=697, shrink=1000, feature_weighting='TF-IDF', similarity='tversky', normalize=False,
# tversky_alpha=1.0, tversky_beta=1.0)
recommender_4 = RP3betaRecommender(urm_train)
recommender_4.fit(topK=16,
alpha=0.03374950051351756,
beta=0.24087176329409027,
normalize_similarity=False)
recommender_5 = SLIM_BPR_Cython(urm_train)
recommender_5.fit(lambda_i=0.0926694015,
lambda_j=0.001697250,
learning_rate=0.002391,
epochs=65,
topK=200)
recommender_6 = ALSRecommender(urm_train)
recommender_6.fit(alpha=5, iterations=40, reg=0.3)
self.recommender_1 = recommender_1
self.recommender_2 = recommender_2
self.recommender_3 = recommender_3
self.recommender_4 = recommender_4
self.recommender_5 = recommender_5
self.recommender_6 = recommender_6
self.recommender_7 = recommender_7
if self.eurm:
if Path(self.data_folder / 'Data/uicm_orig_sparse.npz').is_file():
print("Previous uicm_sparse found")
self.score_matrix_1 = sps.load_npz(self.data_folder /
'Data/uicm_sparse.npz')
else:
print("uicm_sparse not found, create new one...")
self.score_matrix_1 = self.recommender_1._compute_item_matrix_score(
np.arange(self.num_users))
sps.save_npz(self.data_folder / 'Data/uicm_orig_sparse.npz',
self.score_matrix_1)
self.score_matrix_2 = self.recommender_2._compute_item_matrix_score(
np.arange(self.num_users))
self.score_matrix_3 = self.recommender_3._compute_item_matrix_score(
np.arange(self.num_users))
self.score_matrix_4 = self.recommender_4._compute_item_matrix_score(
np.arange(self.num_users))
self.score_matrix_5 = self.recommender_5._compute_item_matrix_score(
np.arange(self.num_users))
self.score_matrix_6 = self.recommender_6._compute_item_score(
np.arange(self.num_users))
self.score_matrix_1 = normalize(self.score_matrix_2,
norm='max',
axis=1)
self.score_matrix_2 = normalize(self.score_matrix_2,
norm='max',
axis=1)
self.score_matrix_3 = normalize(self.score_matrix_3,
norm='max',
axis=1)
self.score_matrix_4 = normalize(self.score_matrix_4,
norm='max',
axis=1)
self.score_matrix_5 = normalize(self.score_matrix_5,
norm='max',
axis=1)
self.score_matrix_6 = normalize(self.score_matrix_6,
norm='max',
axis=1)
"topK": 466,
"shrink": 9,
"similarity": "dice",
"normalize": False
}
URM_train = sps.csr_matrix(URM_train)
profile_length = np.ediff1d(URM_train.indptr)
block_size = int(len(profile_length) * 0.05)
sorted_users = np.argsort(profile_length)
slim_model = SLIM_BPR_Cython(URM_train, recompile_cython=False)
slim_model.fit(**slim_best_parameters)
rp3_model = RP3betaRecommender(URM_train)
rp3_model.fit(**rp3_best_parameters)
userCF_model = UserKNNCFRecommender(URM_train)
userCF_model.fit(**userKNNCF_best_parameters)
MAP_slim_per_group = []
MAP_rp3_per_group = []
MAP_userCF_per_group = []
cutoff = 10
URM_train = sps.csr_matrix(URM_train)
profile_length = np.ediff1d(URM_train.indptr)
block_size = int(len(profile_length) * 0.05)
sorted_users = np.argsort(profile_length)
for group_id in range(0, 20):
start_pos = group_id * block_size
end_pos = min((group_id + 1) * block_size, len(profile_length))