docstr: Args
      src_tokens: padded tensor (B, T, C * feat)
      src_lengths: tensor of original lengths of input utterances (B,)
docstr_tok: ["Args","src_tokens",":","padded","tensor","(","B",",","T",",","C","*","feat",")","src_lengths",":","tensor","of","original","lengths","of","input","utterances","(","B",",",")"]
code: def forward(self, src_tokens, src_lengths=None, **kwargs):
      """
      Args
          src_tokens: padded tensor (B, T, C * feat)
          src_lengths: tensor of original lengths of input utterances (B,)
      """
      bsz, max_seq_len, _ = src_tokens.size()
      # (B, C, T, feat)
      x = (
          src_tokens.view(
              bsz, max_seq_len, self.in_channels, self.input_dim
          )
          .transpose(1, 2)
          .contiguous()
      )
  
      for input_layer in self.input_layers:
          x = input_layer(x)
          x = torch.tanh(x)
  
      for conv_layer in self.conv_layers:
          x = conv_layer(x)
  
      bsz, _, output_seq_len, _ = x.size()
  
      # (B, C, T, feat) -> (B, T, C, feat) -> (T, B, C, feat) ->
      # (T, B, C * feat)
      x = (
          x.transpose(1, 2)
          .transpose(0, 1)
          .contiguous()
          .view(output_seq_len, bsz, -1)
      )
  
      input_lengths = src_lengths.clone()
      for k, s in self.conv_kernel_sizes_and_strides:
          p = k // 2
          input_lengths = (input_lengths.float() + 2 * p - k) / s + 1
          input_lengths = input_lengths.floor().long()
  
      packed_x = nn.utils.rnn.pack_padded_sequence(x, input_lengths)
  
      h0 = x.new(2 * self.num_blstm_layers, bsz, self.lstm_size).zero_()
      c0 = x.new(2 * self.num_blstm_layers, bsz, self.lstm_size).zero_()
      packed_outs, _ = self.lstm(packed_x, (h0, c0))
  
      # unpack outputs and apply dropout
      x, output_lengths = nn.utils.rnn.pad_packed_sequence(packed_outs)
      if self.dropout is not None:
          x = self.dropout(x)
  
      encoder_padding_mask = (
          lengths_to_padding_mask(output_lengths)
          .to(src_tokens.device)
          .t()
      )
  
      return {
          "encoder_out": x,  # (T, B, C)
          "encoder_padding_mask": encoder_padding_mask,  # (T, B)
      }
  
imports: from ast import literal_eval
  from typing import List, Tuple
  import torch
  import torch.nn
  import torch.nn.functional
  from fairseq import checkpoint_utils, utils
  from fairseq.data.data_utils import lengths_to_padding_mask
  from fairseq.models import FairseqEncoder, FairseqEncoderDecoderModel, FairseqIncrementalDecoder, register_model, register_model_architecture
label_desc: Use image node_id 2 for calling the BerardEncoder obj's underlying member method code with example usage: obj.forward(src_tokens, src_lengths) and returns: dict