Restore a character-level sequence to sequence model from to generate predictions.

This script loads the s2s.h5 model saved by lstm_seq2seq.py and generates sequences from it. It assumesthat no changes have been made (for example: latent_dim is unchanged,and the input data and model architecture are unchanged).

See lstm_seq2seq.py for more details on themodel architecture and how it is trained.

  1. from __future__ import print_function
  3. from keras.models import Model, load_model
  4. from keras.layers import Input
  5. import numpy as np
  7. batch_size = 64  # Batch size for training.
  8. epochs = 100  # Number of epochs to train for.
  9. latent_dim = 256  # Latent dimensionality of the encoding space.
  10. num_samples = 10000  # Number of samples to train on.
  11. # Path to the data txt file on disk.
  12. data_path = 'fra-eng/fra.txt'
  14. # Vectorize the data.  We use the same approach as the training script.
  15. # NOTE: the data must be identical, in order for the character -> integer
  16. # mappings to be consistent.
  17. # We omit encoding target_texts since they are not needed.
  18. input_texts = []
  19. target_texts = []
  20. input_characters = set()
  21. target_characters = set()
  22. with open(data_path, 'r', encoding='utf-8') as f:
  23.     lines = f.read().split('\n')
  24. for line in lines[: min(num_samples, len(lines) - 1)]:
  25.     input_text, target_text = line.split('\t')
  26.     # We use "tab" as the "start sequence" character
  27.     # for the targets, and "\n" as "end sequence" character.
  28.     target_text = '\t' + target_text + '\n'
  29.     input_texts.append(input_text)
  30.     target_texts.append(target_text)
  31.     for char in input_text:
  32.         if char not in input_characters:
  33.             input_characters.add(char)
  34.     for char in target_text:
  35.         if char not in target_characters:
  36.             target_characters.add(char)
  38. input_characters = sorted(list(input_characters))
  39. target_characters = sorted(list(target_characters))
  40. num_encoder_tokens = len(input_characters)
  41. num_decoder_tokens = len(target_characters)
  42. max_encoder_seq_length = max([len(txt) for txt in input_texts])
  43. max_decoder_seq_length = max([len(txt) for txt in target_texts])
  45. print('Number of samples:', len(input_texts))
  46. print('Number of unique input tokens:', num_encoder_tokens)
  47. print('Number of unique output tokens:', num_decoder_tokens)
  48. print('Max sequence length for inputs:', max_encoder_seq_length)
  49. print('Max sequence length for outputs:', max_decoder_seq_length)
  51. input_token_index = dict(
  52.     [(char, i) for i, char in enumerate(input_characters)])
  53. target_token_index = dict(
  54.     [(char, i) for i, char in enumerate(target_characters)])
  56. encoder_input_data = np.zeros(
  57.     (len(input_texts), max_encoder_seq_length, num_encoder_tokens),
  58.     dtype='float32')
  60. for i, input_text in enumerate(input_texts):
  61.     for t, char in enumerate(input_text):
  62.         encoder_input_data[i, t, input_token_index[char]] = 1.
  64. # Restore the model and construct the encoder and decoder.
  65. model = load_model('s2s.h5')
  67. encoder_inputs = model.input[0]   # input_1
  68. encoder_outputs, state_h_enc, state_c_enc = model.layers[2].output   # lstm_1
  69. encoder_states = [state_h_enc, state_c_enc]
  70. encoder_model = Model(encoder_inputs, encoder_states)
  72. decoder_inputs = model.input[1]   # input_2
  73. decoder_state_input_h = Input(shape=(latent_dim,), name='input_3')
  74. decoder_state_input_c = Input(shape=(latent_dim,), name='input_4')
  75. decoder_states_inputs = [decoder_state_input_h, decoder_state_input_c]
  76. decoder_lstm = model.layers[3]
  77. decoder_outputs, state_h_dec, state_c_dec = decoder_lstm(
  78.     decoder_inputs, initial_state=decoder_states_inputs)
  79. decoder_states = [state_h_dec, state_c_dec]
  80. decoder_dense = model.layers[4]
  81. decoder_outputs = decoder_dense(decoder_outputs)
  82. decoder_model = Model(
  83.     [decoder_inputs] + decoder_states_inputs,
  84.     [decoder_outputs] + decoder_states)
  86. # Reverse-lookup token index to decode sequences back to
  87. # something readable.
  88. reverse_input_char_index = dict(
  89.     (i, char) for char, i in input_token_index.items())
  90. reverse_target_char_index = dict(
  91.     (i, char) for char, i in target_token_index.items())
  94. # Decodes an input sequence.  Future work should support beam search.
  95. def decode_sequence(input_seq):
  96.     # Encode the input as state vectors.
  97.     states_value = encoder_model.predict(input_seq)
  99.     # Generate empty target sequence of length 1.
  100.     target_seq = np.zeros((1, 1, num_decoder_tokens))
  101.     # Populate the first character of target sequence with the start character.
  102.     target_seq[0, 0, target_token_index['\t']] = 1.
  104.     # Sampling loop for a batch of sequences
  105.     # (to simplify, here we assume a batch of size 1).
  106.     stop_condition = False
  107.     decoded_sentence = ''
  108.     while not stop_condition:
  109.         output_tokens, h, c = decoder_model.predict(
  110.             [target_seq] + states_value)
  112.         # Sample a token
  113.         sampled_token_index = np.argmax(output_tokens[0, -1, :])
  114.         sampled_char = reverse_target_char_index[sampled_token_index]
  115.         decoded_sentence += sampled_char
  117.         # Exit condition: either hit max length
  118.         # or find stop character.
  119.         if (sampled_char == '\n' or
  120.            len(decoded_sentence) > max_decoder_seq_length):
  121.             stop_condition = True
  123.         # Update the target sequence (of length 1).
  124.         target_seq = np.zeros((1, 1, num_decoder_tokens))
  125.         target_seq[0, 0, sampled_token_index] = 1.
  127.         # Update states
  128.         states_value = [h, c]
  130.     return decoded_sentence
  133. for seq_index in range(100):
  134.     # Take one sequence (part of the training set)
  135.     # for trying out decoding.
  136.     input_seq = encoder_input_data[seq_index: seq_index + 1]
  137.     decoded_sentence = decode_sequence(input_seq)
  138.     print('-')
  139.     print('Input sentence:', input_texts[seq_index])
  140.     print('Decoded sentence:', decoded_sentence)