ultralytics 8.3.138__py3-none-any.whl → 8.3.140__py3-none-any.whl

tests/test_cuda.py

@@ -41,7 +41,6 @@ def test_amp():
 
 
 @pytest.mark.slow
-@pytest.mark.skipif(IS_JETSON, reason="Temporary disable ONNX for Jetson")
 @pytest.mark.skipif(not DEVICES, reason="No CUDA devices available")
 @pytest.mark.parametrize(
     "task, dynamic, int8, half, batch, simplify, nms",
@@ -50,7 +49,9 @@ def test_amp():
         for task, dynamic, int8, half, batch, simplify, nms in product(
             TASKS, [True, False], [False], [False], [1, 2], [True, False], [True, False]
         )
-        if not ((int8 and half) or (task == "classify" and nms) or (task == "obb" and nms and not TORCH_1_13))
+        if not (
+            (int8 and half) or (task == "classify" and nms) or (task == "obb" and nms and (not TORCH_1_13 or IS_JETSON))
+        )
     ],
 )
 def test_export_onnx_matrix(task, dynamic, int8, half, batch, simplify, nms):

tests/test_python.py

@@ -198,7 +198,13 @@ def test_track_stream():
 
 def test_val():
     """Test the validation mode of the YOLO model."""
-    YOLO(MODEL).val(data="coco8.yaml", imgsz=32)
+    metrics = YOLO(MODEL).val(data="coco8.yaml", imgsz=32)
+    metrics.to_df()
+    metrics.to_csv()
+    metrics.to_xml()
+    metrics.to_html()
+    metrics.to_json()
+    metrics.to_sql()
 
 
 def test_train_scratch():
@@ -264,7 +270,8 @@ def test_predict_callback_and_setup():
 @pytest.mark.parametrize("model", MODELS)
 def test_results(model):
     """Test YOLO model results processing and output in various formats."""
-    results = YOLO(WEIGHTS_DIR / model)([SOURCE, SOURCE], imgsz=160)
+    temp_s = "https://ultralytics.com/images/boats.jpg" if model == "yolo11n-obb.pt" else SOURCE
+    results = YOLO(WEIGHTS_DIR / model)([temp_s, temp_s], imgsz=160)
     for r in results:
         r = r.cpu().numpy()
         print(r, len(r), r.path)  # print numpy attributes

tests/test_solutions.py

@@ -12,7 +12,7 @@ import pytest
 
 from tests import MODEL, TMP
 from ultralytics import solutions
-from ultralytics.utils import ASSETS_URL, IS_RASPBERRYPI, LINUX, checks
+from ultralytics.utils import ASSETS_URL, IS_RASPBERRYPI, checks
 from ultralytics.utils.downloads import safe_download
 
 # Pre-defined arguments values
@@ -180,10 +180,7 @@ def process_video(solution, video_path, needs_frame_count=False):
     cap.release()
 
 
-@pytest.mark.skipif(
-    (LINUX and checks.IS_PYTHON_3_11) or IS_RASPBERRYPI,
-    reason="Disabled for testing due to --slow test errors after YOLOE PR.",
-)
+@pytest.mark.skipif(IS_RASPBERRYPI, reason="Disabled for testing due to --slow test errors after YOLOE PR.")
 @pytest.mark.parametrize("name, solution_class, needs_frame_count, video, kwargs", SOLUTIONS)
 def test_solution(name, solution_class, needs_frame_count, video, kwargs):
     """Test individual Ultralytics solution."""
@@ -300,6 +297,7 @@ def test_streamlit_handle_video_upload_creates_file():
     os.remove("ultralytics.mp4")
 
 
+@pytest.mark.skipif(IS_RASPBERRYPI, reason="Disabled due to slow performance on Raspberry Pi.")
 def test_similarity_search_app_init():
     """Test SearchApp initializes with required attributes."""
     app = solutions.SearchApp(device="cpu")
@@ -307,6 +305,7 @@ def test_similarity_search_app_init():
     assert hasattr(app, "run")
 
 
+@pytest.mark.skipif(IS_RASPBERRYPI, reason="Disabled due to slow performance on Raspberry Pi.")
 def test_similarity_search_complete(tmp_path):
     """Test VisualAISearch end-to-end with sample image and query."""
     from PIL import Image

ultralytics/__init__.py

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

ultralytics/engine/exporter.py

@@ -981,6 +981,7 @@ class Exporter:
             custom_input_op_name_np_data_path=np_data,
             enable_batchmatmul_unfold=True,  # fix lower no. of detected objects on GPU delegate
             output_signaturedefs=True,  # fix error with Attention block group convolution
+            disable_group_convolution=self.args.format == "tfjs",  # fix TF.js error with group convolution
             optimization_for_gpu_delegate=True,
         )
         YAML.save(f / "metadata.yaml", self.metadata)  # add metadata.yaml

ultralytics/engine/results.py

@@ -13,8 +13,7 @@ import numpy as np
 import torch
 
 from ultralytics.data.augment import LetterBox
-from ultralytics.utils import LOGGER, SimpleClass, ops
-from ultralytics.utils.checks import check_requirements
+from ultralytics.utils import LOGGER, DataExportMixin, SimpleClass, ops
 from ultralytics.utils.plotting import Annotator, colors, save_one_box
 from ultralytics.utils.torch_utils import smart_inference_mode
 
@@ -184,7 +183,7 @@ class BaseTensor(SimpleClass):
         return self.__class__(self.data[idx], self.orig_shape)
 
 
-class Results(SimpleClass):
+class Results(SimpleClass, DataExportMixin):
     """
     A class for storing and manipulating inference results.
 
@@ -828,212 +827,6 @@ class Results(SimpleClass):
 
         return results
 
-    def to_df(self, normalize=False, decimals=5):
-        """
-        Converts detection results to a Pandas Dataframe.
-
-        This method converts the detection results into Pandas Dataframe format. It includes information
-        about detected objects such as bounding boxes, class names, confidence scores, and optionally
-        segmentation masks and keypoints.
-
-        Args:
-            normalize (bool): Whether to normalize the bounding box coordinates by the image dimensions.
-                If True, coordinates will be returned as float values between 0 and 1.
-            decimals (int): Number of decimal places to round the output values to.
-
-        Returns:
-            (DataFrame): A Pandas Dataframe containing all the information in results in an organized way.
-
-        Examples:
-            >>> results = model("path/to/image.jpg")
-            >>> for result in results:
-            >>>     df_result = result.to_df()
-            >>>     print(df_result)
-        """
-        import pandas as pd  # scope for faster 'import ultralytics'
-
-        return pd.DataFrame(self.summary(normalize=normalize, decimals=decimals))
-
-    def to_csv(self, normalize=False, decimals=5, *args, **kwargs):
-        """
-        Converts detection results to a CSV format.
-
-        This method serializes the detection results into a CSV format. It includes information
-        about detected objects such as bounding boxes, class names, confidence scores, and optionally
-        segmentation masks and keypoints.
-
-        Args:
-            normalize (bool): Whether to normalize the bounding box coordinates by the image dimensions.
-                If True, coordinates will be returned as float values between 0 and 1.
-            decimals (int): Number of decimal places to round the output values to.
-            *args (Any): Variable length argument list to be passed to pandas.DataFrame.to_csv().
-            **kwargs (Any): Arbitrary keyword arguments to be passed to pandas.DataFrame.to_csv().
-
-
-        Returns:
-            (str): CSV containing all the information in results in an organized way.
-
-        Examples:
-            >>> results = model("path/to/image.jpg")
-            >>> for result in results:
-            >>>     csv_result = result.to_csv()
-            >>>     print(csv_result)
-        """
-        return self.to_df(normalize=normalize, decimals=decimals).to_csv(*args, **kwargs)
-
-    def to_xml(self, normalize=False, decimals=5, *args, **kwargs):
-        """
-        Converts detection results to XML format.
-
-        This method serializes the detection results into an XML format. It includes information
-        about detected objects such as bounding boxes, class names, confidence scores, and optionally
-        segmentation masks and keypoints.
-
-        Args:
-            normalize (bool): Whether to normalize the bounding box coordinates by the image dimensions.
-                If True, coordinates will be returned as float values between 0 and 1.
-            decimals (int): Number of decimal places to round the output values to.
-            *args (Any): Variable length argument list to be passed to pandas.DataFrame.to_xml().
-            **kwargs (Any): Arbitrary keyword arguments to be passed to pandas.DataFrame.to_xml().
-
-        Returns:
-            (str): An XML string containing all the information in results in an organized way.
-
-        Examples:
-            >>> results = model("path/to/image.jpg")
-            >>> for result in results:
-            >>>     xml_result = result.to_xml()
-            >>>     print(xml_result)
-        """
-        check_requirements("lxml")
-        df = self.to_df(normalize=normalize, decimals=decimals)
-        return '<?xml version="1.0" encoding="utf-8"?>\n<root></root>' if df.empty else df.to_xml(*args, **kwargs)
-
-    def to_html(self, normalize=False, decimals=5, index=False, *args, **kwargs):
-        """
-        Converts detection results to HTML format.
-
-        This method serializes the detection results into an HTML format. It includes information
-        about detected objects such as bounding boxes, class names, confidence scores, and optionally
-        segmentation masks and keypoints.
-
-        Args:
-            normalize (bool): Whether to normalize the bounding box coordinates by the image dimensions.
-                If True, coordinates will be returned as float values between 0 and 1.
-            decimals (int): Number of decimal places to round the output values to.
-            index (bool): Whether to include the DataFrame index in the HTML output.
-            *args (Any): Variable length argument list to be passed to pandas.DataFrame.to_html().
-            **kwargs (Any): Arbitrary keyword arguments to be passed to pandas.DataFrame.to_html().
-
-        Returns:
-            (str): An HTML string containing all the information in results in an organized way.
-
-        Examples:
-            >>> results = model("path/to/image.jpg")
-            >>> for result in results:
-            >>>     html_result = result.to_html()
-            >>>     print(html_result)
-        """
-        df = self.to_df(normalize=normalize, decimals=decimals)
-        return "<table></table>" if df.empty else df.to_html(index=index, *args, **kwargs)
-
-    def tojson(self, normalize=False, decimals=5):
-        """Deprecated version of to_json()."""
-        LOGGER.warning("'result.tojson()' is deprecated, replace with 'result.to_json()'.")
-        return self.to_json(normalize, decimals)
-
-    def to_json(self, normalize=False, decimals=5):
-        """
-        Converts detection results to JSON format.
-
-        This method serializes the detection results into a JSON-compatible format. It includes information
-        about detected objects such as bounding boxes, class names, confidence scores, and optionally
-        segmentation masks and keypoints.
-
-        Args:
-            normalize (bool): Whether to normalize the bounding box coordinates by the image dimensions.
-                If True, coordinates will be returned as float values between 0 and 1.
-            decimals (int): Number of decimal places to round the output values to.
-
-        Returns:
-            (str): A JSON string containing the serialized detection results.
-
-        Examples:
-            >>> results = model("path/to/image.jpg")
-            >>> for result in results:
-            >>>     json_result = result.to_json()
-            >>>     print(json_result)
-
-        Notes:
-            - For classification tasks, the JSON will contain class probabilities instead of bounding boxes.
-            - For object detection tasks, the JSON will include bounding box coordinates, class names, and
-              confidence scores.
-            - If available, segmentation masks and keypoints will also be included in the JSON output.
-            - The method uses the `summary` method internally to generate the data structure before
-              converting it to JSON.
-        """
-        import json
-
-        return json.dumps(self.summary(normalize=normalize, decimals=decimals), indent=2)
-
-    def to_sql(self, table_name="results", normalize=False, decimals=5, db_path="results.db"):
-        """
-        Converts detection results to an SQL-compatible format.
-
-        This method serializes the detection results into a format compatible with SQL databases.
-        It includes information about detected objects such as bounding boxes, class names, confidence scores,
-        and optionally segmentation masks, keypoints or oriented bounding boxes.
-
-        Args:
-            table_name (str): Name of the SQL table where the data will be inserted.
-            normalize (bool): Whether to normalize the bounding box coordinates by the image dimensions.
-                If True, coordinates will be returned as float values between 0 and 1.
-            decimals (int): Number of decimal places to round the bounding boxes values to.
-            db_path (str): Path to the SQLite database file.
-
-        Examples:
-            >>> results = model("path/to/image.jpg")
-            >>> for result in results:
-            >>>     result.to_sql()
-        """
-        import json
-        import sqlite3
-
-        # Convert results to a list of dictionaries
-        data = self.summary(normalize=normalize, decimals=decimals)
-        if len(data) == 0:
-            LOGGER.warning("No results to save to SQL. Results dict is empty.")
-            return
-
-        # Connect to the SQLite database
-        conn = sqlite3.connect(db_path)
-        cursor = conn.cursor()
-
-        # Create table if it doesn't exist
-        columns = (
-            "id INTEGER PRIMARY KEY AUTOINCREMENT, class_name TEXT, confidence REAL, box TEXT, masks TEXT, kpts TEXT"
-        )
-        cursor.execute(f"CREATE TABLE IF NOT EXISTS {table_name} ({columns})")
-
-        # Insert data into the table
-        for item in data:
-            cursor.execute(
-                f"INSERT INTO {table_name} (class_name, confidence, box, masks, kpts) VALUES (?, ?, ?, ?, ?)",
-                (
-                    item.get("name"),
-                    item.get("confidence"),
-                    json.dumps(item.get("box", {})),
-                    json.dumps(item.get("segments", {})),
-                    json.dumps(item.get("keypoints", {})),
-                ),
-            )
-
-        # Commit and close the connection
-        conn.commit()
-        conn.close()
-
-        LOGGER.info(f"Detection results successfully written to SQL table '{table_name}' in database '{db_path}'.")
-
 
 class Boxes(BaseTensor):
     """

ultralytics/utils/__init__.py

@@ -187,6 +187,159 @@ class TQDM(rich.tqdm if TQDM_RICH else tqdm.tqdm):
         return super().__iter__()
 
 
+class DataExportMixin:
+    """
+    Mixin class for exporting validation metrics or prediction results in various formats.
+
+    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, Pandas DataFrame
+    CSV, XML, HTML, JSON and SQLite (SQL)
+
+    Methods:
+        to_df(): Convert summary to a Pandas DataFrame.
+        to_csv(): Export results as a CSV string.
+        to_xml(): Export results as an XML string (requires `lxml`).
+        to_html(): Export results as an HTML table.
+        to_json(): Export results as a JSON string.
+        tojson(): Deprecated alias for `to_json()`.
+        to_sql(): Export results to an SQLite database.
+
+    Examples:
+        >>> model = YOLO("yolov8n.pt")
+        >>> results = model("image.jpg")
+        >>> df = results.to_df()
+        >>> print(df)
+        >>> csv_data = results.to_csv()
+        >>> results.to_sql(table_name="yolo_results")
+    """
+
+    def to_df(self, normalize=False, decimals=5):
+        """
+        Create a pandas DataFrame from the prediction results summary or validation metrics.
+
+        Args:
+            normalize (bool, optional): Normalize numerical values for easier comparison. Defaults to False.
+            decimals (int, optional): Decimal places to round floats. Defaults to 5.
+
+        Returns:
+            (DataFrame): DataFrame containing the summary data.
+        """
+        import pandas as pd  # scope for faster 'import ultralytics'
+
+        return pd.DataFrame(self.summary(normalize=normalize, decimals=decimals))
+
+    def to_csv(self, normalize=False, decimals=5):
+        """
+        Export results to CSV string format.
+
+        Args:
+           normalize (bool, optional): Normalize numeric values. Defaults to False.
+           decimals (int, optional): Decimal precision. Defaults to 5.
+
+        Returns:
+           (str): CSV content as string.
+        """
+        return self.to_df(normalize=normalize, decimals=decimals).to_csv()
+
+    def to_xml(self, normalize=False, decimals=5):
+        """
+        Export results to XML format.
+
+        Args:
+            normalize (bool, optional): Normalize numeric values. Defaults to False.
+            decimals (int, optional): Decimal precision. Defaults to 5.
+
+        Returns:
+            (str): XML string.
+
+        Note:
+            Requires `lxml` package to be installed.
+        """
+        from ultralytics.utils.checks import check_requirements
+
+        check_requirements("lxml")
+        df = self.to_df(normalize=normalize, decimals=decimals)
+        return '<?xml version="1.0" encoding="utf-8"?>\n<root></root>' if df.empty else df.to_xml()
+
+    def to_html(self, normalize=False, decimals=5, index=False):
+        """
+        Export results to HTML table format.
+
+        Args:
+            normalize (bool, optional): Normalize numeric values. Defaults to False.
+            decimals (int, optional): Decimal precision. Defaults to 5.
+            index (bool, optional): Whether to include index column in the HTML table. Defaults to False.
+
+        Returns:
+            (str): HTML representation of the results.
+        """
+        df = self.to_df(normalize=normalize, decimals=decimals)
+        return "<table></table>" if df.empty else df.to_html(index=index)
+
+    def tojson(self, normalize=False, decimals=5):
+        """Deprecated version of to_json()."""
+        LOGGER.warning("'result.tojson()' is deprecated, replace with 'result.to_json()'.")
+        return self.to_json(normalize, decimals)
+
+    def to_json(self, normalize=False, decimals=5):
+        """
+        Export results to JSON format.
+
+        Args:
+            normalize (bool, optional): Normalize numeric values. Defaults to False.
+            decimals (int, optional): Decimal precision. Defaults to 5.
+
+        Returns:
+            (str): JSON-formatted string of the results.
+        """
+        return self.to_df(normalize=normalize, decimals=decimals).to_json(orient="records", indent=2)
+
+    def to_sql(self, normalize=False, decimals=5, table_name="results", db_path="results.db"):
+        """
+        Save results to an SQLite database.
+
+        Args:
+            normalize (bool, optional): Normalize numeric values. Defaults to False.
+            decimals (int, optional): Decimal precision. Defaults to 5.
+            table_name (str, optional): Name of the SQL table. Defaults to "results".
+            db_path (str, optional): SQLite database file path. Defaults to "results.db".
+        """
+        df = self.to_df(normalize, decimals)
+        if df.empty or df.columns.empty:  # Exit if df is None or has no columns (i.e., no schema)
+            return
+
+        import sqlite3
+
+        conn = sqlite3.connect(db_path)
+        cursor = conn.cursor()
+
+        # Dynamically create table schema based on summary to support prediction and validation results export
+        columns = []
+        for col in df.columns:
+            sample_val = df[col].dropna().iloc[0] if not df[col].dropna().empty else ""
+            if isinstance(sample_val, dict):
+                col_type = "TEXT"
+            elif isinstance(sample_val, (float, int)):
+                col_type = "REAL"
+            else:
+                col_type = "TEXT"
+            columns.append(f'"{col}" {col_type}')  # Quote column names to handle special characters like hyphens
+
+        # Create table (Drop table from db if it's already exist)
+        cursor.execute(f'DROP TABLE IF EXISTS "{table_name}"')
+        cursor.execute(f'CREATE TABLE "{table_name}" (id INTEGER PRIMARY KEY AUTOINCREMENT, {", ".join(columns)})')
+
+        for _, row in df.iterrows():
+            values = [json.dumps(v) if isinstance(v, dict) else v for v in row]
+            column_names = ", ".join(f'"{col}"' for col in df.columns)
+            placeholders = ", ".join("?" for _ in df.columns)
+            cursor.execute(f'INSERT INTO "{table_name}" ({column_names}) VALUES ({placeholders})', values)
+
+        conn.commit()
+        conn.close()
+        LOGGER.info(f"Results saved to SQL table '{table_name}' in '{db_path}'.")
+
+
 class SimpleClass:
     """
     A simple base class for creating objects with string representations of their attributes.

ultralytics/utils/benchmarks.py

@@ -23,6 +23,7 @@ TensorFlow.js           | `tfjs`                    | yolo11n_web_model/
 PaddlePaddle            | `paddle`                  | yolo11n_paddle_model/
 MNN                     | `mnn`                     | yolo11n.mnn
 NCNN                    | `ncnn`                    | yolo11n_ncnn_model/
+IMX                     | `imx`                     | yolo11n_imx_model/
 RKNN                    | `rknn`                    | yolo11n_rknn_model/
 """
 

ultralytics/utils/checks.py

@@ -165,6 +165,15 @@ def check_imgsz(imgsz, stride=32, min_dim=1, max_dim=2, floor=0):
     return sz
 
 
+@functools.lru_cache
+def check_uv():
+    """Check if uv is installed and can run successfully."""
+    try:
+        return subprocess.run(["uv", "-V"], capture_output=True).returncode == 0
+    except FileNotFoundError:
+        return False
+
+
 @functools.lru_cache
 def check_version(
     current: str = "0.0.0",
@@ -388,21 +397,27 @@ def check_requirements(requirements=ROOT.parent / "requirements.txt", exclude=()
             pkgs.append(r)
 
     @Retry(times=2, delay=1)
-    def attempt_install(packages, commands):
-        """Attempt pip install command with retries on failure."""
-        return subprocess.check_output(f"pip install --no-cache-dir {packages} {commands}", shell=True).decode()
+    def attempt_install(packages, commands, use_uv):
+        """Attempt package installation with uv if available, falling back to pip."""
+        if use_uv:
+            # Note requires --break-system-packages on ARM64 dockerfile
+            cmd = f"uv pip install --system --no-cache-dir {packages} {commands} --index-strategy=unsafe-best-match --break-system-packages --prerelease=allow"
+        else:
+            cmd = f"pip install --no-cache-dir {packages} {commands}"
+        return subprocess.check_output(cmd, shell=True).decode()
 
     s = " ".join(f'"{x}"' for x in pkgs)  # console string
     if s:
         if install and AUTOINSTALL:  # check environment variable
+            # Note uv fails on arm64 macOS and Raspberry Pi runners
             n = len(pkgs)  # number of packages updates
             LOGGER.info(f"{prefix} Ultralytics requirement{'s' * (n > 1)} {pkgs} not found, attempting AutoUpdate...")
             try:
                 t = time.time()
                 assert ONLINE, "AutoUpdate skipped (offline)"
-                LOGGER.info(attempt_install(s, cmds))
+                LOGGER.info(attempt_install(s, cmds, use_uv=not ARM64 and check_uv()))
                 dt = time.time() - t
-                LOGGER.info(f"{prefix} AutoUpdate success ✅ {dt:.1f}s, installed {n} package{'s' * (n > 1)}: {pkgs}")
+                LOGGER.info(f"{prefix} AutoUpdate success ✅ {dt:.1f}s")
                 LOGGER.warning(
                     f"{prefix} {colorstr('bold', 'Restart runtime or rerun command for updates to take effect')}\n"
                 )
@@ -894,7 +909,6 @@ check_torchvision()  # check torch-torchvision compatibility
 
 # Define constants
 IS_PYTHON_3_8 = PYTHON_VERSION.startswith("3.8")
-IS_PYTHON_3_11 = PYTHON_VERSION.startswith("3.11")
 IS_PYTHON_3_12 = PYTHON_VERSION.startswith("3.12")
 IS_PYTHON_3_13 = PYTHON_VERSION.startswith("3.13")
 

ultralytics/utils/metrics.py

@@ -8,7 +8,7 @@ from pathlib import Path
 import numpy as np
 import torch
 
-from ultralytics.utils import LOGGER, SimpleClass, TryExcept, checks, plt_settings
+from ultralytics.utils import LOGGER, DataExportMixin, SimpleClass, TryExcept, checks, plt_settings
 
 OKS_SIGMA = (
     np.array([0.26, 0.25, 0.25, 0.35, 0.35, 0.79, 0.79, 0.72, 0.72, 0.62, 0.62, 1.07, 1.07, 0.87, 0.87, 0.89, 0.89])
@@ -865,7 +865,7 @@ class Metric(SimpleClass):
         ]
 
 
-class DetMetrics(SimpleClass):
+class DetMetrics(SimpleClass, DataExportMixin):
     """
     Utility class for computing detection metrics such as precision, recall, and mean average precision (mAP).
 
@@ -961,8 +961,29 @@ class DetMetrics(SimpleClass):
         """Return dictionary of computed performance metrics and statistics."""
         return self.box.curves_results
 
+    def summary(self, **kwargs):
+        """Returns per-class detection metrics with shared scalar values included."""
+        scalars = {
+            "box-map": self.box.map,
+            "box-map50": self.box.map50,
+            "box-map75": self.box.map75,
+        }
+        per_class = {
+            "box-p": self.box.p,
+            "box-r": self.box.r,
+            "box-f1": self.box.f1,
+        }
+        return [
+            {
+                "class_name": self.names[i] if hasattr(self, "names") and i in self.names else str(i),
+                **{k: v[i] for k, v in per_class.items()},
+                **scalars,
+            }
+            for i in range(len(next(iter(per_class.values()), [])))
+        ]
 
-class SegmentMetrics(SimpleClass):
+
+class SegmentMetrics(SimpleClass, DataExportMixin):
     """
     Calculates and aggregates detection and segmentation metrics over a given set of classes.
 
@@ -1097,6 +1118,29 @@ class SegmentMetrics(SimpleClass):
         """Return dictionary of computed performance metrics and statistics."""
         return self.box.curves_results + self.seg.curves_results
 
+    def summary(self, **kwargs):
+        """Returns per-class segmentation metrics with shared scalar values included (box + mask)."""
+        scalars = {
+            "box-map": self.box.map,
+            "box-map50": self.box.map50,
+            "box-map75": self.box.map75,
+            "mask-map": self.seg.map,
+            "mask-map50": self.seg.map50,
+            "mask-map75": self.seg.map75,
+        }
+        per_class = {
+            "box-p": self.box.p,
+            "box-r": self.box.r,
+            "box-f1": self.box.f1,
+            "mask-p": self.seg.p,
+            "mask-r": self.seg.r,
+            "mask-f1": self.seg.f1,
+        }
+        return [
+            {"class_name": self.names[i], **{k: v[i] for k, v in per_class.items()}, **scalars}
+            for i in range(len(next(iter(per_class.values()), [])))
+        ]
+
 
 class PoseMetrics(SegmentMetrics):
     """
@@ -1229,8 +1273,31 @@ class PoseMetrics(SegmentMetrics):
         """Return dictionary of computed performance metrics and statistics."""
         return self.box.curves_results + self.pose.curves_results
 
+    def summary(self, **kwargs):
+        """Returns per-class pose metrics with shared scalar values included (box + pose)."""
+        scalars = {
+            "box-map": self.box.map,
+            "box-map50": self.box.map50,
+            "box-map75": self.box.map75,
+            "pose-map": self.pose.map,
+            "pose-map50": self.pose.map50,
+            "pose-map75": self.pose.map75,
+        }
+        per_class = {
+            "box-p": self.box.p,
+            "box-r": self.box.r,
+            "box-f1": self.box.f1,
+            "pose-p": self.pose.p,
+            "pose-r": self.pose.r,
+            "pose-f1": self.pose.f1,
+        }
+        return [
+            {"class_name": self.names[i], **{k: v[i] for k, v in per_class.items()}, **scalars}
+            for i in range(len(next(iter(per_class.values()), [])))
+        ]
+
 
-class ClassifyMetrics(SimpleClass):
+class ClassifyMetrics(SimpleClass, DataExportMixin):
     """
     Class for computing classification metrics including top-1 and top-5 accuracy.
 
@@ -1286,8 +1353,12 @@ class ClassifyMetrics(SimpleClass):
         """Return a list of curves for accessing specific metrics curves."""
         return []
 
+    def summary(self, **kwargs):
+        """Returns a single-row summary for classification metrics (top1/top5)."""
+        return [{"classify-top1": self.top1, "classify-top5": self.top5}]
+
 
-class OBBMetrics(SimpleClass):
+class OBBMetrics(SimpleClass, DataExportMixin):
     """
     Metrics for evaluating oriented bounding box (OBB) detection.
 
@@ -1316,6 +1387,7 @@ class OBBMetrics(SimpleClass):
         self.names = names
         self.box = Metric()
         self.speed = {"preprocess": 0.0, "inference": 0.0, "loss": 0.0, "postprocess": 0.0}
+        self.task = "obb"
 
     def process(self, tp, conf, pred_cls, target_cls, on_plot=None):
         """
@@ -1383,3 +1455,16 @@ class OBBMetrics(SimpleClass):
     def curves_results(self):
         """Return a list of curves for accessing specific metrics curves."""
         return []
+
+    def summary(self, **kwargs):
+        """Returns per-class detection metrics with shared scalar values included."""
+        scalars = {
+            "box-map": self.box.map,
+            "box-map50": self.box.map50,
+            "box-map75": self.box.map75,
+        }
+        per_class = {"box-p": self.box.p, "box-r": self.box.r, "box-f1": self.box.f1}
+        return [
+            {"class_name": self.names[i], **{k: v[i] for k, v in per_class.items()}, **scalars}
+            for i in range(len(next(iter(per_class.values()), [])))
+        ]

{ultralytics-8.3.138.dist-info → ultralytics-8.3.140.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ultralytics
-Version: 8.3.138
+Version: 8.3.140
 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.138.dist-info → ultralytics-8.3.140.dist-info}/RECORD

@@ -1,13 +1,13 @@
 tests/__init__.py,sha256=xnMhv3O_DF1YrW4zk__ZywQzAaoTDjPKPoiI1Ktss1w,670
 tests/conftest.py,sha256=rsIAipRKfrVNoTaJ1LdpYue8AbcJ_fr3d3WIlM_6uXY,2982
 tests/test_cli.py,sha256=vXUC_EK0fa87JRhHsCOZf7AJQ5_Jm1sL8u-yhmsaQh0,5851
-tests/test_cuda.py,sha256=L_2xp2TH-pInsdI8UrbZ5onRtHQGdUVoPXnyX6Ot4_U,7950
+tests/test_cuda.py,sha256=k4i-6lrp_hczJjbLk_uJOTfMeZZN5o3Dj9jbPA0TzB4,7912
 tests/test_engine.py,sha256=aGqZ8P7QO5C_nOa1b4FOyk92Ysdk5WiP-ST310Vyxys,4962
 tests/test_exports.py,sha256=dhZn86LdbapW15RthQF870LGxDjC1MUZhlGdBgPmgIQ,9716
 tests/test_integrations.py,sha256=dQteeRsRVuT_p5-T88-7jqT65Zm9iAXkyKg-KQ1_TQ8,6341
-tests/test_python.py,sha256=KWsncKpeDdRmjRftmJpsMl7bBLI3TG_I7Lb4kuemZzQ,25618
-tests/test_solutions.py,sha256=4_Ce7VmsAoALN79a72nEpRgIJqx1oGnCY7yre9a-5vk,12671
-ultralytics/__init__.py,sha256=dNL32IT6IwReXAZE3Gp8ZeYZDxmgnF_xLn60OR9wXzg,730
+tests/test_python.py,sha256=Zx9OlPN11_D1WSLpi9nPFqORNHNz0lEn6mxVNL2ZHjE,25852
+tests/test_solutions.py,sha256=7n4CqKj2guj09UFKe4jufrrC16xRBUIjiRAfGDoAMI8,12808
+ultralytics/__init__.py,sha256=27HzhLPFDZjawOY0VuVN8Sn9RoiF9R4NJj3_CBuiuIs,730
 ultralytics/assets/bus.jpg,sha256=wCAZxJecGR63Od3ZRERe9Aja1Weayrb9Ug751DS_vGM,137419
 ultralytics/assets/zidane.jpg,sha256=Ftc4aeMmen1O0A3o6GCDO9FlfBslLpTAw0gnetx7bts,50427
 ultralytics/cfg/__init__.py,sha256=mpvLR68Iff4J59zYGhysSl8VwIVVzV_VMOYeVdqnYj4,39544
@@ -118,10 +118,10 @@ ultralytics/data/scripts/get_coco.sh,sha256=UuJpJeo3qQpTHVINeOpmP0NYmg8PhEFE3A8J
 ultralytics/data/scripts/get_coco128.sh,sha256=qmRQl_hOKrsdHrTrnyQuFIH01oDz3lfaz138OgGfLt8,650
 ultralytics/data/scripts/get_imagenet.sh,sha256=hr42H16bM47iT27rgS7MpEo-GeOZAYUQXgr0B2cwn48,1705
 ultralytics/engine/__init__.py,sha256=lm6MckFYCPTbqIoX7w0s_daxdjNeBeKW6DXppv1-QUM,70
-ultralytics/engine/exporter.py,sha256=tJTl6AkJ-OCgE1pstsu2iOSHqidkuqejPetNCg8S64k,70841
+ultralytics/engine/exporter.py,sha256=BZWa7Mnl1BPvbPiD-RJs6M5Bca4sm3_MQgjoHesvXEs,70949
 ultralytics/engine/model.py,sha256=BtC5KYNrdfhryrS7b6ZXDIsmtObEeIDTePCv1gO4br4,52952
 ultralytics/engine/predictor.py,sha256=rZ5mIPeejkxUerpTfUf_1rSAklOR3THqoejlil4C04w,21651
-ultralytics/engine/results.py,sha256=MhbyMCwgslmtV53fqii4UJUaLQ4gKTKdkXi7vvmJDAE,79628
+ultralytics/engine/results.py,sha256=2sNNhAc2zaIRaQBXl_36gAKK31V8tgNDcgC4ZPiGqKI,70072
 ultralytics/engine/trainer.py,sha256=xdgNAgq6umJ6915tiCK3U22NeY7w1HnvmAhXlwS_hYI,38955
 ultralytics/engine/tuner.py,sha256=zEW1UpLlZ6N4xbvS7MxICkshRlaFgLNfuADA0VfRpao,12629
 ultralytics/engine/validator.py,sha256=f9UUv3QqQStLrO1nojrHkdS58qYQxKXaoIQQria6WyA,17054
@@ -233,11 +233,11 @@ ultralytics/trackers/utils/__init__.py,sha256=lm6MckFYCPTbqIoX7w0s_daxdjNeBeKW6D
 ultralytics/trackers/utils/gmc.py,sha256=843LlmqWuXdUULBNpxVCZlil-_2QG-UwvscUCFbpGjA,14541
 ultralytics/trackers/utils/kalman_filter.py,sha256=A0CqOnnaKH6kr0XwuHzyHmIU6aJAjJYxF9jVlNBKZHo,21326
 ultralytics/trackers/utils/matching.py,sha256=7eIufSdeN7cXuFMjvcfvz0Ldq84m4YKZl5IGxBR8IIo,7169
-ultralytics/utils/__init__.py,sha256=9RF8KyUHd_YyovvZzlcnZzxx-jkxBLrxfXfkFVj64Iw,52882
+ultralytics/utils/__init__.py,sha256=7VT2VSCIgDPInuNKO0sy2_3-qUwuCafLG0wF4wAyjBg,59059
 ultralytics/utils/autobatch.py,sha256=kg05q2qKg74y_Uq2vvr01i3KhLfpVR7sT0IXBt3_kyI,4921
 ultralytics/utils/autodevice.py,sha256=OKZfTbswg6SlsYGCGMqROkA-451CXGG47oeyC5Q1kFM,7232
-ultralytics/utils/benchmarks.py,sha256=lDNNnLeLUzmqKrqrqlCOiau-q7A-gcLooZP2dbxCu-U,30214
-ultralytics/utils/checks.py,sha256=GJbfMl608ihHSjN78Xjjky10Cglv-CYsxJ7Ra7HeH1U,33204
+ultralytics/utils/benchmarks.py,sha256=iqjxD29srcCpimtAhbSidpsjnUlMhNR5S6QGPZyz16I,30287
+ultralytics/utils/checks.py,sha256=SinI5gY-znVbQ-JXk1JaHIlSp2kuBv92Rv99NWFzOFg,33763
 ultralytics/utils/dist.py,sha256=aytW0JEkcA5ZTZucV92ot7Bn-apiej8aLk3QNWicjAc,4103
 ultralytics/utils/downloads.py,sha256=G1nd7c7Gwjf58nZzDVpXDtoFtzhZYbjKBnwbZVMWRG0,22333
 ultralytics/utils/errors.py,sha256=vY9h2evFSrHnZdHJVVrmm8Zzw4qVDLyo9DeYW5g0dFk,1573
@@ -245,7 +245,7 @@ ultralytics/utils/export.py,sha256=Rr5R3GdJBapJJt1XHkH6VQwYN52-L_7wGiRDCgnb7BY,8
 ultralytics/utils/files.py,sha256=0K4O1cgqRiXaDw7EQK13TqA5SME_RrvfDVQSPetNr5w,8042
 ultralytics/utils/instance.py,sha256=UOEsXR9V-bXNRk6BTonASBEgeMqvzzAk4S7VdXZJUAM,18090
 ultralytics/utils/loss.py,sha256=Woc_rj7ptCyezHdylEygXMeSEgivYu_B9jJHD4UwxWE,37607
-ultralytics/utils/metrics.py,sha256=n8guPEADBMRNpeXNShEX-fxVv9xck8S4QaOIiaW_kl0,56037
+ultralytics/utils/metrics.py,sha256=8x4S7y-rBKRkM47f_o7jfMHA1Bz8SDq3t-R1FXlQNEM,59267
 ultralytics/utils/ops.py,sha256=YFwPrKlPcgEmgAWqnJVR0Ccx5NQgp5e3P-YYHwVSP0k,34779
 ultralytics/utils/patches.py,sha256=_dhIU_eDklQE-aWIjpyjPHl_wOwZoGuIUQnXgdSwk_A,5020
 ultralytics/utils/plotting.py,sha256=oFq19c3tRng-dKHEH-j-S_wLG4CZ_mk8wqE_Gab2H8A,47221
@@ -264,9 +264,9 @@ ultralytics/utils/callbacks/neptune.py,sha256=yYUgEgSv6L39sSev6vjwhAWU3DlPDsbSDV
 ultralytics/utils/callbacks/raytune.py,sha256=A8amUGpux7dYES-L1iSeMoMXBySGWCD1aUqT7vcG-pU,1284
 ultralytics/utils/callbacks/tensorboard.py,sha256=jgYnym3cUQFAgN1GzTyO7l3jINtfAh8zhrllDvnLuVQ,5339
 ultralytics/utils/callbacks/wb.py,sha256=iDRFXI4IIDm8R5OI89DMTmjs8aHLo1HRCLkOFKdaMG4,7507
-ultralytics-8.3.138.dist-info/licenses/LICENSE,sha256=DZak_2itbUtvHzD3E7GNUYSRK6jdOJ-GqncQ2weavLA,34523
-ultralytics-8.3.138.dist-info/METADATA,sha256=106NtnFyYbqCGa4Qz3VS2r9kAit_FObW2-HtID3Ozv4,37200
-ultralytics-8.3.138.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
-ultralytics-8.3.138.dist-info/entry_points.txt,sha256=YM_wiKyTe9yRrsEfqvYolNO5ngwfoL4-NwgKzc8_7sI,93
-ultralytics-8.3.138.dist-info/top_level.txt,sha256=XP49TwiMw4QGsvTLSYiJhz1xF_k7ev5mQ8jJXaXi45Q,12
-ultralytics-8.3.138.dist-info/RECORD,,
+ultralytics-8.3.140.dist-info/licenses/LICENSE,sha256=DZak_2itbUtvHzD3E7GNUYSRK6jdOJ-GqncQ2weavLA,34523
+ultralytics-8.3.140.dist-info/METADATA,sha256=ubcLXOXQF7RbhxNBCUSmLJxf6IhihoPeoaBx5LU1r0M,37200
+ultralytics-8.3.140.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
+ultralytics-8.3.140.dist-info/entry_points.txt,sha256=YM_wiKyTe9yRrsEfqvYolNO5ngwfoL4-NwgKzc8_7sI,93
+ultralytics-8.3.140.dist-info/top_level.txt,sha256=XP49TwiMw4QGsvTLSYiJhz1xF_k7ev5mQ8jJXaXi45Q,12
+ultralytics-8.3.140.dist-info/RECORD,,