if test:
hyb.fit(data['train'].tocsr(), data['UCM'].tocsr())
if split_users:
group_cold, group_one, group_two, group_three = get_target_users_group(
data['target_users'], data['train'])
result_cold = hyb.evaluate_MAP_target(data['test'], group_cold)
result_one = hyb.evaluate_MAP_target(data['test'], group_one)
result_two = hyb.evaluate_MAP_target(data['test'], group_two)
result_three = hyb.evaluate_MAP_target(data['test'], group_three)
print(
f'Total MAP: {result_cold["MAP"] + result_one["MAP"] + result_two["MAP"] + result_three["MAP"]:.5f}'
)
elif not split_users:
hyb.evaluate_MAP_target(data['test'], data['target_users'])
print("\nInitial {}".format(weights_initial))
print("Middle {}".format(weights_middle))
print("End {}".format(weights_end))
else:
URM_final = data['train'] + data['test']
URM_final = URM_final.tocsr()
hyb.fit(URM_final, data['UCM'].tocsr())
write_output(hyb, target_user_list=data['target_users'])
################################################ Test ##################################################
'fw': 'None',
'a_alpha': 0.0,
'alpha': 0.12331166243379268,
'beta': 1.9752288743799558
}
max_map = 0
data = get_data()
test = True
args = best_asymmetric
itemCF = ItemBasedCollaborativeFiltering(args['topK'],
args['shrink'],
feature_weighting=args['fw'],
similarity=args['similarity'],
tversky_alpha=args['alpha'],
tversky_beta=args['beta'],
asymmetric_alpha=args['a_alpha'])
if test:
itemCF.fit(data['train'])
result = itemCF.evaluate_MAP_target(data['test'], data['target_users'])
else:
URM_final = data['train'] + data['test']
itemCF.fit(URM_final)
write_output(itemCF, target_user_list=data['target_users'])
################################################ Test ##################################################
if self.topK != False:
self.W_sparse = similarityMatrixTopK(self.W_sparse, k=self.topK)
self.W_sparse = check_matrix(self.W_sparse, format='csr')
self.RM = self.URM_train.dot(self.W_sparse)
def get_expected_ratings(self, user_id):
expected_recommendations = self.RM[user_id].todense()
return np.squeeze(np.asarray(expected_recommendations))
if __name__ == '__main__':
train, test = split_train_leave_k_out_user_wise(get_data()['URM_all'],
k_out=1)
urm = train + test
evaluator = EvaluatorHoldout(test, [10])
rp3 = RP3betaRecommender(urm)
rp3.fit(alpha=0.032949920239451876,
beta=0.14658580479486563,
normalize_similarity=True,
topK=75)
# rp3.evaluate_MAP_target(test, get_data()['target_users'])
# result, result_string = evaluator.evaluateRecommender(rp3)
write_output(rp3, get_data()['target_users'])
#print(f"MAP: {result[10]['MAP']:.5f}")
if __name__ == '__main__':
evaluate = True
train, test = split_train_leave_k_out_user_wise(get_data()['URM_all'],
k_out=1)
SLIMElasticNet_args = {'l1_ratio': 1e-05, 'alpha': 0.001, 'topK': 1000}
if evaluate:
evaluator = EvaluatorHoldout(test, [10],
target_users=get_data()['target_users'])
slel = SLIMElasticNetRecommender(train)
slel.fit(l1_ratio=SLIMElasticNet_args['l1_ratio'],
topK=SLIMElasticNet_args['topK'],
alpha=SLIMElasticNet_args['alpha'])
result, result_string = evaluator.evaluateRecommender(slel)
print(f"MAP: {result[10]['MAP']:.5f}")
else:
urm_all = train + test
hybrid = HybridRecommender(urm_all, ucm)
hybrid.fit(weight_itemcf=weight_itemcf,
weight_p3=weight_p3,
weight_rp3=weight_rp3,
weight_als=weight_als)
write_output(hybrid, get_data()['target_users'])
expected_ratings = self.get_expected_ratings(user_id)
recommended_items = np.flip(np.argsort(expected_ratings), 0)
if exclude_seen:
unseen_items_mask = np.in1d(recommended_items,
self.URM_train[user_id].indices,
assume_unique=True,
invert=True)
recommended_items = recommended_items[unseen_items_mask]
return recommended_items[:at]
def get_expected_ratings(self, user_id):
expected_recommendations = self.RM[user_id].todense()
return np.squeeze(np.asarray(expected_recommendations))
################################################ Test ##################################################
if __name__ == '__main__':
data = get_data()
URM = data['train'].tocsr()
URM_test = data['test'].tocsr()
URM_final = URM_test + URM
FBICF = FeatureBoostedItemCollaborativeFiltering(29, 5)
FBICF.fit(URM)
FBICF.evaluate_MAP_target(URM_test, data['target_users'])
FBICF.fit(URM_final)
write_output(FBICF, data['target_users'])
################################################ Test ##################################################