def initialize_components(self):
self.item_cosineCF_recommender = Cosine_Similarity(self.train,
topK=200,
shrink=15,
normalize=True,
mode='cosine')
self.user_cosineCF_recommender = Cosine_Similarity(self.train.T,
topK=200,
shrink=15,
normalize=True,
mode='cosine')
self.item_bpr_recommender = SLIM_BPR_Cython(self.train,
positive_threshold=0)
self.svd_recommender = PureSVDRecommender(self.train)
self.cbf_bpr_recommender = SLIM_BPR_Cython(self.icm.T,
positive_threshold=0)
self.cbf_recommender = Cosine_Similarity(self.icm.T,
topK=50,
shrink=10,
normalize=True,
mode='cosine')
if self.ensemble_weights["IALS"] == 0:
self.ials_recommender = IALS_numpy(iters=0)
else:
self.ials_recommender = IALS_numpy()
def run_SLIM():
dataReader = Movielens10MReader()
URM_train = dataReader.get_URM_train()
URM_test = dataReader.get_URM_test()
recommender = SLIM_BPR_Cython(URM_train,
recompile_cython=False,
positive_threshold=4,
sparse_weights=True)
#recommender = MF_BPR_Cython(URM_train, recompile_cython=False, positive_threshold=4)
logFile = open("Result_log.txt", "a")
recommender.fit(epochs=2,
validate_every_N_epochs=1,
URM_test=URM_test,
logFile=logFile,
batch_size=1,
sgd_mode='rmsprop',
learning_rate=1e-4)
results_run = recommender.evaluateRecommendations(URM_test, at=5)
print(results_run)
def __init__(self, data: DataObject):
super(Hybrid201AlphaRecommender, self).__init__(data.urm_train)
self.data = data
urm = data.urm_train
urm = sps.vstack([data.urm_train, data.icm_all_augmented.T])
urm = urm.tocsr()
self.rec1 = SLIM_BPR_Cython(urm)
self.rec2 = ItemKNNCFRecommender(urm)
self.rec3 = RP3betaRecommender(urm)
self.random_seed = data.random_seed
try:
self.rec1.load_model(
"stored_recommenders/slim_bpr/",
f'with_icm_{self.random_seed}_topK=15000_epochs=250_learning_rate=1e-05_lambda_i=0.01_lambda_j=0.01'
)
except:
self.rec1.fit(sgd_mode="adagrad",
topK=15000,
epochs=250,
learning_rate=1e-05,
lambda_i=0.01,
lambda_j=0.01)
self.rec1.save_model(
"stored_recommenders/slim_bpr/",
f'with_icm_{self.random_seed}_topK=15000_epochs=250_learning_rate=1e-05_lambda_i=0.01_lambda_j=0.01'
)
try:
self.rec2.load_model(
"stored_recommenders/item_cf/",
f'with_icm_{self.random_seed}_topK=20000_shrink=20000_feature_weighting=TF-IDF'
)
except:
self.rec2.fit(topK=20000, shrink=20000, feature_weighting="TF-IDF")
self.rec2.save_model(
"stored_recommenders/item_cf/",
f'with_icm_{self.random_seed}_topK=20000_shrink=20000_feature_weighting=TF-IDF'
)
try:
self.rec3.load_model(
"stored_recommenders/rp3_beta/",
f'with_icm_{self.random_seed}_topK=10000_alpha=0.55_beta=0.01_implicit=True_normalize_similarity=True'
)
except:
self.rec3.fit(topK=10000,
alpha=0.55,
beta=0.01,
implicit=True,
normalize_similarity=True)
self.rec3.save_model(
"stored_recommenders/rp3_beta/",
f'with_icm_{self.random_seed}_topK=10000_alpha=0.55_beta=0.01_implicit=True_normalize_similarity=True'
)
self.hybrid_rec = Hybrid1XXAlphaRecommender(
data,
recommenders=[self.rec1, self.rec2, self.rec3],
max_cutoff=20)
class Hybrid101AlphaRecommender(BaseRecommender):
"""Hybrid101AlphaRecommender recommender"""
RECOMMENDER_NAME = "Hybrid101AlphaRecommender"
def __init__(self, data: DataObject):
super(Hybrid101AlphaRecommender, self).__init__(data.urm_train)
self.data = data
self.rec1 = SLIM_BPR_Cython(data.urm_train)
self.rec2 = ItemKNNCFRecommender(data.urm_train)
self.rec3 = RP3betaRecommender(data.urm_train)
self.rec1.fit(sgd_mode="adagrad",
topK=15000,
epochs=250,
learning_rate=1e-05,
lambda_i=0.01,
lambda_j=0.01)
# self.rec1.fit(topK=435, epochs=115, symmetric=True, sgd_mode='adagrad', lambda_i=0.0010067865845523253,
# lambda_j=3.764224446055186e-05, learning_rate=0.00024125117955549121)
self.rec2.fit(topK=20000, shrink=20000, feature_weighting="TF-IDF")
self.rec3.fit(topK=10000,
alpha=0.55,
beta=0.01,
implicit=True,
normalize_similarity=True)
self.hybrid_rec = Hybrid1XXAlphaRecommender(
data,
recommenders=[self.rec1, self.rec2, self.rec3],
max_cutoff=20)
def fit(self):
weights = [[
69.4, 25.7, 11.7, 9.4, 8.4, 5.4, 6.6, 6., 5.5, 5.6, 5., 4.4, 3.3,
5.7, 4.2, 3.7, 4.5, 2.8, 3.8, 3.4
],
[
77.8, 29.3, 17.4, 9., 8.5, 8.9, 5.9, 5.9, 5.4, 5.1, 6.,
6.3, 4.4, 4.6, 5.2, 4.9, 3.5, 3.3, 3.5, 4.3
],
[
78.5, 29.2, 15.6, 10.9, 9.4, 6.5, 8.3, 5.7, 6.3, 6.6,
4.3, 4.2, 4.3, 4.6, 6.1, 4.7, 5.1, 4.7, 4.9, 5.1
]]
self.hybrid_rec.fit(weights=weights)
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):
return self.hybrid_rec.recommend(user_id_array=user_id_array,
cutoff=cutoff)
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()))
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 initialize_components(self):
self.train = self.rescale_wrt_insertion_order(self.train)
self.item_cosineCF_recommender = Cosine_Similarity(self.train, topK=200, shrink=15, normalize=True, mode='cosine')
self.user_cosineCF_recommender = Cosine_Similarity(self.train.T, topK=200, shrink=15, normalize=True, mode='cosine')
self.svd_recommender = PureSVDRecommender(self.train)
self.cbf_bpr_recommender = SLIM_BPR_Cython(self.icm.T, positive_threshold=0)
self.cbf_recommender = Cosine_Similarity(self.icm.T, topK=50, shrink=10, normalize=True, mode='cosine')
self.item_rp3b_recommender = RP3betaRecommender(self.train)
self.user_rp3b_recommender = RP3betaRecommender(self.train.T)
self.bpr_mf = BPR_matrix_factorization(factors=800, regularization=0.01, learning_rate=0.01, iterations=300)
self.ials_cg_mf = IALS_CG(iterations=15, calculate_training_loss=True, factors=500, use_cg=True, regularization=1e-3)
self.lightfm = LightFM_Recommender(self.train, self.icm, no_components=200)
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 fit(self,
alpha=0.5,
epochs=300,
positive_threshold_BPR=None,
train_with_sparse_weights=None,
symmetric=True,
random_seed=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,
**earlystopping_kwargs):
# build the virtual URM
self.alpha = alpha
urm = self.URM_train * self.alpha
icm = self.ICM_train * (1 - self.alpha)
virtual_URM = sps.vstack([urm, icm.T])
self.virtual_URM = virtual_URM.tocsr()
self.__slim_bpr = SLIM_BPR_Cython(
self.virtual_URM,
verbose=self.verbose,
free_mem_threshold=self.free_mem_treshold,
recompile_cython=self.recompile_cython)
self.__slim_bpr.fit(
epochs=epochs,
positive_threshold_BPR=positive_threshold_BPR,
train_with_sparse_weights=train_with_sparse_weights,
symmetric=symmetric,
random_seed=random_seed,
batch_size=batch_size,
lambda_i=lambda_i,
lambda_j=lambda_j,
learning_rate=learning_rate,
topK=topK,
sgd_mode=sgd_mode,
gamma=gamma,
beta_1=beta_1,
beta_2=beta_2,
**earlystopping_kwargs)
self.W_sparse = self.__slim_bpr.W_sparse
def __init__(self, URM_train):
super(HybridWarmRecommender, self).__init__(URM_train)
recommender_1 = ItemKNNCFRecommender(URM_train)
recommender_1.fit(topK=20, shrink=30)
recommender_2 = SLIM_BPR_Cython(URM_train)
recommender_2.fit(epochs=40,
lambda_i=0.01,
lambda_j=0.001,
learning_rate=1e-4,
topK=200)
# recommender_3 = TopPop(URM_train)
# recommender_3.fit()
self.URM_train = check_matrix(URM_train.copy(), 'csr')
self.recommender_1 = recommender_1
self.recommender_2 = recommender_2
def __init__(self,
URM_train,
ICM_train,
submission=False,
verbose=True,
seed=1205):
super(LinearHybrid006, self).__init__(URM_train, verbose=verbose)
self.URM_train = URM_train
self.ICM_train = ICM_train
self.__rec1 = P3alphaRecommender(URM_train, verbose=False)
self.__rec1_params = {
'topK': 131,
'alpha': 0.33660811631883863,
'normalize_similarity': False
}
self.__rec2 = ItemKNNCBFRecommender(URM_train,
ICM_train,
verbose=False)
self.__rec2_params = {
'topK': 205,
'shrink': 1000,
'similarity': 'cosine',
'normalize': True,
'feature_weighting': 'BM25'
}
self.__rec3 = SLIM_BPR_Cython(URM_train, verbose=False)
self.__rec3_params = {
'topK': 979,
'epochs': 130,
'symmetric': False,
'sgd_mode': 'adam',
'lambda_i': 0.004947329669424629,
'lambda_j': 1.1534760845071758e-05,
'learning_rate': 0.0001
}
self.__a = self.__b = self.__c = None
self.seed = seed
self.__submission = submission
class Hybrid000AlphaRecommender(BaseRecommender):
"""Hybrid000AlphaRecommender recommender"""
RECOMMENDER_NAME = "Hybrid000AlphaRecommender"
def __init__(self, URM_train, UCM, cold_users, warm_users):
super(Hybrid000AlphaRecommender, self).__init__(URM_train)
self.warm_recommender = SLIM_BPR_Cython(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,
epochs=500,
topK=14000,
shrink=2,
lambda_i=0.0,
lambda_j=0.0):
self.warm_recommender.fit(epochs=epochs,
lambda_i=lambda_i,
lambda_j=lambda_j,
random_seed=random_seed)
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 __init__(self, data: DataObject):
super(Hybrid101AlphaRecommender, self).__init__(data.urm_train)
self.data = data
self.rec1 = SLIM_BPR_Cython(data.urm_train)
self.rec2 = ItemKNNCFRecommender(data.urm_train)
self.rec3 = RP3betaRecommender(data.urm_train)
self.rec1.fit(sgd_mode="adagrad",
topK=15000,
epochs=250,
learning_rate=1e-05,
lambda_i=0.01,
lambda_j=0.01)
# self.rec1.fit(topK=435, epochs=115, symmetric=True, sgd_mode='adagrad', lambda_i=0.0010067865845523253,
# lambda_j=3.764224446055186e-05, learning_rate=0.00024125117955549121)
self.rec2.fit(topK=20000, shrink=20000, feature_weighting="TF-IDF")
self.rec3.fit(topK=10000,
alpha=0.55,
beta=0.01,
implicit=True,
normalize_similarity=True)
self.hybrid_rec = Hybrid1XXAlphaRecommender(
data,
recommenders=[self.rec1, self.rec2, self.rec3],
max_cutoff=20)
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
'min_rating': 0.4999280105627021,
'implicit': [False, False, False]
}
alpha1 = 0.4
alpha2 = 0.5399999999999999
alpha3 = 0.06000000000000005
print(
"***************************Ensure the parameter is good**********************"
)
URM_train, URM_test = train_test_holdout(URM_all, train_perc=0.8)
itemCF_recommender = ItemKNNCFRecommender(URM_train)
itemCF_recommender.fit(**itemCFParam)
slim_recommender = SLIM_BPR_Cython(URM_train, recompile_cython=False)
slim_recommender.fit(**slimParam)
p3_recommender = P3alphaRecommender(URM_train)
p3_recommender.fit(**p3Param)
recommender1 = SimilarityHybridRecommender(URM_train,
itemCF_recommender.W_sparse,
slim_recommender.W_sparse,
p3_recommender.W_sparse)
recommender1.fit(topK=100, alpha1=alpha1, alpha2=alpha2, alpha3=alpha3)
evaluator_validation = EvaluatorHoldout(URM_test, cutoff_list=[10])
eval_res = evaluator_validation.evaluateRecommender(recommender1)
MAP = eval_res[0][10]['MAP']
print("The MAP in one test is: ", MAP)
pyplot.show()
#np.random.seed(1234)
URM_train, URM_test = train_test_holdout(URM_all, train_perc=0.97)
ICM_train, ICM_test = train_test_holdout(ICM_all, train_perc=0.8)
evaluator_validation = EvaluatorHoldout(URM_test,
cutoff_list=[10],
exclude_seen=True)
earlystopping_keywargs = {
"validation_every_n": 10,
"stop_on_validation": True,
"evaluator_object": evaluator_validation,
"lower_validations_allowed": 5,
"validation_metric": "MAP",
}
recommender = SLIM_BPR_Cython(URM_train, recompile_cython=False)
recommender.fit(
**{
"topK": 1000,
"epochs": 130,
"symmetric": False,
"sgd_mode": "adagrad",
"lambda_i": 1e-05,
"lambda_j": 0.01,
"learning_rate": 0.0001
})
print(evaluator_validation.evaluateRecommender(recommender))
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)
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
}),
]
URM_train, URM_test = train_test_holdout(URM_all, train_perc=0.8)
ICM_train, ICM_test = train_test_holdout(ICM_all, train_perc=0.8)
evaluator_validation = EvaluatorHoldout(URM_test,
cutoff_list=[10],
exclude_seen=True)
earlystopping_keywargs = {
"validation_every_n": 10,
"stop_on_validation": True,
"evaluator_object": evaluator_validation,
"lower_validations_allowed": 5,
"validation_metric": "MAP",
}
# MAP 0.057, kaggle MAP 0.054
recommender1 = SLIM_BPR_Cython(URM_train, recompile_cython=False)
recommender1.load_model('SavedModels', 'SLIM_BPR_Cyrhon')
#recommender1.fit(**{"topK": 865, "epochs": 1000, "symmetric": False, "sgd_mode": "adagrad", "lambda_i": 0.01,
# "lambda_j": 1e-05, "learning_rate": 0.0001})
#recommender.save_model('SavedModels', 'SLIM_BPR_Cyrhon')
w1 = recommender1.W_sparse
# MAP 0.052
#recommender2 = P3alphaRecommender.P3alphaRecommender(URM_train)
#recommender2.fit(**{"topK": 998, "alpha": 0.08643815887780361, "normalize_similarity": False})
#recommender2.save_model('SavedModels', 'P3alpha')
#w2 = recommender2.W_sparse
# Bad MAP 0.035
# recommender = RP3betaRecommender.RP3betaRecommender(URM_train)
# recommender.fit(**{"topK": 1000, "alpha": 2.0, "beta": 0.0, "normalize_similarity": True})
def slim_tuning(f,
epochs=300,
train_with_sparse_weights=None,
symmetric=True,
verbose=False,
random_seed=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):
seed = 13
map_dict = {}
description_list = []
flag = 0
k_fold = 2
for i in range(0, k_fold):
data_reader = DataReader()
data = DataObject(data_reader, k=1, random_seed=seed)
rec = SLIM_BPR_Cython(data.urm_train)
rec.fit(epochs=epochs,
train_with_sparse_weights=train_with_sparse_weights,
symmetric=symmetric,
verbose=verbose,
random_seed=random_seed,
batch_size=batch_size,
lambda_i=lambda_i,
lambda_j=lambda_j,
learning_rate=learning_rate,
topK=topK,
sgd_mode=sgd_mode,
gamma=gamma,
beta_1=beta_1,
beta_2=beta_2)
# initializing the description list
if (len(description_list) == 0):
for _, _, description in data.urm_train_users_by_type:
description_list.append(description)
# initializing the dictionary
if (flag == 0):
flag = 1
for d in description_list:
map_dict[d] = 0
for n, users, description in data.urm_train_users_by_type:
eval, map = MyEvaluator.evaluate_algorithm(data.urm_test,
users,
rec,
at=10,
remove_top=0)
print(f"\t {description},\t {eval}")
map_dict[description] += map
print(
"epochs={}, train_with_sparse_weights = {},symmetric = {}, batch_size = {},"
.format(epochs, train_with_sparse_weights, symmetric, batch_size))
print(
"lambda_i = {}, lambda_j = {}, learning_rate = {}, topK = {},".format(
lambda_i, lambda_j, learning_rate, topK))
print("sgd_mode={}, sgd_mode={}, beta_1={}, beta_2={}".format(
sgd_mode, sgd_mode, beta_1, beta_2))
for d in description_list:
map_dict[d] /= k_fold
print(d + "\t\t" + "average map: " + str(map_dict[d]))
f.write(
"\nepochs={}, train_with_sparse_weights = {},symmetric = {}, batch_size = {},"
.format(epochs, train_with_sparse_weights, symmetric, batch_size))
f.write("\nlambda_i = {}, lambda_j = {}, learning_rate = {}, topK = {},".
format(lambda_i, lambda_j, learning_rate, topK))
f.write("\nsgd_mode={}, sgd_mode={}, beta_1={}, beta_2={}".format(
sgd_mode, sgd_mode, beta_1, beta_2))
for d in description_list:
f.write("\n" + d + "\t\t" + "average map: " + str(map_dict[d]))
f.write("\n\n")
f.flush()
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}),
]
class SStorinoEnsemble:
def __init__(self, urm_train, urm_test, icm, parameters=None):
if parameters is None:
parameters = {
"USER_CF": 0.8,
"USER_BPR": 0.7,
"ITEM_CF": 1,
"ITEM_BPR": 0.8,
"CBF": 0.3,
"IALS": 1.0,
"CBF_BPR": 1
}
self.ensemble_weights = parameters
self.train = urm_train.tocsr()
self.test = urm_test.tocsr()
self.icm = icm.tocsr()
self.initialize_components()
def initialize_components(self):
self.user_bpr_recommender = SLIM_BPR_Cython(self.train.T,
positive_threshold=0)
def fit(self):
self.user_bpr_w = self.user_bpr_recommender.fit(
epochs=6,
topK=200,
lambda_i=0.0,
lambda_j=0.0, # lambda_j=0.0005
gamma=0.9,
beta_1=0.00099,
beta_2=0.00099,
batch_size=20000,
sgd_mode='adagrad',
learning_rate=1e-2)
def recommend(self, user_id, combiner, at=10):
user_profile = self.train[user_id, :]
user_bpr_r = self.user_bpr_w[user_id].dot(self.train).toarray().ravel()
scores = [
[user_bpr_r, self.ensemble_weights["USER_BPR"], "USER_BPR"],
]
for r in scores:
self.filter_seen(user_id, r[0])
return combiner.combine(scores, at)
def filter_seen(self, user_id, scores):
start_pos = int(self.train.indptr[user_id])
end_pos = int(self.train.indptr[user_id + 1])
user_profile = self.train.indices[start_pos:end_pos]
scores[user_profile] = -1000000 #-np.inf
return scores
def recommend_batch(self, user_list, combiner, at=10):
res = np.array([])
n = 0
for i in user_list:
recList = self.recommend(i, combiner, at).T
tuple = np.concatenate(([i], recList))
if (res.size == 0):
res = tuple
else:
res = np.vstack([res, tuple])
return res
def get_component_data(self):
print('сука')
class SSLIM_BPR(BaseItemSimilarityMatrixRecommender):
RECOMMENDER_NAME = "S-SLIM_BPR"
def __init__(self,
URM_train,
ICM_train,
verbose=True,
free_mem_threshold=0.5,
recompile_cython=False):
super(SSLIM_BPR, self).__init__(URM_train, verbose=verbose)
self.ICM_train = ICM_train
self.free_mem_treshold = free_mem_threshold
self.recompile_cython = recompile_cython
self.verbose = verbose
def fit(self,
alpha=0.5,
epochs=300,
positive_threshold_BPR=None,
train_with_sparse_weights=None,
symmetric=True,
random_seed=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,
**earlystopping_kwargs):
# build the virtual URM
self.alpha = alpha
urm = self.URM_train * self.alpha
icm = self.ICM_train * (1 - self.alpha)
virtual_URM = sps.vstack([urm, icm.T])
self.virtual_URM = virtual_URM.tocsr()
self.__slim_bpr = SLIM_BPR_Cython(
self.virtual_URM,
verbose=self.verbose,
free_mem_threshold=self.free_mem_treshold,
recompile_cython=self.recompile_cython)
self.__slim_bpr.fit(
epochs=epochs,
positive_threshold_BPR=positive_threshold_BPR,
train_with_sparse_weights=train_with_sparse_weights,
symmetric=symmetric,
random_seed=random_seed,
batch_size=batch_size,
lambda_i=lambda_i,
lambda_j=lambda_j,
learning_rate=learning_rate,
topK=topK,
sgd_mode=sgd_mode,
gamma=gamma,
beta_1=beta_1,
beta_2=beta_2,
**earlystopping_kwargs)
self.W_sparse = self.__slim_bpr.W_sparse
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))
if __name__ == '__main__':
dataReader = Movielens10MReader()
URM_train = dataReader.get_URM_train()
URM_validation = dataReader.get_URM_validation()
URM_test = dataReader.get_URM_test()
recommender_list = []
recommender_list.append(ItemKNNCFRecommender(URM_train))
recommender_list.append(UserKNNCFRecommender(URM_train))
recommender_list.append(MF_BPR_Cython(URM_train))
recommender_list.append(FunkSVD(URM_train))
recommender_list.append(SLIM_BPR_Cython(URM_train, sparse_weights=False))
recommender_list.append(SLIM_RMSE(URM_train))
for recommender in recommender_list:
print("Algorithm: {}".format(recommender.__class__))
recommender.fit()
results_run = recommender.evaluateRecommendations(URM_test, at=5, exclude_seen=True)
print("Algorithm: {}, results: {}".format(recommender.__class__, results_run))
def initialize_components(self):
self.user_bpr_recommender = SLIM_BPR_Cython(self.train.T,
positive_threshold=0)
class Hybrid201AlphaRecommender(BaseRecommender):
"""Hybrid201AlphaRecommender recommender"""
RECOMMENDER_NAME = "Hybrid201AlphaRecommender"
def __init__(self, data: DataObject):
super(Hybrid201AlphaRecommender, self).__init__(data.urm_train)
self.data = data
urm = data.urm_train
urm = sps.vstack([data.urm_train, data.icm_all_augmented.T])
urm = urm.tocsr()
self.rec1 = SLIM_BPR_Cython(urm)
self.rec2 = ItemKNNCFRecommender(urm)
self.rec3 = RP3betaRecommender(urm)
self.random_seed = data.random_seed
try:
self.rec1.load_model(
"stored_recommenders/slim_bpr/",
f'with_icm_{self.random_seed}_topK=15000_epochs=250_learning_rate=1e-05_lambda_i=0.01_lambda_j=0.01'
)
except:
self.rec1.fit(sgd_mode="adagrad",
topK=15000,
epochs=250,
learning_rate=1e-05,
lambda_i=0.01,
lambda_j=0.01)
self.rec1.save_model(
"stored_recommenders/slim_bpr/",
f'with_icm_{self.random_seed}_topK=15000_epochs=250_learning_rate=1e-05_lambda_i=0.01_lambda_j=0.01'
)
try:
self.rec2.load_model(
"stored_recommenders/item_cf/",
f'with_icm_{self.random_seed}_topK=20000_shrink=20000_feature_weighting=TF-IDF'
)
except:
self.rec2.fit(topK=20000, shrink=20000, feature_weighting="TF-IDF")
self.rec2.save_model(
"stored_recommenders/item_cf/",
f'with_icm_{self.random_seed}_topK=20000_shrink=20000_feature_weighting=TF-IDF'
)
try:
self.rec3.load_model(
"stored_recommenders/rp3_beta/",
f'with_icm_{self.random_seed}_topK=10000_alpha=0.55_beta=0.01_implicit=True_normalize_similarity=True'
)
except:
self.rec3.fit(topK=10000,
alpha=0.55,
beta=0.01,
implicit=True,
normalize_similarity=True)
self.rec3.save_model(
"stored_recommenders/rp3_beta/",
f'with_icm_{self.random_seed}_topK=10000_alpha=0.55_beta=0.01_implicit=True_normalize_similarity=True'
)
self.hybrid_rec = Hybrid1XXAlphaRecommender(
data,
recommenders=[self.rec1, self.rec2, self.rec3],
max_cutoff=20)
def fit(self):
weights = [[
69.4, 25.7, 11.7, 9.4, 8.4, 5.4, 6.6, 6., 5.5, 5.6, 5., 4.4, 3.3,
5.7, 4.2, 3.7, 4.5, 2.8, 3.8, 3.4
],
[
77.8, 29.3, 17.4, 9., 8.5, 8.9, 5.9, 5.9, 5.4, 5.1, 6.,
6.3, 4.4, 4.6, 5.2, 4.9, 3.5, 3.3, 3.5, 4.3
],
[
78.5, 29.2, 15.6, 10.9, 9.4, 6.5, 8.3, 5.7, 6.3, 6.6,
4.3, 4.2, 4.3, 4.6, 6.1, 4.7, 5.1, 4.7, 4.9, 5.1
]]
self.hybrid_rec.fit(weights=weights)
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):
return self.hybrid_rec.recommend(user_id_array=user_id_array,
cutoff=cutoff)
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
}),
]
