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 = 32,
      hidden_init_method: str = "default",
      hidden_blocks: int = 2,
  ):
      super().__init__()
  
      self._hidden_steps = hidden_steps
      self._hidden_init_method = hidden_init_method
      self._hidden_blocks = hidden_blocks
  
      if self._hidden_init_method == "default":
          self._hidden_init_method = "params"
  
      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,
              )
          )
  
      diagonal = 0 if mask_future else None
  
      if self.hidden_init_method == "params":
          # learnable initial hidden values
          self.init_hidden = torch.nn.Parameter(
              torch.nn.init.xavier_normal_(
                  torch.empty(hidden_steps, hidden_size)
              )
          )
          self.init_cross_att = TransformerDecoder(
              num_layers=1,
              hidden_size=hidden_size,
              inner_size=inner_size,
              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.init_cross_att.diagonal = diagonal
      elif self.hidden_init_method == "bridge":
          # initialize latent with attention bridge
          self.att_bridge = AttentionBridge(
              hidden_size=hidden_size,
              k=hidden_steps,
              bridge_size=inner_size,
          )
  
      # cross-attention encoder
      layer = TransformerDecoder(
          num_layers=1,
          hidden_size=hidden_size,
          inner_size=inner_size,
          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,
      )
      layer.diagonal = diagonal
      self.cross_att_layers = torch.nn.ModuleList(
          [copy.deepcopy(layer) for _ in range(hidden_blocks)]
      )
  
      # 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)]
      )
  
file_path: NeMo/nemo/collections/nlp/modules/common/transformer/perceiver_encoders.py
imports: import copy
  import torch
  from nemo.collections.nlp.modules.common.transformer.transformer_decoders import TransformerDecoder
  from nemo.collections.nlp.modules.common.transformer.transformer_encoders import TransformerEncoder
  from nemo.collections.nlp.modules.common.transformer.transformer_modules import AttentionBridge
label_desc: Use image node_id 1 to create a new PerceiverEncoder object from inherited base classes: torch.nn with example: obj = PerceiverEncoder(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)