def main():
read_f = file("./data/train_data", "rb")
train_generator = cPickle.load(read_f)
read_f.close()
read_f = file("./data/emb", "rb")
embedding_matrix, _, _ = cPickle.load(read_f)
read_f.close()
test_generator = DataGenerator("test", args.batch_size)
model = Network(args.embedding_size, args.embedding_dimension, embedding_matrix, args.hidden_dimension).cuda()
best_model = Network(args.embedding_size, args.embedding_dimension, embedding_matrix, args.hidden_dimension).cuda()
optimizer = optim.Adam(model.parameters(), lr=args.learning_rate, weight_decay=args.l2_reg)
best_result = 0.0
for echo in range(args.epoch_num):
info = "[" + echo * ">" + " " * (args.epoch_num - echo) + "]"
sys.stderr.write(info + "\r")
cost1, cost2, cost, total_num = 0.0, 0.0, 0.0, 0
for data in train_generator.generate_data(shuffle=True):
zp_rep, npc_rep, np_rep, feature = model.forward(data, dropout=args.dropout)
output = model.generate_score(zp_rep, npc_rep, np_rep, feature)
optimizer.zero_grad()
dis1 = output[data['wid']] - output[data['cid']] + args.margin
dis2 = output[data['uwid']] - args.wrong_bound
dis3 = args.correct_bound - output[data['ucid']]
triplet_loss = torch.sum(dis1 * (dis1 > 0).cuda().float()) + torch.sum(
dis2 * (dis2 > 0).cuda().float()) + torch.sum(dis3 * (dis3 > 0).cuda().float())
cos_sim_sum = torch.sum(1 - F.cosine_similarity(np_rep[data['cid1']], np_rep[data['cid2']]))
sim_w = 0.5
num = data["result"].shape[0]
total_loss = triplet_loss + sim_w * cos_sim_sum
total_loss.backward()
cost += total_loss.item() * num
cost1 += triplet_loss.item() * num
cost2 += cos_sim_sum.item() * num
total_num += num
optimizer.step()
train_re = evaluate_train(train_generator, model)
dev_re, dev_cost = evaluate_dev(train_generator, model, args.margin)
if dev_re > best_result:
best_result = dev_re
net_copy(best_model, model)
test_re = evaluate_test(test_generator, model)
print 'Epoch %s; Train Cost: %.4f, %.4f, %.4f; Train Result: %.4f; Dev Result: %.4f, %.4f; Test Result: %.4f' % (
echo, cost / total_num, cost1 / total_num, cost2 / total_num, train_re, dev_re, dev_cost, test_re)
print >> sys.stderr
torch.save(best_model, "./models/model")
re = evaluate_test(test_generator, best_model)
print "Performance on Test: F", re
mu=1.1)
gen_hr_imgs[:, c, i, j] = torch.tensor(new_pixel)
gen_hr_imgs = gen_hr_imgs.data.cpu().numpy()
gen_hr_imgs = np.transpose(gen_hr_imgs, (0, 3, 1, 2))
save_samples(
lr_batch.data.cpu().numpy(),
samples_dir + '/lr_' + str(mu * 10) + '_' + str(e) + '.jpg')
save_samples(
hr_batch.data.cpu().numpy(),
samples_dir + '/hr_' + str(mu * 10) + '_' + str(e) + '.jpg')
save_samples(
gen_hr_imgs,
samples_dir + '/generate_' + str(mu * 10) + '_' + str(e) + '.jpg')
continue
prior_logits, conditioning_logits = model.forward(hr_batch, lr_batch)
optimizer.zero_grad()
def calc_losses(logits, labels):
logits = logits.reshape(-1, 256)
labels = torch.tensor(labels, dtype=torch.int64)
labels = labels.reshape(-1)
labels = labels.to(device)
return criterion(logits, labels)
loss1 = calc_losses(prior_logits + conditioning_logits, labels)
loss2 = calc_losses(conditioning_logits, labels)
loss3 = calc_losses(prior_logits, labels)
loss = loss1 + loss2
