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