def evaluate(model, input, output):
model.eval()
with torch.no_grad():
correct = 0
result = model(input)
for idx, gt_class in enumerate(output):
pred_class = argmax(result[idx])
gt_class = argmax(gt_class)
if gt_class == pred_class:
correct += 1
return float(correct)
def evaluate_all(model, data):
model.eval()
with torch.no_grad():
# Slowly evaluates sample-by-sample
correct = 0
total = len(data)
for sentence, gt_class in data:
pred_class = argmax(model([sentence]))
gt_class = argmax(gt_class)
if gt_class == pred_class:
correct += 1
return float(correct) / float(total)
def evaluate_all(model, data):
with torch.no_grad():
correct = 0
total = len(data)
input_data = process_input(data)
for sentence, gt_class in input_data:
precheck_sent = Variable(sentence)
pred_class = argmax(model(precheck_sent.unsqueeze(0)))
if gt_class == pred_class:
correct += 1
return float(correct) / float(total)
def _viterbi_decode(self, feats):
backpointers = []
# Initialize the viterbi variables in log space
init_vvars = torch.Tensor(1, self.tagset_size).fill_(-10000.)
init_vvars[0][self.tag_to_ix[START_TAG]] = 0
# forward_var at step i holds the viterbi variables for step i-1
forward_var = init_vvars.cuda() if self.is_cuda else init_vvars
for feat in feats:
next_tag_var = forward_var.view(1, -1).expand(
self.tagset_size, self.tagset_size) + self.transitions
_, bptrs_t = torch.max(next_tag_var, dim=1)
bptrs_t = bptrs_t.squeeze().data.cpu().numpy()
next_tag_var = next_tag_var.data.cpu().numpy()
viterbivars_t = next_tag_var[range(len(bptrs_t)), bptrs_t]
viterbivars_t = torch.FloatTensor(viterbivars_t)
if self.is_cuda:
viterbivars_t = viterbivars_t.cuda()
forward_var = viterbivars_t + feat
backpointers.append(bptrs_t)
# Transition to STOP_TAG
terminal_var = forward_var + self.transitions[self.tag_to_ix[STOP_TAG]]
terminal_var.data[self.tag_to_ix[STOP_TAG]] = -10000.
terminal_var.data[self.tag_to_ix[START_TAG]] = -10000.
best_tag_id = argmax(terminal_var.unsqueeze(0))
path_score = terminal_var[best_tag_id]
# Follow the back pointers to decode the best path.
best_path = [best_tag_id]
for bptrs_t in reversed(backpointers):
best_tag_id = bptrs_t[best_tag_id]
best_path.append(best_tag_id)
# Pop off the start tag (we dont want to return that to the caller)
start = best_path.pop()
assert start == self.tag_to_ix[START_TAG] # Sanity check
best_path.reverse()
return path_score, best_path
def generate(self, input, beam_width=0, k=5000):
with torch.no_grad():
if beam_width == 0: # Eager
decoded, _, _ = self.forward(input)
decoded = decoded.detach().cpu()
result = []
for idx in range(len(decoded)):
token = argmax(decoded[idx])
result.append(token)
if token == SOS_token:
break
return result[::-1]
else: # Beam search
encoder_hidden, mean, logv = self._encode_to_latent(input)
std = torch.exp(0.5 * logv)
z = torch.randn((self.max_length, self.latent_size))
if self.is_cuda:
z = z.cuda()
z = z * std + mean
prev_beam = Beam(beam_width)
prev_beam.add(0., False, [EOS_token], encoder_hidden)
hidden = self.latent2hidden(z)
while True:
curr_beam = Beam(beam_width)
for (prefix_prob, complete), (prefix,
hidden_state) in prev_beam:
if complete:
curr_beam.add(prefix_prob, True, prefix,
hidden_state)
else:
decoder_input = torch.LongTensor([prefix[-1]])
if self.is_cuda:
decoder_input = decoder_input.cuda()
decoder_output, decoder_hidden, decoder_attention = self.decoder(
decoder_input, hidden_state, hidden)
if k == -1:
k = self.vocab_size
topv, topi = decoder_output.topk(k)
topv, topi = topv.squeeze(), topi.squeeze()
for idx, next_prob in enumerate(topv):
next_prob = next_prob.cpu().detach().item()
token = topi[idx].cpu().detach().item()
complete = (token == SOS_token)
# Adding probs because this is actually log probs (from log softmax)
curr_beam.add(prefix_prob + next_prob,
complete, prefix + [token],
decoder_hidden)
(best_prob, best_complete), (best_prefix,
_) = max(curr_beam)
if best_complete or len(best_prefix) - 1 == -1:
print('Found best candidate with probability: %s' %
best_prob)
return best_prefix[1:][::-1]
prev_beam = curr_beam