docstr: Forward function for `Transformer`.
  
  Args:
      mlvl_feats (list(Tensor)): Input queries from
          different level. Each element has shape
          [bs, embed_dims, h, w].
      mlvl_masks (list(Tensor)): The key_padding_mask from
          different level used for encoder and decoder,
          each element has shape  [bs, h, w].
      query_embed (Tensor): The query embedding for decoder,
          with shape [num_query, c].
      mlvl_pos_embeds (list(Tensor)): The positional encoding
          of feats from different level, has the shape
           [bs, embed_dims, h, w].
      reg_branches (obj:`nn.ModuleList`): Regression heads for
          feature maps from each decoder layer. Only would
          be passed when
          `with_box_refine` is True. Default to None.
      cls_branches (obj:`nn.ModuleList`): Classification heads
          for feature maps from each decoder layer. Only would
           be passed when `as_two_stage`
           is True. Default to None.
  
  
  Returns:
      tuple[Tensor]: results of decoder containing the following tensor.
  
          - inter_states: Outputs from decoder. If
              return_intermediate_dec is True output has shape                       (num_dec_layers, bs, num_query, embed_dims), else has                       shape (1, bs, num_query, embed_dims).
          - init_reference_out: The initial value of reference                     points, has shape (bs, num_queries, 4).
          - inter_references_out: The internal value of reference                     points in decoder, has shape                     (num_dec_layers, bs,num_query, embed_dims)
          - enc_outputs_class: The classification score of                     proposals generated from                     encoder's feature maps, has shape                     (batch, h*w, num_classes).                     Only would be returned when `as_two_stage` is True,                     otherwise None.
          - enc_outputs_coord_unact: The regression results                     generated from encoder's feature maps., has shape                     (batch, h*w, 4). Only would                     be returned when `as_two_stage` is True,                     otherwise None.
code: def forward(
      self,
      mlvl_feats,
      mlvl_masks,
      query_embed,
      mlvl_pos_embeds,
      reg_branches=None,
      cls_branches=None,
      return_encoder_output=False,
      attn_masks=None,
      **kwargs,
  ):
      """Forward function for `Transformer`.
  
          Args:
              mlvl_feats (list(Tensor)): Input queries from
                  different level. Each element has shape
                  [bs, embed_dims, h, w].
              mlvl_masks (list(Tensor)): The key_padding_mask from
                  different level used for encoder and decoder,
                  each element has shape  [bs, h, w].
              query_embed (Tensor): The query embedding for decoder,
                  with shape [num_query, c].
              mlvl_pos_embeds (list(Tensor)): The positional encoding
                  of feats from different level, has the shape
                   [bs, embed_dims, h, w].
              reg_branches (obj:`nn.ModuleList`): Regression heads for
                  feature maps from each decoder layer. Only would
                  be passed when
                  `with_box_refine` is True. Default to None.
              cls_branches (obj:`nn.ModuleList`): Classification heads
                  for feature maps from each decoder layer. Only would
                   be passed when `as_two_stage`
                   is True. Default to None.
  
  
          Returns:
              tuple[Tensor]: results of decoder containing the following tensor.
  
                  - inter_states: Outputs from decoder. If
                      return_intermediate_dec is True output has shape \
                        (num_dec_layers, bs, num_query, embed_dims), else has \
                        shape (1, bs, num_query, embed_dims).
                  - init_reference_out: The initial value of reference \
                      points, has shape (bs, num_queries, 4).
                  - inter_references_out: The internal value of reference \
                      points in decoder, has shape \
                      (num_dec_layers, bs,num_query, embed_dims)
                  - enc_outputs_class: The classification score of \
                      proposals generated from \
                      encoder's feature maps, has shape \
                      (batch, h*w, num_classes). \
                      Only would be returned when `as_two_stage` is True, \
                      otherwise None.
                  - enc_outputs_coord_unact: The regression results \
                      generated from encoder's feature maps., has shape \
                      (batch, h*w, 4). Only would \
                      be returned when `as_two_stage` is True, \
                      otherwise None.
          """
      assert self.as_two_stage or query_embed is not None
  
      feat_flatten = []
      mask_flatten = []
      lvl_pos_embed_flatten = []
      spatial_shapes = []
      for lvl, (feat, mask, pos_embed) in enumerate(
          zip(mlvl_feats, mlvl_masks, mlvl_pos_embeds)
      ):
          bs, c, h, w = feat.shape
          spatial_shape = (h, w)
          spatial_shapes.append(spatial_shape)
          feat = feat.flatten(2).transpose(1, 2)
          mask = mask.flatten(1)
          pos_embed = pos_embed.flatten(2).transpose(1, 2)
          lvl_pos_embed = pos_embed + self.level_embeds[lvl].view(
              1, 1, -1
          )
          lvl_pos_embed_flatten.append(lvl_pos_embed)
          feat_flatten.append(feat)
          mask_flatten.append(mask)
      feat_flatten = torch.cat(feat_flatten, 1)
      mask_flatten = torch.cat(mask_flatten, 1)
      lvl_pos_embed_flatten = torch.cat(lvl_pos_embed_flatten, 1)
      spatial_shapes = torch.as_tensor(
          spatial_shapes, dtype=torch.long, device=feat_flatten.device
      )
      level_start_index = torch.cat(
          (
              spatial_shapes.new_zeros((1,)),
              spatial_shapes.prod(1).cumsum(0)[:-1],
          )
      )
      valid_ratios = torch.stack(
          [self.get_valid_ratio(m) for m in mlvl_masks], 1
      )
  
      reference_points = self.get_reference_points(
          spatial_shapes, valid_ratios, device=feat.device
      )
  
      feat_flatten = feat_flatten.permute(
          1, 0, 2
      )  # (H*W, bs, embed_dims)
      lvl_pos_embed_flatten = lvl_pos_embed_flatten.permute(
          1, 0, 2
      )  # (H*W, bs, embed_dims)
      memory = self.encoder(
          query=feat_flatten,
          key=None,
          value=None,
          query_pos=lvl_pos_embed_flatten,
          query_key_padding_mask=mask_flatten,
          spatial_shapes=spatial_shapes,
          reference_points=reference_points,
          level_start_index=level_start_index,
          valid_ratios=valid_ratios,
          **kwargs,
      )
  
      memory = memory.permute(1, 0, 2)
      bs, _, c = memory.shape
      if self.as_two_stage:
          (
              output_memory,
              output_proposals,
          ) = self.gen_encoder_output_proposals(
              memory, mask_flatten, spatial_shapes
          )
          enc_outputs_class = cls_branches[self.decoder.num_layers](
              output_memory
          )
          enc_outputs_coord_unact = (
              reg_branches[self.decoder.num_layers](output_memory)
              + output_proposals
          )
  
          topk = self.two_stage_num_proposals
          topk = query_embed.shape[0]
          topk_proposals = torch.topk(
              enc_outputs_class[..., 0], topk, dim=1
          )[1]
          topk_coords_unact = torch.gather(
              enc_outputs_coord_unact,
              1,
              topk_proposals.unsqueeze(-1).repeat(1, 1, 4),
          )
          topk_coords_unact = topk_coords_unact.detach()
          reference_points = topk_coords_unact.sigmoid()
          init_reference_out = reference_points
          pos_trans_out = self.pos_trans_norm(
              self.pos_trans(
                  self.get_proposal_pos_embed(topk_coords_unact)
              )
          )
  
          if not self.mixed_selection:
              query_pos, query = torch.split(pos_trans_out, c, dim=2)
          else:
              # query_embed here is the content embed for deformable DETR
              query = query_embed.unsqueeze(0).expand(bs, -1, -1)
              query_pos, _ = torch.split(pos_trans_out, c, dim=2)
      else:
          query_pos, query = torch.split(query_embed, c, dim=1)
          query_pos = query_pos.unsqueeze(0).expand(bs, -1, -1)
          query = query.unsqueeze(0).expand(bs, -1, -1)
          reference_points = self.reference_points(query_pos).sigmoid()
          init_reference_out = reference_points
  
      # decoder
      query = query.permute(1, 0, 2)
      memory = memory.permute(1, 0, 2)
      query_pos = query_pos.permute(1, 0, 2)
      inter_states, inter_references = self.decoder(
          query=query,
          key=None,
          value=memory,
          query_pos=query_pos,
          key_padding_mask=mask_flatten,
          reference_points=reference_points,
          spatial_shapes=spatial_shapes,
          level_start_index=level_start_index,
          valid_ratios=valid_ratios,
          reg_branches=reg_branches,
          attn_masks=attn_masks,
          **kwargs,
      )
  
      inter_references_out = inter_references
      if self.as_two_stage:
          if return_encoder_output:
              return (
                  inter_states,
                  init_reference_out,
                  inter_references_out,
                  enc_outputs_class,
                  enc_outputs_coord_unact,
                  memory,
              )
          return (
              inter_states,
              init_reference_out,
              inter_references_out,
              enc_outputs_class,
              enc_outputs_coord_unact,
          )
      if return_encoder_output:
          return (
              inter_states,
              init_reference_out,
              inter_references_out,
              None,
              None,
              memory,
          )
      return (
          inter_states,
          init_reference_out,
          inter_references_out,
          None,
          None,
      )
  
imports: import math
  import warnings
  import torch
  import torch.nn
  from mmcv.cnn import build_norm_layer
  from mmcv.cnn.bricks.transformer import BaseTransformerLayer, TransformerLayerSequence, build_transformer_layer_sequence
  from mmcv.ops import MultiScaleDeformableAttention
  from mmengine.model import BaseModule
  from mmengine.model.weight_init import xavier_init
  from torch.nn.init import normal_
  from mmdet.models.layers.transformer import inverse_sigmoid
  from mmdet.registry import MODELS
label_desc: Use image node_id 4 for calling the CoDeformableDetrTransformer obj's underlying member method code with example usage: obj.forward(mlvl_feats, mlvl_masks, query_embed, mlvl_pos_embeds, reg_branches, cls_branches, return_encoder_output, attn_masks) and returns: inter_states,  init_reference_out,  inter_references_out,  None,  None, inter_states,  init_reference_out,  inter_references_out,  enc_outputs_class,  enc_outputs_coord_unact, inter_states,  init_reference_out,  inter_references_out,  None,  None,  memory, inter_states,  init_reference_out,  inter_references_out,  enc_outputs_class,  enc_outputs_coord_unact,  memory