def train():
alpha, beta, gamma, lam = args.alpha, args.beta, args.gamma, args.lam
print('======== experiment settings =========')
print('alpha : %0.4f, beta : %0.4f, gamma : %0.4f, lam : %0.4f, p : %0.4f, ws : %d, ns : %d, maxT : % d, minT : %d, max_iter : %d, d : %d' % (alpha, beta, gamma, lam, args.p, args.ws, args.ns,args.maxT,args.minT,args.max_iter, args.d))
print('========== processing data ===========')
dul = DataUtils(model_path)
if args.rec:
test_user, test_item, test_rate = dul.read_data(args.test_data)
print("constructing graph....")
gul = GraphUtils(model_path)
gul.construct_training_graph(args.train_data)
edge_dict_u = gul.edge_dict_u
edge_list = gul.edge_list
walk_generator(gul,args)
print("getting context and negative samples....")
context_dict_u, neg_dict_u, context_dict_v, neg_dict_v, node_u, node_v = get_context_and_negative_samples(gul, args)
node_list_u, node_list_v = {}, {}
init_embedding_vectors(node_u, node_v, node_list_u, node_list_v, args)
last_loss, count, epsilon = 0, 0, 1e-3
print("============== training ==============")
for iter in range(0, args.max_iter):
s1 = "\r[%s%s]%0.2f%%"%("*"* iter," "*(args.max_iter-iter),iter*100.0/(args.max_iter-1))
loss = 0
visited_u = dict(zip(node_list_u.keys(), [0] * len(node_list_u.keys())))
visited_v = dict(zip(node_list_v.keys(), [0] * len(node_list_v.keys())))
random.shuffle(edge_list)
for i in range(len(edge_list)):
u, v, w = edge_list[i]
length = len(context_dict_u[u])
random.shuffle(context_dict_u[u])
if visited_u.get(u) < length:
# print(u)
index_list = list(range(visited_u.get(u),min(visited_u.get(u)+1,length)))
for index in index_list:
context_u = context_dict_u[u][index]
neg_u = neg_dict_u[u][index]
# center,context,neg,node_list,eta
for z in context_u:
tmp_z, tmp_loss = skip_gram(u, z, neg_u, node_list_u, lam, alpha)
node_list_u[z]['embedding_vectors'] += tmp_z
loss += tmp_loss
visited_u[u] = index_list[-1]+3
length = len(context_dict_v[v])
random.shuffle(context_dict_v[v])
if visited_v.get(v) < length:
# print(v)
index_list = list(range(visited_v.get(v),min(visited_v.get(v)+1,length)))
for index in index_list:
context_v = context_dict_v[v][index]
neg_v = neg_dict_v[v][index]
# center,context,neg,node_list,eta
for z in context_v:
tmp_z, tmp_loss = skip_gram(v, z, neg_v, node_list_v, lam, beta)
node_list_v[z]['embedding_vectors'] += tmp_z
loss += tmp_loss
visited_v[v] = index_list[-1]+3
update_u, update_v, tmp_loss = KL_divergence(edge_dict_u, u, v, node_list_u, node_list_v, lam, gamma)
loss += tmp_loss
node_list_u[u]['embedding_vectors'] += update_u
node_list_v[v]['embedding_vectors'] += update_v
delta_loss = abs(loss - last_loss)
if last_loss > loss:
lam *= 1.05
else:
lam *= 0.95
last_loss = loss
if delta_loss < epsilon:
break
sys.stdout.write(s1)
sys.stdout.flush()
def train(args):
model_path = os.path.join('../', args.model_name)
if os.path.exists(model_path) is False:
os.makedirs(model_path)
alpha, beta, gamma, lam = args.alpha, args.beta, args.gamma, args.lam
print('======== experiment settings =========')
print(
'alpha : %0.4f, beta : %0.4f, gamma : %0.4f, lam : %0.4f, p : %0.4f, ws : %d, ns : %d, maxT : % d, minT : %d, max_iter : %d, d : %d'
% (alpha, beta, gamma, lam, args.p, args.ws, args.ns, args.maxT,
args.minT, args.max_iter, args.d))
print('========== processing data ===========')
dul = DataUtils(model_path)
if args.rec:
test_user, test_item, test_rate = dul.read_data(args.test_data)
print("constructing graph....")
gul = GraphUtils(model_path)
gul.construct_training_graph(args.train_data)
edge_dict_u = gul.edge_dict_u
edge_list = gul.edge_list
walk_generator(gul, args)
print("getting context and negative samples....")
context_dict_u, neg_dict_u, context_dict_v, neg_dict_v, node_u, node_v = get_context_and_negative_samples(
gul, args)
node_list_u, node_list_v = {}, {}
init_embedding_vectors(node_u, node_v, node_list_u, node_list_v, args)
last_loss, count, epsilon = 0, 0, 1e-3
print("============== training ==============")
for iter in range(0, args.max_iter):
s1 = "\r[%s%s]%0.2f%%" % ("*" * iter, " " *
(args.max_iter - iter), iter * 100.0 /
(args.max_iter - 1))
loss = 0
num = 0
visited_u = dict(zip(node_list_u.keys(),
[0] * len(node_list_u.keys())))
visited_v = dict(zip(node_list_v.keys(),
[0] * len(node_list_v.keys())))
random.shuffle(edge_list)
for (u, v, w) in edge_list:
if visited_u.get(u) == 0 or random.random() > 0.95:
# print(u)
length = len(context_dict_u[u])
index_list = random.sample(list(range(length)), min(length, 1))
for index in index_list:
context_u = context_dict_u[u][index]
neg_u = neg_dict_u[u][index]
# center,context,neg,node_list,eta
for k, z in enumerate(context_u):
tmp_z, tmp_loss = skip_gram(u, z, neg_u, node_list_u,
lam, alpha)
node_list_u[z]['embedding_vectors'] += tmp_z
loss += tmp_loss
visited_u[u] = 1
if visited_v.get(v) == 0 or random.random() > 0.95:
# print(v)
length = len(context_dict_v[v])
index_list = random.sample(list(range(length)), min(length, 1))
for index in index_list:
context_v = context_dict_v[v][index]
neg_v = neg_dict_v[v][index]
# center,context,neg,node_list,eta
for k, z in enumerate(context_v):
tmp_z, tmp_loss = skip_gram(v, z, neg_v, node_list_v,
lam, beta)
node_list_v[z]['embedding_vectors'] += tmp_z
loss += tmp_loss
visited_v[v] = 1
# print(len(edge_dict_u))
update_u, update_v, tmp_loss = KL_divergence(
edge_dict_u, u, v, node_list_u, node_list_v, lam, gamma)
loss += tmp_loss
node_list_u[u]['embedding_vectors'] += update_u
node_list_v[v]['embedding_vectors'] += update_v
count = iter
num += 1
delta_loss = abs(loss - last_loss)
if last_loss > loss:
lam *= 1.05
else:
lam *= 0.95
last_loss = loss
if delta_loss < epsilon:
break
sys.stdout.write(s1)
sys.stdout.flush()
save_to_file(node_list_u, node_list_v, model_path, args)
print("")
if args.rec:
print("============== testing ===============")
f1, map, mrr, mndcg = top_N(test_user, test_item, test_rate,
node_list_u, node_list_v, args.top_n)
print(
'recommendation metrics: F1 : %0.4f, MAP : %0.4f, MRR : %0.4f, NDCG : %0.4f'
% (round(f1, 4), round(map, 4), round(mrr, 4), round(mndcg, 4)))
if args.lip:
print("============== testing ===============")
auc_roc, auc_pr = link_prediction(args)
print('link prediction metrics: AUC_ROC : %0.4f, AUC_PR : %0.4f' %
(round(auc_roc, 4), round(auc_pr, 4)))
def train_by_sampling(args):
model_path = os.path.join('../', args.model_name)
if os.path.exists(model_path) is False:
os.makedirs(model_path)
alpha, beta, gamma, lam = args.alpha, args.beta, args.gamma, args.lam
print('======== experiment settings =========')
print(
'alpha : %0.4f, beta : %0.4f, gamma : %0.4f, lam : %0.4f, p : %0.4f, ws : %d, ns : %d, maxT : % d, minT : %d, max_iter : %d, d : %d'
% (alpha, beta, gamma, lam, args.p, args.ws, args.ns, args.maxT,
args.minT, args.max_iter, args.d))
print('========== processing data ===========')
dul = DataUtils(model_path)
if args.rec:
test_user, test_item, test_rate = dul.read_data(args.test_data)
print("constructing graph....")
gul = GraphUtils(model_path)
gul.construct_training_graph(
args.train_data) # train_data='../data/wiki/rating_train.dat'
edge_dict_u = gul.edge_dict_u # dict形式的点边关系
edge_list = gul.edge_list # list形式的点边关系
walk_generator(gul, args) # 生成随机游走
print("getting context and negative samples....")
context_dict_u, neg_dict_u, context_dict_v, neg_dict_v, node_u, node_v = get_context_and_negative_samples(
gul, args)
node_list_u, node_list_v = {}, {}
init_embedding_vectors(node_u, node_v, node_list_u, node_list_v,
args) # 初始化节点embedding
last_loss, count, epsilon = 0, 0, 1e-3
print("============== training ==============")
for iter in range(0, args.max_iter):
s1 = "\r[%s%s]%0.2f%%" % ("*" * iter, " " *
(args.max_iter - iter), iter * 100.0 /
(args.max_iter - 1))
loss = 0
visited_u = dict(zip(node_list_u.keys(),
[0] * len(node_list_u.keys()))) # u类别初始为0
visited_v = dict(zip(node_list_v.keys(),
[0] * len(node_list_v.keys()))) # v类别初始为0
random.shuffle(edge_list) # edge_list: 点边信息
for i in range(len(edge_list)):
u, v, w = edge_list[i]
length = len(context_dict_u[u]) # 周围邻居的数量
random.shuffle(context_dict_u[u])
if visited_u.get(u) < length:
# print(u)
index_list = list(
range(visited_u.get(u), min(visited_u.get(u) + 1, length)))
for index in index_list:
context_u = context_dict_u[u][index] # 选择节点的一个邻居
neg_u = neg_dict_u[u][
index] # 选择节点的负采样信息; 负采样本身就是随机的，所以只需打乱context即可，并且多个epoch训练时，负采样样本也不同
# center,context,neg,node_list,eta
for z in context_u: # 每一个邻居节点，都进行skip-gram更新embedding
tmp_z, tmp_loss = skip_gram(u, z, neg_u, node_list_u,
lam, alpha)
node_list_u[u][
'embedding_vectors'] += tmp_z # 更新节点embedding
loss += tmp_loss
visited_u[u] = index_list[-1] + 3
length = len(context_dict_v[v])
random.shuffle(context_dict_v[v])
if visited_v.get(v) < length:
# print(v)
index_list = list(
range(visited_v.get(v), min(visited_v.get(v) + 1, length)))
for index in index_list:
context_v = context_dict_v[v][index]
neg_v = neg_dict_v[v][index]
# center,context,neg,node_list,eta
for z in context_v:
tmp_z, tmp_loss = skip_gram(v, z, neg_v, node_list_v,
lam, beta)
node_list_v[v]['embedding_vectors'] += tmp_z
loss += tmp_loss
visited_v[v] = index_list[-1] + 3
# edge_dict_u:边连接的信息
update_u, update_v, tmp_loss = KL_divergence(
edge_dict_u, u, v, node_list_u, node_list_v, lam,
gamma) # 计算KL-deversion
loss += tmp_loss
node_list_u[u]['embedding_vectors'] += update_u
node_list_v[v]['embedding_vectors'] += update_v
# 求的是梯度上升，loss越大越好
delta_loss = abs(loss - last_loss)
if last_loss > loss:
lam *= 1.05
else:
lam *= 0.95
last_loss = loss
if delta_loss < epsilon:
break
sys.stdout.write(s1)
sys.stdout.flush()
save_to_file(node_list_u, node_list_v, model_path, args)
print("")
if args.rec:
print("============== testing ===============")
f1, map, mrr, mndcg = top_N(test_user, test_item, test_rate,
node_list_u, node_list_v, args.top_n)
print(
'recommendation metrics: F1 : %0.4f, MAP : %0.4f, MRR : %0.4f, NDCG : %0.4f'
% (round(f1, 4), round(map, 4), round(mrr, 4), round(mndcg, 4)))
if args.lip:
print("============== testing ===============")
auc_roc, auc_pr = link_prediction(args)
print('link prediction metrics: AUC_ROC : %0.4f, AUC_PR : %0.4f' %
(round(auc_roc, 4), round(auc_pr, 4)))
