ultralytics 8.3.86__py3-none-any.whl → 8.3.88__py3-none-any.whl

ultralytics/utils/callbacks/comet.py

@@ -1,6 +1,10 @@
 # Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
-
+from collections.abc import Callable
 from types import SimpleNamespace
+from typing import Any, List, Optional
+
+import cv2
+import numpy as np
 
 from ultralytics.utils import LOGGER, RANK, SETTINGS, TESTS_RUNNING, ops
 from ultralytics.utils.metrics import ClassifyMetrics, DetMetrics, OBBMetrics, PoseMetrics, SegmentMetrics
@@ -16,7 +20,7 @@ try:
     from pathlib import Path
 
     # Ensures certain logging functions only run for supported tasks
-    COMET_SUPPORTED_TASKS = ["detect"]
+    COMET_SUPPORTED_TASKS = ["detect", "segment"]
 
     # Names of plots created by Ultralytics that are logged to Comet
     CONFUSION_MATRIX_PLOT_NAMES = "confusion_matrix", "confusion_matrix_normalized"
@@ -177,7 +181,7 @@ def _format_ground_truth_annotations_for_detection(img_idx, image_path, batch, c
     return {"name": "ground_truth", "data": data}
 
 
-def _format_prediction_annotations_for_detection(image_path, metadata, class_label_map=None, class_map=None):
+def _format_prediction_annotations(image_path, metadata, class_label_map=None, class_map=None):
     """Format YOLO predictions for object detection visualization."""
     stem = image_path.stem
     image_id = int(stem) if stem.isnumeric() else stem
@@ -193,6 +197,12 @@ def _format_prediction_annotations_for_detection(image_path, metadata, class_lab
         # with prediction's category ID indices (can start from one)
         label_index_offset = sorted(class_map)[0]
 
+    try:
+        # import pycotools utilities to decompress annotations for various tasks, e.g. segmentation
+        from pycocotools.mask import decode  # noqa
+    except ImportError:
+        decode = None
+
     data = []
     for prediction in predictions:
         boxes = prediction["bbox"]
@@ -201,17 +211,39 @@ def _format_prediction_annotations_for_detection(image_path, metadata, class_lab
         if class_label_map:
             cls_label = str(class_label_map[cls_label - label_index_offset])
 
-        data.append({"boxes": [boxes], "label": cls_label, "score": score})
+        annotation_data = {"boxes": [boxes], "label": cls_label, "score": score}
+
+        if decode is not None:
+            # do segmentation processing only if we are able to decode it
+            segments = prediction.get("segmentation", None)
+            if segments is not None:
+                segments = _extract_segmentation_annotation(segments, decode)
+                if segments is not None:
+                    annotation_data["points"] = segments
+
+        data.append(annotation_data)
 
     return {"name": "prediction", "data": data}
 
 
+def _extract_segmentation_annotation(segmentation_raw: str, decode: Callable) -> Optional[List[List[Any]]]:
+    """Extracts segmentation annotation from compressed segmentations as list of polygons."""
+    try:
+        mask = decode(segmentation_raw)
+        contours, _ = cv2.findContours(mask, cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)
+        annotations = [np.array(polygon).squeeze() for polygon in contours if len(polygon) >= 3]
+        return [annotation.ravel().tolist() for annotation in annotations]
+    except Exception as e:
+        LOGGER.warning(f"COMET WARNING: Failed to extract segmentation annotation: {e}")
+    return None
+
+
 def _fetch_annotations(img_idx, image_path, batch, prediction_metadata_map, class_label_map, class_map):
     """Join the ground truth and prediction annotations if they exist."""
     ground_truth_annotations = _format_ground_truth_annotations_for_detection(
         img_idx, image_path, batch, class_label_map
     )
-    prediction_annotations = _format_prediction_annotations_for_detection(
+    prediction_annotations = _format_prediction_annotations(
         image_path, prediction_metadata_map, class_label_map, class_map
     )
 

ultralytics/utils/instance.py

@@ -188,12 +188,12 @@ class Instances:
 
     Attributes:
         _bboxes (Bboxes): Internal object for handling bounding box operations.
-        keypoints (ndarray): keypoints(x, y, visible) with shape [N, 17, 3]. Default is None.
+        keypoints (np.ndarray): keypoints(x, y, visible) with shape [N, 17, 3]. Default is None.
         normalized (bool): Flag indicating whether the bounding box coordinates are normalized.
-        segments (ndarray): Segments array with shape [N, 1000, 2] after resampling.
+        segments (np.ndarray): Segments array with shape [N, 1000, 2] after resampling.
 
     Args:
-        bboxes (ndarray): An array of bounding boxes with shape [N, 4].
+        bboxes (np.ndarray): An array of bounding boxes with shape [N, 4].
         segments (list | ndarray, optional): A list or array of object segments. Default is None.
         keypoints (ndarray, optional): An array of keypoints with shape [N, 17, 3]. Default is None.
         bbox_format (str, optional): The format of bounding boxes ('xywh' or 'xyxy'). Default is 'xywh'.

ultralytics/utils/plotting.py

@@ -271,84 +271,6 @@ class Annotator:
         else:
             return txt_color
 
-    def circle_label(self, box, label="", color=(128, 128, 128), txt_color=(255, 255, 255), margin=2):
-        """
-        Draws a label with a background circle centered within a given bounding box.
-
-        Args:
-            box (tuple): The bounding box coordinates (x1, y1, x2, y2).
-            label (str): The text label to be displayed.
-            color (tuple, optional): The background color of the rectangle (B, G, R).
-            txt_color (tuple, optional): The color of the text (R, G, B).
-            margin (int, optional): The margin between the text and the rectangle border.
-        """
-        # If label have more than 3 characters, skip other characters, due to circle size
-        if len(label) > 3:
-            print(
-                f"Length of label is {len(label)}, initial 3 label characters will be considered for circle annotation!"
-            )
-            label = label[:3]
-
-        # Calculate the center of the box
-        x_center, y_center = int((box[0] + box[2]) / 2), int((box[1] + box[3]) / 2)
-        # Get the text size
-        text_size = cv2.getTextSize(str(label), cv2.FONT_HERSHEY_SIMPLEX, self.sf - 0.15, self.tf)[0]
-        # Calculate the required radius to fit the text with the margin
-        required_radius = int(((text_size[0] ** 2 + text_size[1] ** 2) ** 0.5) / 2) + margin
-        # Draw the circle with the required radius
-        cv2.circle(self.im, (x_center, y_center), required_radius, color, -1)
-        # Calculate the position for the text
-        text_x = x_center - text_size[0] // 2
-        text_y = y_center + text_size[1] // 2
-        # Draw the text
-        cv2.putText(
-            self.im,
-            str(label),
-            (text_x, text_y),
-            cv2.FONT_HERSHEY_SIMPLEX,
-            self.sf - 0.15,
-            self.get_txt_color(color, txt_color),
-            self.tf,
-            lineType=cv2.LINE_AA,
-        )
-
-    def text_label(self, box, label="", color=(128, 128, 128), txt_color=(255, 255, 255), margin=5):
-        """
-        Draws a label with a background rectangle centered within a given bounding box.
-
-        Args:
-            box (tuple): The bounding box coordinates (x1, y1, x2, y2).
-            label (str): The text label to be displayed.
-            color (tuple, optional): The background color of the rectangle (B, G, R).
-            txt_color (tuple, optional): The color of the text (R, G, B).
-            margin (int, optional): The margin between the text and the rectangle border.
-        """
-        # Calculate the center of the bounding box
-        x_center, y_center = int((box[0] + box[2]) / 2), int((box[1] + box[3]) / 2)
-        # Get the size of the text
-        text_size = cv2.getTextSize(label, cv2.FONT_HERSHEY_SIMPLEX, self.sf - 0.1, self.tf)[0]
-        # Calculate the top-left corner of the text (to center it)
-        text_x = x_center - text_size[0] // 2
-        text_y = y_center + text_size[1] // 2
-        # Calculate the coordinates of the background rectangle
-        rect_x1 = text_x - margin
-        rect_y1 = text_y - text_size[1] - margin
-        rect_x2 = text_x + text_size[0] + margin
-        rect_y2 = text_y + margin
-        # Draw the background rectangle
-        cv2.rectangle(self.im, (rect_x1, rect_y1), (rect_x2, rect_y2), color, -1)
-        # Draw the text on top of the rectangle
-        cv2.putText(
-            self.im,
-            label,
-            (text_x, text_y),
-            cv2.FONT_HERSHEY_SIMPLEX,
-            self.sf - 0.1,
-            self.get_txt_color(color, txt_color),
-            self.tf,
-            lineType=cv2.LINE_AA,
-        )
-
     def box_label(self, box, label="", color=(128, 128, 128), txt_color=(255, 255, 255), rotated=False):
         """
         Draws a bounding box to image with label.
@@ -591,342 +513,6 @@ class Annotator:
         height = y_max - y_min
         return width, height, width * height
 
-    def draw_region(self, reg_pts=None, color=(0, 255, 0), thickness=5):
-        """
-        Draw region line.
-
-        Args:
-            reg_pts (list): Region Points (for line 2 points, for region 4 points)
-            color (tuple): Region Color value
-            thickness (int): Region area thickness value
-        """
-        cv2.polylines(self.im, [np.array(reg_pts, dtype=np.int32)], isClosed=True, color=color, thickness=thickness)
-
-        # Draw small circles at the corner points
-        for point in reg_pts:
-            cv2.circle(self.im, (point[0], point[1]), thickness * 2, color, -1)  # -1 fills the circle
-
-    def draw_centroid_and_tracks(self, track, color=(255, 0, 255), track_thickness=2):
-        """
-        Draw centroid point and track trails.
-
-        Args:
-            track (list): object tracking points for trails display
-            color (tuple): tracks line color
-            track_thickness (int): track line thickness value
-        """
-        points = np.hstack(track).astype(np.int32).reshape((-1, 1, 2))
-        cv2.polylines(self.im, [points], isClosed=False, color=color, thickness=track_thickness)
-        cv2.circle(self.im, (int(track[-1][0]), int(track[-1][1])), track_thickness * 2, color, -1)
-
-    def queue_counts_display(self, label, points=None, region_color=(255, 255, 255), txt_color=(0, 0, 0)):
-        """
-        Displays queue counts on an image centered at the points with customizable font size and colors.
-
-        Args:
-            label (str): Queue counts label.
-            points (tuple): Region points for center point calculation to display text.
-            region_color (tuple): RGB queue region color.
-            txt_color (tuple): RGB text display color.
-        """
-        x_values = [point[0] for point in points]
-        y_values = [point[1] for point in points]
-        center_x = sum(x_values) // len(points)
-        center_y = sum(y_values) // len(points)
-
-        text_size = cv2.getTextSize(label, 0, fontScale=self.sf, thickness=self.tf)[0]
-        text_width = text_size[0]
-        text_height = text_size[1]
-
-        rect_width = text_width + 20
-        rect_height = text_height + 20
-        rect_top_left = (center_x - rect_width // 2, center_y - rect_height // 2)
-        rect_bottom_right = (center_x + rect_width // 2, center_y + rect_height // 2)
-        cv2.rectangle(self.im, rect_top_left, rect_bottom_right, region_color, -1)
-
-        text_x = center_x - text_width // 2
-        text_y = center_y + text_height // 2
-
-        # Draw text
-        cv2.putText(
-            self.im,
-            label,
-            (text_x, text_y),
-            0,
-            fontScale=self.sf,
-            color=txt_color,
-            thickness=self.tf,
-            lineType=cv2.LINE_AA,
-        )
-
-    def display_objects_labels(self, im0, text, txt_color, bg_color, x_center, y_center, margin):
-        """
-        Display the bounding boxes labels in parking management app.
-
-        Args:
-            im0 (ndarray): Inference image.
-            text (str): Object/class name.
-            txt_color (tuple): Display color for text foreground.
-            bg_color (tuple): Display color for text background.
-            x_center (float): The x position center point for bounding box.
-            y_center (float): The y position center point for bounding box.
-            margin (int): The gap between text and rectangle for better display.
-        """
-        text_size = cv2.getTextSize(text, 0, fontScale=self.sf, thickness=self.tf)[0]
-        text_x = x_center - text_size[0] // 2
-        text_y = y_center + text_size[1] // 2
-
-        rect_x1 = text_x - margin
-        rect_y1 = text_y - text_size[1] - margin
-        rect_x2 = text_x + text_size[0] + margin
-        rect_y2 = text_y + margin
-        cv2.rectangle(im0, (rect_x1, rect_y1), (rect_x2, rect_y2), bg_color, -1)
-        cv2.putText(im0, text, (text_x, text_y), 0, self.sf, txt_color, self.tf, lineType=cv2.LINE_AA)
-
-    def display_analytics(self, im0, text, txt_color, bg_color, margin):
-        """
-        Display the overall statistics for parking lots.
-
-        Args:
-            im0 (ndarray): Inference image.
-            text (dict): Labels dictionary.
-            txt_color (tuple): Display color for text foreground.
-            bg_color (tuple): Display color for text background.
-            margin (int): Gap between text and rectangle for better display.
-        """
-        horizontal_gap = int(im0.shape[1] * 0.02)
-        vertical_gap = int(im0.shape[0] * 0.01)
-        text_y_offset = 0
-        for label, value in text.items():
-            txt = f"{label}: {value}"
-            text_size = cv2.getTextSize(txt, 0, self.sf, self.tf)[0]
-            if text_size[0] < 5 or text_size[1] < 5:
-                text_size = (5, 5)
-            text_x = im0.shape[1] - text_size[0] - margin * 2 - horizontal_gap
-            text_y = text_y_offset + text_size[1] + margin * 2 + vertical_gap
-            rect_x1 = text_x - margin * 2
-            rect_y1 = text_y - text_size[1] - margin * 2
-            rect_x2 = text_x + text_size[0] + margin * 2
-            rect_y2 = text_y + margin * 2
-            cv2.rectangle(im0, (rect_x1, rect_y1), (rect_x2, rect_y2), bg_color, -1)
-            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 estimate_pose_angle(a, b, c):
-        """
-        Calculate the pose angle for object.
-
-        Args:
-            a (float) : The value of pose point a
-            b (float): The value of pose point b
-            c (float): The value o pose point c
-
-        Returns:
-            angle (degree): Degree value of angle between three points
-        """
-        a, b, c = np.array(a), np.array(b), np.array(c)
-        radians = np.arctan2(c[1] - b[1], c[0] - b[0]) - np.arctan2(a[1] - b[1], a[0] - b[0])
-        angle = np.abs(radians * 180.0 / np.pi)
-        if angle > 180.0:
-            angle = 360 - angle
-        return angle
-
-    def draw_specific_points(self, keypoints, indices=None, radius=2, conf_thres=0.25):
-        """
-        Draw specific keypoints for gym steps counting.
-
-        Args:
-            keypoints (list): Keypoints data to be plotted.
-            indices (list, optional): Keypoint indices to be plotted. Defaults to [2, 5, 7].
-            radius (int, optional): Keypoint radius. Defaults to 2.
-            conf_thres (float, optional): Confidence threshold for keypoints. Defaults to 0.25.
-
-        Returns:
-            (numpy.ndarray): Image with drawn keypoints.
-
-        Note:
-            Keypoint format: [x, y] or [x, y, confidence].
-            Modifies self.im in-place.
-        """
-        indices = indices or [2, 5, 7]
-        points = [(int(k[0]), int(k[1])) for i, k in enumerate(keypoints) if i in indices and k[2] >= conf_thres]
-
-        # Draw lines between consecutive points
-        for start, end in zip(points[:-1], points[1:]):
-            cv2.line(self.im, start, end, (0, 255, 0), 2, lineType=cv2.LINE_AA)
-
-        # Draw circles for keypoints
-        for pt in points:
-            cv2.circle(self.im, pt, radius, (0, 0, 255), -1, lineType=cv2.LINE_AA)
-
-        return self.im
-
-    def plot_workout_information(self, display_text, position, color=(104, 31, 17), txt_color=(255, 255, 255)):
-        """
-        Draw text with a background on the image.
-
-        Args:
-            display_text (str): The text to be displayed.
-            position (tuple): Coordinates (x, y) on the image where the text will be placed.
-            color (tuple, optional): Text background color
-            txt_color (tuple, optional): Text foreground color
-        """
-        (text_width, text_height), _ = cv2.getTextSize(display_text, 0, self.sf, self.tf)
-
-        # Draw background rectangle
-        cv2.rectangle(
-            self.im,
-            (position[0], position[1] - text_height - 5),
-            (position[0] + text_width + 10, position[1] - text_height - 5 + text_height + 10 + self.tf),
-            color,
-            -1,
-        )
-        # Draw text
-        cv2.putText(self.im, display_text, position, 0, self.sf, txt_color, self.tf)
-
-        return text_height
-
-    def plot_angle_and_count_and_stage(
-        self, angle_text, count_text, stage_text, center_kpt, color=(104, 31, 17), txt_color=(255, 255, 255)
-    ):
-        """
-        Plot the pose angle, count value, and step stage.
-
-        Args:
-            angle_text (str): Angle value for workout monitoring
-            count_text (str): Counts value for workout monitoring
-            stage_text (str): Stage decision for workout monitoring
-            center_kpt (list): Centroid pose index for workout monitoring
-            color (tuple, optional): Text background color
-            txt_color (tuple, optional): Text foreground color
-        """
-        # Format text
-        angle_text, count_text, stage_text = f" {angle_text:.2f}", f"Steps : {count_text}", f" {stage_text}"
-
-        # Draw angle, count and stage text
-        angle_height = self.plot_workout_information(
-            angle_text, (int(center_kpt[0]), int(center_kpt[1])), color, txt_color
-        )
-        count_height = self.plot_workout_information(
-            count_text, (int(center_kpt[0]), int(center_kpt[1]) + angle_height + 20), color, txt_color
-        )
-        self.plot_workout_information(
-            stage_text, (int(center_kpt[0]), int(center_kpt[1]) + angle_height + count_height + 40), color, txt_color
-        )
-
-    def seg_bbox(self, mask, mask_color=(255, 0, 255), label=None, txt_color=(255, 255, 255)):
-        """
-        Function for drawing segmented object in bounding box shape.
-
-        Args:
-            mask (np.ndarray): A 2D array of shape (N, 2) containing the contour points of the segmented object.
-            mask_color (tuple): RGB color for the contour and label background.
-            label (str, optional): Text label for the object. If None, no label is drawn.
-            txt_color (tuple): RGB color for the label text.
-        """
-        if mask.size == 0:  # no masks to plot
-            return
-
-        cv2.polylines(self.im, [np.int32([mask])], isClosed=True, color=mask_color, thickness=2)
-        if label:
-            text_size, _ = cv2.getTextSize(label, 0, self.sf, self.tf)
-            cv2.rectangle(
-                self.im,
-                (int(mask[0][0]) - text_size[0] // 2 - 10, int(mask[0][1]) - text_size[1] - 10),
-                (int(mask[0][0]) + text_size[0] // 2 + 10, int(mask[0][1] + 10)),
-                mask_color,
-                -1,
-            )
-            cv2.putText(
-                self.im, label, (int(mask[0][0]) - text_size[0] // 2, int(mask[0][1])), 0, self.sf, txt_color, self.tf
-            )
-
-    def sweep_annotator(self, line_x=0, line_y=0, label=None, color=(221, 0, 186), txt_color=(255, 255, 255)):
-        """
-        Function for drawing a sweep annotation line and an optional label.
-
-        Args:
-            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): RGB color for the line and label background.
-            txt_color (tuple): RGB color for the label text.
-        """
-        # Draw the sweep line
-        cv2.line(self.im, (line_x, 0), (line_x, line_y), color, self.tf * 2)
-
-        # Draw label, if provided
-        if label:
-            (text_width, text_height), _ = cv2.getTextSize(label, cv2.FONT_HERSHEY_SIMPLEX, self.sf, self.tf)
-            cv2.rectangle(
-                self.im,
-                (line_x - text_width // 2 - 10, line_y // 2 - text_height // 2 - 10),
-                (line_x + text_width // 2 + 10, line_y // 2 + text_height // 2 + 10),
-                color,
-                -1,
-            )
-            cv2.putText(
-                self.im,
-                label,
-                (line_x - text_width // 2, line_y // 2 + text_height // 2),
-                cv2.FONT_HERSHEY_SIMPLEX,
-                self.sf,
-                txt_color,
-                self.tf,
-            )
-
-    def plot_distance_and_line(
-        self, pixels_distance, centroids, line_color=(104, 31, 17), centroid_color=(255, 0, 255)
-    ):
-        """
-        Plot the distance and line on frame.
-
-        Args:
-            pixels_distance (float): Pixels distance between two bbox centroids.
-            centroids (list): Bounding box centroids data.
-            line_color (tuple, optional): Distance line color.
-            centroid_color (tuple, optional): Bounding box centroid color.
-        """
-        # Get the text size
-        text = f"Pixels Distance: {pixels_distance:.2f}"
-        (text_width_m, text_height_m), _ = cv2.getTextSize(text, 0, self.sf, self.tf)
-
-        # Define corners with 10-pixel margin and draw rectangle
-        cv2.rectangle(self.im, (15, 25), (15 + text_width_m + 20, 25 + text_height_m + 20), line_color, -1)
-
-        # Calculate the position for the text with a 10-pixel margin and draw text
-        text_position = (25, 25 + text_height_m + 10)
-        cv2.putText(
-            self.im,
-            text,
-            text_position,
-            0,
-            self.sf,
-            (255, 255, 255),
-            self.tf,
-            cv2.LINE_AA,
-        )
-
-        cv2.line(self.im, centroids[0], centroids[1], line_color, 3)
-        cv2.circle(self.im, centroids[0], 6, centroid_color, -1)
-        cv2.circle(self.im, centroids[1], 6, centroid_color, -1)
-
-    def visioneye(self, box, center_point, color=(235, 219, 11), pin_color=(255, 0, 255)):
-        """
-        Function for pinpoint human-vision eye mapping and plotting.
-
-        Args:
-            box (list): Bounding box coordinates
-            center_point (tuple): center point for vision eye view
-            color (tuple): object centroid and line color value
-            pin_color (tuple): visioneye point color value
-        """
-        center_bbox = int((box[0] + box[2]) / 2), int((box[1] + box[3]) / 2)
-        cv2.circle(self.im, center_point, self.tf * 2, pin_color, -1)
-        cv2.circle(self.im, center_bbox, self.tf * 2, color, -1)
-        cv2.line(self.im, center_point, center_bbox, color, self.tf)
-
 
 @TryExcept()  # known issue https://github.com/ultralytics/yolov5/issues/5395
 @plt_settings()

{ultralytics-8.3.86.dist-info → ultralytics-8.3.88.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: ultralytics
-Version: 8.3.86
+Version: 8.3.88
 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>
@@ -63,7 +63,7 @@ Provides-Extra: export
 Requires-Dist: onnx>=1.12.0; extra == "export"
 Requires-Dist: coremltools>=7.0; (platform_system != "Windows" and python_version <= "3.11") and extra == "export"
 Requires-Dist: scikit-learn>=1.3.2; (platform_system != "Windows" and python_version <= "3.11") and extra == "export"
-Requires-Dist: openvino<2025.0.0,>=2024.0.0; extra == "export"
+Requires-Dist: openvino!=2025.0.0,>=2024.0.0; extra == "export"
 Requires-Dist: tensorflow>=2.0.0; extra == "export"
 Requires-Dist: tensorflowjs>=3.9.0; extra == "export"
 Requires-Dist: tensorstore>=0.1.63; (platform_machine == "aarch64" and python_version >= "3.9") and extra == "export"
@@ -248,13 +248,13 @@ See [Segmentation Docs](https://docs.ultralytics.com/tasks/segment/) for usage e
 
 See [Classification Docs](https://docs.ultralytics.com/tasks/classify/) for usage examples with these models trained on [ImageNet](https://docs.ultralytics.com/datasets/classify/imagenet/), which include 1000 pretrained classes.
 
-| Model                                                                                        | size<br><sup>(pixels) | acc<br><sup>top1 | acc<br><sup>top5 | Speed<br><sup>CPU ONNX<br>(ms) | Speed<br><sup>T4 TensorRT10<br>(ms) | params<br><sup>(M) | FLOPs<br><sup>(B) at 640 |
+| Model                                                                                        | size<br><sup>(pixels) | acc<br><sup>top1 | acc<br><sup>top5 | Speed<br><sup>CPU ONNX<br>(ms) | Speed<br><sup>T4 TensorRT10<br>(ms) | params<br><sup>(M) | FLOPs<br><sup>(B) at 224 |
 | -------------------------------------------------------------------------------------------- | --------------------- | ---------------- | ---------------- | ------------------------------ | ----------------------------------- | ------------------ | ------------------------ |
-| [YOLO11n-cls](https://github.com/ultralytics/assets/releases/download/v8.3.0/yolo11n-cls.pt) | 224                   | 70.0             | 89.4             | 5.0 ± 0.3                      | 1.1 ± 0.0                           | 1.6                | 3.3                      |
-| [YOLO11s-cls](https://github.com/ultralytics/assets/releases/download/v8.3.0/yolo11s-cls.pt) | 224                   | 75.4             | 92.7             | 7.9 ± 0.2                      | 1.3 ± 0.0                           | 5.5                | 12.1                     |
-| [YOLO11m-cls](https://github.com/ultralytics/assets/releases/download/v8.3.0/yolo11m-cls.pt) | 224                   | 77.3             | 93.9             | 17.2 ± 0.4                     | 2.0 ± 0.0                           | 10.4               | 39.3                     |
-| [YOLO11l-cls](https://github.com/ultralytics/assets/releases/download/v8.3.0/yolo11l-cls.pt) | 224                   | 78.3             | 94.3             | 23.2 ± 0.3                     | 2.8 ± 0.0                           | 12.9               | 49.4                     |
-| [YOLO11x-cls](https://github.com/ultralytics/assets/releases/download/v8.3.0/yolo11x-cls.pt) | 224                   | 79.5             | 94.9             | 41.4 ± 0.9                     | 3.8 ± 0.0                           | 28.4               | 110.4                    |
+| [YOLO11n-cls](https://github.com/ultralytics/assets/releases/download/v8.3.0/yolo11n-cls.pt) | 224                   | 70.0             | 89.4             | 5.0 ± 0.3                      | 1.1 ± 0.0                           | 1.6                | 0.5                      |
+| [YOLO11s-cls](https://github.com/ultralytics/assets/releases/download/v8.3.0/yolo11s-cls.pt) | 224                   | 75.4             | 92.7             | 7.9 ± 0.2                      | 1.3 ± 0.0                           | 5.5                | 1.6                      |
+| [YOLO11m-cls](https://github.com/ultralytics/assets/releases/download/v8.3.0/yolo11m-cls.pt) | 224                   | 77.3             | 93.9             | 17.2 ± 0.4                     | 2.0 ± 0.0                           | 10.4               | 5.0                      |
+| [YOLO11l-cls](https://github.com/ultralytics/assets/releases/download/v8.3.0/yolo11l-cls.pt) | 224                   | 78.3             | 94.3             | 23.2 ± 0.3                     | 2.8 ± 0.0                           | 12.9               | 6.2                      |
+| [YOLO11x-cls](https://github.com/ultralytics/assets/releases/download/v8.3.0/yolo11x-cls.pt) | 224                   | 79.5             | 94.9             | 41.4 ± 0.9                     | 3.8 ± 0.0                           | 28.4               | 13.7                     |
 
 - **acc** values are model accuracies on the [ImageNet](https://www.image-net.org/) dataset validation set. <br>Reproduce by `yolo val classify data=path/to/ImageNet device=0`
 - **Speed** averaged over ImageNet val images using an [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/) instance. <br>Reproduce by `yolo val classify data=path/to/ImageNet batch=1 device=0|cpu`