code: def forward(self,  # pylint: disable=arguments-differ
                  inputs: PackedSequence,
                  initial_state: Optional[Tuple[torch.Tensor, torch.Tensor]] = None) -> \
              Tuple[Union[torch.Tensor, PackedSequence], Tuple[torch.Tensor, torch.Tensor]]:
          
          if not initial_state:
              hidden_states = [None] * len(self.lstm_layers)
          elif initial_state[0].size()[0] != len(self.lstm_layers):
              raise ConfigurationError("Initial states were passed to forward() but the number of "
                                       "initial states does not match the number of layers.")
          else:
              hidden_states = list(zip(initial_state[0].split(1, 0),
                                       initial_state[1].split(1, 0)))
  
          output_sequence = inputs
          final_states = []
          for i, state in enumerate(hidden_states):
              layer = getattr(self, 'layer_{}'.format(i))
              # The state is duplicated to mirror the Pytorch API for LSTMs.
              output_sequence, final_state = layer(output_sequence, state)
              final_states.append(final_state)
  
          final_hidden_state, final_cell_state = tuple(torch.cat(state_list, 0) for state_list in zip(*final_states))
          return output_sequence, (final_hidden_state, final_cell_state)
docs: Parameters
          ----------
          inputs : ``PackedSequence``, required.
              A batch first ``PackedSequence`` to run the stacked LSTM over.
          initial_state : Tuple[torch.Tensor, torch.Tensor], optional, (default = None)
              A tuple (state, memory) representing the initial hidden state and memory
              of the LSTM. Each tensor has shape (1, batch_size, output_dimension).
  
          Returns
          -------
          output_sequence : PackedSequence
              The encoded sequence of shape (batch_size, sequence_length, hidden_size)
          final_states: Tuple[torch.Tensor, torch.Tensor]
              The per-layer final (state, memory) states of the LSTM, each with shape
              (num_layers, batch_size, hidden_size).