code: def pad_gt(gt_labels, gt_bboxes, gt_scores=None):
      r"""Pad 0 in gt_labels and gt_bboxes.
      Args:
          gt_labels (Tensor|List[Tensor], int64): Label of gt_bboxes,
              shape is [B, n, 1] or [[n_1, 1], [n_2, 1], ...], here n = sum(n_i)
          gt_bboxes (Tensor|List[Tensor], float32): Ground truth bboxes,
              shape is [B, n, 4] or [[n_1, 4], [n_2, 4], ...], here n = sum(n_i)
          gt_scores (Tensor|List[Tensor]|None, float32): Score of gt_bboxes,
              shape is [B, n, 1] or [[n_1, 4], [n_2, 4], ...], here n = sum(n_i)
      Returns:
          pad_gt_labels (Tensor, int64): shape[B, n, 1]
          pad_gt_bboxes (Tensor, float32): shape[B, n, 4]
          pad_gt_scores (Tensor, float32): shape[B, n, 1]
          pad_gt_mask (Tensor, float32): shape[B, n, 1], 1 means bbox, 0 means no bbox
      """
      if isinstance(gt_labels, paddle.Tensor) and isinstance(
          gt_bboxes, paddle.Tensor
      ):
          assert (
              gt_labels.ndim == gt_bboxes.ndim and gt_bboxes.ndim == 3
          )
          pad_gt_mask = (
              gt_bboxes.sum(axis=-1, keepdim=True) > 0
          ).astype(gt_bboxes.dtype)
          if gt_scores is None:
              gt_scores = pad_gt_mask.clone()
          assert gt_labels.ndim == gt_scores.ndim
  
          return gt_labels, gt_bboxes, gt_scores, pad_gt_mask
      elif isinstance(gt_labels, list) and isinstance(gt_bboxes, list):
          assert len(gt_labels) == len(
              gt_bboxes
          ), "The number of `gt_labels` and `gt_bboxes` is not equal. "
          num_max_boxes = max([len(a) for a in gt_bboxes])
          batch_size = len(gt_bboxes)
          # pad label and bbox
          pad_gt_labels = paddle.zeros(
              [batch_size, num_max_boxes, 1], dtype=gt_labels[0].dtype
          )
          pad_gt_bboxes = paddle.zeros(
              [batch_size, num_max_boxes, 4], dtype=gt_bboxes[0].dtype
          )
          pad_gt_scores = paddle.zeros(
              [batch_size, num_max_boxes, 1], dtype=gt_bboxes[0].dtype
          )
          pad_gt_mask = paddle.zeros(
              [batch_size, num_max_boxes, 1], dtype=gt_bboxes[0].dtype
          )
          for i, (label, bbox) in enumerate(zip(gt_labels, gt_bboxes)):
              if len(label) > 0 and len(bbox) > 0:
                  pad_gt_labels[i, : len(label)] = label
                  pad_gt_bboxes[i, : len(bbox)] = bbox
                  pad_gt_mask[i, : len(bbox)] = 1.0
                  if gt_scores is not None:
                      pad_gt_scores[i, : len(gt_scores[i])] = gt_scores[
                          i
                      ]
          if gt_scores is None:
              pad_gt_scores = pad_gt_mask.clone()
          return (
              pad_gt_labels,
              pad_gt_bboxes,
              pad_gt_scores,
              pad_gt_mask,
          )
      else:
          raise ValueError(
              "The input `gt_labels` or `gt_bboxes` is invalid! "
          )
  
file_path: PaddleDetection/ppdet/modeling/assigners/utils.py
imports: from __future__ import absolute_import
  from __future__ import division
  from __future__ import print_function
  import paddle
  import paddle.nn.functional
label_desc: Use image node_id 1 for calling a global function with example usage: pad_gt(gt_labels, gt_bboxes, gt_scores) and returns: gt_labels,  gt_bboxes,  gt_scores,  pad_gt_mask, pad_gt_labels,  pad_gt_bboxes,  pad_gt_scores,  pad_gt_mask