code: def __init__(
      self,
      conv_layers: List[Tuple[int, int, int]],
      dropout: float = 0.0,
      mode: str = "default",
      conv_bias: bool = False,
  ):
      super().__init__()
  
      assert mode in {"default", "layer_norm"}
  
      def block(
          n_in,
          n_out,
          k,
          stride,
          is_layer_norm=False,
          is_group_norm=False,
          conv_bias=False,
      ):
          def make_conv():
              conv = nn.Conv1d(
                  n_in, n_out, k, stride=stride, bias=conv_bias
              )
              nn.init.kaiming_normal_(conv.weight)
              return conv
  
          assert (
              is_layer_norm and is_group_norm
          ) == False, "layer norm and group norm are exclusive"
  
          if is_layer_norm:
              return nn.Sequential(
                  make_conv(),
                  nn.Dropout(p=dropout),
                  nn.Sequential(
                      TransposeLast(),
                      Fp32LayerNorm(dim, elementwise_affine=True),
                      TransposeLast(),
                  ),
                  nn.GELU(),
              )
          elif is_group_norm:
              return nn.Sequential(
                  make_conv(),
                  nn.Dropout(p=dropout),
                  Fp32GroupNorm(dim, dim, affine=True),
                  nn.GELU(),
              )
          else:
              return nn.Sequential(
                  make_conv(), nn.Dropout(p=dropout), nn.GELU()
              )
  
      in_d = 1
      self.conv_layers = nn.ModuleList()
      for i, cl in enumerate(conv_layers):
          assert len(cl) == 3, "invalid conv definition: " + str(cl)
          (dim, k, stride) = cl
  
          self.conv_layers.append(
              block(
                  in_d,
                  dim,
                  k,
                  stride,
                  is_layer_norm=mode == "layer_norm",
                  is_group_norm=mode == "default" and i == 0,
                  conv_bias=conv_bias,
              )
          )
          in_d = dim
  
imports: import math
  from dataclasses import dataclass, field
  from typing import List, Tuple
  import numpy
  import torch
  import torch.nn
  import torch.nn.functional
  from fairseq import utils
  from fairseq.data.data_utils import compute_mask_indices
  from fairseq.dataclass import ChoiceEnum, FairseqDataclass
  from fairseq.distributed import fsdp_wrap
  from fairseq.models import BaseFairseqModel, register_model
  from fairseq.distributed.fully_sharded_data_parallel import FullyShardedDataParallel
  from fairseq.modules import Fp32GroupNorm, Fp32LayerNorm, GradMultiply, GumbelVectorQuantizer, LayerNorm, MultiheadAttention, RelPositionalEncoding, SamePad, TransposeLast
  from fairseq.modules.checkpoint_activations import checkpoint_wrapper
  from fairseq.modules.conformer_layer import ConformerWav2Vec2EncoderLayer
  from fairseq.modules.transformer_sentence_encoder import init_bert_params
  from fairseq.utils import buffered_arange, index_put, is_xla_tensor
  from .utils import pad_to_multiple
label_desc: Use image node_id 1 to create a new ConvFeatureExtractionModel object from inherited base classes: nn with example: obj = ConvFeatureExtractionModel(conv_layers, dropout, mode, conv_bias)