code: def forward(self, inputs, begin_state=None): # pylint: disable=arguments-differ
          
          encoded = self.embedding(inputs)
          if begin_state is None:
              begin_state = self.begin_state(batch_size=inputs.shape[1])
          out_states = []
          for i, (e, s) in enumerate(zip(self.encoder, begin_state)):
              encoded, state = e(encoded, s)
              out_states.append(state)
              if self._drop_h and i != len(self.encoder)-1:
                  encoded = nd.Dropout(encoded, p=self._drop_h, axes=(0,))
          if self._dropout:
              encoded = nd.Dropout(encoded, p=self._dropout, axes=(0,))
          with autograd.predict_mode():
              out = self.decoder(encoded)
          return out, out_states
docs: Implement forward computation.
  
          Parameters
          -----------
          inputs : NDArray
              input tensor with shape `(sequence_length, batch_size)`
              when `layout` is "TNC".
          begin_state : list
              initial recurrent state tensor with length equals to num_layers.
              the initial state with shape `(1, batch_size, num_hidden)`
  
          Returns
          --------
          out: NDArray
              output tensor with shape `(sequence_length, batch_size, input_size)`
              when `layout` is "TNC".
          out_states: list
              output recurrent state tensor with length equals to num_layers.
              the state with shape `(1, batch_size, num_hidden)`