Function seq2seq_model

translation/python/translation.py:121–168

Create a Keras model for the seq2seq translation. Args: num_encoder_tokens: Total number of distinct tokens in the inputs to the encoder. num_decoder_tokens: Total number of distinct tokens in the outputs to/from the decoder latent_dim: Number of latent dimensions in the L

(num_encoder_tokens, num_decoder_tokens, latent_dim)

def seq2seq_model(num_encoder_tokens, num_decoder_tokens, latent_dim):
  """Create a Keras model for the seq2seq translation.

  Args:
    num_encoder_tokens: Total number of distinct tokens in the inputs
      to the encoder.
    num_decoder_tokens: Total number of distinct tokens in the outputs
      to/from the decoder
    latent_dim: Number of latent dimensions in the LSTMs.

  Returns:
    encoder_inputs: Instance of `keras.Input`, symbolic tensor as input to
      the encoder LSTM.
    encoder_states: Instance of `keras.Input`, symbolic tensor for output
      states (h and c) from the encoder LSTM.
    decoder_inputs: Instance of `keras.Input`, symbolic tensor as input to
      the decoder LSTM.
    decoder_lstm: `keras.Layer` instance, the decoder LSTM.
    decoder_dense: `keras.Layer` instance, the Dense layer in the decoder.
    model: `keras.Model` instance, the entire translation model that can be
      used in training.
  """
  # Define an input sequence and process it.
  encoder_inputs = Input(shape=(None, num_encoder_tokens))
  encoder = LSTM(latent_dim,
                 return_state=True)
  _, state_h, state_c = encoder(encoder_inputs)
  # We discard `encoder_outputs` and only keep the states.
  encoder_states = [state_h, state_c]

  # Set up the decoder, using `encoder_states` as initial state.
  decoder_inputs = Input(shape=(None, num_decoder_tokens))
  # We set up our decoder to return full output sequences,
  # and to return internal states as well. We don't use the
  # return states in the training model, but we will use them in inference.
  decoder_lstm = LSTM(FLAGS.latent_dim,
                      return_sequences=True,
                      return_state=True)
  decoder_outputs, _, _ = decoder_lstm(decoder_inputs,
                                       initial_state=encoder_states)
  decoder_dense = Dense(num_decoder_tokens, activation='softmax')
  decoder_outputs = decoder_dense(decoder_outputs)

  # Define the model that will turn
  # `encoder_input_data` & `decoder_input_data` into `decoder_target_data`
  model = Model([encoder_inputs, decoder_inputs], decoder_outputs)
  return (encoder_inputs, encoder_states, decoder_inputs, decoder_lstm,
          decoder_dense, model)


def decode_sequence(input_seq,