class_docstr: VGG + Transformer encoder
class_docstr_tok: ["VGG","+","Transformer","encoder"]
docstr: src_tokens: padded tensor (B, T, C * feat)
  src_lengths: tensor of original lengths of input utterances (B,)
docstr_tok: ["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, **kwargs):
      """
      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()
      x = src_tokens.view(
          bsz, max_seq_len, self.in_channels, self.input_dim
      )
      x = x.transpose(1, 2).contiguous()
      # (B, C, T, feat)
  
      for layer_idx in range(len(self.conv_layers)):
          x = self.conv_layers[layer_idx](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)
      x = x.contiguous().view(output_seq_len, bsz, -1)
  
      input_lengths = src_lengths.clone()
      for s in self.pooling_kernel_sizes:
          input_lengths = (input_lengths.float() / s).ceil().long()
  
      encoder_padding_mask, _ = lengths_to_encoder_padding_mask(
          input_lengths, batch_first=True
      )
      if not encoder_padding_mask.any():
          encoder_padding_mask = None
  
      subsampling_factor = int(max_seq_len * 1.0 / output_seq_len + 0.5)
      attn_mask = self.lengths_to_attn_mask(
          input_lengths, subsampling_factor
      )
  
      transformer_layer_idx = 0
  
      for layer_idx in range(len(self.transformer_layers)):
          if isinstance(
              self.transformer_layers[layer_idx],
              TransformerEncoderLayer,
          ):
              x = self.transformer_layers[layer_idx](
                  x, encoder_padding_mask, attn_mask
              )
  
              if self.transformer_sampling[transformer_layer_idx] != 1:
                  sampling_factor = self.transformer_sampling[
                      transformer_layer_idx
                  ]
                  x, encoder_padding_mask, attn_mask = self.slice(
                      x,
                      encoder_padding_mask,
                      attn_mask,
                      sampling_factor,
                  )
  
              transformer_layer_idx += 1
  
          else:
              x = self.transformer_layers[layer_idx](x)
  
      # encoder_padding_maks is a (T x B) tensor, its [t, b] elements indicate
      # whether encoder_output[t, b] is valid or not (valid=0, invalid=1)
  
      return {
          "encoder_out": x,  # (T, B, C)
          "encoder_padding_mask": encoder_padding_mask.t()
          if encoder_padding_mask is not None
          else None,
          # (B, T) --> (T, B)
      }
  
imports: import argparse
  import math
  from collections.abc import Iterable
  import torch
  import torch.nn
  from examples.speech_recognition.data.data_utils import lengths_to_encoder_padding_mask
  from fairseq import utils
  from fairseq.models import FairseqEncoder, FairseqEncoderDecoderModel, FairseqEncoderModel, FairseqIncrementalDecoder, register_model, register_model_architecture
  from fairseq.modules import LinearizedConvolution, TransformerDecoderLayer, TransformerEncoderLayer, VGGBlock
label_desc: Use image node_id 2 for calling the VGGTransformerEncoder obj's underlying member method code with example usage: obj.forward(src_tokens, src_lengths) and returns: dict