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 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))
