class_docstr: Luong Attention-based Seq2Seq model. Implementation based on https://arxiv.org/pdf/1508.04025.pdf.
  
  Parameters
  ----------
  hidden_size: int
      The hidden size of both encoder and decoder RNN cells
  cell : TensorFlow cell function
      The RNN function cell for your encoder and decoder stack, e.g. tf.keras.layers.GRUCell
  embedding_layer : tl.Layer
      A embedding layer, e.g. tl.layers.Embedding(vocabulary_size=voc_size, embedding_size=emb_dim)
  method : str
      The three alternatives to calculate the attention scores, e.g. "dot", "general" and "concat"
  name : str
      The model name
  
  
  Returns
  -------
      static single layer attention-based Seq2Seq model.
docstr: Inference mode
docstr_tok: ["Inference","mode"]
code: def inference(
      self,
      src_seq,
      encoding_hidden_states,
      last_hidden_states,
      seq_length,
      sos,
  ):
      """Inference mode"""
      """
          Parameters
          ----------
          src_seq : input tensor
              The source sequences 
          encoding_hidden_states : a list of tensor
              The list of encoder's hidden states at each time step
          last_hidden_states: tensor
              The last hidden_state from encoder
          seq_length : int
              The expected length of your predicted sequence.
          sos : int
              <SOS> : The token of "start of sequence"
          """
  
      batch_size = src_seq.shape[0]
      decoding = [[sos] for i in range(batch_size)]
      dec_output = self.embedding_layer(decoding)
      outputs = [[0] for i in range(batch_size)]
      for step in range(seq_length):
          dec_output, last_hidden_states = self.dec_layer(
              dec_output,
              encoding_hidden_states,
              last_hidden_states,
              method=self.method,
              return_last_state=True,
          )
          dec_output = tf.reshape(
              dec_output, [-1, dec_output.shape[-1]]
          )
          dec_output = self.dense_layer(dec_output)
          dec_output = tf.reshape(
              dec_output, [batch_size, -1, dec_output.shape[-1]]
          )
          dec_output = tf.argmax(dec_output, -1)
          outputs = tf.concat([outputs, dec_output], 1)
          dec_output = self.embedding_layer(dec_output)
  
      return outputs[:, 1:]
  
imports: import numpy
  import tensorflow
  import tensorlayer
  from tensorlayer.layers import Dense, Dropout, Input
  from tensorlayer.layers.core import Layer
  from tensorlayer.models import Model
label_desc: Use image node_id 2 for calling the Seq2seqLuongAttention obj's underlying member method code with example usage: obj.inference(src_seq, encoding_hidden_states, last_hidden_states, seq_length, sos) and returns: outputs