code: def forward(self, feats, pad_mask=None, gt_meta=None):
      # input projection and embedding
      (
          feat_flatten,
          spatial_shapes,
          level_start_index,
          mask_flatten,
          lvl_pos_embed_flatten,
          valid_ratios,
      ) = self._get_encoder_input(feats, pad_mask)
  
      # encoder
      memory = self.encoder(
          feat_flatten,
          spatial_shapes,
          level_start_index,
          mask_flatten,
          lvl_pos_embed_flatten,
          valid_ratios,
      )
  
      # prepare denoising training
      if self.training:
          (
              denoising_class,
              denoising_bbox,
              attn_mask,
              dn_meta,
          ) = get_contrastive_denoising_training_group(
              gt_meta,
              self.num_classes,
              self.num_queries,
              self.denoising_class_embed.weight,
              self.num_denoising,
              self.label_noise_ratio,
              self.box_noise_scale,
          )
          if self.dual_queries:
              denoising_class_groups = []
              denoising_bbox_groups = []
              attn_mask_groups = []
              dn_meta_groups = []
              for g_id in range(self.dual_groups):
                  (
                      denoising_class_gid,
                      denoising_bbox_gid,
                      attn_mask_gid,
                      dn_meta_gid,
                  ) = get_contrastive_denoising_training_group(
                      gt_meta,
                      self.num_classes,
                      self.num_queries,
                      self.denoising_class_embed_groups[g_id].weight,
                      self.num_denoising,
                      self.label_noise_ratio,
                      self.box_noise_scale,
                  )
                  denoising_class_groups.append(denoising_class_gid)
                  denoising_bbox_groups.append(denoising_bbox_gid)
                  attn_mask_groups.append(attn_mask_gid)
                  dn_meta_groups.append(dn_meta_gid)
  
              # combine
              denoising_class = [
                  denoising_class
              ] + denoising_class_groups
              denoising_bbox = [denoising_bbox] + denoising_bbox_groups
              attn_mask = [attn_mask] + attn_mask_groups
              dn_meta = [dn_meta] + dn_meta_groups
      else:
          denoising_class, denoising_bbox, attn_mask, dn_meta = (
              None,
              None,
              None,
              None,
          )
  
      (
          target,
          init_ref_points,
          enc_topk_bboxes,
          enc_topk_logits,
      ) = self._get_decoder_input(
          memory,
          spatial_shapes,
          mask_flatten,
          denoising_class,
          denoising_bbox,
      )
  
      # decoder
      inter_feats, inter_ref_bboxes = self.decoder(
          target,
          init_ref_points,
          memory,
          spatial_shapes,
          level_start_index,
          self.dec_bbox_head,
          self.query_pos_head,
          valid_ratios,
          attn_mask,
          mask_flatten,
      )
      # solve hang during distributed training
      inter_feats[0] += self.denoising_class_embed.weight[0, 0] * 0.0
      if self.dual_queries:
          for g_id in range(self.dual_groups):
              inter_feats[0] += (
                  self.denoising_class_embed_groups[g_id].weight[0, 0]
                  * 0.0
              )
  
      out_bboxes = []
      out_logits = []
      for i in range(self.num_decoder_layers):
          out_logits.append(self.dec_score_head[i](inter_feats[i]))
          if i == 0:
              out_bboxes.append(
                  F.sigmoid(
                      self.dec_bbox_head[i](inter_feats[i])
                      + inverse_sigmoid(init_ref_points)
                  )
              )
          else:
              out_bboxes.append(
                  F.sigmoid(
                      self.dec_bbox_head[i](inter_feats[i])
                      + inverse_sigmoid(inter_ref_bboxes[i - 1])
                  )
              )
  
      out_bboxes = paddle.stack(out_bboxes)
      out_logits = paddle.stack(out_logits)
      return (
          out_bboxes,
          out_logits,
          enc_topk_bboxes,
          enc_topk_logits,
          dn_meta,
      )
  
imports: from __future__ import absolute_import
  from __future__ import division
  from __future__ import print_function
  import paddle
  import paddle.nn
  import paddle.nn.functional
  from paddle import ParamAttr
  from paddle.regularizer import L2Decay
  from ppdet.core.workspace import register
  from ..layers import MultiHeadAttention
  from .position_encoding import PositionEmbedding
  from ..heads.detr_head import MLP
  from .deformable_transformer import MSDeformableAttention
  from ..initializer import linear_init_, constant_, xavier_uniform_, normal_, bias_init_with_prob
  from .utils import _get_clones, get_valid_ratio, get_contrastive_denoising_training_group, get_sine_pos_embed, inverse_sigmoid
label_desc: Use image node_id 6 for calling the GroupDINOTransformer obj's underlying member method code with example usage: obj.forward(feats, pad_mask, gt_meta) and returns: out_bboxes,  out_logits,  enc_topk_bboxes,  enc_topk_logits,  dn_meta