def align(self, output=None, align_encoder_id=0, reverse=False, **kwargs):
if len(self.filenames.test) != len(self.extensions):
raise Exception('wrong number of input files')
binary = self.binary and any(self.binary)
paths = self.filenames.test or [None]
lines = utils.read_lines(paths, binary=self.binary)
for line_id, lines in enumerate(lines):
token_ids = [
sentence if vocab is None else
utils.sentence_to_token_ids(sentence, vocab.vocab, character_level=self.character_level.get(ext))
for ext, vocab, sentence in zip(self.extensions, self.vocabs, lines)
]
_, weights = self.seq2seq_model.step(data=[token_ids], align=True, update_model=False)
trg_vocab = self.trg_vocab[0]
trg_token_ids = token_ids[len(self.src_ext)]
trg_tokens = [trg_vocab.reverse[i] if i < len(trg_vocab.reverse) else utils._UNK for i in trg_token_ids]
weights = weights.squeeze()
max_len = weights.shape[1]
if binary:
src_tokens = None
else:
src_tokens = lines[align_encoder_id].split()[:max_len - 1] + [utils._EOS]
trg_tokens = trg_tokens[:weights.shape[0] - 1] + [utils._EOS]
output_file = output and '{}.{}.pdf'.format(output, line_id + 1)
utils.heatmap(src_tokens, trg_tokens, weights, output_file=output_file, reverse=reverse)
def map_to_ids(sentence_tuple):
token_ids = [
sentence if vocab is None else
utils.sentence_to_token_ids(sentence, vocab.vocab, character_level=self.character_level.get(ext))
for ext, vocab, sentence in zip(self.extensions, self.vocabs, sentence_tuple)
]
return token_ids
def map_to_ids(sentence_tuple):
token_ids = [
utils.sentence_to_token_ids(
sentence, vocab.vocab, character_level=char_level)
if vocab is not None else
sentence # when `sentence` is not a sentence but a vector...
for vocab, sentence, char_level in zip(
self.vocabs, sentence_tuple, self.character_level)
]
return token_ids
def align(self, sess, output=None, wav_files=None, **kwargs):
if len(self.src_ext) != 1:
raise NotImplementedError
if len(self.filenames.test) != len(self.extensions):
raise Exception('wrong number of input files')
for line_id, lines in enumerate(
utils.read_lines(self.filenames.test, self.extensions,
self.binary_input)):
token_ids = [
utils.sentence_to_token_ids(
sentence, vocab.vocab, character_level=char_level)
if vocab is not None else sentence for vocab, sentence,
char_level in zip(self.vocabs, lines, self.character_level)
]
_, weights = self.seq2seq_model.step(sess,
data=[token_ids],
forward_only=True,
align=True,
update_model=False)
trg_tokens = [
self.trg_vocab.reverse[i]
if i < len(self.trg_vocab.reverse) else utils._UNK
for i in token_ids[-1]
]
weights = weights.squeeze()[:len(trg_tokens), :len(token_ids[0])].T
max_len = weights.shape[0]
if self.binary_input[0]:
src_tokens = None
else:
src_tokens = lines[0].split()[:max_len]
if wav_files is not None:
wav_file = wav_files[line_id]
else:
wav_file = None
output_file = '{}.{}.svg'.format(output, line_id +
1) if output is not None else None
utils.heatmap(src_tokens,
trg_tokens,
weights.T,
wav_file=wav_file,
output_file=output_file)
def align(self, sess, output=None, align_encoder_id=0, **kwargs):
if self.binary and any(self.binary):
raise NotImplementedError
if len(self.filenames.test) != len(self.extensions):
raise Exception('wrong number of input files')
for line_id, lines in enumerate(utils.read_lines(self.filenames.test)):
token_ids = [
sentence if vocab is None else utils.sentence_to_token_ids(
sentence,
vocab.vocab,
character_level=self.character_level.get(ext)) for ext,
vocab, sentence in zip(self.extensions, self.vocabs, lines)
]
_, weights = self.seq2seq_model.step(sess,
data=[token_ids],
forward_only=True,
align=True,
update_model=False)
trg_vocab = self.trg_vocab[0] # FIXME
trg_token_ids = token_ids[len(self.src_ext)]
trg_tokens = [
trg_vocab.reverse[i]
if i < len(trg_vocab.reverse) else utils._UNK
for i in trg_token_ids
]
weights = weights.squeeze()
max_len = weights.shape[1]
utils.debug(weights)
trg_tokens.append(utils._EOS)
src_tokens = lines[align_encoder_id].split()[:max_len -
1] + [utils._EOS]
output_file = '{}.{}.svg'.format(output, line_id +
1) if output is not None else None
utils.heatmap(src_tokens,
trg_tokens,
weights,
output_file=output_file)
def _decode_sentence(self,
sess,
src_sentences,
beam_size=1,
remove_unk=False):
# TODO: merge this with read_dataset
token_ids = [
utils.sentence_to_token_ids(
sentence, vocab.vocab, character_level=char_level)
if vocab is not None else
sentence # when `sentence` is not a sentence but a vector...
for vocab, sentence, char_level in zip(self.vocabs, src_sentences,
self.character_level)
]
if beam_size <= 1 and not isinstance(sess, list):
trg_token_ids, _ = self.model.greedy_decoding(sess, token_ids)
else:
hypotheses, scores = self.model.beam_search_decoding(
sess, token_ids, beam_size, ngrams=self.ngrams)
trg_token_ids = hypotheses[
0] # first hypothesis is the highest scoring one
# remove EOS symbols from output
if utils.EOS_ID in trg_token_ids:
trg_token_ids = trg_token_ids[:trg_token_ids.index(utils.EOS_ID)]
trg_tokens = [
self.trg_vocab.reverse[i]
if i < len(self.trg_vocab.reverse) else utils._UNK
for i in trg_token_ids
]
if remove_unk:
trg_tokens = [token for token in trg_tokens if token != utils._UNK]
if self.character_level[-1]:
return ''.join(trg_tokens)
else:
return ' '.join(trg_tokens).replace('@@ ',
'') # merge subword units
