code: def __init__(
      self,
      num_layers: int,
      hidden_size: int,
      inner_size: int,
      mask_future: bool = False,
      num_attention_heads: int = 1,
      attn_score_dropout: float = 0.0,
      attn_layer_dropout: float = 0.0,
      ffn_dropout: float = 0.0,
      hidden_act: str = "relu",
      pre_ln: bool = False,
      pre_ln_final_layer_norm: bool = True,
      hidden_steps: int = 4,
      hidden_init_method: str = "default",
      hidden_blocks: int = 2,
      pooling_type: str = "max",
  ):
      super().__init__()
  
      # minimal steps to allow reduction
      self._hidden_steps = hidden_steps
      self._hidden_init_method = hidden_init_method
      self._hidden_blocks = hidden_blocks
      self._pooling_type = pooling_type
  
      if self._hidden_steps < 2:
          raise ValueError(
              "Expected hidden_steps >= 2 but received hidden_steps = {self._hidden_steps}"
          )
  
      if self.hidden_init_method not in self.supported_init_methods:
          raise ValueError(
              "Unknown hidden_init_method = {hidden_init_method}, supported methods are {supported_init_methods}".format(
                  hidden_init_method=self.hidden_init_method,
                  supported_init_methods=self.supported_init_methods,
              )
          )
  
      if self._pooling_type not in self.supported_arch:
          raise ValueError(
              f"Unknown pooling_type = {pooling_type}. Available values = {self.supported_arch}"
          )
  
      # self-attention encoder
      layer = TransformerEncoder(
          num_layers=num_layers,
          hidden_size=hidden_size,
          inner_size=inner_size,
          mask_future=mask_future,
          num_attention_heads=num_attention_heads,
          attn_score_dropout=attn_score_dropout,
          attn_layer_dropout=attn_layer_dropout,
          ffn_dropout=ffn_dropout,
          hidden_act=hidden_act,
          pre_ln=pre_ln,
          pre_ln_final_layer_norm=pre_ln_final_layer_norm,
      )
      self.self_att_layers = torch.nn.ModuleList(
          [copy.deepcopy(layer) for _ in range(hidden_blocks)]
      )
  
      self.pooling = self._build_pooling_module()
  
file_path: NeMo/nemo/collections/asr/modules/transformer/reduction_encoders.py
imports: import copy
  import torch
  from nemo.collections.asr.modules.transformer.transformer_encoders import TransformerEncoder
label_desc: Use image node_id 1 to create a new PoolingEncoder object from inherited base classes: torch.nn with example: obj = PoolingEncoder(num_layers, hidden_size, inner_size, mask_future, num_attention_heads, attn_score_dropout, attn_layer_dropout, ffn_dropout, hidden_act, pre_ln, pre_ln_final_layer_norm, hidden_steps, hidden_init_method, hidden_blocks, pooling_type)