dgenerate-ultralytics-headless 8.3.236__py3-none-any.whl → 8.3.239__py3-none-any.whl

ultralytics/solutions/parking_management.py

@@ -92,7 +92,7 @@ class ParkingPtsSelection:
 
         for text, cmd in [
             ("Upload Image", self.upload_image),
-            ("Remove Last BBox", self.remove_last_bounding_box),
+            ("Remove Last Bounding Box", self.remove_last_bounding_box),
             ("Save", self.save_to_json),
         ]:
             self.tk.Button(button_frame, text=text, command=cmd).pack(side=self.tk.LEFT)
@@ -186,9 +186,9 @@ class ParkingManagement(BaseSolution):
         json_file (str): Path to the JSON file containing parking region details.
         json (list[dict]): Loaded JSON data containing parking region information.
         pr_info (dict[str, int]): Dictionary storing parking information (Occupancy and Available spaces).
-        arc (tuple[int, int, int]): RGB color tuple for available region visualization.
-        occ (tuple[int, int, int]): RGB color tuple for occupied region visualization.
-        dc (tuple[int, int, int]): RGB color tuple for centroid visualization of detected objects.
+        arc (tuple[int, int, int]): BGR color tuple for available region visualization.
+        occ (tuple[int, int, int]): BGR color tuple for occupied region visualization.
+        dc (tuple[int, int, int]): BGR color tuple for centroid visualization of detected objects.
 
     Methods:
         process: Process the input image for parking lot management and visualization.
@@ -205,11 +205,11 @@ class ParkingManagement(BaseSolution):
         super().__init__(**kwargs)
 
         self.json_file = self.CFG["json_file"]  # Load parking regions JSON data
-        if self.json_file is None:
-            LOGGER.warning("json_file argument missing. Parking region details required.")
-            raise ValueError("❌ Json file path can not be empty")
+        if not self.json_file:
+            LOGGER.warning("ParkingManagement requires `json_file` with parking region coordinates.")
+            raise ValueError("❌ JSON file path cannot be empty.")
 
-        with open(self.json_file) as f:
+        with open(self.json_file, encoding="utf-8") as f:
             self.json = json.load(f)
 
         self.pr_info = {"Occupancy": 0, "Available": 0}  # Dictionary for parking information
@@ -239,28 +239,32 @@ class ParkingManagement(BaseSolution):
             >>> results = parking_manager.process(image)
         """
         self.extract_tracks(im0)  # Extract tracks from im0
-        es, fs = len(self.json), 0  # Empty slots, filled slots
+        available_slots, occupied_slots = len(self.json), 0
         annotator = SolutionAnnotator(im0, self.line_width)  # Initialize annotator
 
         for region in self.json:
             # Convert points to a NumPy array with the correct dtype and reshape properly
-            pts_array = np.array(region["points"], dtype=np.int32).reshape((-1, 1, 2))
-            rg_occupied = False  # Occupied region initialization
+            region_polygon = np.array(region["points"], dtype=np.int32).reshape((-1, 1, 2))
+            region_occupied = False
             for box, cls in zip(self.boxes, self.clss):
                 xc, yc = int((box[0] + box[2]) / 2), int((box[1] + box[3]) / 2)
-                dist = cv2.pointPolygonTest(pts_array, (xc, yc), False)
-                if dist >= 0:
+                inside_distance = cv2.pointPolygonTest(region_polygon, (xc, yc), False)
+                if inside_distance >= 0:
                     # cv2.circle(im0, (xc, yc), radius=self.line_width * 4, color=self.dc, thickness=-1)
                     annotator.display_objects_labels(
                         im0, self.model.names[int(cls)], (104, 31, 17), (255, 255, 255), xc, yc, 10
                     )
-                    rg_occupied = True
+                    region_occupied = True
                     break
-            fs, es = (fs + 1, es - 1) if rg_occupied else (fs, es)
+            if region_occupied:
+                occupied_slots += 1
+                available_slots -= 1
             # Plot regions
-            cv2.polylines(im0, [pts_array], isClosed=True, color=self.occ if rg_occupied else self.arc, thickness=2)
+            cv2.polylines(
+                im0, [region_polygon], isClosed=True, color=self.occ if region_occupied else self.arc, thickness=2
+            )
 
-        self.pr_info["Occupancy"], self.pr_info["Available"] = fs, es
+        self.pr_info["Occupancy"], self.pr_info["Available"] = occupied_slots, available_slots
 
         annotator.display_analytics(im0, self.pr_info, (104, 31, 17), (255, 255, 255), 10)
 

ultralytics/solutions/queue_management.py

@@ -14,7 +14,7 @@ class QueueManager(BaseSolution):
 
     Attributes:
         counts (int): The current count of objects in the queue.
-        rect_color (tuple[int, int, int]): RGB color tuple for drawing the queue region rectangle.
+        rect_color (tuple[int, int, int]): BGR color tuple for drawing the queue region rectangle.
         region_length (int): The number of points defining the queue region.
         track_line (list[tuple[int, int]]): List of track line coordinates.
         track_history (dict[int, list[tuple[int, int]]]): Dictionary storing tracking history for each object.
@@ -30,10 +30,10 @@ class QueueManager(BaseSolution):
         >>> cap = cv2.VideoCapture("path/to/video.mp4")
         >>> queue_manager = QueueManager(region=[100, 100, 200, 200, 300, 300])
         >>> while cap.isOpened():
-        >>>     success, im0 = cap.read()
-        >>>     if not success:
-        >>>         break
-        >>>     results = queue_manager.process(im0)
+        ...     success, im0 = cap.read()
+        ...     if not success:
+        ...         break
+        ...     results = queue_manager.process(im0)
     """
 
     def __init__(self, **kwargs: Any) -> None:

ultralytics/solutions/region_counter.py

@@ -67,7 +67,7 @@ class RegionCounter(BaseSolution):
             text_color (tuple[int, int, int]): BGR color for the text within the region.
 
         Returns:
-            (dict[str, any]): Returns a dictionary including the region information i.e. name, region_color etc.
+            (dict[str, Any]): Region information including name, polygon, and display colors.
         """
         region = self.region_template.copy()
         region.update(
@@ -82,7 +82,7 @@ class RegionCounter(BaseSolution):
         return region
 
     def initialize_regions(self):
-        """Initialize regions only once."""
+        """Initialize regions from `self.region` only once."""
         if self.region is None:
             self.initialize_region()
         if not isinstance(self.region, dict):  # Ensure self.region is initialized and structured as a dictionary

ultralytics/solutions/security_alarm.py

@@ -98,7 +98,7 @@ class SecurityAlarm(BaseSolution):
         message["Subject"] = "Security Alert"
 
         # Add the text message body
-        message_body = f"Ultralytics ALERT!!! {records} objects have been detected!!"
+        message_body = f"Ultralytics alert: {records} object(s) detected."
         message.attach(MIMEText(message_body))
 
         # Attach the image

ultralytics/solutions/solutions.py

@@ -177,7 +177,7 @@ class BaseSolution:
             self.track_ids = self.track_data.id.int().cpu().tolist()
             self.confs = self.track_data.conf.cpu().tolist()
         else:
-            self.LOGGER.warning("no tracks found!")
+            self.LOGGER.warning("No tracks found.")
             self.boxes, self.clss, self.track_ids, self.confs = [], [], [], []
 
     def store_tracking_history(self, track_id: int, box) -> None:
@@ -271,7 +271,7 @@ class SolutionAnnotator(Annotator):
         font_size (int): Size of the font used for text annotations.
         font (str): Path to the font file used for text rendering.
         pil (bool): Whether to use PIL for text rendering.
-        example (str): An example attribute for demonstration purposes.
+        example (str): Example text used to detect non-ASCII labels for PIL rendering.
 
     Methods:
         draw_region: Draw a region using specified points, colors, and thickness.
@@ -312,7 +312,7 @@ class SolutionAnnotator(Annotator):
             font_size (int, optional): Font size for text annotations.
             font (str): Path to the font file.
             pil (bool): Indicates whether to use PIL for rendering text.
-            example (str): An example parameter for demonstration purposes.
+            example (str): Example text used to detect non-ASCII labels for PIL rendering.
         """
         super().__init__(im, line_width, font_size, font, pil, example)
 
@@ -326,7 +326,7 @@ class SolutionAnnotator(Annotator):
 
         Args:
             reg_pts (list[tuple[int, int]], optional): Region points (for line 2 points, for region 4+ points).
-            color (tuple[int, int, int]): RGB color value for the region.
+            color (tuple[int, int, int]): BGR color value for the region (OpenCV format).
             thickness (int): Line thickness for drawing the region.
         """
         cv2.polylines(self.im, [np.array(reg_pts, dtype=np.int32)], isClosed=True, color=color, thickness=thickness)
@@ -347,8 +347,8 @@ class SolutionAnnotator(Annotator):
         Args:
             label (str): Queue counts label.
             points (list[tuple[int, int]], optional): Region points for center point calculation to display text.
-            region_color (tuple[int, int, int]): RGB queue region color.
-            txt_color (tuple[int, int, int]): RGB text display color.
+            region_color (tuple[int, int, int]): BGR queue region color (OpenCV format).
+            txt_color (tuple[int, int, int]): BGR text color (OpenCV format).
         """
         x_values = [point[0] for point in points]
         y_values = [point[1] for point in points]
@@ -388,13 +388,13 @@ class SolutionAnnotator(Annotator):
         bg_color: tuple[int, int, int],
         margin: int,
     ):
-        """Display the overall statistics for parking lots, object counter etc.
+        """Display overall statistics for Solutions (e.g., parking management and object counting).
 
         Args:
             im0 (np.ndarray): Inference image.
             text (dict[str, Any]): Labels dictionary.
-            txt_color (tuple[int, int, int]): Display color for text foreground.
-            bg_color (tuple[int, int, int]): Display color for text background.
+            txt_color (tuple[int, int, int]): Text color (BGR, OpenCV format).
+            bg_color (tuple[int, int, int]): Background color (BGR, OpenCV format).
             margin (int): Gap between text and rectangle for better display.
         """
         horizontal_gap = int(im0.shape[1] * 0.02)
@@ -415,22 +415,45 @@ class SolutionAnnotator(Annotator):
             cv2.putText(im0, txt, (text_x, text_y), 0, self.sf, txt_color, self.tf, lineType=cv2.LINE_AA)
             text_y_offset = rect_y2
 
+    @staticmethod
+    def _point_xy(point: Any) -> tuple[float, float]:
+        """Convert a keypoint-like object to an (x, y) tuple of floats."""
+        if hasattr(point, "detach"):  # torch.Tensor
+            point = point.detach()
+        if hasattr(point, "cpu"):  # torch.Tensor
+            point = point.cpu()
+        if hasattr(point, "numpy"):  # torch.Tensor
+            point = point.numpy()
+        if hasattr(point, "tolist"):  # numpy / torch
+            point = point.tolist()
+        return float(point[0]), float(point[1])
+
     @staticmethod
     @lru_cache(maxsize=256)
-    def estimate_pose_angle(a: list[float], b: list[float], c: list[float]) -> float:
+    def _estimate_pose_angle_cached(a: tuple[float, float], b: tuple[float, float], c: tuple[float, float]) -> float:
+        """Calculate the angle between three points for workout monitoring (cached)."""
+        radians = math.atan2(c[1] - b[1], c[0] - b[0]) - math.atan2(a[1] - b[1], a[0] - b[0])
+        angle = abs(radians * 180.0 / math.pi)
+        return angle if angle <= 180.0 else (360 - angle)
+
+    @staticmethod
+    def estimate_pose_angle(a: Any, b: Any, c: Any) -> float:
         """Calculate the angle between three points for workout monitoring.
 
         Args:
-            a (list[float]): The coordinates of the first point.
-            b (list[float]): The coordinates of the second point (vertex).
-            c (list[float]): The coordinates of the third point.
+            a (Any): The coordinates of the first point (e.g. list/tuple/NumPy array/torch tensor).
+            b (Any): The coordinates of the second point (vertex).
+            c (Any): The coordinates of the third point.
 
         Returns:
             (float): The angle in degrees between the three points.
         """
-        radians = math.atan2(c[1] - b[1], c[0] - b[0]) - math.atan2(a[1] - b[1], a[0] - b[0])
-        angle = abs(radians * 180.0 / math.pi)
-        return angle if angle <= 180.0 else (360 - angle)
+        a_xy, b_xy, c_xy = (
+            SolutionAnnotator._point_xy(a),
+            SolutionAnnotator._point_xy(b),
+            SolutionAnnotator._point_xy(c),
+        )
+        return SolutionAnnotator._estimate_pose_angle_cached(a_xy, b_xy, c_xy)
 
     def draw_specific_kpts(
         self,
@@ -543,7 +566,7 @@ class SolutionAnnotator(Annotator):
         """Plot the distance and line between two centroids on the frame.
 
         Args:
-            pixels_distance (float): Pixels distance between two bbox centroids.
+            pixels_distance (float): Pixel distance between two bounding-box centroids.
             centroids (list[tuple[int, int]]): Bounding box centroids data.
             line_color (tuple[int, int, int]): Distance line color.
             centroid_color (tuple[int, int, int]): Bounding box centroid color.
@@ -634,8 +657,8 @@ class SolutionAnnotator(Annotator):
             line_x (int): The x-coordinate of the sweep line.
             line_y (int): The y-coordinate limit of the sweep line.
             label (str, optional): Text label to be drawn in center of sweep line. If None, no label is drawn.
-            color (tuple[int, int, int]): RGB color for the line and label background.
-            txt_color (tuple[int, int, int]): RGB color for the label text.
+            color (tuple[int, int, int]): BGR color for the line and label background (OpenCV format).
+            txt_color (tuple[int, int, int]): BGR color for the label text (OpenCV format).
         """
         # Draw the sweep line
         cv2.line(self.im, (line_x, 0), (line_x, line_y), color, self.tf * 2)
@@ -695,15 +718,15 @@ class SolutionAnnotator(Annotator):
             box (tuple[float, float, float, float]): The bounding box coordinates (x1, y1, x2, y2).
             label (str): The text label to be displayed.
             color (tuple[int, int, int]): The background color of the rectangle (B, G, R).
-            txt_color (tuple[int, int, int]): The color of the text (R, G, B).
-            shape (str): The shape of the label i.e "circle" or "rect"
+            txt_color (tuple[int, int, int]): The color of the text (B, G, R).
+            shape (str): Label shape. Options: "circle" or "rect".
             margin (int): The margin between the text and the rectangle border.
         """
         if shape == "circle" and len(label) > 3:
             LOGGER.warning(f"Length of label is {len(label)}, only first 3 letters will be used for circle annotation.")
             label = label[:3]
 
-        x_center, y_center = int((box[0] + box[2]) / 2), int((box[1] + box[3]) / 2)  # Calculate center of the bbox
+        x_center, y_center = int((box[0] + box[2]) / 2), int((box[1] + box[3]) / 2)  # Bounding-box center
         text_size = cv2.getTextSize(label, cv2.FONT_HERSHEY_SIMPLEX, self.sf - 0.15, self.tf)[0]  # Get size of the text
         text_x, text_y = x_center - text_size[0] // 2, y_center + text_size[1] // 2  # Calculate top-left corner of text
 

ultralytics/solutions/speed_estimation.py

@@ -62,7 +62,7 @@ class SpeedEstimator(BaseSolution):
         """Process an input frame to estimate object speeds based on tracking data.
 
         Args:
-            im0 (np.ndarray): Input image for processing with shape (H, W, C) for RGB images.
+            im0 (np.ndarray): Input image for processing with shape (H, W, C) in OpenCV BGR format.
 
         Returns:
             (SolutionResults): Contains processed image `plot_im` and `total_tracks` (number of tracked objects).

ultralytics/trackers/basetrack.py

@@ -19,7 +19,7 @@ class TrackState:
     Examples:
         >>> state = TrackState.New
         >>> if state == TrackState.New:
-        >>>     print("Object is newly detected.")
+        ...     print("Object is newly detected.")
     """
 
     New = 0

ultralytics/trackers/bot_sort.py

@@ -45,9 +45,9 @@ class BOTrack(STrack):
 
     Examples:
         Create a BOTrack instance and update its features
-        >>> bo_track = BOTrack(tlwh=[100, 50, 80, 40], score=0.9, cls=1, feat=np.random.rand(128))
+        >>> bo_track = BOTrack(xywh=np.array([100, 50, 80, 40, 0]), score=0.9, cls=1, feat=np.random.rand(128))
         >>> bo_track.predict()
-        >>> new_track = BOTrack(tlwh=[110, 60, 80, 40], score=0.85, cls=1, feat=np.random.rand(128))
+        >>> new_track = BOTrack(xywh=np.array([110, 60, 80, 40, 0]), score=0.85, cls=1, feat=np.random.rand(128))
         >>> bo_track.update(new_track, frame_id=2)
     """
 
@@ -59,7 +59,8 @@ class BOTrack(STrack):
         """Initialize a BOTrack object with temporal parameters, such as feature history, alpha, and current features.
 
         Args:
-            xywh (np.ndarray): Bounding box coordinates in xywh format (center x, center y, width, height).
+            xywh (np.ndarray): Bounding box in `(x, y, w, h, idx)` or `(x, y, w, h, angle, idx)` format, where (x, y) is
+                the center, (w, h) are width and height, and `idx` is the detection index.
             score (float): Confidence score of the detection.
             cls (int): Class ID of the detected object.
             feat (np.ndarray, optional): Feature vector associated with the detection.

ultralytics/trackers/byte_tracker.py

@@ -56,8 +56,8 @@ class STrack(BaseTrack):
         """Initialize a new STrack instance.
 
         Args:
-            xywh (list[float]): Bounding box coordinates and dimensions in the format (x, y, w, h, [a], idx), where (x,
-                y) is the center, (w, h) are width and height, [a] is optional aspect ratio, and idx is the id.
+            xywh (list[float]): Bounding box in `(x, y, w, h, idx)` or `(x, y, w, h, angle, idx)` format, where (x, y)
+                is the center, (w, h) are width and height, and `idx` is the detection index.
             score (float): Confidence score of the detection.
             cls (Any): Class label for the detected object.
         """
@@ -338,7 +338,7 @@ class BYTETracker:
         # Step 3: Second association, with low score detection boxes association the untrack to the low score detections
         detections_second = self.init_track(results_second, feats_second)
         r_tracked_stracks = [strack_pool[i] for i in u_track if strack_pool[i].state == TrackState.Tracked]
-        # TODO
+        # TODO: consider fusing scores or appearance features for second association.
         dists = matching.iou_distance(r_tracked_stracks, detections_second)
         matches, u_track, _u_detection_second = matching.linear_assignment(dists, thresh=0.5)
         for itracked, idet in matches:
@@ -389,7 +389,7 @@ class BYTETracker:
         self.tracked_stracks, self.lost_stracks = self.remove_duplicate_stracks(self.tracked_stracks, self.lost_stracks)
         self.removed_stracks.extend(removed_stracks)
         if len(self.removed_stracks) > 1000:
-            self.removed_stracks = self.removed_stracks[-999:]  # clip remove stracks to 1000 maximum
+            self.removed_stracks = self.removed_stracks[-1000:]  # clip removed stracks to 1000 maximum
 
         return np.asarray([x.result for x in self.tracked_stracks if x.is_activated], dtype=np.float32)
 

ultralytics/trackers/utils/gmc.py

@@ -34,11 +34,10 @@ class GMC:
     Examples:
         Create a GMC object and apply it to a frame
         >>> gmc = GMC(method="sparseOptFlow", downscale=2)
-        >>> frame = np.array([[1, 2, 3], [4, 5, 6]])
-        >>> processed_frame = gmc.apply(frame)
-        >>> print(processed_frame)
-        array([[1, 2, 3],
-               [4, 5, 6]])
+        >>> frame = np.random.randint(0, 255, (480, 640, 3), dtype=np.uint8)
+        >>> warp = gmc.apply(frame)
+        >>> print(warp.shape)
+        (2, 3)
     """
 
     def __init__(self, method: str = "sparseOptFlow", downscale: int = 2) -> None:
@@ -85,7 +84,7 @@ class GMC:
         self.initializedFirstFrame = False
 
     def apply(self, raw_frame: np.ndarray, detections: list | None = None) -> np.ndarray:
-        """Apply object detection on a raw frame using the specified method.
+        """Estimate a 2×3 motion compensation warp for a frame.
 
         Args:
             raw_frame (np.ndarray): The raw frame to be processed, with shape (H, W, C).
@@ -145,7 +144,7 @@ class GMC:
         try:
             (_, H) = cv2.findTransformECC(self.prevFrame, frame, H, self.warp_mode, self.criteria, None, 1)
         except Exception as e:
-            LOGGER.warning(f"find transform failed. Set warp as identity {e}")
+            LOGGER.warning(f"findTransformECC failed; using identity warp. {e}")
 
         return H
 

ultralytics/trackers/utils/kalman_filter.py

@@ -167,9 +167,10 @@ class KalmanFilterXYAH:
             covariance (np.ndarray): Covariance matrix of the predicted states with shape (N, 8, 8).
 
         Examples:
+            >>> kf = KalmanFilterXYAH()
             >>> mean = np.random.rand(10, 8)  # 10 object states
             >>> covariance = np.random.rand(10, 8, 8)  # Covariance matrices for 10 object states
-            >>> predicted_mean, predicted_covariance = kalman_filter.multi_predict(mean, covariance)
+            >>> predicted_mean, predicted_covariance = kf.multi_predict(mean, covariance)
         """
         std_pos = [
             self._std_weight_position * mean[:, 3],

ultralytics/trackers/utils/matching.py

@@ -26,9 +26,10 @@ def linear_assignment(cost_matrix: np.ndarray, thresh: float, use_lap: bool = Tr
         use_lap (bool): Use lap.lapjv for the assignment. If False, scipy.optimize.linear_sum_assignment is used.
 
     Returns:
-        matched_indices (np.ndarray): Array of matched indices of shape (K, 2), where K is the number of matches.
-        unmatched_a (np.ndarray): Array of unmatched indices from the first set, with shape (L,).
-        unmatched_b (np.ndarray): Array of unmatched indices from the second set, with shape (M,).
+        matched_indices (list[list[int]] | np.ndarray): Matched indices of shape (K, 2), where K is the number of
+            matches.
+        unmatched_a (np.ndarray): Unmatched indices from the first set, with shape (L,).
+        unmatched_b (np.ndarray): Unmatched indices from the second set, with shape (M,).
 
     Examples:
         >>> cost_matrix = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

ultralytics/utils/__init__.py

@@ -14,6 +14,7 @@ import socket
 import sys
 import threading
 import time
+import warnings
 from functools import lru_cache
 from pathlib import Path
 from threading import Lock
@@ -132,6 +133,14 @@ os.environ["TF_CPP_MIN_LOG_LEVEL"] = "3"  # suppress verbose TF compiler warning
 os.environ["TORCH_CPP_LOG_LEVEL"] = "ERROR"  # suppress "NNPACK.cpp could not initialize NNPACK" warnings
 os.environ["KINETO_LOG_LEVEL"] = "5"  # suppress verbose PyTorch profiler output when computing FLOPs
 
+# Centralized warning suppression
+warnings.filterwarnings("ignore", message="torch.distributed.reduce_op is deprecated")  # PyTorch deprecation
+warnings.filterwarnings("ignore", message="The figure layout has changed to tight")  # matplotlib>=3.7.2
+warnings.filterwarnings("ignore", category=FutureWarning, module="timm")  # mobileclip timm.layers deprecation
+warnings.filterwarnings("ignore", category=torch.jit.TracerWarning)  # ONNX/TorchScript export tracer warnings
+warnings.filterwarnings("ignore", category=UserWarning, message=".*prim::Constant.*")  # ONNX shape warning
+warnings.filterwarnings("ignore", category=DeprecationWarning, module="coremltools")  # CoreML np.bool deprecation
+
 # Precompiled type tuples for faster isinstance() checks
 FLOAT_OR_INT = (float, int)
 STR_OR_PATH = (str, Path)
@@ -142,7 +151,7 @@ class DataExportMixin:
 
     This class provides utilities to export performance metrics (e.g., mAP, precision, recall) or prediction results
     from classification, object detection, segmentation, or pose estimation tasks into various formats: Polars
-    DataFrame, CSV and JSON.
+    DataFrame, CSV, and JSON.
 
     Methods:
         to_df: Convert summary to a Polars DataFrame.
@@ -159,14 +168,14 @@ class DataExportMixin:
     """
 
     def to_df(self, normalize=False, decimals=5):
-        """Create a polars DataFrame from the prediction results summary or validation metrics.
+        """Create a Polars DataFrame from the prediction results summary or validation metrics.
 
         Args:
             normalize (bool, optional): Normalize numerical values for easier comparison.
             decimals (int, optional): Decimal places to round floats.
 
         Returns:
-            (DataFrame): DataFrame containing the summary data.
+            (polars.DataFrame): Polars DataFrame containing the summary data.
         """
         import polars as pl  # scope for faster 'import ultralytics'
 

ultralytics/utils/benchmarks.py

@@ -1,6 +1,6 @@
 # Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
 """
-Benchmark a YOLO model formats for speed and accuracy.
+Benchmark YOLO model formats for speed and accuracy.
 
 Usage:
     from ultralytics.utils.benchmarks import ProfileModels, benchmark
@@ -78,7 +78,7 @@ def benchmark(
         **kwargs (Any): Additional keyword arguments for exporter.
 
     Returns:
-        (polars.DataFrame): A polars DataFrame with benchmark results for each format, including file size, metric, and
+        (polars.DataFrame): A Polars DataFrame with benchmark results for each format, including file size, metric, and
             inference time.
 
     Examples:

ultralytics/utils/callbacks/tensorboard.py

@@ -9,7 +9,6 @@ try:
     PREFIX = colorstr("TensorBoard: ")
 
     # Imports below only required if TensorBoard enabled
-    import warnings
     from copy import deepcopy
 
     import torch
@@ -61,32 +60,27 @@ def _log_tensorboard_graph(trainer) -> None:
     p = next(trainer.model.parameters())  # for device, type
     im = torch.zeros((1, 3, *imgsz), device=p.device, dtype=p.dtype)  # input image (must be zeros, not empty)
 
-    with warnings.catch_warnings():
-        warnings.simplefilter("ignore", category=UserWarning)  # suppress jit trace warning
-        warnings.simplefilter("ignore", category=torch.jit.TracerWarning)  # suppress jit trace warning
-
-        # Try simple method first (YOLO)
+    # Try simple method first (YOLO)
+    try:
+        trainer.model.eval()  # place in .eval() mode to avoid BatchNorm statistics changes
+        WRITER.add_graph(torch.jit.trace(torch_utils.unwrap_model(trainer.model), im, strict=False), [])
+        LOGGER.info(f"{PREFIX}model graph visualization added ✅")
+        return
+    except Exception as e1:
+        # Fallback to TorchScript export steps (RTDETR)
         try:
-            trainer.model.eval()  # place in .eval() mode to avoid BatchNorm statistics changes
-            WRITER.add_graph(torch.jit.trace(torch_utils.unwrap_model(trainer.model), im, strict=False), [])
+            model = deepcopy(torch_utils.unwrap_model(trainer.model))
+            model.eval()
+            model = model.fuse(verbose=False)
+            for m in model.modules():
+                if hasattr(m, "export"):  # Detect, RTDETRDecoder (Segment and Pose use Detect base class)
+                    m.export = True
+                    m.format = "torchscript"
+            model(im)  # dry run
+            WRITER.add_graph(torch.jit.trace(model, im, strict=False), [])
             LOGGER.info(f"{PREFIX}model graph visualization added ✅")
-            return
-
-        except Exception:
-            # Fallback to TorchScript export steps (RTDETR)
-            try:
-                model = deepcopy(torch_utils.unwrap_model(trainer.model))
-                model.eval()
-                model = model.fuse(verbose=False)
-                for m in model.modules():
-                    if hasattr(m, "export"):  # Detect, RTDETRDecoder (Segment and Pose use Detect base class)
-                        m.export = True
-                        m.format = "torchscript"
-                model(im)  # dry run
-                WRITER.add_graph(torch.jit.trace(model, im, strict=False), [])
-                LOGGER.info(f"{PREFIX}model graph visualization added ✅")
-            except Exception as e:
-                LOGGER.warning(f"{PREFIX}TensorBoard graph visualization failure {e}")
+        except Exception as e2:
+            LOGGER.warning(f"{PREFIX}TensorBoard graph visualization failure: {e1} -> {e2}")
 
 
 def on_pretrain_routine_start(trainer) -> None:

ultralytics/utils/checks.py

@@ -379,8 +379,8 @@ def check_apt_requirements(requirements):
             f"{prefix} Ultralytics requirement{'s' * (len(missing_packages) > 1)} {missing_packages} not found, attempting AutoUpdate..."
         )
         # Optionally update package list first
-        if is_sudo_available():
-            subprocess.run(["sudo", "apt", "update"], check=False)
+        cmd = (["sudo"] if is_sudo_available() else []) + ["apt", "update"]
+        result = subprocess.run(cmd, check=True, capture_output=True, text=True)
 
         # Build and run the install command
         cmd = (["sudo"] if is_sudo_available() else []) + ["apt", "install", "-y"] + missing_packages
@@ -476,7 +476,8 @@ def check_requirements(requirements=ROOT.parent / "requirements.txt", exclude=()
             try:
                 t = time.time()
                 assert ONLINE, "AutoUpdate skipped (offline)"
-                LOGGER.info(attempt_install(s, cmds, use_uv=not ARM64 and check_uv()))
+                use_uv = not ARM64 and check_uv()  # uv fails on ARM64
+                LOGGER.info(attempt_install(s, cmds, use_uv=use_uv))
                 dt = time.time() - t
                 LOGGER.info(f"{prefix} AutoUpdate success ✅ {dt:.1f}s")
                 LOGGER.warning(

ultralytics/utils/downloads.py

@@ -81,7 +81,7 @@ def delete_dsstore(path: str | Path, files_to_delete: tuple[str, ...] = (".DS_St
         >>> delete_dsstore("path/to/dir")
 
     Notes:
-        ".DS_store" files are created by the Apple operating system and contain metadata about folders and files. They
+        ".DS_Store" files are created by the Apple operating system and contain metadata about folders and files. They
         are hidden system files and can cause issues when transferring files between different operating systems.
     """
     for file in files_to_delete:

ultralytics/utils/export/tensorflow.py

@@ -90,10 +90,24 @@ def onnx2saved_model(
     if int8:
         tmp_file = output_dir / "tmp_tflite_int8_calibration_images.npy"  # int8 calibration images file
         if images is not None:
-            output_dir.mkdir()
+            output_dir.mkdir(parents=True, exist_ok=True)
             np.save(str(tmp_file), images)  # BHWC
             np_data = [["images", tmp_file, [[[[0, 0, 0]]]], [[[[255, 255, 255]]]]]]
 
+    # Patch onnx.helper for onnx_graphsurgeon compatibility with ONNX>=1.17
+    # The float32_to_bfloat16 function was removed in ONNX 1.17, but onnx_graphsurgeon still uses it
+    import onnx.helper
+
+    if not hasattr(onnx.helper, "float32_to_bfloat16"):
+        import struct
+
+        def float32_to_bfloat16(fval):
+            """Convert float32 to bfloat16 (truncates lower 16 bits of mantissa)."""
+            ival = struct.unpack("=I", struct.pack("=f", fval))[0]
+            return ival >> 16
+
+        onnx.helper.float32_to_bfloat16 = float32_to_bfloat16
+
     import onnx2tf  # scoped for after ONNX export for reduced conflict during import
 
     LOGGER.info(f"{prefix} starting TFLite export with onnx2tf {onnx2tf.__version__}...")
@@ -196,7 +210,7 @@ def pb2tfjs(pb_file: str, output_dir: str, half: bool = False, int8: bool = Fals
     LOGGER.info(f"\n{prefix} output node names: {outputs}")
 
     quantization = "--quantize_float16" if half else "--quantize_uint8" if int8 else ""
-    with spaces_in_path(pb_file) as fpb_, spaces_in_path(output_dir) as f_:  # exporter can not handle spaces in path
+    with spaces_in_path(pb_file) as fpb_, spaces_in_path(output_dir) as f_:  # exporter cannot handle spaces in paths
         cmd = (
             "tensorflowjs_converter "
             f'--input_format=tf_frozen_model {quantization} --output_node_names={outputs} "{fpb_}" "{f_}"'