first commit

ultralytics/models/yolo/detectbin/predict.py

@@ -0,0 +1,121 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+import torch
+from ultralytics.engine.predictor import BasePredictor
+from ultralytics.engine.results import Results
+from ultralytics.utils import ops
+
+
+class DetectionPredictor(BasePredictor):
+    """
+    A class extending the BasePredictor class for prediction based on a detection model.
+
+    Example:
+        ```python
+        from ultralytics.utils import ASSETS
+        from ultralytics.models.yolo.detect import DetectionPredictor
+
+        args = dict(model='yolov8n.pt', source=ASSETS)
+        predictor = DetectionPredictor(overrides=args)
+        predictor.predict_cli()
+        ```
+    """
+
+    def postprocess(self, preds, img, orig_imgs):
+        """Post-processes predictions and returns a list of Results objects."""
+        # if isinstance(preds, (list, tuple)):  # YOLOv8 model in validation model, output = (inference_out, loss_out)
+        #     preds = preds[0]
+        # cls_max = torch.max(preds[:, 4:8, :], dim=1, keepdim=True).values
+        # idx = (cls_max > self.args.conf)
+        # preds[:, -1:, :][idx] = 0
+
+        # preds = ops.non_max_suppression(
+        #     preds,
+        #     self.args.conf,
+        #     self.args.iou,
+        #     agnostic=self.args.agnostic_nms,
+        #     max_det=self.args.max_det,
+        #     classes=self.args.classes,
+        # )
+
+        if isinstance(preds, (list, tuple)):  # YOLOv8 model in validation model, output = (inference_out, loss_out)
+            preds = preds[0]
+            preds_c = preds.clone()
+
+        nms_cls = ops.non_max_suppression(
+            preds[:, :8, :],
+            self.args.conf,
+            self.args.iou,
+            agnostic=self.args.agnostic_nms,
+            max_det=self.args.max_det,
+            classes=self.args.classes,
+        )
+
+        nms_obj = ops.non_max_suppression(
+            torch.cat((preds_c[:, :4, :], preds_c[:, -1:, :]), dim=1),
+            self.args.conf,
+            self.args.iou,
+            agnostic=self.args.agnostic_nms,
+            max_det=self.args.max_det,
+            classes=self.args.classes,
+        )
+
+        preds = [n.clone() for n in nms_cls]
+        for i in range(len(nms_cls)):
+            nms_obj[i][:, 5] = len(self.model.names) - 1
+            if nms_obj[i].size(0) == 0:  # Skip if there are no objects
+                continue
+            if nms_cls[i].size(0) == 0:
+                preds[i] = nms_obj[i]
+                continue
+            iou = self.box_iou(nms_cls[i][:, :4], nms_obj[i][:, :4])
+            idxs = []
+            # 将多分类置信度低、二分类置信度高，且IOU较大的框替换
+            matchs = torch.ones_like(iou)
+            matchs[nms_cls[i][:, 4] > 0.3, :] = 0  # new_track_thresh
+            matchs[:, nms_obj[i][:, 4] < 0.3] = 0
+            matchs[iou < self.args.iou] = 0
+            rows, cols = torch.where(matchs == 1)
+            preds[i][rows, :] = nms_obj[i][cols, :]
+            idxs.append(cols)
+
+            # 将二分类无对应多分类结果的框附后
+            max_values = torch.max(iou, dim=0)[0]
+            idxs = torch.where(max_values < self.args.iou)[0]
+            idxs = torch.tensor([i for i in idxs if i not in cols]).to(torch.int64)
+            preds[i] = torch.cat((preds[i], nms_obj[i][idxs, :]), dim=0)
+
+            # for m in range(len(nms_obj[i])):
+            #     if (torch.max(iou[:, m]) < self.args.iou) and (m not in idxs):
+            #         preds[i] = torch.cat((preds[i], nms_obj[i][m, :]), dim=0)
+
+        if not isinstance(orig_imgs, list):  # input images are a torch.Tensor, not a list
+            orig_imgs = ops.convert_torch2numpy_batch(orig_imgs)
+
+        results = []
+        for i, pred in enumerate(preds):
+            orig_img = orig_imgs[i]
+            pred[:, :4] = ops.scale_boxes(img.shape[2:], pred[:, :4], orig_img.shape)
+            img_path = self.batch[0][i]
+            results.append(Results(orig_img, path=img_path, names=self.model.names, boxes=pred))
+        return results
+    
+    def box_iou(self, box1, box2, eps=1e-7):
+        """
+        Calculate intersection-over-union (IoU) of boxes. Both sets of boxes are expected to be in (x1, y1, x2, y2) format.
+        Based on https://github.com/pytorch/vision/blob/master/torchvision/ops/boxes.py
+
+        Args:
+            box1 (torch.Tensor): A tensor of shape (N, 4) representing N bounding boxes.
+            box2 (torch.Tensor): A tensor of shape (M, 4) representing M bounding boxes.
+            eps (float, optional): A small value to avoid division by zero. Defaults to 1e-7.
+
+        Returns:
+            (torch.Tensor): An NxM tensor containing the pairwise IoU values for every element in box1 and box2.
+        """
+
+        # inter(N,M) = (rb(N,M,2) - lt(N,M,2)).clamp(0).prod(2)
+        (a1, a2), (b1, b2) = box1.unsqueeze(1).chunk(2, 2), box2.unsqueeze(0).chunk(2, 2)
+        inter = (torch.min(a2, b2) - torch.max(a1, b1)).clamp_(0).prod(2)
+
+        # IoU = inter / (area1 + area2 - inter)
+        return inter / ((a2 - a1).prod(2) + (b2 - b1).prod(2) - inter + eps)