def main():
training_matrix = read_training_data()
social_matrix = read_friend_data()
ground_truth = read_ground_truth()
LFBCA.precompute_rec_scores(training_matrix, social_matrix)
LFBCA.save_result("./tmp/")
result_out = open("./result/gis13_wang_top_" + str(top_k) + ".txt", 'w')
all_uids = list(range(user_num))
all_lids = list(range(poi_num))
np.random.shuffle(all_uids)
precision, recall = [], []
for cnt, uid in enumerate(all_uids):
if uid in ground_truth:
overall_scores = [LFBCA.predict(uid, lid)
if training_matrix[uid, lid] == 0 else -1
for lid in all_lids]
overall_scores = np.array(overall_scores)
predicted = list(reversed(overall_scores.argsort()))[:top_k]
actual = ground_truth[uid]
precision.append(precisionk(actual, predicted[:10]))
recall.append(recallk(actual, predicted[:10]))
print(cnt, uid, "pre@10:", np.mean(precision), "rec@10:", np.mean(recall))
result_out.write('\t'.join([
str(cnt),
str(uid),
','.join([str(lid) for lid in predicted])
]) + '\n')
def main():
training_tuples = read_training_data()
ground_truth = read_ground_truth()
GeoMF.load_result("./tmp/")
result_out = open("./result/kdd14_top_" + str(top_k) + ".txt", 'w')
all_uids = list(range(user_num))
all_lids = list(range(poi_num))
np.random.shuffle(all_uids)
precision, recall = [], []
for cnt, uid in enumerate(all_uids):
if uid in ground_truth:
overall_scores = [
GeoMF.predict(uid, lid) if
(uid, lid) not in training_tuples else -1 for lid in all_lids
]
overall_scores = np.array(overall_scores)
predicted = list(reversed(overall_scores.argsort()))[:top_k]
actual = ground_truth[uid]
precision.append(precisionk(actual, predicted[:10]))
recall.append(recallk(actual, predicted[:10]))
print(cnt, uid, "pre@10:", np.mean(precision), "rec@10:",
np.mean(recall))
result_out.write('\t'.join([
str(cnt),
str(uid), ','.join([str(lid) for lid in predicted])
]) + '\n')
def main():
sparse_training_matrices, training_tuples, visited_lids = read_training_data()
ground_truth = read_ground_truth()
TAMF.train(sparse_training_matrices, max_iters=30, load_sigma=False)
TAMF.save_model("./tmp/")
# TAMF.load_model("./tmp/")
result_out = open("./result/recsys13_top_" + str(top_k) + ".txt", 'w')
all_uids = range(user_num)
all_lids = range(poi_num)
np.random.shuffle(all_uids)
precision, recall = [], []
for cnt, uid in enumerate(all_uids):
if uid in ground_truth:
overall_scores = [TAMF.predict(uid, lid)
if (uid, lid) not in training_tuples else -1
for lid in all_lids]
overall_scores = np.array(overall_scores)
predicted = list(reversed(overall_scores.argsort()))[:top_k]
actual = ground_truth[uid]
precision.append(precisionk(actual, predicted[:10]))
recall.append(recallk(actual, predicted[:10]))
print(cnt, uid, "pre@10:", np.mean(precision), "rec@10:", np.mean(recall))
result_out.write('\t'.join([
str(cnt),
str(uid),
','.join([str(lid) for lid in predicted])
]) + '\n')
def main():
training_matrix = read_training_data()
social_relations = read_friend_data()
ground_truth = read_ground_truth()
poi_coos = read_poi_coos()
U.pre_compute_rec_scores(training_matrix)
# U.load_result("./tmp/")
S.compute_friend_sim(social_relations, training_matrix)
G.fit_distance_distribution(training_matrix, poi_coos)
result_out = open("./result/sigir11_top_" + str(top_k) + ".txt", 'w')
all_uids = list(range(user_num))
all_lids = list(range(poi_num))
np.random.shuffle(all_uids)
precision, recall = [], []
for cnt, uid in enumerate(all_uids):
if uid in ground_truth:
U_scores = normalize([
U.predict(uid, lid) if training_matrix[uid, lid] == 0 else -1
for lid in all_lids
])
S_scores = normalize([
S.predict(uid, lid) if training_matrix[uid, lid] == 0 else -1
for lid in all_lids
])
G_scores = normalize([
G.predict(uid, lid) if training_matrix[uid, lid] == 0 else -1
for lid in all_lids
])
U_scores = np.array(U_scores)
S_scores = np.array(S_scores)
G_scores = np.array(G_scores)
overall_scores = (1.0 - alpha - beta
) * U_scores + alpha * S_scores + beta * G_scores
predicted = list(reversed(overall_scores.argsort()))[:top_k]
actual = ground_truth[uid]
precision.append(precisionk(actual, predicted[:10]))
recall.append(recallk(actual, predicted[:10]))
print(cnt, uid, "pre@10:", np.mean(precision), "rec@10:",
np.mean(recall))
result_out.write('\t'.join([
str(cnt),
str(uid), ','.join([str(lid) for lid in predicted])
]) + '\n')
def main():
training_matrix = read_training_data()
social_matrix = read_friend_data()
ground_truth = read_ground_truth()
poi_coos = read_poi_coos()
poi_cate_matrix = read_category_data()
AKDE.precompute_kernel_parameters(training_matrix, poi_coos)
SC.compute_beta(training_matrix, social_matrix)
SC.save_result("./tmp/")
# SC.load_result("./tmp/")
CC.compute_gamma(training_matrix, poi_cate_matrix)
CC.save_result("./tmp/")
# CC.load_result("./tmp/")
result_out = open("./result/sigir15_zhang_top_" + str(top_k) + ".txt", 'w')
all_uids = list(range(user_num))
all_lids = list(range(poi_num))
np.random.shuffle(all_uids)
precision, recall = [], []
for cnt, uid in enumerate(all_uids):
if uid in ground_truth:
overall_scores = [
AKDE.predict(uid, lid) * SC.predict(uid, lid) *
CC.predict(uid, lid) if training_matrix[uid, lid] == 0 else -1
for lid in all_lids
]
overall_scores = np.array(overall_scores)
predicted = list(reversed(overall_scores.argsort()))[:top_k]
actual = ground_truth[uid]
precision.append(precisionk(actual, predicted[:10]))
recall.append(recallk(actual, predicted[:10]))
print(cnt, uid, "pre@10:", np.mean(precision), "rec@10:",
np.mean(recall))
result_out.write('\t'.join([
str(cnt),
str(uid), ','.join([str(lid) for lid in predicted])
]) + '\n')
def main():
sparse_training_matrix, training_tuples = read_sparse_training_data()
training_check_ins = read_training_check_ins(sparse_training_matrix)
sorted_training_check_ins = {
uid: sorted(training_check_ins[uid], key=lambda k: k[1])
for uid in training_check_ins
}
social_relations = read_friend_data()
ground_truth = read_ground_truth()
poi_coos = read_poi_coos()
FCF.compute_friend_sim(social_relations, poi_coos, sparse_training_matrix)
KDE.precompute_kernel_parameters(sparse_training_matrix, poi_coos)
AMC.build_location_location_transition_graph(sorted_training_check_ins)
result_out = open("./result/gis14_top_" + str(top_k) + ".txt", 'w')
all_uids = list(range(user_num))
all_lids = list(range(poi_num))
np.random.shuffle(all_uids)
precision, recall = [], []
for cnt, uid in enumerate(all_uids):
if uid in ground_truth:
overall_scores = [
KDE.predict(uid, lid) * FCF.predict(uid, lid) *
AMC.predict(uid, lid) if
(uid, lid) not in training_tuples else -1 for lid in all_lids
]
overall_scores = np.array(overall_scores)
predicted = list(reversed(overall_scores.argsort()))[:top_k]
actual = ground_truth[uid]
precision.append(precisionk(actual, predicted[:10]))
recall.append(recallk(actual, predicted[:10]))
print(cnt, uid, "pre@10:", np.mean(precision), "rec@10:",
np.mean(recall))
result_out.write('\t'.join([
str(cnt),
str(uid), ','.join([str(lid) for lid in predicted])
]) + '\n')
def main():
sparse_training_matrix, training_tuples = read_training_data()
ground_truth = read_ground_truth()
poi_coos = read_poi_coos()
PFM.train(sparse_training_matrix, max_iters=10, learning_rate=1e-4)
PFM.save_model("./tmp/")
# PFM.load_model("./tmp/")
MGM.multi_center_discovering(sparse_training_matrix, poi_coos)
result_out = open("./result/aaai12_top_" + str(top_k) + ".txt", 'w')
all_uids = list(range(user_num))
all_lids = list(range(poi_num))
np.random.shuffle(all_uids)
precision, recall = [], []
for cnt, uid in enumerate(all_uids):
if uid in ground_truth:
overall_scores = [
PFM.predict(uid, lid) * MGM.predict(uid, lid) if
(uid, lid) not in training_tuples else -1 for lid in all_lids
]
overall_scores = np.array(overall_scores)
predicted = list(reversed(overall_scores.argsort()))[:top_k]
actual = ground_truth[uid]
precision.append(precisionk(actual, predicted[:10]))
recall.append(recallk(actual, predicted[:10]))
print(cnt, uid, "pre@10:", np.mean(precision), "rec@10:",
np.mean(recall))
result_out.write('\t'.join([
str(cnt),
str(uid), ','.join([str(lid) for lid in predicted])
]) + '\n')
def main():
sparse_training_matrices, sparse_training_matrix, sparse_training_matrix_WT, sparse_training_matrix_LT, training_tuples = read_training_data(
)
ground_truth = read_ground_truth()
poi_coos = read_poi_coos()
start_time = time.time()
PFM.train(sparse_training_matrix, max_iters=50, learning_rate=1e-6)
# Multi-Center Weekday
MGMWT.multi_center_discovering(sparse_training_matrix_WT, poi_coos)
# Multi-Center Weekend
MGMLT.multi_center_discovering(sparse_training_matrix_LT, poi_coos)
TAMF.train(sparse_training_matrices, max_iters=5, load_sigma=False)
elapsed_time = time.time() - start_time
print("Done. Elapsed time:", elapsed_time, "s")
execution_time = open("./result/execution_time" + ".txt", 'w')
execution_time.write(str(elapsed_time))
rec_list = open("./result/reclist_top_" + str(top_k) + ".txt", 'w')
result_5 = open("./result/result_top_" + str(5) + ".txt", 'w')
result_10 = open("./result/result_top_" + str(10) + ".txt", 'w')
result_15 = open("./result/result_top_" + str(15) + ".txt", 'w')
result_20 = open("./result/result_top_" + str(20) + ".txt", 'w')
all_uids = list(range(user_num))
all_lids = list(range(poi_num))
np.random.shuffle(all_uids)
# list for different ks
precision_5, recall_5, nDCG_5, MAP_5 = 0, 0, 0, 0
precision_10, recall_10, nDCG_10, MAP_10 = 0, 0, 0, 0
precision_15, recall_15, nDCG_15, MAP_15 = 0, 0, 0, 0
precision_20, recall_20, nDCG_20, MAP_20 = 0, 0, 0, 0
tp = 0
total = 0
for cnt, uid in enumerate(tqdm(all_uids)):
if cnt % 10 == 0:
print(cnt)
if uid in ground_truth:
# What is the meaning of the following structure?
overall_scores = [
PFM.predict(uid, lid) *
(MGMWT.predict(uid, lid) + MGMLT.predict(uid, lid)) *
TAMF.predict(uid, lid) if
(uid, lid) not in training_tuples else -1 for lid in all_lids
]
overall_scores = np.array(overall_scores)
predicted = list(reversed(overall_scores.argsort()))[:top_k]
actual = ground_truth[uid]
act = len(set(actual) & set(predicted))
tp += act
total += len(predicted)
# calculate the average of different k
'''precision_5 = precisionk(actual, predicted[:5])
recall_5 = recallk(actual, predicted[:5])
nDCG_5 = ndcgk(actual, predicted[:5])
MAP_5 = mapk(actual, predicted[:5], 5)'''
precision_10 = precisionk(actual, predicted[:10])
recall_10 = recallk(actual, predicted[:10])
nDCG_10 = ndcgk(actual, predicted[:10])
MAP_10 = mapk(actual, predicted[:10], 10)
'''precision_15 = precisionk(actual, predicted[:15])
recall_15 = recallk(actual, predicted[:15])
nDCG_15 = ndcgk(actual, predicted[:15])
MAP_15 = mapk(actual, predicted[:15], 15)
precision_20 = precisionk(actual, predicted[:20])
recall_20 = recallk(actual, predicted[:20])
nDCG_20 = ndcgk(actual, predicted[:20])
MAP_20 = mapk(actual, predicted[:20], 20)'''
rec_list.write('\t'.join([
str(cnt),
str(uid), ','.join([str(lid) for lid in predicted])
]) + '\n')
# write the different ks
#result_5.write('\t'.join([str(cnt), str(uid), str(precision_5), str(recall_5), str(nDCG_5), str(MAP_5)]) + '\n')
result_10.write('\t'.join([
str(cnt),
str(uid),
str(precision_10),
str(recall_10),
str(nDCG_10),
str(MAP_10)
]) + '\n')
#result_15.write('\t'.join([str(cnt), str(uid), str(precision_15), str(recall_15), str(nDCG_15), str(MAP_15)]) + '\n')
#result_20.write('\t'.join([str(cnt), str(uid), str(precision_20), str(recall_20), str(nDCG_20), str(MAP_20)]) + '\n')
print("actual, total ", tp, total)
print("prec ", tp / total)
print("<< STACP is Finished >>")
def main(result_dir, temp_dir):
sparse_training_matrices, sparse_training_matrix, sparse_training_matrix_WT, sparse_training_matrix_LT, training_tuples, training_matrix = read_training_data(
)
ground_truth = read_ground_truth()
training_matrix2 = read_training_data2()
poi_coos = read_poi_coos()
# social_relations = read_friend_data()
social_matrix = read_friend_data()
start_time = time.time()
PFM.train(sparse_training_matrix, max_iters=10, learning_rate=1e-4)
PFM.save_model(temp_dir)
PFM.load_model(temp_dir)
ctime = time.time()
# Multi-Center Weekday
MGMWT.multi_center_discovering(sparse_training_matrix_WT, poi_coos)
# Multi-Center Weekend
MGMLT.multi_center_discovering(sparse_training_matrix_LT, poi_coos)
print("MGM Done. Elapsed time:", time.time() - ctime, "s")
TAMF.train(sparse_training_matrices,
temp_dir,
max_iters=30,
load_sigma=False)
TAMF.save_model(temp_dir)
TAMF.load_model(temp_dir)
LFBCA.precompute_rec_scores(training_matrix2, social_matrix)
LFBCA.save_result(temp_dir)
# S.compute_friend_sim(social_relations, training_matrix)
elapsed_time = time.time() - start_time
print("Done. Elapsed time:", elapsed_time, "s")
execution_time = open(result_dir + "/execution_time" + ".txt", 'w')
execution_time.write(str(elapsed_time))
rec_list = open(result_dir + "/reclist_top_" + str(top_k) + ".txt", 'w')
result_5 = open(result_dir + "/result_top_" + str(5) + ".txt", 'w')
result_20 = open(result_dir + "/result_top_" + str(20) + ".txt", 'w')
result_15 = open(result_dir + "/result_top_" + str(15) + ".txt", 'w')
result_10 = open(result_dir + "/result_top_" + str(10) + ".txt", 'w')
all_uids = list(range(user_num))
all_lids = list(range(poi_num))
np.random.shuffle(all_uids)
# list for different ks
precision_5, recall_5, nDCG_5, MAP_5 = '', '', '', ''
precision_10, recall_10, nDCG_10, MAP_10 = '', '', '', ''
precision_15, recall_15, nDCG_15, MAP_15 = '', '', '', ''
precision_20, recall_20, nDCG_20, MAP_20 = '', '', '', ''
for cnt, uid in enumerate(all_uids):
if uid in ground_truth:
# What is the meaning of the following structure?
overall_scores = [
PFM.predict(uid, lid) *
(MGMWT.predict(uid, lid) + MGMLT.predict(uid, lid)) *
TAMF.predict(uid, lid) * LFBCA.predict(uid, lid) if
(uid, lid) not in training_tuples else -1 for lid in all_lids
]
overall_scores = np.array(overall_scores)
predicted = list(reversed(overall_scores.argsort()))[:top_k]
actual = ground_truth[uid]
# calculate the average of different k
precision_5 = (precisionk(actual, predicted[:5]))
recall_5 = (recallk(actual, predicted[:5]))
nDCG_5 = (ndcgk(actual, predicted[:5]))
MAP_5 = (mapk(actual, predicted[:5], 5))
precision_10 = (precisionk(actual, predicted[:10]))
recall_10 = (recallk(actual, predicted[:10]))
nDCG_10 = (ndcgk(actual, predicted[:10]))
MAP_10 = (mapk(actual, predicted[:10], 10))
precision_15 = (precisionk(actual, predicted[:15]))
recall_15 = (recallk(actual, predicted[:15]))
nDCG_15 = (ndcgk(actual, predicted[:15]))
MAP_15 = (mapk(actual, predicted[:15], 15))
precision_20 = (precisionk(actual, predicted[:20]))
recall_20 = (recallk(actual, predicted[:20]))
nDCG_20 = (ndcgk(actual, predicted[:20]))
MAP_20 = (mapk(actual, predicted[:20], 20))
print(cnt, uid, "pre@10:", np.mean(precision_10), "rec@10:",
np.mean(recall_10))
rec_list.write('\t'.join([
str(cnt),
str(uid), ','.join([str(lid) for lid in predicted])
]) + '\n')
# write the different ks
result_5.write('\t'.join([
str(cnt),
str(uid),
str(precision_5),
str(recall_5),
str(nDCG_5),
str(MAP_5)
]) + '\n')
result_10.write('\t'.join([
str(cnt),
str(uid),
str(precision_10),
str(recall_10),
str(nDCG_10),
str(MAP_10)
]) + '\n')
result_15.write('\t'.join([
str(cnt),
str(uid),
str(precision_15),
str(recall_15),
str(nDCG_15),
str(MAP_15)
]) + '\n')
result_20.write('\t'.join([
str(cnt),
str(uid),
str(precision_20),
str(recall_20),
str(nDCG_20),
str(MAP_20)
]) + '\n')
print("<< Social-STACP is Finished >>")
def main():
training_tuples = read_training_data()
ground_truth = read_ground_truth()
start_time = time.time()
LMF.train_model()
LG.max_checkins(train_file)
LG.read_poi_coos(poi_file)
LG.rec_score()
print("End of Train")
elapsed_time = time.time() - start_time
print("Done. Elapsed time:", elapsed_time, "s")
execution_time = open("./result/execution_time" + ".txt", 'w')
execution_time.write(str(elapsed_time))
rec_list = open("./result/reclist_top_" + str(top_k) + ".txt", 'w')
result_5 = open("./result/result_top_" + str(5) + ".txt", 'w')
result_10 = open("./result/result_top_" + str(10) + ".txt", 'w')
result_15 = open("./result/result_top_" + str(15) + ".txt", 'w')
result_20 = open("./result/result_top_" + str(20) + ".txt", 'w')
all_uids = list(range(user_num))
all_lids = list(range(poi_num))
np.random.shuffle(all_uids)
# list for different ks
precision_5, recall_5, nDCG_5, MAP_5 = [], [], [], []
precision_10, recall_10, nDCG_10, MAP_10 = [], [], [], []
precision_15, recall_15, nDCG_15, MAP_15 = [], [], [], []
precision_20, recall_20, nDCG_20, MAP_20 = [], [], [], []
for cnt, uid in enumerate(all_uids):
if uid in ground_truth:
overall_scores = [
LG.predict(uid=uid, lid=lid) *
LMF.predict_logistic(uid, lid) if
(uid, lid) not in training_tuples else -1 for lid in all_lids
]
overall_scores = np.array(overall_scores)
predicted = list(reversed(overall_scores.argsort()))[:top_k]
actual = ground_truth[uid]
# calculate the average of different k
precision_5.append(precisionk(actual, predicted[:5]))
recall_5.append(recallk(actual, predicted[:5]))
nDCG_5.append(ndcgk(actual, predicted[:5]))
MAP_5.append(mapk(actual, predicted[:5], 5))
precision_10.append(precisionk(actual, predicted[:10]))
recall_10.append(recallk(actual, predicted[:10]))
nDCG_10.append(ndcgk(actual, predicted[:10]))
MAP_10.append(mapk(actual, predicted[:10], 10))
precision_15.append(precisionk(actual, predicted[:15]))
recall_15.append(recallk(actual, predicted[:15]))
nDCG_15.append(ndcgk(actual, predicted[:15]))
MAP_15.append(mapk(actual, predicted[:15], 15))
precision_20.append(precisionk(actual, predicted[:20]))
recall_20.append(recallk(actual, predicted[:20]))
nDCG_20.append(ndcgk(actual, predicted[:20]))
MAP_20.append(mapk(actual, predicted[:20], 20))
print(cnt, uid, "pre@10:", np.mean(precision_10), "rec@10:",
np.mean(recall_10))
rec_list.write('\t'.join([
str(cnt),
str(uid), ','.join([str(lid) for lid in predicted])
]) + '\n')
# write the different ks
result_5.write('\t'.join([
str(cnt),
str(uid),
str(np.mean(precision_5)),
str(np.mean(recall_5)),
str(np.mean(nDCG_5)),
str(np.mean(MAP_5))
]) + '\n')
result_10.write('\t'.join([
str(cnt),
str(uid),
str(np.mean(precision_10)),
str(np.mean(recall_10)),
str(np.mean(nDCG_10)),
str(np.mean(MAP_10))
]) + '\n')
result_15.write('\t'.join([
str(cnt),
str(uid),
str(np.mean(precision_15)),
str(np.mean(recall_15)),
str(np.mean(nDCG_15)),
str(np.mean(MAP_15))
]) + '\n')
result_20.write('\t'.join([
str(cnt),
str(uid),
str(np.mean(precision_20)),
str(np.mean(recall_20)),
str(np.mean(nDCG_20)),
str(np.mean(MAP_20))
]) + '\n')
print("<< Task Finished >>")
def main():
sparse_training_matrices, training_tuples, visited_lids = read_training_data(
)
ground_truth = read_ground_truth()
# max_train=30
TAMF.train(sparse_training_matrices, max_iters=1, load_sigma=False)
TAMF.save_model("./tmp/")
# TAMF.load_model("./tmp/")
all_uids = range(user_num)
all_lids = range(poi_num)
np.random.shuffle(all_uids)
# Change name of file where you want to save the results here:
rec_list = open("../datasets/result/reclist_top_" + str(top_k) + ".txt",
'w')
result_10 = open("../datasets/result/result_top_" + str(10) + ".txt", 'w')
result_20 = open("../datasets/result/result_top_" + str(20) + ".txt", 'w')
precision10, recall10, ndcg10 = 0, 0, 0
precision20, recall20, ndcg20 = 0, 0, 0
for cnt, uid in enumerate(all_uids):
if uid in ground_truth:
overall_scores = [
TAMF.predict(uid, lid) if
(uid, lid) not in training_tuples else -1 for lid in all_lids
]
overall_scores = np.array(overall_scores)
predicted = list(reversed(overall_scores.argsort()))[:top_k]
actual = ground_truth[uid]
precision10 = precisionk(actual, predicted[:10])
recall10 = recallk(actual, predicted[:10])
ndcg10 = ndcgk(actual, predicted[:10])
precision20 = precisionk(actual, predicted[:20])
recall20 = recallk(actual, predicted[:20])
ndcg20 = ndcgk(actual, predicted[:20])
rec_list.write('\t'.join([
str(cnt),
str(uid), ','.join([str(lid) for lid in predicted])
]) + '\n')
# write the different ks
result_10.write('\t'.join([
str(cnt),
str(uid),
str(precision10),
str(recall10),
str(ndcg10)
]) + '\n')
result_20.write('\t'.join([
str(cnt),
str(uid),
str(precision20),
str(recall20),
str(ndcg20)
]) + '\n')
def train(evaluate=False):
global OBJS
training_matrix = read_training_data()
social_relations = read_friend_data()
ground_truth = read_ground_truth()
poi_coos = read_poi_coos()
U.pre_compute_rec_scores(training_matrix)
S.compute_friend_sim(social_relations, training_matrix)
G.fit_distance_distribution(training_matrix, poi_coos)
#U.save_result("U")
#U.load_result("U.pkl")
# objs = {'social':S,'geo':G}
# OBJS = objs
# with open("trained.pkl","wb") as fh:
# joblib.dump(objs,fh)
if evaluate == False:
return 0
result_out = open("result/sigir11_top_" + str(top_k) + ".txt", 'w')
all_uids = list(range(user_num))
all_lids = list(range(poi_num))
np.random.shuffle(all_uids)
precision, recall = [], []
for cnt, uid in enumerate(all_uids):
if uid in ground_truth:
U_scores = normalize([
U.predict(uid, lid) if training_matrix[uid, lid] == 0 else -1
for lid in all_lids
])
S_scores = normalize([
S.predict(uid, lid) if training_matrix[uid, lid] == 0 else -1
for lid in all_lids
])
G_scores = normalize([
G.predict(uid, lid) if training_matrix[uid, lid] == 0 else -1
for lid in all_lids
])
U_scores = np.array(U_scores)
S_scores = np.array(S_scores)
G_scores = np.array(G_scores)
overall_scores = (1.0 - alpha - beta
) * U_scores + alpha * S_scores + beta * G_scores
predicted = list(reversed(overall_scores.argsort()))[:top_k]
actual = ground_truth[uid]
precision.append(precisionk(actual, predicted[:top_k]))
recall.append(recallk(actual, predicted[:top_k]))
print(cnt, uid, "pre@10:", np.mean(precision), "rec@10:",
np.mean(recall))
result_out.write('\t'.join([
str(cnt),
str(uid), ','.join([str(lid) for lid in predicted])
]) + '\n')
