code: def non_max_suppression(
      prediction,
      conf_thres=0.25,
      iou_thres=0.45,
      classes=None,
      agnostic=False,
      multi_label=False,
      labels=(),
      max_det=300,
  ):
      """Runs Non-Maximum Suppression (NMS) on inference results
  
      Returns:
           list of detections, on (n,6) tensor per image [xyxy, conf, cls]
      """
  
      nc = prediction.shape[2] - 5  # number of classes
      xc = prediction[..., 4] > conf_thres  # candidates
  
      # Checks
      assert (
          0 <= conf_thres <= 1
      ), f"Invalid Confidence threshold {conf_thres}, valid values are between 0.0 and 1.0"
      assert (
          0 <= iou_thres <= 1
      ), f"Invalid IoU {iou_thres}, valid values are between 0.0 and 1.0"
  
      # Settings
      min_wh, max_wh = (
          2,
          7680,
      )  # (pixels) minimum and maximum box width and height
      max_nms = (
          30000  # maximum number of boxes into torchvision.ops.nms()
      )
      time_limit = 10.0  # seconds to quit after
      redundant = True  # require redundant detections
      multi_label &= nc > 1  # multiple labels per box (adds 0.5ms/img)
      merge = False  # use merge-NMS
  
      t = time.time()
      output = [
          torch.zeros((0, 6), device=prediction.device)
      ] * prediction.shape[0]
      for xi, x in enumerate(
          prediction
      ):  # image index, image inference
          # Apply constraints
          x[
              ((x[..., 2:4] < min_wh) | (x[..., 2:4] > max_wh)).any(1),
              4,
          ] = 0  # width-height
          x = x[xc[xi]]  # confidence
  
          # Cat apriori labels if autolabelling
          if labels and len(labels[xi]):
              lb = labels[xi]
              v = torch.zeros((len(lb), nc + 5), device=x.device)
              v[:, :4] = lb[:, 1:5]  # box
              v[:, 4] = 1.0  # conf
              v[range(len(lb)), lb[:, 0].long() + 5] = 1.0  # cls
              x = torch.cat((x, v), 0)
  
          # If none remain process next image
          if not x.shape[0]:
              continue
  
          # Compute conf
          x[:, 5:] *= x[:, 4:5]  # conf = obj_conf * cls_conf
  
          # Box (center x, center y, width, height) to (x1, y1, x2, y2)
          box = xywh2xyxy(x[:, :4])
  
          # Detections matrix nx6 (xyxy, conf, cls)
          if multi_label:
              i, j = (x[:, 5:] > conf_thres).nonzero(as_tuple=False).T
              x = torch.cat(
                  (box[i], x[i, j + 5, None], j[:, None].float()), 1
              )
          else:  # best class only
              conf, j = x[:, 5:].max(1, keepdim=True)
              x = torch.cat((box, conf, j.float()), 1)[
                  conf.view(-1) > conf_thres
              ]
  
          # Filter by class
          if classes is not None:
              x = x[
                  (
                      x[:, 5:6]
                      == torch.tensor(classes, device=x.device)
                  ).any(1)
              ]
  
          # Apply finite constraint
          # if not torch.isfinite(x).all():
          #     x = x[torch.isfinite(x).all(1)]
  
          # Check shape
          n = x.shape[0]  # number of boxes
          if not n:  # no boxes
              continue
          elif n > max_nms:  # excess boxes
              x = x[
                  x[:, 4].argsort(descending=True)[:max_nms]
              ]  # sort by confidence
  
          # Batched NMS
          c = x[:, 5:6] * (0 if agnostic else max_wh)  # classes
          boxes, scores = (
              x[:, :4] + c,
              x[:, 4],
          )  # boxes (offset by class), scores
          i = torchvision.ops.nms(boxes, scores, iou_thres)  # NMS
          if i.shape[0] > max_det:  # limit detections
              i = i[:max_det]
          if merge and (
              1 < n < 3e3
          ):  # Merge NMS (boxes merged using weighted mean)
              # update boxes as boxes(i,4) = weights(i,n) * boxes(n,4)
              iou = box_iou(boxes[i], boxes) > iou_thres  # iou matrix
              weights = iou * scores[None]  # box weights
              x[i, :4] = torch.mm(
                  weights, x[:, :4]
              ).float() / weights.sum(
                  1, keepdim=True
              )  # merged boxes
              if redundant:
                  i = i[iou.sum(1) > 1]  # require redundancy
  
          output[xi] = x[i]
          if (time.time() - t) > time_limit:
              print(f"WARNING: NMS time limit {time_limit}s exceeded")
              break  # time limit exceeded
  
      return output
  
imports: import os
  import time
  import json
  import copy
  import cv2
  import numpy
  import torch
  from torchmetrics.detection.mean_ap import MeanAveragePrecision
  import torchvision
  from pycocotools.coco import COCO
  from pycocotools.cocoeval import COCOeval
  from compression.api import DataLoader, Metric
label_desc: Use image node_id 3 for calling a global function with example usage: non_max_suppression(prediction, conf_thres, iou_thres, classes, agnostic, multi_label, labels, max_det) and returns: output