docstr: build LSTM Seq2Seq model
  :param config:
  :return:
docstr_tok: ["build","LSTM","Seq2Seq","model",":","param","config",":",":","return",":"]
code: def _build_train(self, mc=False, **config):
      """
      build LSTM Seq2Seq model
      :param config:
      :return:
      """
      super()._check_config(**config)
      self.metric = config.get("metric", "mean_squared_error")
      self.latent_dim = config.get("latent_dim", 128)
      self.dropout = config.get("dropout", 0.2)
      self.lr = config.get("lr", 0.001)
      # for restore in continuous training
      self.batch_size = config.get("batch_size", 64)
      training = True if mc else None
  
      # Define an input sequence and process it.
      self.encoder_inputs = Input(
          shape=(None, self.feature_num), name="encoder_inputs"
      )
      encoder = LSTM(
          units=self.latent_dim,
          dropout=self.dropout,
          return_state=True,
          name="encoder_lstm",
      )
      encoder_outputs, state_h, state_c = encoder(
          self.encoder_inputs, training=training
      )
      # We discard `encoder_outputs` and only keep the states.
      self.encoder_states = [state_h, state_c]
  
      # Set up the decoder, using `encoder_states` as initial state.
      self.decoder_inputs = Input(
          shape=(None, self.target_col_num), name="decoder_inputs"
      )
      # 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.
      self.decoder_lstm = LSTM(
          self.latent_dim,
          dropout=self.dropout,
          return_sequences=True,
          return_state=True,
          name="decoder_lstm",
      )
      decoder_outputs, _, _ = self.decoder_lstm(
          self.decoder_inputs,
          training=training,
          initial_state=self.encoder_states,
      )
  
      self.decoder_dense = Dense(
          self.target_col_num, name="decoder_dense"
      )
      decoder_outputs = self.decoder_dense(decoder_outputs)
  
      # Define the model that will turn
      # `encoder_input_data` & `decoder_input_data` into `decoder_target_data`
      self.model = Model(
          [self.encoder_inputs, self.decoder_inputs], decoder_outputs
      )
      self.model.compile(
          loss="mse",
          metrics=[self.metric],
          optimizer=keras.optimizers.RMSprop(lr=self.lr),
      )
      return self.model
  
imports: import pickle
  import numpy
  from tensorflow.keras.models import Model
  from tensorflow.keras.layers import Input, LSTM, Dense
  import tensorflow.keras
  from bigdl.orca.automl.model.abstract import BaseModel
  from bigdl.orca.automl.metrics import Evaluator
label_desc: Use image node_id 2 for calling the LSTMSeq2Seq obj's underlying member method code with example usage: obj._build_train(mc) and returns: self