ultralytics 8.2.94__py3-none-any.whl → 8.2.96__py3-none-any.whl

tests/__init__.py

@@ -1,13 +1,13 @@
 # Ultralytics YOLO 🚀, AGPL-3.0 license
 
-from ultralytics.utils import ASSETS, ROOT, WEIGHTS_DIR, checks, is_dir_writeable
+from ultralytics.utils import ASSETS, ROOT, WEIGHTS_DIR, checks
 
 # Constants used in tests
 MODEL = WEIGHTS_DIR / "path with spaces" / "yolov8n.pt"  # test spaces in path
 CFG = "yolov8n.yaml"
 SOURCE = ASSETS / "bus.jpg"
+SOURCES_LIST = [ASSETS / "bus.jpg", ASSETS, ASSETS / "*", ASSETS / "**/*.jpg"]
 TMP = (ROOT / "../tests/tmp").resolve()  # temp directory for test files
-IS_TMP_WRITEABLE = is_dir_writeable(TMP)
 CUDA_IS_AVAILABLE = checks.cuda_is_available()
 CUDA_DEVICE_COUNT = checks.cuda_device_count()
 
@@ -15,6 +15,7 @@ __all__ = (
     "MODEL",
     "CFG",
     "SOURCE",
+    "SOURCES_LIST",
     "TMP",
     "IS_TMP_WRITEABLE",
     "CUDA_IS_AVAILABLE",

tests/test_python.py

@@ -1,6 +1,7 @@
 # Ultralytics YOLO 🚀, AGPL-3.0 license
 
 import contextlib
+import csv
 import urllib
 from copy import copy
 from pathlib import Path
@@ -12,7 +13,7 @@ import torch
 import yaml
 from PIL import Image
 
-from tests import CFG, IS_TMP_WRITEABLE, MODEL, SOURCE, TMP
+from tests import CFG, MODEL, SOURCE, SOURCES_LIST, TMP
 from ultralytics import RTDETR, YOLO
 from ultralytics.cfg import MODELS, TASK2DATA, TASKS
 from ultralytics.data.build import load_inference_source
@@ -26,11 +27,14 @@ from ultralytics.utils import (
     WEIGHTS_DIR,
     WINDOWS,
     checks,
+    is_dir_writeable,
     is_github_action_running,
 )
 from ultralytics.utils.downloads import download
 from ultralytics.utils.torch_utils import TORCH_1_9
 
+IS_TMP_WRITEABLE = is_dir_writeable(TMP)  # WARNING: must be run once tests start as TMP does not exist on tests/init
+
 
 def test_model_forward():
     """Test the forward pass of the YOLO model."""
@@ -70,11 +74,37 @@ def test_model_profile():
 @pytest.mark.skipif(not IS_TMP_WRITEABLE, reason="directory is not writeable")
 def test_predict_txt():
     """Tests YOLO predictions with file, directory, and pattern sources listed in a text file."""
-    txt_file = TMP / "sources.txt"
-    with open(txt_file, "w") as f:
-        for x in [ASSETS / "bus.jpg", ASSETS, ASSETS / "*", ASSETS / "**/*.jpg"]:
-            f.write(f"{x}\n")
-    _ = YOLO(MODEL)(source=txt_file, imgsz=32)
+    file = TMP / "sources_multi_row.txt"
+    with open(file, "w") as f:
+        for src in SOURCES_LIST:
+            f.write(f"{src}\n")
+    results = YOLO(MODEL)(source=file, imgsz=32)
+    assert len(results) == 7  # 1 + 2 + 2 + 2 = 7 images
+
+
+@pytest.mark.skipif(True, reason="disabled for testing")
+@pytest.mark.skipif(not IS_TMP_WRITEABLE, reason="directory is not writeable")
+def test_predict_csv_multi_row():
+    """Tests YOLO predictions with sources listed in multiple rows of a CSV file."""
+    file = TMP / "sources_multi_row.csv"
+    with open(file, "w", newline="") as f:
+        writer = csv.writer(f)
+        writer.writerow(["source"])
+        writer.writerows([[src] for src in SOURCES_LIST])
+    results = YOLO(MODEL)(source=file, imgsz=32)
+    assert len(results) == 7  # 1 + 2 + 2 + 2 = 7 images
+
+
+@pytest.mark.skipif(True, reason="disabled for testing")
+@pytest.mark.skipif(not IS_TMP_WRITEABLE, reason="directory is not writeable")
+def test_predict_csv_single_row():
+    """Tests YOLO predictions with sources listed in a single row of a CSV file."""
+    file = TMP / "sources_single_row.csv"
+    with open(file, "w", newline="") as f:
+        writer = csv.writer(f)
+        writer.writerow(SOURCES_LIST)
+    results = YOLO(MODEL)(source=file, imgsz=32)
+    assert len(results) == 7  # 1 + 2 + 2 + 2 = 7 images
 
 
 @pytest.mark.parametrize("model_name", MODELS)
@@ -239,7 +269,10 @@ def test_results(model):
         r = r.to(device="cpu", dtype=torch.float32)
         r.save_txt(txt_file=TMP / "runs/tests/label.txt", save_conf=True)
         r.save_crop(save_dir=TMP / "runs/tests/crops/")
-        r.tojson(normalize=True)
+        r.to_json(normalize=True)
+        r.to_df(decimals=3)
+        r.to_csv()
+        r.to_xml()
         r.plot(pil=True)
         r.plot(conf=True, boxes=True)
         print(r, len(r), r.path)  # print after methods

ultralytics/__init__.py

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

ultralytics/engine/results.py

@@ -14,6 +14,7 @@ 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.plotting import Annotator, colors, save_one_box
 from ultralytics.utils.torch_utils import smart_inference_mode
 
@@ -818,7 +819,90 @@ 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. Defaults to False.
+            decimals (int): Number of decimal places to round the output values to. Defaults to 5.
+
+        Returns:
+            (DataFrame): A Pandas Dataframe containing all the information in results in an organized way.
+
+        Examples:
+            >>> results = model("path/to/image.jpg")
+            >>> df_result = results[0].to_df()
+            >>> print(df_result)
+        """
+        import pandas as pd
+
+        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. Defaults to False.
+            decimals (int): Number of decimal places to round the output values to. Defaults to 5.
+            *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")
+            >>> csv_result = results[0].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. Defaults to False.
+            decimals (int): Number of decimal places to round the output values to. Defaults to 5.
+            *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")
+            >>> xml_result = results[0].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 tojson(self, normalize=False, decimals=5):
+        """Deprecated version of to_json()."""
+        LOGGER.warning("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.
 
@@ -836,7 +920,7 @@ class Results(SimpleClass):
 
         Examples:
             >>> results = model("path/to/image.jpg")
-            >>> json_result = results[0].tojson()
+            >>> json_result = results[0].to_json()
             >>> print(json_result)
 
         Notes:

ultralytics/engine/trainer.py

@@ -668,13 +668,14 @@ class BaseTrainer:
 
     def final_eval(self):
         """Performs final evaluation and validation for object detection YOLO model."""
+        ckpt = {}
         for f in self.last, self.best:
             if f.exists():
-                strip_optimizer(f)  # strip optimizers
-                if f is self.best:
-                    if self.last.is_file():  # update best.pt train_metrics from last.pt
-                        k = "train_results"
-                        torch.save({**torch.load(self.best), **{k: torch.load(self.last)[k]}}, self.best)
+                if f is self.last:
+                    ckpt = strip_optimizer(f)
+                elif f is self.best:
+                    k = "train_results"  # update best.pt train_metrics from last.pt
+                    strip_optimizer(f, updates={k: ckpt[k]} if k in ckpt else None)
                     LOGGER.info(f"\nValidating {f}...")
                     self.validator.args.plots = self.args.plots
                     self.metrics = self.validator(model=f)

ultralytics/engine/validator.py

@@ -110,7 +110,8 @@ class BaseValidator:
         if self.training:
             self.device = trainer.device
             self.data = trainer.data
-            self.args.half = self.device.type != "cpu"  # force FP16 val during training
+            # force FP16 val during training
+            self.args.half = self.device.type != "cpu" and trainer.amp
             model = trainer.ema.ema or trainer.model
             model = model.half() if self.args.half else model.float()
             # self.model = model

ultralytics/nn/tasks.py

@@ -759,6 +759,10 @@ class SafeClass:
         """Initialize SafeClass instance, ignoring all arguments."""
         pass
 
+    def __call__(self, *args, **kwargs):
+        """Run SafeClass instance, ignoring all arguments."""
+        pass
+
 
 class SafeUnpickler(pickle.Unpickler):
     """Custom Unpickler that replaces unknown classes with SafeClass."""

ultralytics/solutions/parking_management.py

@@ -42,10 +42,10 @@ class ParkingPtsSelection:
         self.image_path = None
         self.image = None
         self.canvas_image = None
-        self.bounding_boxes = []
+        self.rg_data = []  # region coordinates
         self.current_box = []
-        self.img_width = 0
-        self.img_height = 0
+        self.imgw = 0  # image width
+        self.imgh = 0  # image height
 
         # Constants
         self.canvas_max_width = 1280
@@ -64,17 +64,17 @@ class ParkingPtsSelection:
             return
 
         self.image = Image.open(self.image_path)
-        self.img_width, self.img_height = self.image.size
+        self.imgw, self.imgh = self.image.size
 
         # Calculate the aspect ratio and resize image
-        aspect_ratio = self.img_width / self.img_height
+        aspect_ratio = self.imgw / self.imgh
         if aspect_ratio > 1:
             # Landscape orientation
-            canvas_width = min(self.canvas_max_width, self.img_width)
+            canvas_width = min(self.canvas_max_width, self.imgw)
             canvas_height = int(canvas_width / aspect_ratio)
         else:
             # Portrait orientation
-            canvas_height = min(self.canvas_max_height, self.img_height)
+            canvas_height = min(self.canvas_max_height, self.imgh)
             canvas_width = int(canvas_height * aspect_ratio)
 
         # Check if canvas is already initialized
@@ -90,46 +90,34 @@ class ParkingPtsSelection:
         self.canvas.bind("<Button-1>", self.on_canvas_click)
 
         # Reset bounding boxes and current box
-        self.bounding_boxes = []
+        self.rg_data = []
         self.current_box = []
 
     def on_canvas_click(self, event):
         """Handle mouse clicks on canvas to create points for bounding boxes."""
         self.current_box.append((event.x, event.y))
-        x0, y0 = event.x - 3, event.y - 3
-        x1, y1 = event.x + 3, event.y + 3
-        self.canvas.create_oval(x0, y0, x1, y1, fill="red")
+        self.canvas.create_oval(event.x - 3, event.y - 3, event.x + 3, event.y + 3, fill="red")
 
         if len(self.current_box) == 4:
-            self.bounding_boxes.append(self.current_box)
-            self.draw_bounding_box(self.current_box)
+            self.rg_data.append(self.current_box)
+            [
+                self.canvas.create_line(self.current_box[i], self.current_box[(i + 1) % 4], fill="blue", width=2)
+                for i in range(4)
+            ]
             self.current_box = []
 
-    def draw_bounding_box(self, box):
-        """
-        Draw bounding box on canvas.
-
-        Args:
-            box (list): Bounding box data
-        """
-        for i in range(4):
-            x1, y1 = box[i]
-            x2, y2 = box[(i + 1) % 4]
-            self.canvas.create_line(x1, y1, x2, y2, fill="blue", width=2)
-
     def remove_last_bounding_box(self):
         """Remove the last drawn bounding box from canvas."""
         from tkinter import messagebox  # scope for multi-environment compatibility
 
-        if self.bounding_boxes:
-            self.bounding_boxes.pop()  # Remove the last bounding box
+        if self.rg_data:
+            self.rg_data.pop()  # Remove the last bounding box
             self.canvas.delete("all")  # Clear the canvas
             self.canvas.create_image(0, 0, anchor=self.tk.NW, image=self.canvas_image)  # Redraw the image
 
             # Redraw all bounding boxes
-            for box in self.bounding_boxes:
-                self.draw_bounding_box(box)
-
+            for box in self.rg_data:
+                [self.canvas.create_line(box[i], box[(i + 1) % 4], fill="blue", width=2) for i in range(4)]
             messagebox.showinfo("Success", "Last bounding box removed.")
         else:
             messagebox.showwarning("Warning", "No bounding boxes to remove.")
@@ -138,19 +126,19 @@ class ParkingPtsSelection:
         """Saves rescaled bounding boxes to 'bounding_boxes.json' based on image-to-canvas size ratio."""
         from tkinter import messagebox  # scope for multi-environment compatibility
 
-        canvas_width, canvas_height = self.canvas.winfo_width(), self.canvas.winfo_height()
-        width_scaling_factor = self.img_width / canvas_width
-        height_scaling_factor = self.img_height / canvas_height
-        bounding_boxes_data = []
-        for box in self.bounding_boxes:
-            rescaled_box = []
+        rg_data = []  # regions data
+        for box in self.rg_data:
+            rs_box = []  # rescaled box list
             for x, y in box:
-                rescaled_x = int(x * width_scaling_factor)
-                rescaled_y = int(y * height_scaling_factor)
-                rescaled_box.append((rescaled_x, rescaled_y))
-            bounding_boxes_data.append({"points": rescaled_box})
+                rs_box.append(
+                    (
+                        int(x * self.imgw / self.canvas.winfo_width()),  # width scaling
+                        int(y * self.imgh / self.canvas.winfo_height()),
+                    )
+                )  # height scaling
+            rg_data.append({"points": rs_box})
         with open("bounding_boxes.json", "w") as f:
-            json.dump(bounding_boxes_data, f, indent=4)
+            json.dump(rg_data, f, indent=4)
 
         messagebox.showinfo("Success", "Bounding boxes saved to bounding_boxes.json")
 
@@ -160,102 +148,85 @@ class ParkingManagement:
 
     def __init__(
         self,
-        model_path,
-        txt_color=(0, 0, 0),
-        bg_color=(255, 255, 255),
-        occupied_region_color=(0, 255, 0),
-        available_region_color=(0, 0, 255),
-        margin=10,
+        model,  # Ultralytics YOLO model file path
+        json_file,  # Parking management annotation file created from Parking Annotator
+        occupied_region_color=(0, 0, 255),  # occupied region color
+        available_region_color=(0, 255, 0),  # available region color
     ):
         """
         Initializes the parking management system with a YOLOv8 model and visualization settings.
 
         Args:
-            model_path (str): Path to the YOLOv8 model.
-            txt_color (tuple): RGB color tuple for text.
-            bg_color (tuple): RGB color tuple for background.
+            model (str): Path to the YOLOv8 model.
+            json_file (str): file that have all parking slot points data
             occupied_region_color (tuple): RGB color tuple for occupied regions.
             available_region_color (tuple): RGB color tuple for available regions.
-            margin (int): Margin for text display.
         """
-        # Model path and initialization
-        self.model_path = model_path
-        self.model = self.load_model()
-
-        # Labels dictionary
-        self.labels_dict = {"Occupancy": 0, "Available": 0}
-
-        # Visualization details
-        self.margin = margin
-        self.bg_color = bg_color
-        self.txt_color = txt_color
-        self.occupied_region_color = occupied_region_color
-        self.available_region_color = available_region_color
-
-        self.window_name = "Ultralytics YOLOv8 Parking Management System"
-        # Check if environment supports imshow
-        self.env_check = check_imshow(warn=True)
-
-    def load_model(self):
-        """Load the Ultralytics YOLO model for inference and analytics."""
+        # Model initialization
         from ultralytics import YOLO
 
-        return YOLO(self.model_path)
-
-    @staticmethod
-    def parking_regions_extraction(json_file):
-        """
-        Extract parking regions from json file.
+        self.model = YOLO(model)
 
-        Args:
-            json_file (str): file that have all parking slot points
-        """
+        # Load JSON data
         with open(json_file) as f:
-            return json.load(f)
+            self.json_data = json.load(f)
 
-    def process_data(self, json_data, im0, boxes, clss):
+        self.pr_info = {"Occupancy": 0, "Available": 0}  # dictionary for parking information
+
+        self.occ = occupied_region_color
+        self.arc = available_region_color
+
+        self.env_check = check_imshow(warn=True)  # check if environment supports imshow
+
+    def process_data(self, im0):
         """
         Process the model data for parking lot management.
 
         Args:
-            json_data (str): json data for parking lot management
             im0 (ndarray): inference image
-            boxes (list): bounding boxes data
-            clss (list): bounding boxes classes list
-
-        Returns:
-            filled_slots (int): total slots that are filled in parking lot
-            empty_slots (int): total slots that are available in parking lot
         """
-        annotator = Annotator(im0)
-        empty_slots, filled_slots = len(json_data), 0
-        for region in json_data:
-            points_array = np.array(region["points"], dtype=np.int32).reshape((-1, 1, 2))
-            region_occupied = False
+        results = self.model.track(im0, persist=True, show=False)  # object tracking
 
-            for box, cls in zip(boxes, clss):
-                x_center = int((box[0] + box[2]) / 2)
-                y_center = int((box[1] + box[3]) / 2)
-                text = f"{self.model.names[int(cls)]}"
+        es, fs = len(self.json_data), 0  # empty slots, filled slots
+        annotator = Annotator(im0)  # init annotator
 
+        # extract tracks data
+        if results[0].boxes.id is None:
+            self.display_frames(im0)
+            return im0
+
+        boxes = results[0].boxes.xyxy.cpu().tolist()
+        clss = results[0].boxes.cls.cpu().tolist()
+
+        for region in self.json_data:
+            # 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
+            for box, cls in zip(boxes, clss):
+                xc = int((box[0] + box[2]) / 2)
+                yc = int((box[1] + box[3]) / 2)
                 annotator.display_objects_labels(
-                    im0, text, self.txt_color, self.bg_color, x_center, y_center, self.margin
+                    im0, self.model.names[int(cls)], (104, 31, 17), (255, 255, 255), xc, yc, 10
                 )
-                dist = cv2.pointPolygonTest(points_array, (x_center, y_center), False)
+                dist = cv2.pointPolygonTest(pts_array, (xc, yc), False)
                 if dist >= 0:
-                    region_occupied = True
+                    rg_occupied = True
                     break
+            if rg_occupied:
+                fs += 1
+                es -= 1
+
+            # Plotting regions
+            color = self.occ if rg_occupied else self.arc
+            cv2.polylines(im0, [pts_array], isClosed=True, color=color, thickness=2)
 
-            color = self.occupied_region_color if region_occupied else self.available_region_color
-            cv2.polylines(im0, [points_array], isClosed=True, color=color, thickness=2)
-            if region_occupied:
-                filled_slots += 1
-                empty_slots -= 1
+        self.pr_info["Occupancy"] = fs
+        self.pr_info["Available"] = es
 
-        self.labels_dict["Occupancy"] = filled_slots
-        self.labels_dict["Available"] = empty_slots
+        annotator.display_analytics(im0, self.pr_info, (104, 31, 17), (255, 255, 255), 10)
 
-        annotator.display_analytics(im0, self.labels_dict, self.txt_color, self.bg_color, self.margin)
+        self.display_frames(im0)
+        return im0
 
     def display_frames(self, im0):
         """
@@ -265,8 +236,7 @@ class ParkingManagement:
             im0 (ndarray): inference image
         """
         if self.env_check:
-            cv2.namedWindow(self.window_name)
-            cv2.imshow(self.window_name, im0)
+            cv2.imshow("Ultralytics Parking Manager", im0)
             # Break Window
             if cv2.waitKey(1) & 0xFF == ord("q"):
                 return

ultralytics/utils/checks.py

@@ -656,9 +656,10 @@ def check_amp(model):
 
     def amp_allclose(m, im):
         """All close FP32 vs AMP results."""
-        a = m(im, device=device, verbose=False)[0].boxes.data  # FP32 inference
+        batch = [im] * 8
+        a = m(batch, imgsz=128, device=device, verbose=False)[0].boxes.data  # FP32 inference
         with autocast(enabled=True):
-            b = m(im, device=device, verbose=False)[0].boxes.data  # AMP inference
+            b = m(batch, imgsz=128, device=device, verbose=False)[0].boxes.data  # AMP inference
         del m
         return a.shape == b.shape and torch.allclose(a, b.float(), atol=0.5)  # close to 0.5 absolute tolerance
 

ultralytics/utils/torch_utils.py

@@ -533,16 +533,17 @@ class ModelEMA:
             copy_attr(self.ema, model, include, exclude)
 
 
-def strip_optimizer(f: Union[str, Path] = "best.pt", s: str = "") -> None:
+def strip_optimizer(f: Union[str, Path] = "best.pt", s: str = "", updates: dict = None) -> dict:
     """
     Strip optimizer from 'f' to finalize training, optionally save as 's'.
 
     Args:
         f (str): file path to model to strip the optimizer from. Default is 'best.pt'.
         s (str): file path to save the model with stripped optimizer to. If not provided, 'f' will be overwritten.
+        updates (dict): a dictionary of updates to overlay onto the checkpoint before saving.
 
     Returns:
-        None
+        (dict): The combined checkpoint dictionary.
 
     Example:
         ```python
@@ -562,9 +563,9 @@ def strip_optimizer(f: Union[str, Path] = "best.pt", s: str = "") -> None:
         assert "model" in x, "'model' missing from checkpoint"
     except Exception as e:
         LOGGER.warning(f"WARNING ⚠️ Skipping {f}, not a valid Ultralytics model: {e}")
-        return
+        return {}
 
-    updates = {
+    metadata = {
         "date": datetime.now().isoformat(),
         "version": __version__,
         "license": "AGPL-3.0 License (https://ultralytics.com/license)",
@@ -591,9 +592,11 @@ def strip_optimizer(f: Union[str, Path] = "best.pt", s: str = "") -> None:
     # x['model'].args = x['train_args']
 
     # Save
-    torch.save({**updates, **x}, s or f, use_dill=False)  # combine dicts (prefer to the right)
+    combined = {**metadata, **x, **(updates or {})}
+    torch.save(combined, s or f, use_dill=False)  # combine dicts (prefer to the right)
     mb = os.path.getsize(s or f) / 1e6  # file size
     LOGGER.info(f"Optimizer stripped from {f},{f' saved as {s},' if s else ''} {mb:.1f}MB")
+    return combined
 
 
 def convert_optimizer_state_dict_to_fp16(state_dict):

{ultralytics-8.2.94.dist-info → ultralytics-8.2.96.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ultralytics
-Version: 8.2.94
+Version: 8.2.96
 Summary: Ultralytics YOLO for SOTA object detection, multi-object tracking, instance segmentation, pose estimation and image classification.
 Author: Glenn Jocher, Ayush Chaurasia, Jing Qiu
 Maintainer: Glenn Jocher, Ayush Chaurasia, Jing Qiu
@@ -172,14 +172,25 @@ YOLOv8 may also be used directly in a Python environment, and accepts the same [
 from ultralytics import YOLO
 
 # Load a model
-model = YOLO("yolov8n.yaml")  # build a new model from scratch
-model = YOLO("yolov8n.pt")  # load a pretrained model (recommended for training)
-
-# Use the model
-model.train(data="coco8.yaml", epochs=3)  # train the model
-metrics = model.val()  # evaluate model performance on the validation set
-results = model("https://ultralytics.com/images/bus.jpg")  # predict on an image
-path = model.export(format="onnx")  # export the model to ONNX format
+model = YOLO("yolov8n.pt")
+
+# Train the model
+train_results = model.train(
+    data="coco8.yaml",  # path to dataset YAML
+    epochs=100,  # number of training epochs
+    imgsz=640,  # training image size
+    device="cpu",  # device to run on, i.e. device=0 or device=0,1,2,3 or device=cpu
+)
+
+# Evaluate model performance on the validation set
+metrics = model.val()
+
+# Perform object detection on an image
+results = model("path/to/image.jpg")
+results[0].show()
+
+# Export the model to ONNX format
+path = model.export(format="onnx")  # return path to exported model
 ```
 
 See YOLOv8 [Python Docs](https://docs.ultralytics.com/usage/python/) for more examples.
@@ -224,23 +235,6 @@ See [Detection Docs](https://docs.ultralytics.com/tasks/detect/) for usage examp
 
 </details>
 
-<details><summary>Detection (Open Image V7)</summary>
-
-See [Detection Docs](https://docs.ultralytics.com/tasks/detect/) for usage examples with these models trained on [Open Image V7](https://docs.ultralytics.com/datasets/detect/open-images-v7/), which include 600 pre-trained classes.
-
-| Model                                                                                     | size<br><sup>(pixels) | mAP<sup>val<br>50-95 | Speed<br><sup>CPU ONNX<br>(ms) | Speed<br><sup>A100 TensorRT<br>(ms) | params<br><sup>(M) | FLOPs<br><sup>(B) |
-| ----------------------------------------------------------------------------------------- | --------------------- | -------------------- | ------------------------------ | ----------------------------------- | ------------------ | ----------------- |
-| [YOLOv8n](https://github.com/ultralytics/assets/releases/download/v8.2.0/yolov8n-oiv7.pt) | 640                   | 18.4                 | 142.4                          | 1.21                                | 3.5                | 10.5              |
-| [YOLOv8s](https://github.com/ultralytics/assets/releases/download/v8.2.0/yolov8s-oiv7.pt) | 640                   | 27.7                 | 183.1                          | 1.40                                | 11.4               | 29.7              |
-| [YOLOv8m](https://github.com/ultralytics/assets/releases/download/v8.2.0/yolov8m-oiv7.pt) | 640                   | 33.6                 | 408.5                          | 2.26                                | 26.2               | 80.6              |
-| [YOLOv8l](https://github.com/ultralytics/assets/releases/download/v8.2.0/yolov8l-oiv7.pt) | 640                   | 34.9                 | 596.9                          | 2.43                                | 44.1               | 167.4             |
-| [YOLOv8x](https://github.com/ultralytics/assets/releases/download/v8.2.0/yolov8x-oiv7.pt) | 640                   | 36.3                 | 860.6                          | 3.56                                | 68.7               | 260.6             |
-
-- **mAP<sup>val</sup>** values are for single-model single-scale on [Open Image V7](https://docs.ultralytics.com/datasets/detect/open-images-v7/) dataset. <br>Reproduce by `yolo val detect data=open-images-v7.yaml device=0`
-- **Speed** averaged over Open Image V7 val images using an [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/) instance. <br>Reproduce by `yolo val detect data=open-images-v7.yaml batch=1 device=0|cpu`
-
-</details>
-
 <details><summary>Segmentation (COCO)</summary>
 
 See [Segmentation Docs](https://docs.ultralytics.com/tasks/segment/) for usage examples with these models trained on [COCO-Seg](https://docs.ultralytics.com/datasets/segment/coco/), which include 80 pre-trained classes.

{ultralytics-8.2.94.dist-info → ultralytics-8.2.96.dist-info}/RECORD

@@ -1,4 +1,4 @@
-tests/__init__.py,sha256=9evx3lOdKZeY1iWXvH-FkMkgf8jLucWICoabzeD6aYg,626
+tests/__init__.py,sha256=JMahSIGmWc9B303_FBqQu6FKhxN3deI3a-q4Ftc-3Pw,666
 tests/conftest.py,sha256=3ZtD4VlMKK5jVJwIPCrNAcG63vywJzdLq7U2AfYR2VI,2919
 tests/test_cli.py,sha256=E4lMt49TGo12Lb5CgQfpk1bwyFUZuFxF0V9j_ykV7xM,4821
 tests/test_cuda.py,sha256=uD-ddNEcBMFQmQ9iE4fIGh0EIcGwEoDEUNVCEHicaWE,5133
@@ -6,9 +6,9 @@ tests/test_engine.py,sha256=xW-UT9_9xZp-7-hSnbJgMw_ezTk6NqTOIiA59XZDmxA,4934
 tests/test_explorer.py,sha256=IMFvZ9uMoEXVC5FwdaVh0821wBgs7muVF6aw1F-auAI,2572
 tests/test_exports.py,sha256=Uezf3OatpPHlo5qoPw-2kqkZxuMCF9L4XF2riD4vmII,8225
 tests/test_integrations.py,sha256=xglcfMPjfVh346PV8WTpk6tBxraCXEFJEQyyJMr5tyU,6064
-tests/test_python.py,sha256=08fg47DuJflumuUBto480-9VCqtEGAhQjNnQdcHs9_c,22242
+tests/test_python.py,sha256=vkA0F9XgOSpU1BxI2Lzq69f6g-vi8PtOfmb_7P96ZUk,23560
 tests/test_solutions.py,sha256=p_2edhl96Ty3jwzSf02Q2m2mTu9skc0Z-eMcUuuXfLg,3300
-ultralytics/__init__.py,sha256=O6sPQ_8fCEfwvfDZLx6eIevrmM_KAbE4h0FlV6oM2lg,695
+ultralytics/__init__.py,sha256=lwq1oD-BHTsuvQhJupzGRvRWeuEv9C4c8j-G4SsFupE,695
 ultralytics/assets/bus.jpg,sha256=wCAZxJecGR63Od3ZRERe9Aja1Weayrb9Ug751DS_vGM,137419
 ultralytics/assets/zidane.jpg,sha256=Ftc4aeMmen1O0A3o6GCDO9FlfBslLpTAw0gnetx7bts,50427
 ultralytics/cfg/__init__.py,sha256=pkB7wk0pHOA3xzKzMbS-hA0iJoPOWVNnwZJh0LuWh-w,33089
@@ -101,10 +101,10 @@ ultralytics/engine/__init__.py,sha256=mHtJuK4hwF8cuV-VHDc7tp6u6D1gHz2Z7JI8grmQDT
 ultralytics/engine/exporter.py,sha256=MtBFbJp3ifhn9sQXuQb7vxxOmtS_SOw7lnQhrq4H42c,57078
 ultralytics/engine/model.py,sha256=AB9tu7kJW-QiTAp0F_J8KQJ4FijsHXcYBTaVHb7aMrg,52281
 ultralytics/engine/predictor.py,sha256=MgMWHUJdRcVCaVmOyvdy2Gjk_EyRHv-ar0SSGxQe8F4,17471
-ultralytics/engine/results.py,sha256=x5Ptr5uGjEz63_N1DnfDg2ktNhLqT93oPyIPruuWp6w,70986
-ultralytics/engine/trainer.py,sha256=GtuAXRElX7CJ-XAQy_XqmvzzsD25SrRlViRGADKec2c,36681
+ultralytics/engine/results.py,sha256=8RJlN8J-_9w-mrDZm9wC-DZJTPBS7v1c_r_R173QyRM,75043
+ultralytics/engine/trainer.py,sha256=VOuR9WpDgYILevpWnWAtKLEIcJ4iFG41HxOCSbOy0YA,36657
 ultralytics/engine/tuner.py,sha256=gPqDTHH7vRB2O3YyH26m1BjVKbXxuA2XAlPRzTKFZsc,11838
-ultralytics/engine/validator.py,sha256=yaUMb5efBvgFg8M24IFlmv3J-acbbSgtqLCk-mM07Wo,14623
+ultralytics/engine/validator.py,sha256=483Ad87Irk7IBlJNLu2SQAJsb7YriALTX9GIgriCmRg,14650
 ultralytics/hub/__init__.py,sha256=AM_twjV9ouUmyxh3opoPgTqDpMOd8xIOHsAKdWS2L18,5663
 ultralytics/hub/auth.py,sha256=kDLakGa2NbzvMAeXc2UdzZ65r0AH-XeM_JfsDY97WGk,5545
 ultralytics/hub/session.py,sha256=UXKHwidZxjiz0AMATsuUAS7nP584afN0S2pLGA4EOjI,16888
@@ -169,7 +169,7 @@ ultralytics/models/yolo/world/train.py,sha256=gaDrAmLJpg9qDtmL5evA5HsV2yb4RTRSfk
 ultralytics/models/yolo/world/train_world.py,sha256=IsnCEVt6DcM9lUskCKmIN-M8MM79xLpwTRqRoAHUnZ4,4857
 ultralytics/nn/__init__.py,sha256=4BPLHY89xEM_al5uK0aOmFgiML6CMGEZbezxOvTjOEs,587
 ultralytics/nn/autobackend.py,sha256=DZTIHsp2PLs8H2-oQR9LqA-uPj8DARGonCXzRv2Pkdc,31546
-ultralytics/nn/tasks.py,sha256=GbRUqOmLS6wTB2U6Z3IojXE96jCrs33vrCwVGxmD_34,47777
+ultralytics/nn/tasks.py,sha256=5ESFTm1CYt7uSCyWkW7rsLAdMLPHSBla95GWj439SrA,47894
 ultralytics/nn/modules/__init__.py,sha256=m8x-XRHVLWMECPeysVlv1TQenV-n8oAbK1gxnoXzLpk,2553
 ultralytics/nn/modules/activation.py,sha256=chhn469wnRHEs5BMGNBYXwPYZc_7-urspTT8fnBd-xA,895
 ultralytics/nn/modules/block.py,sha256=n6Xhevz8_n05UCt_vmZ7eVRiDbA_zV_TvWNBbpZe-qA,34352
@@ -183,7 +183,7 @@ ultralytics/solutions/analytics.py,sha256=bGuZes11D7DNiTsHdwu6PJ0QA0vCiqMMAtZ7Ny
 ultralytics/solutions/distance_calculation.py,sha256=o_DAHk4JX8n2Vt7E68MX67mREOBZuy5skbXtVZ6iu_4,5228
 ultralytics/solutions/heatmap.py,sha256=oEVivA4KAK6z0wA5Ca_a2qTckQN8tCt9MCpsPREeNnk,10375
 ultralytics/solutions/object_counter.py,sha256=QXSg2a5IBW70lirIKml8xNgPDyzUy7dLt2gUn59_18A,9941
-ultralytics/solutions/parking_management.py,sha256=z0-g2nehh4aA1nO71foT8Rw5pQTxKnEdcKJb1Arrd0Q,10134
+ultralytics/solutions/parking_management.py,sha256=tGD1dglpIu5KhDWF7xaIRwbqETfpxCfvyvlUsNEsjUQ,9119
 ultralytics/solutions/queue_management.py,sha256=yKPGc2-fN-lMpNddkxjN7xYGIJwMdoU-VIDRxQ1KPow,4869
 ultralytics/solutions/speed_estimation.py,sha256=c9OPGpDU9x6Dj4SobNc-sO90EZTPTGeKkW5u6C6Zj7g,4623
 ultralytics/solutions/streamlit_inference.py,sha256=MKf5P3O5oJwIKu2h_URvzaQjMWoSEMDMBwordplfRxo,5703
@@ -199,7 +199,7 @@ ultralytics/trackers/utils/matching.py,sha256=3Ie1WNNRZ4_q3365F03XD7Nr9juZB_08mw
 ultralytics/utils/__init__.py,sha256=BRqC6AE9epuZJy4XcGzGfuR2zNiXx-mfot2JQomterw,44097
 ultralytics/utils/autobatch.py,sha256=AXboYfNSnTGsYj5FmgGYPQd0crfkeleyms6QXQfZGQ4,4194
 ultralytics/utils/benchmarks.py,sha256=UsVJXTgB6xQ8QBjlNghN3WuZQwXShQjuqv2RcGBLHDY,23640
-ultralytics/utils/checks.py,sha256=0CSbjlHDe3CNEMDlxXcjna2CWjaTQnYBVqIF_P_QVl4,28857
+ultralytics/utils/checks.py,sha256=PmdN42XJ7IIUNbeiY8zjPIfJceaxAO04nc780EoYxTc,28910
 ultralytics/utils/dist.py,sha256=NDFga-uKxkBX2zLxFHSene_cCiGQJoyOeCXcN9JIOIk,2358
 ultralytics/utils/downloads.py,sha256=uLsYFN2G4g2joTNrsZsfc8ytvfNNRXDPkI20qgkZ2B8,21897
 ultralytics/utils/errors.py,sha256=GqP_Jgj_n0paxn8OMhn3DTCgoNkB2WjUcUaqs-M6SQk,816
@@ -211,7 +211,7 @@ ultralytics/utils/ops.py,sha256=dsXNdyrYx_p6io6zezig9p84dxS7U-10vceHNVu2IL0,3288
 ultralytics/utils/patches.py,sha256=Oo3DkP7MbXnNGvPfoFSocAkVvaPh9kwMT_9RQUfjVhI,3594
 ultralytics/utils/plotting.py,sha256=bud5mAvFxQ2JD29dReaO4c7Z00k6jIaPJJCznIoyy2w,61543
 ultralytics/utils/tal.py,sha256=ECsu95xEqOItmxMDN4YTD3FsUiIsQNWy0pZC3TfvFfk,16877
-ultralytics/utils/torch_utils.py,sha256=NgZtDgjQkAVCAqCdFrFMSU9Fl_x3pYqaYa1mhAvOb_8,29312
+ultralytics/utils/torch_utils.py,sha256=lTTbFD8SlnXT11O9E8NKTQnrXEOsRmayywQP6niUZMc,29535
 ultralytics/utils/triton.py,sha256=gg1finxno_tY2Ge9PMhmu7PI9wvoFZoiicdT4Bhqv3w,3936
 ultralytics/utils/tuner.py,sha256=AtEtK6pOt9xVTyx864OpNRVxNdAxz5aKHzveiXwkD1A,6250
 ultralytics/utils/callbacks/__init__.py,sha256=YrWqC3BVVaTLob4iCPR6I36mUxIUOpPJW7B_LjT78Qw,214
@@ -225,9 +225,9 @@ ultralytics/utils/callbacks/neptune.py,sha256=5Z3ua5YBTUS56FH8VQKQG1aaIo9fH8GEyz
 ultralytics/utils/callbacks/raytune.py,sha256=ODVYzy-CoM4Uge0zjkh3Hnh9nF2M0vhDrSenXnvcizw,705
 ultralytics/utils/callbacks/tensorboard.py,sha256=0kn4IR10no99UCIheojWRujgybmUHSx5fPI6Vsq6l_g,4135
 ultralytics/utils/callbacks/wb.py,sha256=9-fjQIdLjr3b73DTE3rHO171KvbH1VweJ-bmbv-rqTw,6747
-ultralytics-8.2.94.dist-info/LICENSE,sha256=DZak_2itbUtvHzD3E7GNUYSRK6jdOJ-GqncQ2weavLA,34523
-ultralytics-8.2.94.dist-info/METADATA,sha256=tqncGrC7zri313tqgv5vjcUWYKeUYHhlWpPCXMtxIO0,41897
-ultralytics-8.2.94.dist-info/WHEEL,sha256=5Mi1sN9lKoFv_gxcPtisEVrJZihrm_beibeg5R6xb4I,91
-ultralytics-8.2.94.dist-info/entry_points.txt,sha256=YM_wiKyTe9yRrsEfqvYolNO5ngwfoL4-NwgKzc8_7sI,93
-ultralytics-8.2.94.dist-info/top_level.txt,sha256=XP49TwiMw4QGsvTLSYiJhz1xF_k7ev5mQ8jJXaXi45Q,12
-ultralytics-8.2.94.dist-info/RECORD,,
+ultralytics-8.2.96.dist-info/LICENSE,sha256=DZak_2itbUtvHzD3E7GNUYSRK6jdOJ-GqncQ2weavLA,34523
+ultralytics-8.2.96.dist-info/METADATA,sha256=bZUZH71HHVFy1f_7FP0i3Tlu-kJJLZ2ODLbd2tqmUPY,39504
+ultralytics-8.2.96.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+ultralytics-8.2.96.dist-info/entry_points.txt,sha256=YM_wiKyTe9yRrsEfqvYolNO5ngwfoL4-NwgKzc8_7sI,93
+ultralytics-8.2.96.dist-info/top_level.txt,sha256=XP49TwiMw4QGsvTLSYiJhz1xF_k7ev5mQ8jJXaXi45Q,12
+ultralytics-8.2.96.dist-info/RECORD,,

{ultralytics-8.2.94.dist-info → ultralytics-8.2.96.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.0.0)
+Generator: setuptools (75.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any