def reconstruct(args, model, batches, vocab):
for iteration, bl in enumerate(batches):
batch, batch_lens = bl.text
target, target_lens = bl.target
if args.cuda:
batch = Variable(batch.cuda(), volatile=True)
else:
batch = Variable(batch, volatile=True)
outputs = model(batch,
batch_lens,
str_out=True,
beam_size=args.beam_size,
max_len_decode=args.max_len_decode)
print("TRUE: {}".format(transform(batch.data.squeeze(), vocab.itos)))
print("Reconstruct: {}\n\n".format(transform(outputs, vocab.itos)))
def generate_from_seed(args, model, batches, vocab, data_len):
"""
Generate a script from a seed tuple
Args
args (argparse.ArgumentParser)
seeds (BatchIter) : BatchIter object for a file of seeds, the seed file should be in the
same format as normal validation data
"""
for iteration, bl in enumerate(batches):
batch, batch_lens = bl.text
target, target_lens = bl.target
if args.cuda:
batch = Variable(batch.cuda(), volatile=True)
else:
batch = Variable(batch, volatile=True)
src_lens = torch.LongTensor([batch.size(1)])
dhidden, latent_values = model(
batch, src_lens, encode_only=True) #get latent encoding for seed
model.decoder.init_feed_(
Variable(torch.zeros(1, model.decoder.attn_dim)))
_, _, dhidden, dec_outputs = model.train(batch,
1,
dhidden,
latent_values, [],
return_hid=True) #decode seed
#print("seq len {}, decode after {} steps".format(seq_len, i+1))
# beam set current state to last word in the sequence
beam_inp = batch[:, -1]
# init beam initializesthe beam with the last sequence element
outputs = model.beam_decode(beam_inp,
dhidden,
latent_values,
args.beam_size,
args.max_len_decode,
init_beam=True)
print("TRUE: {}".format(transform(batch.data.squeeze(), vocab.itos)))
print("Reconstruct: {}\n\n".format(transform(outputs, vocab.itos)))
def sample_outputs(model, vocab):
model.latent_root.prune_()
for _ in range(100):
val1 = np.random.randint(313)
val2 = np.random.randint(32)
val3 = np.random.randint(38)
val4 = np.random.randint(12)
val5 = np.random.randint(6)
# values = [val1, val2, 15, val4, val5]
values = [247, 12, 15, val4, 1]
outputs = model.decode(values)
print("Reconstruct: {}\n\n".format(transform(outputs, vocab.itos)))
def do_ranking(model, vocab):
dataset = du.NarrativeClozeDataset(args.data,
vocab,
src_seq_length=MAX_EVAL_SEQ_LEN,
min_seq_length=MIN_EVAL_SEQ_LEN)
batches = BatchIter(dataset,
args.batch_size,
sort_key=lambda x: len(x.actual),
train=False,
device=device)
ranked_acc = 0.0
if args.emb_type:
print("RANKING WITH ROLE EMB")
vocab2 = du.load_vocab(args.vocab2)
role_dataset = du.NarrativeClozeDataset(
args.role_data,
vocab2,
src_seq_length=MAX_EVAL_SEQ_LEN,
min_seq_length=MIN_EVAL_SEQ_LEN)
role_batches = BatchIter(role_dataset,
args.batch_size,
sort_key=lambda x: len(x.actual),
train=False,
device=device)
assert len(dataset) == len(
role_dataset), "Dataset and Role dataset must be of same length."
for iteration, (bl, rbl) in enumerate(zip(batches, role_batches)):
if (iteration + 1) % 25 == 0:
print("iteration {}".format(iteration + 1))
## DATA STEPS
all_texts = [
bl.actual, bl.actual_tgt, bl.dist1, bl.dist1_tgt, bl.dist2,
bl.dist2_tgt, bl.dist3, bl.dist3_tgt, bl.dist4, bl.dist4_tgt,
bl.dist5, bl.dist5_tgt
] # each is a tup
all_roles = [
rbl.actual, rbl.dist1, rbl.dist2, rbl.dist3, rbl.dist4,
rbl.dist5
] # tgts are not needed for role
assert len(all_roles) == 6, "6 = 6 * 1."
assert len(all_texts) == 12, "12 = 6 * 2."
all_texts_vars = []
all_roles_vars = []
if use_cuda:
for tup in all_texts:
all_texts_vars.append((Variable(tup[0].cuda(),
volatile=True), tup[1]))
for tup in all_roles:
all_roles_vars.append((Variable(tup[0].cuda(),
volatile=True), tup[1]))
else:
for tup in all_texts:
all_texts_vars.append((Variable(tup[0],
volatile=True), tup[1]))
for tup in all_roles:
all_roles_vars.append((Variable(tup[0],
volatile=True), tup[1]))
# will itetrate 2 at a time using iterator and next
vars_iter = iter(all_texts_vars)
roles_iter = iter(all_roles_vars)
# run the model and collect ppls for all 6 sentences
pps = []
for tup in vars_iter:
## INIT AND DECODE before every sentence
hidden = model.init_hidden(args.batch_size)
next_tup = next(vars_iter)
role_tup = next(roles_iter)
nll = calc_perplexity(args, model, tup[0], vocab, next_tup[0],
next_tup[1], hidden, role_tup[0])
pp = torch.exp(nll)
#print("NEG-LOSS {} PPL {}".format(nll.data[0], pp.data[0]))
pps.append(pp.data.numpy()[0])
# low perplexity == top ranked sentence- correct answer is the first one of course
assert len(pps) == 6, "6 targets."
#print("\n")
all_texts_str = [
transform(text[0].data.numpy()[0], vocab.itos)
for text in all_texts_vars
]
#print("ALL: {}".format(all_texts_str))
min_index = np.argmin(pps)
if min_index == 0:
ranked_acc += 1
#print("TARGET: {}".format(transform(all_texts_vars[1][0].data.numpy()[0], vocab.itos)))
#print("CORRECT: {}".format(transform(all_texts_vars[1][0].data.numpy()[0], vocab.itos)))
#else:
# print the ones that are wrong
#print("TARGET: {}".format(transform(all_texts_vars[1][0].data.numpy()[0], vocab.itos)))
#print("WRONG: {}".format(transform(all_texts_vars[min_index+2][0].data.numpy()[0], vocab.itos)))
if (iteration + 1) == args.max_decode:
print("Max decode reached. Exiting.")
break
ranked_acc /= (iteration + 1) * 1 / 100 # multiplying to get percent
print("Average acc(%): {}".format(ranked_acc))
return ranked_acc
else: # THIS IS FOR MODEL WITHOUT ROLE EMB
print("RANKING WITHOUT ROLE EMB.")
for iteration, bl in enumerate(batches):
if (iteration + 1) % 25 == 0:
print("iteration {}".format(iteration + 1))
## DATA STEPS
all_texts = [
bl.actual, bl.actual_tgt, bl.dist1, bl.dist1_tgt, bl.dist2,
bl.dist2_tgt, bl.dist3, bl.dist3_tgt, bl.dist4, bl.dist4_tgt,
bl.dist5, bl.dist5_tgt
] # each is a tup
assert len(all_texts) == 12, "12 = 6 * 2."
all_texts_vars = []
if use_cuda:
for tup in all_texts:
all_texts_vars.append((Variable(tup[0].cuda(),
volatile=True), tup[1]))
else:
for tup in all_texts:
all_texts_vars.append((Variable(tup[0],
volatile=True), tup[1]))
# will itetrate 2 at a time using iterator and next
vars_iter = iter(all_texts_vars)
# run the model for all 6 sentences
pps = []
for tup in vars_iter:
## INIT AND DECODE before every sentence
hidden = model.init_hidden(args.batch_size)
next_tup = next(vars_iter)
nll = calc_perplexity(args, model, tup[0], vocab, next_tup[0],
next_tup[1], hidden)
pp = torch.exp(nll)
#print("NEG-LOSS {} PPL {}".format(nll.data[0], pp.data[0]))
pps.append(pp.data.numpy()[0])
# low perplexity == top ranked sentence- correct answer is the first one of course
assert len(pps) == 6, "6 targets."
#print("\n")
all_texts_str = [
transform(text[0].data.numpy()[0], vocab.itos)
for text in all_texts_vars
]
#print("ALL: {}".format(all_texts_str))
min_index = np.argmin(pps)
if min_index == 0:
ranked_acc += 1
#print("TARGET: {}".format(transform(all_texts_vars[1][0].data.numpy()[0], vocab.itos)))
#print("CORRECT: {}".format(transform(all_texts_vars[1][0].data.numpy()[0], vocab.itos)))
#else:
# print the ones that are wrong
#print("TARGET: {}".format(transform(all_texts_vars[1][0].data.numpy()[0], vocab.itos)))
#print("WRONG: {}".format(transform(all_texts_vars[min_index+2][0].data.numpy()[0], vocab.itos)))
if (iteration + 1) == args.max_decode:
print("Max decode reached. Exiting.")
break
ranked_acc /= (iteration + 1) * 1 / 100 # multiplying to get percent
print("Average acc(%): {}".format(ranked_acc))
return ranked_acc
def gen_from_seed(model, vocab, eos_id, pad_id, sos_id, tup_id):
if args.emb_type: # GEN FROM SEED WITH ROLE EMB
print("GEN SEED WITH ROLE EMB")
vocab2 = du.load_vocab(args.vocab2)
# will use this to feed in role ids in beam decode
ROLES = [
vocab2.stoi[TUP_TOK], vocab2.stoi[VERB], vocab2.stoi[SUB],
vocab2.stoi[OBJ], vocab2.stoi[PREP]
]
dataset = du.LMRoleSentenceDataset(
args.data,
vocab,
args.role_data,
vocab2,
src_seq_length=MAX_EVAL_SEQ_LEN,
min_seq_length=MIN_EVAL_SEQ_LEN) #put in filter pred later
dataset = du.LMRoleSentenceDataset(args.data, vocab, args.role_data,
vocab2) #put in filter pred later
batches = BatchIter(dataset,
args.batch_size,
sort_key=lambda x: len(x.text),
train=False,
device=device)
for iteration, bl in enumerate(batches):
if (iteration + 1) % 25 == 0:
print("iteration {}".format(iteration + 1))
## DATA STEPS
batch, batch_lens = bl.text
target, target_lens = bl.target
role, role_lens = bl.role
if use_cuda:
batch = Variable(batch.cuda(), volatile=True)
role = Variable(role.cuda(), volatile=True)
else:
batch = Variable(batch, volatile=True)
role = Variable(role, volatile=True)
## INIT AND DECODE
hidden = model.init_hidden(args.batch_size)
#run the model first on t-1 events, except last word. we know corresponding role ids as well.
seq_len = batch.size(1)
for i in range(seq_len - 1):
inp = batch[:, i]
inp = inp.unsqueeze(args.batch_size)
typ = role[:, i]
typ = typ.unsqueeze(1)
_, hidden = model(inp, hidden, typ)
#print("seq len {}, decode after {} steps".format(seq_len, i+1))
# beam set current state to last word in the sequence
beam_inp = batch[:, i + 1]
# do not need this anymore as assuming last sequence role obj is prep.
#role_inp = role[:, i+1]
# print("ROLES LIST: {}".format(ROLES))
# print("FIRST ID: {}".format(role[:, i+1]))
# init beam initializes the beam with the last sequence element. ROLE is a list of roe type ids.
outputs = beam_decode(model,
beam_inp,
hidden,
args.max_len_decode,
args.beam_size,
pad_id,
sos_id,
eos_id,
tup_idx=tup_id,
init_beam=True,
roles=ROLES)
predicted_events = get_pred_events(outputs, vocab)
print("CONTEXT: {}".format(
transform(batch.data.squeeze(), vocab.itos)))
print("PRED_t: {}".format(
predicted_events)) # n_best stitched together.
if (iteration + 1) == args.max_decode:
print("Max decode reached. Exiting.")
break
else:
print("GEN SEED WITHOUT ROLE EMB")
dataset = du.LMSentenceDataset(
args.data,
vocab,
src_seq_length=MAX_EVAL_SEQ_LEN,
min_seq_length=MIN_EVAL_SEQ_LEN) #put in filter pred later
batches = BatchIter(dataset,
args.batch_size,
sort_key=lambda x: len(x.text),
train=False,
device=device)
for iteration, bl in enumerate(batches):
if (iteration + 1) % 25 == 0:
print("iteration {}".format(iteration + 1))
## DATA STEPS
batch, batch_lens = bl.text
target, target_lens = bl.target
if use_cuda:
batch = Variable(batch.cuda(), volatile=True)
else:
batch = Variable(batch, volatile=True)
## INIT AND DECODE
hidden = model.init_hidden(args.batch_size)
#run the model first on t-1 events, except last word
seq_len = batch.size(1)
for i in range(seq_len - 1):
inp = batch[:, i]
inp = inp.unsqueeze(args.batch_size)
_, hidden = model(inp, hidden)
#print("seq len {}, decode after {} steps".format(seq_len, i+1))
# beam set current state to last word in the sequence
beam_inp = batch[:, i + 1]
# init beam initializesthe beam with the last sequence element
outputs = beam_decode(model,
beam_inp,
hidden,
args.max_len_decode,
args.beam_size,
pad_id,
sos_id,
eos_id,
tup_idx=tup_id,
init_beam=True)
predicted_events = get_pred_events(outputs, vocab)
print("CONTEXT: {}".format(
transform(batch.data.squeeze(), vocab.itos)))
print("PRED_t: {}".format(
predicted_events)) # n_best stitched together.
if (iteration + 1) == args.max_decode:
print("Max decode reached. Exiting.")
break
def do_ranking(args, model, batches, vocab, data_len, use_cuda):
print("RANKING")
ranked_acc = 0.0
tup_idx = vocab.stoi[TUP_TOK]
for iteration, bl in enumerate(batches):
if (iteration + 1) % 25 == 0:
print("iteration {}".format(iteration + 1))
all_texts = [
bl.actual, bl.actual_tgt, bl.dist1, bl.dist1_tgt, bl.dist2,
bl.dist2_tgt, bl.dist3, bl.dist3_tgt, bl.dist4, bl.dist4_tgt,
bl.dist5, bl.dist5_tgt
] # each is a tup
assert len(all_texts) == 12, "12 = 6 * 2."
all_texts_vars = []
for tup in all_texts:
all_texts_vars.append((Variable(tup[0], volatile=True), tup[1]))
# will itetrate 2 at a time using iterator and next
vars_iter = iter(all_texts_vars)
# run the model for all 6 sentences
pps = []
first_tup = -1
for i in range(bl.actual[0].shape[1]):
if bl.actual[0][0, i] == tup_idx:
first_tup = i
break
if first_tup == -1:
print("WARNING: First TUP is -1")
src_tup = Variable(bl.actual[0][:, :first_tup + 1].view(1, -1),
volatile=True)
src_lens = torch.LongTensor([src_tup.shape[1]])
if use_cuda:
src_tup = src_tup.cuda()
src_lens = src_lens.cuda()
dhidden, latent_values = model(src_tup, src_lens, encode_only=True)
# Latent and hidden have been initialized with the first tuple
for tup in vars_iter:
## INIT FEED AND DECODE before every sentence.
if use_cuda:
model.decoder.init_feed_(
Variable(torch.zeros(1, model.decoder.attn_dim).cuda()))
else:
model.decoder.init_feed_(
Variable(torch.zeros(1, model.decoder.attn_dim)))
next_tup = next(vars_iter)
if use_cuda:
_, _, _, dec_outputs = model.train(tup[0].cuda(), 1, dhidden,
latent_values, [])
else:
_, _, _, dec_outputs = model.train(tup[0], 1, dhidden,
latent_values, [])
logits = model.logits_out(dec_outputs).cpu()
logits = logits.transpose(
0, 1).contiguous() # convert to [batch, seq, vocab]
nll = masked_cross_entropy(logits, next_tup[0],
Variable(next_tup[1]))
#nll = calc_perplexity(args, model, tup[0], vocab, next_tup[0], next_tup[1], hidden)
pp = torch.exp(nll)
#print("NEG-LOSS {} PPL {}".format(nll.data[0], pp.data[0]))
pps.append(pp.data.numpy())
# low perplexity == top ranked sentence- correct answer is the first one of course
assert len(pps) == 6, "6 targets."
#print("\n")
all_texts_str = [
transform(text[0].data.numpy()[0], vocab.itos)
for text in all_texts_vars
]
#print("ALL: {}".format(all_texts_str))
min_index = np.argmin(pps)
if min_index == 0:
ranked_acc += 1
#print("TARGET: {}".format(transform(all_texts_vars[1][0].data.numpy()[0], vocab.itos)))
#print("CORRECT: {}".format(transform(all_texts_vars[1][0].data.numpy()[0], vocab.itos)))
#else:
# print the ones that are wrong
#print("TARGET: {}".format(transform(all_texts_vars[1][0].data.numpy()[0], vocab.itos)))
#print("WRONG: {}".format(transform(all_texts_vars[min_index+2][0].data.numpy()[0], vocab.itos)))
if (iteration + 1) == args.max_decode:
print("Max decode reached. Exiting.")
break
ranked_acc /= (iteration + 1) * 1 / 100 # multiplying to get percent
print("Average acc(%): {}".format(ranked_acc))
def do_ranking(args, model, batches, vocab, vocab2, data_len, use_cuda):
print("RANKING")
ranked_acc = 0.0
tup_idx = vocab.stoi[TUP_TOK]
for iteration, bl in enumerate(batches):
if (iteration + 1) % 25 == 0:
print("iteration {}".format(iteration + 1))
all_texts = [
bl.actual, bl.actual_tgt, bl.dist1, bl.dist1_tgt, bl.dist2,
bl.dist2_tgt, bl.dist3, bl.dist3_tgt, bl.dist4, bl.dist4_tgt,
bl.dist5, bl.dist5_tgt
] # each is a tup
assert len(all_texts) == 12, "12 = 6 * 2."
all_texts_vars = []
for tup in all_texts:
all_texts_vars.append((Variable(tup[0], volatile=True), tup[1]))
# will itetrate 2 at a time using iterator and next
vars_iter = iter(all_texts_vars)
# run the model for all 6 sentences
pps = []
first_tup = -1
for i in range(bl.actual[0].shape[1]):
if bl.actual[0][0, i] == tup_idx:
first_tup = i
break
if first_tup == -1:
print("WARNING: First TUP is -1")
# print("bl.actual: ",bl.actual[0].size())
src_tup = Variable(bl.actual[0][:, :first_tup + 1].view(1, -1),
volatile=True)
src_lens = torch.LongTensor([src_tup.shape[1]])
f_vals = torch.LongTensor([[0, 2, 2, 2, 2]])
# print("f_vals: ",f_vals.size())
if use_cuda:
src_tup = src_tup.cuda()
src_lens = src_lens.cuda()
f_vals = f_vals.cuda()
# print('src_tup: ',src_tup.size())
dhidden, latent_values = model(src_tup,
src_lens,
f_vals=f_vals,
encode_only=True)
latent_gumbels = model.latent_gumbels
frames_infer = latent_gumbels[0, :, :].data.cpu()
# total_frames_infer=latent_gumbels.data.cpu()
seed_infer_idx = torch.argmax(frames_infer, -1)[0]
# seed_meaning = [vocab.itos[int(item.numpy())] for item in src_tup.cpu().data[0]]
# seed_frame_infer = vocab2.itos[int(seed_infer_idx.numpy())]
# f_vals = torch.LongTensor([[seed_infer_idx,0,0,0,0]]).cuda()
f_vals = torch.LongTensor([[seed_infer_idx, 0, 0, 0, 0]]).cuda()
# print("seed_meaning: ",seed_meaning)
# print('seed_frame_infer: ',seed_frame_infer)
# Latent and hidden have been initialized with the first tuple
for tup in vars_iter:
## INIT FEED AND DECODE before every sentence.
if use_cuda:
model.decoder.init_feed_(
Variable(torch.zeros(1, model.decoder.attn_dim).cuda()))
else:
model.decoder.init_feed_(
Variable(torch.zeros(1, model.decoder.attn_dim)))
next_tup = next(vars_iter)
# print("next_tup[0]: ",next_tup[0].size())
# print("next_tup[1]: ",next_tup[1])
cropped_input = next_tup[0][0, :24].view(1, -1).cuda()
cropped_input_len = next_tup[1] - 5
# print("cropped_input: ",cropped_input.size())
# print("cropped_input_len: ",cropped_input_len)
# _, _, _, dec_outputs = model(next_tup[0].cuda(), Variable(next_tup[1]).cuda(),f_vals=f_vals)
_, _, _, dec_outputs = model(cropped_input.cuda(),
Variable(cropped_input_len).cuda(),
f_vals=f_vals)
logits = model.logits.transpose(
0, 1).contiguous() # convert to [batch, seq, vocab]
# print("logits: ",logits.size())
tup_latent_gumbels = model.latent_gumbels
tup_frames_infer = tup_latent_gumbels[0, :, :].data.cpu()
tup_total_frames_infer = tup_latent_gumbels.data.cpu()
tup_seed_infer_idx = torch.argmax(tup_frames_infer, -1)
# print("next_tup_meaning: ",[vocab.itos[int(item.numpy())] for item in next_tup[0].cpu().data[0]])
tup_seed_infer_idx_meaning = [
vocab2.itos[int(item.numpy())]
for item in tup_seed_infer_idx.cpu().data
]
# print("tup_seed_infer_idx_meaning: ",tup_seed_infer_idx_meaning)
# logits = logits.transpose(0,1).contiguous() # convert to [batch, seq, vocab]
# print("logits: ",logits.size())
# print('next_tup[0]',next_tup[0].size())
# print('next_tup[1]',next_tup[0].size())
# nll = masked_cross_entropy(logits, next_tup[0].cuda(), Variable(next_tup[1]).cuda())
nll = masked_cross_entropy(logits, cropped_input,
Variable(cropped_input_len).cuda())
#nll = calc_perplexity(args, model, tup[0], vocab, next_tup[0], next_tup[1], hidden)
pp = torch.exp(nll)
#print("NEG-LOSS {} PPL {}".format(nll.data[0], pp.data[0]))
pps.append(pp.data.cpu().numpy())
# low perplexity == top ranked sentence- correct answer is the first one of course
assert len(pps) == 6, "6 targets."
#print("\n")
all_texts_str = [
transform(text[0].data.numpy()[0], vocab.itos)
for text in all_texts_vars
]
#print("ALL: {}".format(all_texts_str))
min_index = np.argmin(pps)
if min_index == 0:
ranked_acc += 1
#print("TARGET: {}".format(transform(all_texts_vars[1][0].data.numpy()[0], vocab.itos)))
#print("CORRECT: {}".format(transform(all_texts_vars[1][0].data.numpy()[0], vocab.itos)))
#else:
# print the ones that are wrong
#print("TARGET: {}".format(transform(all_texts_vars[1][0].data.numpy()[0], vocab.itos)))
#print("WRONG: {}".format(transform(all_texts_vars[min_index+2][0].data.numpy()[0], vocab.itos)))
if (iteration + 1) == args.max_decode:
print("Max decode reached. Exiting.")
break
ranked_acc /= (iteration + 1) * 1 / 100 # multiplying to get percent
print("Average acc(%): {}".format(ranked_acc))
return ranked_acc
def do_ranking(args, model, batches, vocab, data_len, use_cuda):
print("RANKING")
ranked_acc = 0.0
tup_idx = vocab.stoi[TUP_TOK]
for iteration, bl in enumerate(batches):
if (iteration + 1) % 25 == 0:
print("iteration {}".format(iteration + 1))
all_texts = [
bl.actual, bl.actual_tgt, bl.dist1, bl.dist1_tgt, bl.dist2,
bl.dist2_tgt, bl.dist3, bl.dist3_tgt, bl.dist4, bl.dist4_tgt,
bl.dist5, bl.dist5_tgt
] # each is a tup
assert len(all_texts) == 12, "12 = 6 * 2."
all_texts_vars = []
for tup in all_texts:
all_texts_vars.append((Variable(tup[0], volatile=True), tup[1]))
# will itetrate 2 at a time using iterator and next
vars_iter = iter(all_texts_vars)
# run the model for all 6 sentences
pps = []
first_tup = -1
for i in range(bl.actual[0].shape[1]):
if bl.actual[0][0, i] == tup_idx:
first_tup = i
break
if first_tup == -1:
print("WARNING: First TUP is -1")
# print("bl.actual: ",bl.actual[0].size())
src_tup = Variable(bl.actual[0][:, :first_tup + 1].view(1, -1),
volatile=True)
src_lens = torch.LongTensor([src_tup.shape[1]])
f_vals = torch.LongTensor([[0, 0, 0, 0, 0]])
# print("f_vals: ",f_vals.size())
if use_cuda:
src_tup = src_tup.cuda()
src_lens = src_lens.cuda()
f_vals = f_vals.cuda()
dhidden, latent_values = model(src_tup,
src_lens,
f_vals=f_vals,
encode_only=True)
# Latent and hidden have been initialized with the first tuple
for tup in vars_iter:
## INIT FEED AND DECODE before every sentence.
if use_cuda:
model.decoder.init_feed_(
Variable(torch.zeros(1, model.decoder.attn_dim).cuda()))
else:
model.decoder.init_feed_(
Variable(torch.zeros(1, model.decoder.attn_dim)))
next_tup = next(vars_iter)
if use_cuda:
_, _, _, dec_outputs = model.train(tup[0].cuda(), 1, dhidden,
latent_values, [])
else:
_, _, _, dec_outputs = model.train(tup[0], 1, dhidden,
latent_values, [])
logits = model.logits.transpose(
0, 1).contiguous() # convert to [batch, seq, vocab]
tup_0_meaning = [
vocab.itos[int(item.numpy())] for item in tup[0].cpu().data[0]
]
next_tup_meaning = [
vocab.itos[int(item.numpy())]
for item in next_tup[0].cpu().data[0]
]
nll = masked_cross_entropy(logits, next_tup[0].cuda(),
Variable(next_tup[1]).cuda())
pp = torch.exp(nll)
pps.append(pp.data.cpu().numpy())
assert len(pps) == 6, "6 targets."
all_texts_str = [
transform(text[0].data.numpy()[0], vocab.itos)
for text in all_texts_vars
]
min_index = np.argmin(pps)
if min_index == 0:
ranked_acc += 1
if (iteration + 1) == args.max_decode:
print("Max decode reached. Exiting.")
break
ranked_acc /= (iteration + 1) * 1 / 100 # multiplying to get percent
print("Average acc(%): {}".format(ranked_acc))
return ranked_acc
