ultralytics 8.2.91__tar.gz → 8.2.93__tar.gz

{ultralytics-8.2.91/ultralytics.egg-info → ultralytics-8.2.93}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ultralytics
-Version: 8.2.91
+Version: 8.2.93
 Summary: Ultralytics YOLOv8 for SOTA object detection, multi-object tracking, instance segmentation, pose estimation and image classification.
 Author: Glenn Jocher, Ayush Chaurasia, Jing Qiu
 Maintainer: Glenn Jocher, Ayush Chaurasia, Jing Qiu

{ultralytics-8.2.91 → ultralytics-8.2.93}/ultralytics/__init__.py

@@ -1,6 +1,6 @@
 # Ultralytics YOLO 🚀, AGPL-3.0 license
 
-__version__ = "8.2.91"
+__version__ = "8.2.93"
 
 
 import os

{ultralytics-8.2.91 → ultralytics-8.2.93}/ultralytics/data/base.py

@@ -91,6 +91,11 @@ class BaseDataset(Dataset):
         self.npy_files = [Path(f).with_suffix(".npy") for f in self.im_files]
         self.cache = cache.lower() if isinstance(cache, str) else "ram" if cache is True else None
         if (self.cache == "ram" and self.check_cache_ram()) or self.cache == "disk":
+            if self.cache == "ram" and hyp.deterministic:
+                LOGGER.warning(
+                    "WARNING ⚠️ cache='ram' may produce non-deterministic training results. "
+                    "Consider cache='disk' as a deterministic alternative if your disk space allows."
+                )
             self.cache_images()
 
         # Transforms

{ultralytics-8.2.91 → ultralytics-8.2.93}/ultralytics/engine/exporter.py

@@ -391,7 +391,7 @@ class Exporter:
         """YOLOv8 ONNX export."""
         requirements = ["onnx>=1.12.0"]
         if self.args.simplify:
-            requirements += ["onnxslim==0.1.32", "onnxruntime" + ("-gpu" if torch.cuda.is_available() else "")]
+            requirements += ["onnxslim==0.1.34", "onnxruntime" + ("-gpu" if torch.cuda.is_available() else "")]
         check_requirements(requirements)
         import onnx  # noqa
 

{ultralytics-8.2.91 → ultralytics-8.2.93}/ultralytics/engine/results.py

@@ -522,7 +522,13 @@ class Results(SimpleClass):
                     .contiguous()
                     / 255
                 )
-            idx = pred_boxes.cls if pred_boxes and color_mode == "class" else reversed(range(len(pred_masks)))
+            idx = (
+                pred_boxes.id
+                if pred_boxes.id is not None and color_mode == "instance"
+                else pred_boxes.cls
+                if pred_boxes and color_mode == "class"
+                else reversed(range(len(pred_masks)))
+            )
             annotator.masks(pred_masks.data, colors=[colors(x, True) for x in idx], im_gpu=im_gpu)
 
         # Plot Detect results
@@ -535,7 +541,16 @@ class Results(SimpleClass):
                 annotator.box_label(
                     box,
                     label,
-                    color=colors(i if color_mode == "instance" else c, True),
+                    color=colors(
+                        c
+                        if color_mode == "class"
+                        else id
+                        if id is not None
+                        else i
+                        if color_mode == "instance"
+                        else None,
+                        True,
+                    ),
                     rotated=is_obb,
                 )
 

{ultralytics-8.2.91 → ultralytics-8.2.93}/ultralytics/models/nas/val.py

@@ -44,7 +44,7 @@ class NASValidator(DetectionValidator):
             self.args.iou,
             labels=self.lb,
             multi_label=False,
-            agnostic=self.args.single_cls,
+            agnostic=self.args.single_cls or self.args.agnostic_nms,
             max_det=self.args.max_det,
             max_time_img=0.5,
         )

{ultralytics-8.2.91 → ultralytics-8.2.93}/ultralytics/models/sam/modules/transformer.py

@@ -61,7 +61,6 @@ class TwoWayTransformer(nn.Module):
         Attributes:
             depth (int): Number of layers in the transformer.
             embedding_dim (int): Channel dimension for input embeddings.
-            embedding_dim (int): Channel dimension for input embeddings.
             num_heads (int): Number of heads for multihead attention.
             mlp_dim (int): Internal channel dimension for the MLP block.
             layers (nn.ModuleList): List of TwoWayAttentionBlock layers.

{ultralytics-8.2.91 → ultralytics-8.2.93}/ultralytics/models/yolo/obb/val.py

@@ -45,7 +45,7 @@ class OBBValidator(DetectionValidator):
             labels=self.lb,
             nc=self.nc,
             multi_label=True,
-            agnostic=self.args.single_cls,
+            agnostic=self.args.single_cls or self.args.agnostic_nms,
             max_det=self.args.max_det,
             rotated=True,
         )

{ultralytics-8.2.91 → ultralytics-8.2.93}/ultralytics/models/yolo/pose/val.py

@@ -69,7 +69,7 @@ class PoseValidator(DetectionValidator):
             self.args.iou,
             labels=self.lb,
             multi_label=True,
-            agnostic=self.args.single_cls,
+            agnostic=self.args.single_cls or self.args.agnostic_nms,
             max_det=self.args.max_det,
             nc=self.nc,
         )

{ultralytics-8.2.91 → ultralytics-8.2.93}/ultralytics/models/yolo/segment/val.py

@@ -76,7 +76,7 @@ class SegmentationValidator(DetectionValidator):
             self.args.iou,
             labels=self.lb,
             multi_label=True,
-            agnostic=self.args.single_cls,
+            agnostic=self.args.single_cls or self.args.agnostic_nms,
             max_det=self.args.max_det,
             nc=self.nc,
         )

{ultralytics-8.2.91 → ultralytics-8.2.93}/ultralytics/nn/tasks.py

@@ -1,6 +1,8 @@
 # Ultralytics YOLO 🚀, AGPL-3.0 license
 
 import contextlib
+import pickle
+import types
 from copy import deepcopy
 from pathlib import Path
 
@@ -750,7 +752,35 @@ def temporary_modules(modules=None, attributes=None):
                 del sys.modules[old]
 
 
-def torch_safe_load(weight):
+class SafeClass:
+    """A placeholder class to replace unknown classes during unpickling."""
+
+    def __init__(self, *args, **kwargs):
+        """Initialize SafeClass instance, ignoring all arguments."""
+        pass
+
+
+class SafeUnpickler(pickle.Unpickler):
+    """Custom Unpickler that replaces unknown classes with SafeClass."""
+
+    def find_class(self, module, name):
+        """Attempt to find a class, returning SafeClass if not among safe modules."""
+        safe_modules = (
+            "torch",
+            "collections",
+            "collections.abc",
+            "builtins",
+            "math",
+            "numpy",
+            # Add other modules considered safe
+        )
+        if module in safe_modules:
+            return super().find_class(module, name)
+        else:
+            return SafeClass
+
+
+def torch_safe_load(weight, safe_only=False):
     """
     Attempts to load a PyTorch model with the torch.load() function. If a ModuleNotFoundError is raised, it catches the
     error, logs a warning message, and attempts to install the missing module via the check_requirements() function.
@@ -758,9 +788,18 @@ def torch_safe_load(weight):
 
     Args:
         weight (str): The file path of the PyTorch model.
+        safe_only (bool): If True, replace unknown classes with SafeClass during loading.
+
+    Example:
+    ```python
+    from ultralytics.nn.tasks import torch_safe_load
+
+    ckpt, file = torch_safe_load("path/to/best.pt", safe_only=True)
+    ```
 
     Returns:
-        (dict): The loaded PyTorch model.
+        ckpt (dict): The loaded model checkpoint.
+        file (str): The loaded filename
     """
     from ultralytics.utils.downloads import attempt_download_asset
 
@@ -779,7 +818,15 @@ def torch_safe_load(weight):
                 "ultralytics.utils.loss.v10DetectLoss": "ultralytics.utils.loss.E2EDetectLoss",  # YOLOv10
             },
         ):
-            ckpt = torch.load(file, map_location="cpu")
+            if safe_only:
+                # Load via custom pickle module
+                safe_pickle = types.ModuleType("safe_pickle")
+                safe_pickle.Unpickler = SafeUnpickler
+                safe_pickle.load = lambda file_obj: SafeUnpickler(file_obj).load()
+                with open(file, "rb") as f:
+                    ckpt = torch.load(f, pickle_module=safe_pickle)
+            else:
+                ckpt = torch.load(file, map_location="cpu")
 
     except ModuleNotFoundError as e:  # e.name is missing module name
         if e.name == "models":
@@ -809,7 +856,7 @@ def torch_safe_load(weight):
         )
         ckpt = {"model": ckpt.model}
 
-    return ckpt, file  # load
+    return ckpt, file
 
 
 def attempt_load_weights(weights, device=None, inplace=True, fuse=False):

{ultralytics-8.2.91 → ultralytics-8.2.93}/ultralytics/solutions/object_counter.py

@@ -60,7 +60,6 @@ class ObjectCounter:
         self.out_counts = 0
         self.count_ids = []
         self.class_wise_count = {}
-        self.count_txt_thickness = 0
 
         # Tracks info
         self.track_history = defaultdict(list)
@@ -136,7 +135,7 @@ class ObjectCounter:
             # Extract tracks
             for box, track_id, cls in zip(boxes, track_ids, clss):
                 # Draw bounding box
-                annotator.box_label(box, label=f"{self.names[cls]}#{track_id}", color=colors(int(track_id), True))
+                annotator.box_label(box, label=self.names[cls], color=colors(int(track_id), True))
 
                 # Store class info
                 if self.names[cls] not in self.class_wise_count:
@@ -182,10 +181,9 @@ class ObjectCounter:
                             self.count_ids.append(track_id)
 
                             # Determine the direction of movement (IN or OUT)
-                            direction = (box[0] - prev_position[0]) * (
-                                self.counting_region.centroid.x - prev_position[0]
-                            )
-                            if direction > 0:
+                            dx = (box[0] - prev_position[0]) * (self.counting_region.centroid.x - prev_position[0])
+                            dy = (box[1] - prev_position[1]) * (self.counting_region.centroid.y - prev_position[1])
+                            if dx > 0 and dy > 0:
                                 self.in_counts += 1
                                 self.class_wise_count[self.names[cls]]["IN"] += 1
                             else:

{ultralytics-8.2.91 → ultralytics-8.2.93}/ultralytics/solutions/queue_management.py

@@ -20,15 +20,8 @@ class QueueManager:
         names,
         reg_pts=None,
         line_thickness=2,
-        track_thickness=2,
         view_img=False,
-        region_color=(255, 0, 255),
-        view_queue_counts=True,
         draw_tracks=False,
-        count_txt_color=(255, 255, 255),
-        track_color=None,
-        region_thickness=5,
-        fontsize=0.7,
     ):
         """
         Initializes the QueueManager with specified parameters for tracking and counting objects.
@@ -38,57 +31,35 @@ class QueueManager:
             reg_pts (list of tuples, optional): Points defining the counting region polygon. Defaults to a predefined
                 rectangle.
             line_thickness (int, optional): Thickness of the annotation lines. Defaults to 2.
-            track_thickness (int, optional): Thickness of the track lines. Defaults to 2.
             view_img (bool, optional): Whether to display the image frames. Defaults to False.
-            region_color (tuple, optional): Color of the counting region lines (BGR). Defaults to (255, 0, 255).
-            view_queue_counts (bool, optional): Whether to display the queue counts. Defaults to True.
             draw_tracks (bool, optional): Whether to draw tracks of the objects. Defaults to False.
-            count_txt_color (tuple, optional): Color of the count text (BGR). Defaults to (255, 255, 255).
-            track_color (tuple, optional): Color of the tracks. If None, different colors will be used for different
-                tracks. Defaults to None.
-            region_thickness (int, optional): Thickness of the counting region lines. Defaults to 5.
-            fontsize (float, optional): Font size for the text annotations. Defaults to 0.7.
         """
-        # Mouse events state
-        self.is_drawing = False
-        self.selected_point = None
-
         # Region & Line Information
         self.reg_pts = reg_pts if reg_pts is not None else [(20, 60), (20, 680), (1120, 680), (1120, 60)]
         self.counting_region = (
             Polygon(self.reg_pts) if len(self.reg_pts) >= 3 else Polygon([(20, 60), (20, 680), (1120, 680), (1120, 60)])
         )
-        self.region_color = region_color
-        self.region_thickness = region_thickness
 
-        # Image and annotation Information
-        self.im0 = None
+        # annotation Information
         self.tf = line_thickness
         self.view_img = view_img
-        self.view_queue_counts = view_queue_counts
-        self.fontsize = fontsize
 
         self.names = names  # Class names
-        self.annotator = None  # Annotator
-        self.window_name = "Ultralytics YOLOv8 Queue Manager"
 
         # Object counting Information
         self.counts = 0
-        self.count_txt_color = count_txt_color
 
         # Tracks info
         self.track_history = defaultdict(list)
-        self.track_thickness = track_thickness
         self.draw_tracks = draw_tracks
-        self.track_color = track_color
 
         # Check if environment supports imshow
         self.env_check = check_imshow(warn=True)
 
-    def extract_and_process_tracks(self, tracks):
+    def extract_and_process_tracks(self, tracks, im0):
         """Extracts and processes tracks for queue management in a video stream."""
         # Initialize annotator and draw the queue region
-        self.annotator = Annotator(self.im0, self.tf, self.names)
+        annotator = Annotator(im0, self.tf, self.names)
         self.counts = 0  # Reset counts every frame
         if tracks[0].boxes.id is not None:
             boxes = tracks[0].boxes.xyxy.cpu()
@@ -98,7 +69,7 @@ class QueueManager:
             # Extract tracks
             for box, track_id, cls in zip(boxes, track_ids, clss):
                 # Draw bounding box
-                self.annotator.box_label(box, label=f"{self.names[cls]}#{track_id}", color=colors(int(track_id), True))
+                annotator.box_label(box, label=self.names[cls], color=colors(int(track_id), True))
 
                 # Update track history
                 track_line = self.track_history[track_id]
@@ -108,10 +79,10 @@ class QueueManager:
 
                 # Draw track trails if enabled
                 if self.draw_tracks:
-                    self.annotator.draw_centroid_and_tracks(
+                    annotator.draw_centroid_and_tracks(
                         track_line,
-                        color=self.track_color or colors(int(track_id), True),
-                        track_thickness=self.track_thickness,
+                        color=colors(int(track_id), True),
+                        track_thickness=self.line_thickness,
                     )
 
                 prev_position = self.track_history[track_id][-2] if len(self.track_history[track_id]) > 1 else None
@@ -125,21 +96,16 @@ class QueueManager:
         # Display queue counts
         label = f"Queue Counts : {str(self.counts)}"
         if label is not None:
-            self.annotator.queue_counts_display(
+            annotator.queue_counts_display(
                 label,
                 points=self.reg_pts,
-                region_color=self.region_color,
-                txt_color=self.count_txt_color,
+                region_color=(255, 0, 255),
+                txt_color=(104, 31, 17),
             )
 
-        self.display_frames()
-
-    def display_frames(self):
-        """Displays the current frame with annotations."""
         if self.env_check and self.view_img:
-            self.annotator.draw_region(reg_pts=self.reg_pts, thickness=self.region_thickness, color=self.region_color)
-            cv2.namedWindow(self.window_name)
-            cv2.imshow(self.window_name, self.im0)
+            annotator.draw_region(reg_pts=self.reg_pts, thickness=self.tf * 2, color=(255, 0, 255))
+            cv2.imshow("Ultralytics YOLOv8 Queue Manager", im0)
             # Close window on 'q' key press
             if cv2.waitKey(1) & 0xFF == ord("q"):
                 return
@@ -152,12 +118,8 @@ class QueueManager:
             im0 (ndarray): Current frame from the video stream.
             tracks (list): List of tracks obtained from the object tracking process.
         """
-        self.im0 = im0  # Store the current frame
-        self.extract_and_process_tracks(tracks)  # Extract and process tracks
-
-        if self.view_img:
-            self.display_frames()  # Display the frame if enabled
-        return self.im0
+        self.extract_and_process_tracks(tracks, im0)  # Extract and process tracks
+        return im0
 
 
 if __name__ == "__main__":

ultralytics-8.2.93/ultralytics/solutions/speed_estimation.py

@@ -0,0 +1,116 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+
+from collections import defaultdict
+from time import time
+
+import cv2
+import numpy as np
+
+from ultralytics.utils.checks import check_imshow
+from ultralytics.utils.plotting import Annotator, colors
+
+
+class SpeedEstimator:
+    """A class to estimate the speed of objects in a real-time video stream based on their tracks."""
+
+    def __init__(self, names, reg_pts=None, view_img=False, line_thickness=2, spdl_dist_thresh=10):
+        """
+        Initializes the SpeedEstimator with the given parameters.
+
+        Args:
+            names (dict): Dictionary of class names.
+            reg_pts (list, optional): List of region points for speed estimation. Defaults to [(20, 400), (1260, 400)].
+            view_img (bool, optional): Whether to display the image with annotations. Defaults to False.
+            line_thickness (int, optional): Thickness of the lines for drawing boxes and tracks. Defaults to 2.
+            spdl_dist_thresh (int, optional): Distance threshold for speed calculation. Defaults to 10.
+        """
+        # Region information
+        self.reg_pts = reg_pts if reg_pts is not None else [(20, 400), (1260, 400)]
+
+        self.names = names  # Classes names
+
+        # Tracking information
+        self.trk_history = defaultdict(list)
+
+        self.view_img = view_img  # bool for displaying inference
+        self.tf = line_thickness  # line thickness for annotator
+        self.spd = {}  # set for speed data
+        self.trkd_ids = []  # list for already speed_estimated and tracked ID's
+        self.spdl = spdl_dist_thresh  # Speed line distance threshold
+        self.trk_pt = {}  # set for tracks previous time
+        self.trk_pp = {}  # set for tracks previous point
+
+        # Check if the environment supports imshow
+        self.env_check = check_imshow(warn=True)
+
+    def estimate_speed(self, im0, tracks):
+        """
+        Estimates the speed of objects based on tracking data.
+
+        Args:
+            im0 (ndarray): Image.
+            tracks (list): List of tracks obtained from the object tracking process.
+
+        Returns:
+            (ndarray): The image with annotated boxes and tracks.
+        """
+        if tracks[0].boxes.id is None:
+            return im0
+
+        boxes = tracks[0].boxes.xyxy.cpu()
+        clss = tracks[0].boxes.cls.cpu().tolist()
+        t_ids = tracks[0].boxes.id.int().cpu().tolist()
+        annotator = Annotator(im0, line_width=self.tf)
+        annotator.draw_region(reg_pts=self.reg_pts, color=(255, 0, 255), thickness=self.tf * 2)
+
+        for box, t_id, cls in zip(boxes, t_ids, clss):
+            track = self.trk_history[t_id]
+            bbox_center = (float((box[0] + box[2]) / 2), float((box[1] + box[3]) / 2))
+            track.append(bbox_center)
+
+            if len(track) > 30:
+                track.pop(0)
+
+            trk_pts = np.hstack(track).astype(np.int32).reshape((-1, 1, 2))
+
+            if t_id not in self.trk_pt:
+                self.trk_pt[t_id] = 0
+
+            speed_label = f"{int(self.spd[t_id])} km/h" if t_id in self.spd else self.names[int(cls)]
+            bbox_color = colors(int(t_id), True)
+
+            annotator.box_label(box, speed_label, bbox_color)
+            cv2.polylines(im0, [trk_pts], isClosed=False, color=bbox_color, thickness=self.tf)
+            cv2.circle(im0, (int(track[-1][0]), int(track[-1][1])), self.tf * 2, bbox_color, -1)
+
+            # Calculation of object speed
+            if not self.reg_pts[0][0] < track[-1][0] < self.reg_pts[1][0]:
+                return
+            if self.reg_pts[1][1] - self.spdl < track[-1][1] < self.reg_pts[1][1] + self.spdl:
+                direction = "known"
+            elif self.reg_pts[0][1] - self.spdl < track[-1][1] < self.reg_pts[0][1] + self.spdl:
+                direction = "known"
+            else:
+                direction = "unknown"
+
+            if self.trk_pt.get(t_id) != 0 and direction != "unknown" and t_id not in self.trkd_ids:
+                self.trkd_ids.append(t_id)
+
+                time_difference = time() - self.trk_pt[t_id]
+                if time_difference > 0:
+                    self.spd[t_id] = np.abs(track[-1][1] - self.trk_pp[t_id][1]) / time_difference
+
+            self.trk_pt[t_id] = time()
+            self.trk_pp[t_id] = track[-1]
+
+        if self.view_img and self.env_check:
+            cv2.imshow("Ultralytics Speed Estimation", im0)
+            if cv2.waitKey(1) & 0xFF == ord("q"):
+                return
+
+        return im0
+
+
+if __name__ == "__main__":
+    names = {0: "person", 1: "car"}  # example class names
+    speed_estimator = SpeedEstimator(names)

{ultralytics-8.2.91 → ultralytics-8.2.93/ultralytics.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ultralytics
-Version: 8.2.91
+Version: 8.2.93
 Summary: Ultralytics YOLOv8 for SOTA object detection, multi-object tracking, instance segmentation, pose estimation and image classification.
 Author: Glenn Jocher, Ayush Chaurasia, Jing Qiu
 Maintainer: Glenn Jocher, Ayush Chaurasia, Jing Qiu