code: def non_max_suppression(
      prediction,
      conf_thres=0.25,
      iou_thres=0.45,
      classes=None,
      agnostic=False,
      multi_label=False,
      labels=(),
  ):
      """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
  
      # Settings
      min_wh, max_wh = (
          2,
          4096,
      )  # (pixels) minimum and maximum box width and height
      max_det = 300  # maximum number of detections per image
      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
          x = x[xc[xi]]  # confidence
  
          # Cat apriori labels if autolabelling
          if labels and len(labels[xi]):
              l = labels[xi]
              v = torch.zeros((len(l), nc + 5), device=x.device)
              v[:, :4] = l[:, 1:5]  # box
              v[:, 4] = 1.0  # conf
              v[range(len(l)), l[:, 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)
              ]
  
          # 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 glob
  import logging
  import os
  import re
  import time
  from pathlib import Path
  from typing import List
  import cv2
  import numpy
  import torch
  import torchvision
  from norfair import Detection
label_desc: Use image node_id 6 for calling a global function with example usage: non_max_suppression(prediction, conf_thres, iou_thres, classes, agnostic, multi_label, labels) and returns: output