def translate(self):
device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
model = Model(self.config).to(device)
self.logger.info('Restore model from {}'.format(self.model_file))
model.load_state_dict(torch.load(self.model_file))
model.eval()
best_trans_file = self.input_file + '.best_trans'
beam_trans_file = self.input_file + '.beam_trans'
open(best_trans_file, 'w').close()
open(beam_trans_file, 'w').close()
num_sents = 0
with open(self.input_file, 'r') as f:
for line in f:
if line.strip():
num_sents += 1
all_best_trans = [''] * num_sents
all_beam_trans = [''] * num_sents
with torch.no_grad():
self.logger.info('Start translating {}'.format(self.input_file))
start = time.time()
count = 0
for (src_toks, original_idxs) in self.data_manager.get_trans_input(
self.input_file):
src_toks_cuda = src_toks.to(device)
rets = model.beam_decode(src_toks_cuda)
for i, ret in enumerate(rets):
probs = ret['probs'].cpu().detach().numpy().reshape([-1])
scores = ret['scores'].cpu().detach().numpy().reshape([-1])
symbols = ret['symbols'].cpu().detach().numpy()
best_trans, best_trans_ids, beam_trans = self.get_trans(
probs, scores, symbols)
all_best_trans[original_idxs[i]] = best_trans + '\n'
all_beam_trans[original_idxs[i]] = beam_trans + '\n\n'
count += 1
if count % 100 == 0:
self.logger.info(
' Translating line {}, average {} seconds/sent'.
format(count, (time.time() - start) / count))
model.train()
with open(best_trans_file, 'w') as ftrans, open(beam_trans_file,
'w') as btrans:
ftrans.write(''.join(all_best_trans))
btrans.write(''.join(all_beam_trans))
self.logger.info('Done translating {}, it takes {} minutes'.format(
self.input_file,
float(time.time() - start) / 60.0))
def validate_on_data(model: Model, data: Dataset,
batch_size: int,
use_cuda: bool, max_output_length: int,
level: str, eval_metric: Optional[str],
loss_function: torch.nn.Module = None,
beam_size: int = 0, beam_alpha: int = -1,
batch_type: str = "sentence"
) \
-> (float, float, float, List[str], List[List[str]], List[str],
List[str], List[List[str]], List[np.array]):
"""
Generate translations for the given data.
If `loss_function` is not None and references are given,
also compute the loss.
:param model: model module
:param data: dataset for validation
:param batch_size: validation batch size
:param use_cuda: if True, use CUDA
:param max_output_length: maximum length for generated hypotheses
:param level: segmentation level, one of "char", "bpe", "word"
:param eval_metric: evaluation metric, e.g. "bleu"
:param loss_function: loss function that computes a scalar loss
for given inputs and targets
:param beam_size: beam size for validation.
If 0 then greedy decoding (default).
:param beam_alpha: beam search alpha for length penalty,
disabled if set to -1 (default).
:param batch_type: validation batch type (sentence or token)
:return:
- current_valid_score: current validation score [eval_metric],
- valid_loss: validation loss,
- valid_ppl:, validation perplexity,
- valid_sources: validation sources,
- valid_sources_raw: raw validation sources (before post-processing),
- valid_references: validation references,
- valid_hypotheses: validation_hypotheses,
- decoded_valid: raw validation hypotheses (before post-processing),
- valid_attention_scores: attention scores for validation hypotheses
"""
valid_iter = make_data_iter(dataset=data,
batch_size=batch_size,
batch_type=batch_type,
shuffle=False,
train=False)
valid_sources_raw = [s for s in data.src]
pad_index = model.src_vocab.stoi[PAD_TOKEN]
# disable dropout
model.eval()
# don't track gradients during validation
with torch.no_grad():
all_outputs = []
valid_attention_scores = []
total_loss = 0
total_ntokens = 0
total_nseqs = 0
for valid_batch in iter(valid_iter):
# run as during training to get validation loss (e.g. xent)
batch = Batch(valid_batch, pad_index, use_cuda=use_cuda)
# sort batch now by src length and keep track of order
sort_reverse_index = batch.sort_by_src_lengths()
# run as during training with teacher forcing
if loss_function is not None and batch.trg is not None:
batch_loss = model.get_loss_for_batch(
batch, loss_function=loss_function)
total_loss += batch_loss
total_ntokens += batch.ntokens
total_nseqs += batch.nseqs
# run as during inference to produce translations
output, attention_scores = model.run_batch(
batch=batch,
beam_size=beam_size,
beam_alpha=beam_alpha,
max_output_length=max_output_length)
# sort outputs back to original order
all_outputs.extend(output[sort_reverse_index])
valid_attention_scores.extend(
attention_scores[sort_reverse_index]
if attention_scores is not None else [])
assert len(all_outputs) == len(data)
if loss_function is not None and total_ntokens > 0:
# total validation loss
valid_loss = total_loss
# exponent of token-level negative log prob
valid_ppl = torch.exp(total_loss / total_ntokens)
else:
valid_loss = -1
valid_ppl = -1
# decode back to symbols
decoded_valid = model.trg_vocab.arrays_to_sentences(arrays=all_outputs,
cut_at_eos=True)
# evaluate with metric on full dataset
join_char = " " if level in ["word", "bpe"] else ""
valid_sources = [join_char.join(s) for s in data.src]
valid_references = [join_char.join(t) for t in data.trg]
valid_hypotheses = [join_char.join(t) for t in decoded_valid]
# post-process
if level == "bpe":
valid_sources = [bpe_postprocess(s) for s in valid_sources]
valid_references = [bpe_postprocess(v) for v in valid_references]
valid_hypotheses = [bpe_postprocess(v) for v in valid_hypotheses]
# if references are given, evaluate against them
if valid_references:
assert len(valid_hypotheses) == len(valid_references)
current_valid_score = 0
if eval_metric.lower() == 'bleu':
# this version does not use any tokenization
current_valid_score = bleu(valid_hypotheses, valid_references)
elif eval_metric.lower() == 'chrf':
current_valid_score = chrf(valid_hypotheses, valid_references)
elif eval_metric.lower() == 'token_accuracy':
current_valid_score = token_accuracy(valid_hypotheses,
valid_references,
level=level)
elif eval_metric.lower() == 'sequence_accuracy':
current_valid_score = sequence_accuracy(
valid_hypotheses, valid_references)
else:
current_valid_score = -1
return current_valid_score, valid_loss, valid_ppl, valid_sources, \
valid_sources_raw, valid_references, valid_hypotheses, \
decoded_valid, valid_attention_scores