class_docstr: VGG + Transformer encoder
class_docstr_tok: ["VGG","+","Transformer","encoder"]
docstr: constructor for VGGTransformerEncoder
  
  Args:
      - input_feat_per_channel: feature dim (not including stacked,
        just base feature)
      - in_channel: # input channels (e.g., if stack 8 feature vector
          together, this is 8)
      - vggblock_config: configuration of vggblock, see comments on
          DEFAULT_ENC_VGGBLOCK_CONFIG
      - transformer_config: configuration of transformer layer, see comments
          on DEFAULT_ENC_TRANSFORMER_CONFIG
      - encoder_output_dim: final transformer output embedding dimension
      - transformer_context: (left, right) if set, self-attention will be focused
        on (t-left, t+right)
      - transformer_sampling: an iterable of int, must match with
        len(transformer_config), transformer_sampling[i] indicates sampling
        factor for i-th transformer layer, after multihead att and feedfoward
        part
docstr_tok: ["constructor","for","VGGTransformerEncoder","Args",":","-","input_feat_per_channel",":","feature","dim","(","not","including","stacked",",","just","base","feature",")","-","in_channel",":","#","input","channels","(","e.g.",",","if","stack","8","feature","vector","together",",","this","is","8",")","-","vggblock_config",":","configuration","of","vggblock",",","see","comments","on","DEFAULT_ENC_VGGBLOCK_CONFIG","-","transformer_config",":","configuration","of","transformer","layer",",","see","comments","on","DEFAULT_ENC_TRANSFORMER_CONFIG","-","encoder_output_dim",":","final","transformer","output","embedding","dimension","-","transformer_context",":","(","left",",","right",")","if","set",",","self-attention","will","be","focused","on","(","t-left",",","t+right",")","-","transformer_sampling",":","an","iterable","of","int",",","must","match","with","len","(","transformer_config",")",",","transformer_sampling","[","i","]","indicates","sampling","factor","for","i-th","transformer","layer",",","after","multihead","att","and","feedfoward","part"]
code: def __init__(
      self,
      input_feat_per_channel,
      vggblock_config=DEFAULT_ENC_VGGBLOCK_CONFIG,
      transformer_config=DEFAULT_ENC_TRANSFORMER_CONFIG,
      encoder_output_dim=512,
      in_channels=1,
      transformer_context=None,
      transformer_sampling=None,
  ):
      """constructor for VGGTransformerEncoder
  
      Args:
          - input_feat_per_channel: feature dim (not including stacked,
            just base feature)
          - in_channel: # input channels (e.g., if stack 8 feature vector
              together, this is 8)
          - vggblock_config: configuration of vggblock, see comments on
              DEFAULT_ENC_VGGBLOCK_CONFIG
          - transformer_config: configuration of transformer layer, see comments
              on DEFAULT_ENC_TRANSFORMER_CONFIG
          - encoder_output_dim: final transformer output embedding dimension
          - transformer_context: (left, right) if set, self-attention will be focused
            on (t-left, t+right)
          - transformer_sampling: an iterable of int, must match with
            len(transformer_config), transformer_sampling[i] indicates sampling
            factor for i-th transformer layer, after multihead att and feedfoward
            part
      """
      super().__init__(None)
  
      self.num_vggblocks = 0
      if vggblock_config is not None:
          if not isinstance(vggblock_config, Iterable):
              raise ValueError("vggblock_config is not iterable")
          self.num_vggblocks = len(vggblock_config)
  
      self.conv_layers = nn.ModuleList()
      self.in_channels = in_channels
      self.input_dim = input_feat_per_channel
      self.pooling_kernel_sizes = []
  
      if vggblock_config is not None:
          for _, config in enumerate(vggblock_config):
              (
                  out_channels,
                  conv_kernel_size,
                  pooling_kernel_size,
                  num_conv_layers,
                  layer_norm,
              ) = config
              self.conv_layers.append(
                  VGGBlock(
                      in_channels,
                      out_channels,
                      conv_kernel_size,
                      pooling_kernel_size,
                      num_conv_layers,
                      input_dim=input_feat_per_channel,
                      layer_norm=layer_norm,
                  )
              )
              self.pooling_kernel_sizes.append(pooling_kernel_size)
              in_channels = out_channels
              input_feat_per_channel = self.conv_layers[-1].output_dim
  
      transformer_input_dim = self.infer_conv_output_dim(
          self.in_channels, self.input_dim
      )
      # transformer_input_dim is the output dimension of VGG part
  
      self.validate_transformer_config(transformer_config)
      self.transformer_context = self.parse_transformer_context(
          transformer_context
      )
      self.transformer_sampling = self.parse_transformer_sampling(
          transformer_sampling, len(transformer_config)
      )
  
      self.transformer_layers = nn.ModuleList()
  
      if transformer_input_dim != transformer_config[0][0]:
          self.transformer_layers.append(
              Linear(transformer_input_dim, transformer_config[0][0])
          )
      self.transformer_layers.append(
          TransformerEncoderLayer(
              prepare_transformer_encoder_params(*transformer_config[0])
          )
      )
  
      for i in range(1, len(transformer_config)):
          if transformer_config[i - 1][0] != transformer_config[i][0]:
              self.transformer_layers.append(
                  Linear(
                      transformer_config[i - 1][0],
                      transformer_config[i][0],
                  )
              )
          self.transformer_layers.append(
              TransformerEncoderLayer(
                  prepare_transformer_encoder_params(
                      *transformer_config[i]
                  )
              )
          )
  
      self.encoder_output_dim = encoder_output_dim
      self.transformer_layers.extend(
          [
              Linear(transformer_config[-1][0], encoder_output_dim),
              LayerNorm(encoder_output_dim),
          ]
      )
  
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 1 to create a new VGGTransformerEncoder object from inherited base classes: FairseqEncoder with example: obj = VGGTransformerEncoder(input_feat_per_channel, vggblock_config, transformer_config, encoder_output_dim, in_channels, transformer_context, transformer_sampling)