ultralytics 8.3.113__tar.gz → 8.3.115__tar.gz

{ultralytics-8.3.113/ultralytics.egg-info → ultralytics-8.3.115}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ultralytics
-Version: 8.3.113
+Version: 8.3.115
 Summary: Ultralytics YOLO 🚀 for SOTA object detection, multi-object tracking, instance segmentation, pose estimation and image classification.
 Author-email: Glenn Jocher <glenn.jocher@ultralytics.com>, Jing Qiu <jing.qiu@ultralytics.com>
 Maintainer-email: Ultralytics <hello@ultralytics.com>

{ultralytics-8.3.113 → ultralytics-8.3.115}/ultralytics/__init__.py

@@ -1,6 +1,6 @@
 # Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
 
-__version__ = "8.3.113"
+__version__ = "8.3.115"
 
 import os
 

{ultralytics-8.3.113 → ultralytics-8.3.115}/ultralytics/cfg/datasets/dota8-multispectral.yaml

@@ -6,7 +6,7 @@
 # parent
 # ├── ultralytics
 # └── datasets
-#     └── dota8-multispectral  ← downloads here (1MB)
+#     └── dota8-multispectral  ← downloads here (37.3MB)
 
 # Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
 path: ../datasets/dota8-multispectral # dataset root dir

{ultralytics-8.3.113 → ultralytics-8.3.115}/ultralytics/cfg/trackers/botsort.yaml

@@ -15,7 +15,8 @@ fuse_score: True # Whether to fuse confidence scores with the iou distances befo
 
 # BoT-SORT settings
 gmc_method: sparseOptFlow # method of global motion compensation
-# ReID model related thresh (not supported yet)
-proximity_thresh: 0.5
-appearance_thresh: 0.25
+# ReID model related thresh
+proximity_thresh: 0.5 # minimum IoU for valid match with ReID
+appearance_thresh: 0.25 # minimum appearance similarity for ReID
 with_reid: False
+model: auto # uses native features if detector is YOLO else yolo11n-cls.pt

{ultralytics-8.3.113 → ultralytics-8.3.115}/ultralytics/data/utils.py

@@ -47,7 +47,7 @@ def img2label_paths(img_paths):
     return [sb.join(x.rsplit(sa, 1)).rsplit(".", 1)[0] + ".txt" for x in img_paths]
 
 
-def check_file_speeds(files, threshold_ms=10, max_files=5, prefix=""):
+def check_file_speeds(files, threshold_ms=10, threshold_mb=50, max_files=5, prefix=""):
     """
     Check dataset file access speed and provide performance feedback.
 
@@ -57,6 +57,7 @@ def check_file_speeds(files, threshold_ms=10, max_files=5, prefix=""):
     Args:
         files (list): List of file paths to check for access speed.
         threshold_ms (float, optional): Threshold in milliseconds for ping time warnings.
+        threshold_mb (float, optional): Threshold in megabytes per second for read speed warnings.
         max_files (int, optional): The maximum number of files to check.
         prefix (str, optional): Prefix string to add to log messages.
 
@@ -112,7 +113,7 @@ def check_file_speeds(files, threshold_ms=10, max_files=5, prefix=""):
     else:
         speed_msg = ""
 
-    if avg_ping < threshold_ms:
+    if avg_ping < threshold_ms or avg_speed < threshold_mb:
         LOGGER.info(f"{prefix}Fast image access ✅ ({ping_msg}{speed_msg}{size_msg})")
     else:
         LOGGER.warning(

{ultralytics-8.3.113 → ultralytics-8.3.115}/ultralytics/engine/exporter.py

@@ -351,7 +351,7 @@ class Exporter:
         if self.args.int8 and not self.args.data:
             self.args.data = DEFAULT_CFG.data or TASK2DATA[getattr(model, "task", "detect")]  # assign default data
             LOGGER.warning(
-                "INT8 export requires a missing 'data' arg for calibration. Using default 'data={self.args.data}'."
+                f"INT8 export requires a missing 'data' arg for calibration. Using default 'data={self.args.data}'."
             )
         if tfjs and (ARM64 and LINUX):
             raise SystemError("TF.js exports are not currently supported on ARM64 Linux")

{ultralytics-8.3.113 → ultralytics-8.3.115}/ultralytics/models/yolo/detect/predict.py

@@ -51,6 +51,7 @@ class DetectionPredictor(BasePredictor):
             >>> results = predictor.predict("path/to/image.jpg")
             >>> processed_results = predictor.postprocess(preds, img, orig_imgs)
         """
+        save_feats = getattr(self, "save_feats", False)
         preds = ops.non_max_suppression(
             preds,
             self.args.conf,
@@ -61,12 +62,35 @@ class DetectionPredictor(BasePredictor):
             nc=len(self.model.names),
             end2end=getattr(self.model, "end2end", False),
             rotated=self.args.task == "obb",
+            return_idxs=save_feats,
         )
 
         if not isinstance(orig_imgs, list):  # input images are a torch.Tensor, not a list
             orig_imgs = ops.convert_torch2numpy_batch(orig_imgs)
 
-        return self.construct_results(preds, img, orig_imgs, **kwargs)
+        if save_feats:
+            obj_feats = self.get_obj_feats(self._feats, preds[1])
+            preds = preds[0]
+
+        results = self.construct_results(preds, img, orig_imgs, **kwargs)
+
+        if save_feats:
+            for r, f in zip(results, obj_feats):
+                r.feats = f  # add object features to results
+
+        return results
+
+    def get_obj_feats(self, feat_maps, idxs):
+        """Extract object features from the feature maps."""
+        from math import gcd
+
+        import torch
+
+        s = gcd(*[x.shape[1] for x in feat_maps])  # find smallest vector length
+        obj_feats = torch.cat(
+            [x.permute(0, 2, 3, 1).reshape(x.shape[0], -1, s, x.shape[1] // s).mean(dim=-1) for x in feat_maps], dim=1
+        )  # mean reduce all vectors to same length
+        return [feats[idx] for feats, idx in zip(obj_feats, idxs)]  # for each image in batch, indexed separately
 
     def construct_results(self, preds, img, orig_imgs):
         """

{ultralytics-8.3.113 → ultralytics-8.3.115}/ultralytics/nn/autobackend.py

@@ -538,7 +538,7 @@ class AutoBackend(nn.Module):
             metadata = yaml_load(metadata)
         if metadata and isinstance(metadata, dict):
             for k, v in metadata.items():
-                if k in {"stride", "batch"}:
+                if k in {"stride", "batch", "channels"}:
                     metadata[k] = int(v)
                 elif k in {"imgsz", "names", "kpt_shape", "args"} and isinstance(v, str):
                     metadata[k] = eval(v)

{ultralytics-8.3.113 → ultralytics-8.3.115}/ultralytics/trackers/bot_sort.py

@@ -3,6 +3,10 @@
 from collections import deque
 
 import numpy as np
+import torch
+
+from ultralytics.utils.ops import xywh2xyxy
+from ultralytics.utils.plotting import save_one_box
 
 from .basetrack import TrackState
 from .byte_tracker import BYTETracker, STrack
@@ -186,14 +190,18 @@ class BOTSORT(BYTETracker):
             >>> bot_sort = BOTSORT(args, frame_rate=30)
         """
         super().__init__(args, frame_rate)
+        self.gmc = GMC(method=args.gmc_method)
+
         # ReID module
         self.proximity_thresh = args.proximity_thresh
         self.appearance_thresh = args.appearance_thresh
-
-        if args.with_reid:
-            # Haven't supported BoT-SORT(reid) yet
-            self.encoder = None
-        self.gmc = GMC(method=args.gmc_method)
+        self.encoder = (
+            (lambda feats, s: [f.cpu().numpy() for f in feats])  # native features do not require any model
+            if self.args.model == "auto"
+            else ReID(args.model)
+            if args.with_reid
+            else None
+        )
 
     def get_kalmanfilter(self):
         """Return an instance of KalmanFilterXYWH for predicting and updating object states in the tracking process."""
@@ -204,7 +212,7 @@ class BOTSORT(BYTETracker):
         if len(dets) == 0:
             return []
         if self.args.with_reid and self.encoder is not None:
-            features_keep = self.encoder.inference(img, dets)
+            features_keep = self.encoder(img, dets)
             return [BOTrack(xyxy, s, c, f) for (xyxy, s, c, f) in zip(dets, scores, cls, features_keep)]  # detections
         else:
             return [BOTrack(xyxy, s, c) for (xyxy, s, c) in zip(dets, scores, cls)]  # detections
@@ -212,14 +220,14 @@ class BOTSORT(BYTETracker):
     def get_dists(self, tracks, detections):
         """Calculate distances between tracks and detections using IoU and optionally ReID embeddings."""
         dists = matching.iou_distance(tracks, detections)
-        dists_mask = dists > self.proximity_thresh
+        dists_mask = dists > (1 - self.proximity_thresh)
 
         if self.args.fuse_score:
             dists = matching.fuse_score(dists, detections)
 
         if self.args.with_reid and self.encoder is not None:
             emb_dists = matching.embedding_distance(tracks, detections) / 2.0
-            emb_dists[emb_dists > self.appearance_thresh] = 1.0
+            emb_dists[emb_dists > (1 - self.appearance_thresh)] = 1.0
             emb_dists[dists_mask] = 1.0
             dists = np.minimum(dists, emb_dists)
         return dists
@@ -232,3 +240,19 @@ class BOTSORT(BYTETracker):
         """Reset the BOTSORT tracker to its initial state, clearing all tracked objects and internal states."""
         super().reset()
         self.gmc.reset_params()
+
+
+class ReID:
+    """YOLO model as encoder for re-identification."""
+
+    def __init__(self, model):
+        """Initialize encoder for re-identification."""
+        from ultralytics import YOLO
+
+        self.model = YOLO(model)
+        self.model(embed=[len(self.model.model.model) - 2 if ".pt" in model else -1], verbose=False)  # initialize
+
+    def __call__(self, img, dets):
+        """Extract embeddings for detected objects."""
+        feats = self.model([save_one_box(det, img, save=False) for det in xywh2xyxy(torch.from_numpy(dets[:, :4]))])
+        return [f.cpu().numpy() for f in feats]

{ultralytics-8.3.113 → ultralytics-8.3.115}/ultralytics/trackers/byte_tracker.py

@@ -290,7 +290,7 @@ class BYTETracker:
         self.kalman_filter = self.get_kalmanfilter()
         self.reset_id()
 
-    def update(self, results, img=None):
+    def update(self, results, img=None, feats=None):
         """Updates the tracker with new detections and returns the current list of tracked objects."""
         self.frame_id += 1
         activated_stracks = []
@@ -316,7 +316,7 @@ class BYTETracker:
         cls_keep = cls[remain_inds]
         cls_second = cls[inds_second]
 
-        detections = self.init_track(dets, scores_keep, cls_keep, img)
+        detections = self.init_track(dets, scores_keep, cls_keep, img if feats is None else feats)
         # Add newly detected tracklets to tracked_stracks
         unconfirmed = []
         tracked_stracks = []  # type: list[STrack]
@@ -347,7 +347,7 @@ class BYTETracker:
                 track.re_activate(det, self.frame_id, new_id=False)
                 refind_stracks.append(track)
         # Step 3: Second association, with low score detection boxes association the untrack to the low score detections
-        detections_second = self.init_track(dets_second, scores_second, cls_second, img)
+        detections_second = self.init_track(dets_second, scores_second, cls_second, img if feats is None else feats)
         r_tracked_stracks = [strack_pool[i] for i in u_track if strack_pool[i].state == TrackState.Tracked]
         # TODO
         dists = matching.iou_distance(r_tracked_stracks, detections_second)

{ultralytics-8.3.113 → ultralytics-8.3.115}/ultralytics/trackers/track.py

@@ -44,6 +44,25 @@ def on_predict_start(predictor: object, persist: bool = False) -> None:
     if cfg.tracker_type not in {"bytetrack", "botsort"}:
         raise AssertionError(f"Only 'bytetrack' and 'botsort' are supported for now, but got '{cfg.tracker_type}'")
 
+    if cfg.tracker_type == "botsort" and cfg.with_reid and cfg.model == "auto":
+        from ultralytics.nn.modules.head import Detect
+
+        if not (
+            isinstance(predictor.model.model, torch.nn.Module)
+            and isinstance(predictor.model.model.model[-1], Detect)
+            and not predictor.model.model.model[-1].end2end
+        ):
+            cfg.model = "yolo11n-cls.pt"
+        else:
+            predictor.save_feats = True
+            predictor._feats = None
+
+            # Register hook to extract input of Detect layer
+            def capture_io(module, input, output):
+                predictor._feats = input[0]
+
+            predictor.model.model.model[-1].register_forward_hook(capture_io)
+
     trackers = []
     for _ in range(predictor.dataset.bs):
         tracker = TRACKER_MAP[cfg.tracker_type](args=cfg, frame_rate=30)
@@ -79,7 +98,7 @@ def on_predict_postprocess_end(predictor: object, persist: bool = False) -> None
         det = (result.obb if is_obb else result.boxes).cpu().numpy()
         if len(det) == 0:
             continue
-        tracks = tracker.update(det, result.orig_img)
+        tracks = tracker.update(det, result.orig_img, getattr(result, "feats", None))
         if len(tracks) == 0:
             continue
         idx = tracks[:, -1].astype(int)

{ultralytics-8.3.113 → ultralytics-8.3.115}/ultralytics/utils/__init__.py

@@ -1261,7 +1261,7 @@ class SettingsManager(JSONDict):
             "For help see https://docs.ultralytics.com/quickstart/#ultralytics-settings."
         )
 
-        with torch_distributed_zero_first(RANK):
+        with torch_distributed_zero_first(LOCAL_RANK):
             super().__init__(self.file)
 
             if not self.file.exists() or not self:  # Check if file doesn't exist or is empty

{ultralytics-8.3.113 → ultralytics-8.3.115}/ultralytics/utils/ops.py

@@ -194,6 +194,7 @@ def non_max_suppression(
     in_place=True,
     rotated=False,
     end2end=False,
+    return_idxs=False,
 ):
     """
     Perform non-maximum suppression (NMS) on a set of boxes, with support for masks and multiple labels per box.
@@ -221,6 +222,7 @@ def non_max_suppression(
         in_place (bool): If True, the input prediction tensor will be modified in place.
         rotated (bool): If Oriented Bounding Boxes (OBB) are being passed for NMS.
         end2end (bool): If the model doesn't require NMS.
+        return_idxs (bool): Return the indices of the detections that were kept.
 
     Returns:
         (List[torch.Tensor]): A list of length batch_size, where each element is a tensor of
@@ -248,6 +250,7 @@ def non_max_suppression(
     nm = prediction.shape[1] - nc - 4  # number of masks
     mi = 4 + nc  # mask start index
     xc = prediction[:, 4:mi].amax(1) > conf_thres  # candidates
+    xinds = torch.stack([torch.arange(len(i), device=prediction.device) for i in xc])[..., None]  # to track idxs
 
     # Settings
     # min_wh = 2  # (pixels) minimum box width and height
@@ -263,10 +266,12 @@ def non_max_suppression(
 
     t = time.time()
     output = [torch.zeros((0, 6 + nm), device=prediction.device)] * bs
-    for xi, x in enumerate(prediction):  # image index, image inference
+    keepi = [torch.zeros((0, 1), device=prediction.device)] * bs  # to store the kept idxs
+    for xi, (x, xk) in enumerate(zip(prediction, xinds)):  # image index, (preds, preds indices)
         # Apply constraints
         # x[((x[:, 2:4] < min_wh) | (x[:, 2:4] > max_wh)).any(1), 4] = 0  # width-height
-        x = x[xc[xi]]  # confidence
+        filt = xc[xi]  # confidence
+        x, xk = x[filt], xk[filt]
 
         # Cat apriori labels if autolabelling
         if labels and len(labels[xi]) and not rotated:
@@ -286,20 +291,25 @@ def non_max_suppression(
         if multi_label:
             i, j = torch.where(cls > conf_thres)
             x = torch.cat((box[i], x[i, 4 + j, None], j[:, None].float(), mask[i]), 1)
+            xk = xk[i]
         else:  # best class only
             conf, j = cls.max(1, keepdim=True)
-            x = torch.cat((box, conf, j.float(), mask), 1)[conf.view(-1) > conf_thres]
+            filt = conf.view(-1) > conf_thres
+            x = torch.cat((box, conf, j.float(), mask), 1)[filt]
+            xk = xk[filt]
 
         # Filter by class
         if classes is not None:
             x = x[(x[:, 5:6] == classes).any(1)]
+            x, xk = x[filt], xk[filt]
 
         # Check shape
         n = x.shape[0]  # number of boxes
         if not n:  # no boxes
             continue
         if n > max_nms:  # excess boxes
-            x = x[x[:, 4].argsort(descending=True)[:max_nms]]  # sort by confidence and remove excess boxes
+            filt = x[:, 4].argsort(descending=True)[:max_nms]  # sort by confidence and remove excess boxes
+            x, xk = x[filt], xk[filt]
 
         # Batched NMS
         c = x[:, 5:6] * (0 if agnostic else max_wh)  # classes
@@ -324,12 +334,12 @@ def non_max_suppression(
         #     if redundant:
         #         i = i[iou.sum(1) > 1]  # require redundancy
 
-        output[xi] = x[i]
+        output[xi], keepi[xi] = x[i], xk[i].reshape(-1)
         if (time.time() - t) > time_limit:
             LOGGER.warning(f"NMS time limit {time_limit:.3f}s exceeded")
             break  # time limit exceeded
 
-    return output
+    return (output, keepi) if return_idxs else output
 
 
 def clip_boxes(boxes, shape):

{ultralytics-8.3.113 → ultralytics-8.3.115}/ultralytics/utils/patches.py

@@ -31,7 +31,8 @@ def imread(filename: str, flags: int = cv2.IMREAD_COLOR):
     if filename.endswith((".tiff", ".tif")):
         success, frames = cv2.imdecodemulti(file_bytes, cv2.IMREAD_UNCHANGED)
         if success:
-            return np.stack(frames, axis=2)  # or np.asarray(frames).transpose(1,2,0)
+            # handle RGB images in tif/tiff format
+            return frames[0] if len(frames) == 1 and frames[0].ndim == 3 else np.stack(frames, axis=2)
         return None
     else:
         return cv2.imdecode(file_bytes, flags)

{ultralytics-8.3.113 → ultralytics-8.3.115/ultralytics.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ultralytics
-Version: 8.3.113
+Version: 8.3.115
 Summary: Ultralytics YOLO 🚀 for SOTA object detection, multi-object tracking, instance segmentation, pose estimation and image classification.
 Author-email: Glenn Jocher <glenn.jocher@ultralytics.com>, Jing Qiu <jing.qiu@ultralytics.com>
 Maintainer-email: Ultralytics <hello@ultralytics.com>