def train_D(self, context, context_lens, utt_lens, floors, response, res_lens):
self.context_encoder.eval()
self.discriminator.train()
self.optimizer_D.zero_grad()
batch_size=context.size(0)
c = self.context_encoder(context, context_lens, utt_lens, floors)
x,_ = self.utt_encoder(response[:,1:], res_lens-1)
post_z = self.sample_code_post(x, c)
errD_post = torch.mean(self.discriminator(torch.cat((post_z.detach(), c.detach()),1)))
errD_post.backward(one)
prior_z = self.sample_code_prior(c)
errD_prior = torch.mean(self.discriminator(torch.cat((prior_z.detach(), c.detach()),1)))
errD_prior.backward(minus_one)
alpha = gData(torch.rand(batch_size, 1))
alpha = alpha.expand(prior_z.size())
interpolates = alpha * prior_z.data + ((1 - alpha) * post_z.data)
interpolates = Variable(interpolates, requires_grad=True)
d_input=torch.cat((interpolates, c.detach()),1)
disc_interpolates = torch.mean(self.discriminator(d_input))
gradients = torch.autograd.grad(outputs=disc_interpolates, inputs=interpolates,
grad_outputs=gData(torch.ones(disc_interpolates.size())),
create_graph=True, retain_graph=True, only_inputs=True)[0]
gradient_penalty = ((gradients.contiguous().view(gradients.size(0),-1).norm(2,dim=1)-1)**2).mean()*self.lambda_gp
gradient_penalty.backward()
self.optimizer_D.step()
costD = -(errD_prior - errD_post) + gradient_penalty
return [('train_loss_D', costD.item())]
def evaluate(model, test_loader, vocab, repeat, f_eval):
# TODO:
z_vec = []
local_t = 0
while True:
batch = test_loader.next_batch()
if batch is None:
break
local_t += 1
if local_t != 1033:
continue
context, context_lens, utt_lens, floors, _, _, _, response, res_lens, _ = batch
context, utt_lens = context[:, :,
1:], utt_lens - 1 # remove the sos token in the context and reduce the context length
f_eval.write("Batch %d \n" % (local_t)) # print the context
start = np.maximum(0, context_lens[0] - 5)
for t_id in range(start, context.shape[1], 1):
context_str = indexes2sent(context[0, t_id], vocab, vocab["</s>"],
PAD_token)
f_eval.write("Context %d-%d: %s\n" %
(t_id, floors[0, t_id], context_str))
# print the true outputs
ref_str, _ = indexes2sent(response[0], vocab, vocab["</s>"],
vocab["<s>"])
ref_tokens = ref_str.split(' ')
f_eval.write("Target >> %s\n" % (ref_str.replace(" ' ", "'")))
context, context_lens, utt_lens, floors = gVar(context), gVar(
context_lens), gVar(utt_lens), gData(floors)
prior_z, c_repeated = model.sample_fix_z(context, context_lens,
utt_lens, floors, repeat,
vocab["<s>"], vocab["</s>"])
# nparray: [repeat x hidden_z]
z_vec.append(prior_z)
return z_vec
shuffle=True)
n_iters = train_loader.num_batch / max(1, config['n_iters_d'])
itr = 1
while True: # loop through all batches in training data
model.train()
loss_records = []
batch = train_loader.next_batch()
if batch is None: # end of epoch
break
context, context_lens, utt_lens, floors, _, _, _, response, res_lens, _ = batch
context, utt_lens = context[:, :,
1:], utt_lens - 1 # remove the sos token in the context and reduce the context length
context, context_lens, utt_lens, floors, response, res_lens\
= gVar(context), gVar(context_lens), gVar(utt_lens), gData(floors), gVar(response), gVar(res_lens)
#for i in range(config['n_iters_d']):
loss_AE = model.train_AE(context, context_lens, utt_lens, floors,
response, res_lens)
loss_records.extend(loss_AE)
loss_G = model.train_G(context, context_lens, utt_lens, floors,
response, res_lens)
loss_records.extend(loss_G)
'''
for i in range(config['n_iters_d']):# train discriminator/critic
loss_D = model.train_D(context, context_lens, utt_lens, floors, response, res_lens)
if i==0:
loss_records.extend(loss_D)
if i==config['n_iters_d']-1:
break
import torch.optim as optim
import os
import numpy as np
import random
import sys
#CurrentPath = os.path.abspath(".")
#print(CurrentPath)
#sys.path.insert(0, CurrentPath)
parentPath = os.path.abspath("..")
sys.path.insert(
0, parentPath) # add parent folder to path so as to import common modules
from helper import gVar, gData
from modules import Encoder, ContextEncoder, Variation, Decoder, mean_zero_Variation
import flows as flow
import nn as nn_
one = gData(torch.FloatTensor([1]))
minus_one = one * -1
def log_Normal_diag(x, mean, log_var, average=True, dim=1):
log_normal = -0.5 * (
log_var + torch.pow(x - mean, 2) * torch.pow(torch.exp(log_var), -1))
if average:
return torch.mean(log_normal, dim)
else:
return torch.sum(log_normal, dim)
class DFVAE(nn.Module):
def __init__(self, config, vocab_size, PAD_token=0):
super(DFVAE, self).__init__()
def evaluate(model, metrics, test_loader, vocab, ivocab, f_eval, repeat):
recall_bleus, prec_bleus, bows_extrema, bows_avg, bows_greedy, intra_dist1s, intra_dist2s, avg_lens, inter_dist1s, inter_dist2s\
= [], [], [], [], [], [], [], [], [], []
local_t = 0
while True:
batch = test_loader.next_batch()
if batch is None:
break
local_t += 1
context, context_lens, utt_lens, floors, _, _, _, response, res_lens, _ = batch
context, utt_lens = context[:, :,
1:], utt_lens - 1 # remove the sos token in the context and reduce the context length
f_eval.write("Batch %d \n" % (local_t)) # print the context
start = np.maximum(0, context_lens[0] - 5)
for t_id in range(start, context.shape[1], 1):
context_str = indexes2sent(context[0, t_id], vocab, vocab["</s>"],
PAD_token)
f_eval.write("Context %d-%d: %s\n" %
(t_id, floors[0, t_id], context_str))
# print the true outputs
ref_str, _ = indexes2sent(response[0], vocab, vocab["</s>"],
vocab["<s>"])
ref_tokens = ref_str.split(' ')
f_eval.write("Target >> %s\n" % (ref_str.replace(" ' ", "'")))
context, context_lens, utt_lens, floors = gVar(context), gVar(
context_lens), gVar(utt_lens), gData(floors)
sample_words, sample_lens = model.sample(context, context_lens,
utt_lens, floors, repeat,
vocab["<s>"], vocab["</s>"])
# nparray: [repeat x seq_len]
pred_sents, _ = indexes2sent(sample_words, vocab, vocab["</s>"],
PAD_token)
pred_tokens = [sent.split(' ') for sent in pred_sents]
for r_id, pred_sent in enumerate(pred_sents):
f_eval.write("Sample %d >> %s\n" %
(r_id, pred_sent.replace(" ' ", "'")))
max_bleu, avg_bleu = metrics.sim_bleu(pred_tokens, ref_tokens)
recall_bleus.append(max_bleu)
prec_bleus.append(avg_bleu)
bow_extrema, bow_avg, bow_greedy = metrics.sim_bow(
sample_words, sample_lens, response[:, 1:], res_lens - 2)
bows_extrema.append(bow_extrema)
bows_avg.append(bow_avg)
bows_greedy.append(bow_greedy)
intra_dist1, intra_dist2, inter_dist1, inter_dist2 = metrics.div_distinct(
sample_words, sample_lens)
intra_dist1s.append(intra_dist1)
intra_dist2s.append(intra_dist2)
avg_lens.append(np.mean(sample_lens))
inter_dist1s.append(inter_dist1)
inter_dist2s.append(inter_dist2)
f_eval.write("\n")
recall_bleu = float(np.mean(recall_bleus))
prec_bleu = float(np.mean(prec_bleus))
f1 = 2 * (prec_bleu * recall_bleu) / (prec_bleu + recall_bleu + 10e-12)
bow_extrema = float(np.mean(bows_extrema))
bow_avg = float(np.mean(bows_avg))
bow_greedy = float(np.mean(bows_greedy))
intra_dist1 = float(np.mean(intra_dist1s))
intra_dist2 = float(np.mean(intra_dist2s))
avg_len = float(np.mean(avg_lens))
inter_dist1 = float(np.mean(inter_dist1s))
inter_dist2 = float(np.mean(inter_dist2s))
report = "Avg recall BLEU %f, avg precision BLEU %f, F1 %f, bow_extrema %f, bow_avg %f, bow_greedy %f,\
intra_dist1 %f, intra_dist2 %f, avg_len %f, inter_dist1 %f, inter_dist2 %f (only 1 ref, not final results)" \
% (recall_bleu, prec_bleu, f1, bow_extrema, bow_avg, bow_greedy, intra_dist1, intra_dist2, avg_len, inter_dist1, inter_dist2)
print(report)
f_eval.write(report + "\n")
print("Done testing")
return recall_bleu, prec_bleu, bow_extrema, bow_avg, bow_greedy, intra_dist1, intra_dist2, avg_len, inter_dist1, inter_dist2
shuffle=True)
n_iters = train_loader.num_batch / max(1, config['n_iters_d'])
itr = 1
while True: # loop through all batches in training data
model.train()
loss_records = []
batch = train_loader.next_batch()
if batch is None: # end of epoch
break
context, context_lens, utt_lens, floors, _, _, _, response, res_lens, dialog_act = batch
context, utt_lens = context[:, :,
1:], utt_lens - 1 # remove the sos token in the context and reduce the context length
context, context_lens, utt_lens, floors, response, res_lens, dialog_act\
= gVar(context), gVar(context_lens), gVar(utt_lens), gData(floors), gVar(response), gVar(res_lens), gVar(dialog_act)
loss_AE = model.train_AE(context, context_lens, utt_lens, floors,
response, res_lens, dialog_act)
loss_records.extend(loss_AE)
loss_G = model.train_G(context, context_lens, utt_lens, floors,
response, res_lens)
loss_records.extend(loss_G)
for i in range(config['n_iters_d']): # train discriminator/critic
loss_D = model.train_D(context, context_lens, utt_lens, floors,
response, res_lens)
if i == 0:
loss_records.extend(loss_D)
if i == config['n_iters_d'] - 1:
