class_docstr: LSTM encoder.
docstr: Args:
      src_tokens (LongTensor): tokens in the source language of
          shape `(batch, src_len)`
      src_lengths (LongTensor): lengths of each source sentence of
          shape `(batch)`
      enforce_sorted (bool, optional): if True, `src_tokens` is
          expected to contain sequences sorted by length in a
          decreasing order. If False, this condition is not
          required. Default: True.
docstr_tok: ["Args",":","src_tokens","(","LongTensor",")",":","tokens","in","the","source","language","of","shape","`","(","batch",",","src_len",")","`","src_lengths","(","LongTensor",")",":","lengths","of","each","source","sentence","of","shape","`","(","batch",")","`","enforce_sorted","(","bool",",","optional",")",":","if","True",",","`","src_tokens","`","is","expected","to","contain","sequences","sorted","by","length","in","a","decreasing","order",".","If","False",",","this","condition","is","not","required",".","Default",":","True","."]
code: def forward(
      self,
      src_tokens: Tensor,
      src_lengths: Tensor,
      enforce_sorted: bool = True,
  ):
      """
      Args:
          src_tokens (LongTensor): tokens in the source language of
              shape `(batch, src_len)`
          src_lengths (LongTensor): lengths of each source sentence of
              shape `(batch)`
          enforce_sorted (bool, optional): if True, `src_tokens` is
              expected to contain sequences sorted by length in a
              decreasing order. If False, this condition is not
              required. Default: True.
      """
      if self.left_pad:
          # nn.utils.rnn.pack_padded_sequence requires right-padding;
          # convert left-padding to right-padding
          src_tokens = utils.convert_padding_direction(
              src_tokens,
              torch.zeros_like(src_tokens).fill_(self.padding_idx),
              left_to_right=True,
          )
  
      bsz, seqlen = src_tokens.size()
  
      # embed tokens
      x = self.embed_tokens(src_tokens)
      x = self.dropout_in_module(x)
  
      # B x T x C -> T x B x C
      x = x.transpose(0, 1)
  
      # pack embedded source tokens into a PackedSequence
      packed_x = nn.utils.rnn.pack_padded_sequence(
          x, src_lengths.cpu(), enforce_sorted=enforce_sorted
      )
  
      # apply LSTM
      if self.bidirectional:
          state_size = 2 * self.num_layers, bsz, self.hidden_size
      else:
          state_size = self.num_layers, bsz, self.hidden_size
      h0 = x.new_zeros(*state_size)
      c0 = x.new_zeros(*state_size)
      packed_outs, (final_hiddens, final_cells) = self.lstm(
          packed_x, (h0, c0)
      )
  
      # unpack outputs and apply dropout
      x, _ = nn.utils.rnn.pad_packed_sequence(
          packed_outs, padding_value=self.padding_idx * 1.0
      )
      x = self.dropout_out_module(x)
      assert list(x.size()) == [seqlen, bsz, self.output_units]
  
      if self.bidirectional:
          final_hiddens = self.combine_bidir(final_hiddens, bsz)
          final_cells = self.combine_bidir(final_cells, bsz)
  
      encoder_padding_mask = src_tokens.eq(self.padding_idx).t()
  
      return tuple(
          (
              x,  # seq_len x batch x hidden
              final_hiddens,  # num_layers x batch x num_directions*hidden
              final_cells,  # num_layers x batch x num_directions*hidden
              encoder_padding_mask,  # seq_len x batch
          )
      )
  
imports: from typing import Dict, List, Optional, Tuple
  import torch
  import torch.nn
  import torch.nn.functional
  from fairseq import utils
  from fairseq.models import FairseqEncoder, FairseqEncoderDecoderModel, FairseqIncrementalDecoder, register_model, register_model_architecture
  from fairseq.modules import AdaptiveSoftmax, FairseqDropout
  from torch import Tensor
label_desc: Use image node_id 2 for calling the LSTMEncoder obj's underlying member method code with example usage: obj.forward(src_tokens, src_lengths, enforce_sorted) and returns: tuple