code: def matrix_nms(
      bboxes,
      scores,
      score_threshold,
      post_threshold,
      nms_top_k,
      keep_top_k,
      use_gaussian=False,
      gaussian_sigma=2.0,
      background_label=0,
      normalized=True,
      return_index=False,
      return_rois_num=True,
      name=None,
  ):
      """
      **Matrix NMS**
      This operator does matrix non maximum suppression (NMS).
      First selects a subset of candidate bounding boxes that have higher scores
      than score_threshold (if provided), then the top k candidate is selected if
      nms_top_k is larger than -1. Score of the remaining candidate are then
      decayed according to the Matrix NMS scheme.
      Aftern NMS step, at most keep_top_k number of total bboxes are to be kept
      per image if keep_top_k is larger than -1.
      Args:
          bboxes (Tensor): A 3-D Tensor with shape [N, M, 4] represents the
                             predicted locations of M bounding bboxes,
                             N is the batch size. Each bounding box has four
                             coordinate values and the layout is
                             [xmin, ymin, xmax, ymax], when box size equals to 4.
                             The data type is float32 or float64.
          scores (Tensor): A 3-D Tensor with shape [N, C, M]
                             represents the predicted confidence predictions.
                             N is the batch size, C is the class number, M is
                             number of bounding boxes. For each category there
                             are total M scores which corresponding M bounding
                             boxes. Please note, M is equal to the 2nd dimension
                             of BBoxes. The data type is float32 or float64.
          score_threshold (float): Threshold to filter out bounding boxes with
                                   low confidence score.
          post_threshold (float): Threshold to filter out bounding boxes with
                                  low confidence score AFTER decaying.
          nms_top_k (int): Maximum number of detections to be kept according to
                           the confidences after the filtering detections based
                           on score_threshold.
          keep_top_k (int): Number of total bboxes to be kept per image after NMS
                            step. -1 means keeping all bboxes after NMS step.
          use_gaussian (bool): Use Gaussian as the decay function. Default: False
          gaussian_sigma (float): Sigma for Gaussian decay function. Default: 2.0
          background_label (int): The index of background label, the background
                                  label will be ignored. If set to -1, then all
                                  categories will be considered. Default: 0
          normalized (bool): Whether detections are normalized. Default: True
          return_index(bool): Whether return selected index. Default: False
          return_rois_num(bool): whether return rois_num. Default: True
          name(str): Name of the matrix nms op. Default: None.
      Returns:
          A tuple with three Tensor: (Out, Index, RoisNum) if return_index is True,
          otherwise, a tuple with two Tensor (Out, RoisNum) is returned.
          Out (Tensor): A 2-D Tensor with shape [No, 6] containing the
               detection results.
               Each row has 6 values: [label, confidence, xmin, ymin, xmax, ymax]
               (After version 1.3, when no boxes detected, the lod is changed
               from {0} to {1})
          Index (Tensor): A 2-D Tensor with shape [No, 1] containing the
              selected indices, which are absolute values cross batches.
          rois_num (Tensor): A 1-D Tensor with shape [N] containing
              the number of detected boxes in each image.
      Examples:
          .. code-block:: python
              import paddle
              from ppdet.modeling import ops
              boxes = paddle.static.data(name='bboxes', shape=[None,81, 4],
                                        dtype='float32', lod_level=1)
              scores = paddle.static.data(name='scores', shape=[None,81],
                                        dtype='float32', lod_level=1)
              out = ops.matrix_nms(bboxes=boxes, scores=scores, background_label=0,
                                   score_threshold=0.5, post_threshold=0.1,
                                   nms_top_k=400, keep_top_k=200, normalized=False)
      """
      check_variable_and_dtype(
          bboxes, "BBoxes", ["float32", "float64"], "matrix_nms"
      )
      check_variable_and_dtype(
          scores, "Scores", ["float32", "float64"], "matrix_nms"
      )
      check_type(
          score_threshold, "score_threshold", float, "matrix_nms"
      )
      check_type(post_threshold, "post_threshold", float, "matrix_nms")
      check_type(nms_top_k, "nums_top_k", int, "matrix_nms")
      check_type(keep_top_k, "keep_top_k", int, "matrix_nms")
      check_type(normalized, "normalized", bool, "matrix_nms")
      check_type(use_gaussian, "use_gaussian", bool, "matrix_nms")
      check_type(gaussian_sigma, "gaussian_sigma", float, "matrix_nms")
      check_type(
          background_label, "background_label", int, "matrix_nms"
      )
  
      if in_dynamic_mode():
          attrs = (
              "background_label",
              background_label,
              "score_threshold",
              score_threshold,
              "post_threshold",
              post_threshold,
              "nms_top_k",
              nms_top_k,
              "gaussian_sigma",
              gaussian_sigma,
              "use_gaussian",
              use_gaussian,
              "keep_top_k",
              keep_top_k,
              "normalized",
              normalized,
          )
          out, index, rois_num = C_ops.matrix_nms(
              bboxes, scores, *attrs
          )
          if not return_index:
              index = None
          if not return_rois_num:
              rois_num = None
          return out, rois_num, index
      else:
          helper = LayerHelper("matrix_nms", **locals())
          output = helper.create_variable_for_type_inference(
              dtype=bboxes.dtype
          )
          index = helper.create_variable_for_type_inference(
              dtype="int32"
          )
          outputs = {"Out": output, "Index": index}
          if return_rois_num:
              rois_num = helper.create_variable_for_type_inference(
                  dtype="int32"
              )
              outputs["RoisNum"] = rois_num
  
          helper.append_op(
              type="matrix_nms",
              inputs={"BBoxes": bboxes, "Scores": scores},
              attrs={
                  "background_label": background_label,
                  "score_threshold": score_threshold,
                  "post_threshold": post_threshold,
                  "nms_top_k": nms_top_k,
                  "gaussian_sigma": gaussian_sigma,
                  "use_gaussian": use_gaussian,
                  "keep_top_k": keep_top_k,
                  "normalized": normalized,
              },
              outputs=outputs,
          )
          output.stop_gradient = True
  
          if not return_index:
              index = None
          if not return_rois_num:
              rois_num = None
          return output, rois_num, index
  
imports: import paddle
  import paddle.nn.functional
  import paddle.nn
  from paddle import ParamAttr
  from paddle.regularizer import L2Decay
  from paddle import in_dynamic_mode
  from paddle.common_ops_import import Variable, LayerHelper, check_variable_and_dtype, check_type, check_dtype
label_desc: Use image node_id 11 for calling a global function with example usage: matrix_nms(bboxes, scores, score_threshold, post_threshold, nms_top_k, keep_top_k, use_gaussian, gaussian_sigma, background_label, normalized, return_index, return_rois_num, name) and returns: out,  rois_num,  index, output,  rois_num,  index