ultralytics 8.2.95__py3-none-any.whl → 8.2.97__py3-none-any.whl

tests/test_python.py

@@ -269,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.95"
+__version__ = "8.2.97"
 
 
 import os

ultralytics/cfg/__init__.py

@@ -712,6 +712,7 @@ def entrypoint(debug=""):
         "cfg": lambda: yaml_print(DEFAULT_CFG_PATH),
         "hub": lambda: handle_yolo_hub(args[1:]),
         "login": lambda: handle_yolo_hub(args),
+        "logout": lambda: handle_yolo_hub(args),
         "copy-cfg": copy_default_cfg,
         "explorer": lambda: handle_explorer(args[1:]),
         "streamlit-predict": lambda: handle_streamlit_inference(),

ultralytics/engine/model.py

@@ -206,33 +206,21 @@ class Model(nn.Module):
         Check if the provided model is an Ultralytics HUB model.
 
         This static method determines whether the given model string represents a valid Ultralytics HUB model
-        identifier. It checks for three possible formats: a full HUB URL, an API key and model ID combination,
-        or a standalone model ID.
+        identifier.
 
         Args:
-            model (str): The model identifier to check. This can be a URL, an API key and model ID
-                combination, or a standalone model ID.
+            model (str): The model string to check.
 
         Returns:
             (bool): True if the model is a valid Ultralytics HUB model, False otherwise.
 
         Examples:
-            >>> Model.is_hub_model("https://hub.ultralytics.com/models/example_model")
+            >>> Model.is_hub_model("https://hub.ultralytics.com/models/MODEL")
             True
-            >>> Model.is_hub_model("api_key_example_model_id")
-            True
-            >>> Model.is_hub_model("example_model_id")
-            True
-            >>> Model.is_hub_model("not_a_hub_model.pt")
+            >>> Model.is_hub_model("yolov8n.pt")
             False
         """
-        return any(
-            (
-                model.startswith(f"{HUB_WEB_ROOT}/models/"),  # i.e. https://hub.ultralytics.com/models/MODEL_ID
-                [len(x) for x in model.split("_")] == [42, 20],  # APIKEY_MODEL
-                len(model) == 20 and not Path(model).exists() and all(x not in model for x in "./\\"),  # MODEL
-            )
-        )
+        return model.startswith(f"{HUB_WEB_ROOT}/models/")
 
     def _new(self, cfg: str, task=None, model=None, verbose=False) -> None:
         """

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/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/hub/session.py

@@ -5,6 +5,7 @@ import threading
 import time
 from http import HTTPStatus
 from pathlib import Path
+from urllib.parse import parse_qs, urlparse
 
 import requests
 
@@ -77,7 +78,6 @@ class HUBTrainingSession:
             if not session.client.authenticated:
                 if identifier.startswith(f"{HUB_WEB_ROOT}/models/"):
                     LOGGER.warning(f"{PREFIX}WARNING ⚠️ Login to Ultralytics HUB with 'yolo hub login API_KEY'.")
-                    exit()
                 return None
             if args and not identifier.startswith(f"{HUB_WEB_ROOT}/models/"):  # not a HUB model URL
                 session.create_model(args)
@@ -96,7 +96,8 @@ class HUBTrainingSession:
         self.model_url = f"{HUB_WEB_ROOT}/models/{self.model.id}"
         if self.model.is_trained():
             print(emojis(f"Loading trained HUB model {self.model_url} 🚀"))
-            self.model_file = self.model.get_weights_url("best")
+            url = self.model.get_weights_url("best")  # download URL with auth
+            self.model_file = checks.check_file(url, download_dir=Path(SETTINGS["weights_dir"]) / "hub" / self.model.id)
             return
 
         # Set training args and start heartbeats for HUB to monitor agent
@@ -146,9 +147,8 @@ class HUBTrainingSession:
         Parses the given identifier to determine the type of identifier and extract relevant components.
 
         The method supports different identifier formats:
-            - A HUB URL, which starts with HUB_WEB_ROOT followed by '/models/'
-            - An identifier containing an API key and a model ID separated by an underscore
-            - An identifier that is solely a model ID of a fixed length
+            - A HUB model URL https://hub.ultralytics.com/models/MODEL
+            - A HUB model URL with API Key https://hub.ultralytics.com/models/MODEL?api_key=APIKEY
             - A local filename that ends with '.pt' or '.yaml'
 
         Args:
@@ -160,32 +160,26 @@ class HUBTrainingSession:
         Raises:
             HUBModelError: If the identifier format is not recognized.
         """
-        # Initialize variables
         api_key, model_id, filename = None, None, None
 
-        # Check if identifier is a HUB URL
-        if identifier.startswith(f"{HUB_WEB_ROOT}/models/"):
-            # Extract the model_id after the HUB_WEB_ROOT URL
-            model_id = identifier.split(f"{HUB_WEB_ROOT}/models/")[-1]
+        # path = identifier.split(f"{HUB_WEB_ROOT}/models/")[-1]
+        # parts = path.split("_")
+        # if Path(path).suffix in {".pt", ".yaml"}:
+        #     filename = path
+        # elif len(parts) == 2 and len(parts[0]) == 42 and len(parts[1]) == 20:
+        #     api_key, model_id = parts
+        # elif len(path) == 20:
+        #     model_id = path
+
+        if Path(identifier).suffix in {".pt", ".yaml"}:
+            filename = identifier
+        elif identifier.startswith(f"{HUB_WEB_ROOT}/models/"):
+            parsed_url = urlparse(identifier)
+            model_id = Path(parsed_url.path).stem  # handle possible final backslash robustly
+            query_params = parse_qs(parsed_url.query)  # dictionary, i.e. {"api_key": ["API_KEY_HERE"]}
+            api_key = query_params.get("api_key", [None])[0]
         else:
-            # Split the identifier based on underscores only if it's not a HUB URL
-            parts = identifier.split("_")
-
-            # Check if identifier is in the format of API key and model ID
-            if len(parts) == 2 and len(parts[0]) == 42 and len(parts[1]) == 20:
-                api_key, model_id = parts
-            # Check if identifier is a single model ID
-            elif len(parts) == 1 and len(parts[0]) == 20:
-                model_id = parts[0]
-            # Check if identifier is a local filename
-            elif identifier.endswith(".pt") or identifier.endswith(".yaml"):
-                filename = identifier
-            else:
-                raise HUBModelError(
-                    f"model='{identifier}' could not be parsed. Check format is correct. "
-                    f"Supported formats are Ultralytics HUB URL, apiKey_modelId, modelId, local pt or yaml file."
-                )
-
+            raise HUBModelError(f"model='{identifier} invalid, correct format is {HUB_WEB_ROOT}/models/MODEL_ID")
         return api_key, model_id, filename
 
     def _set_train_args(self):

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-8.2.95.dist-info → ultralytics-8.2.97.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ultralytics
-Version: 8.2.95
+Version: 8.2.97
 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

{ultralytics-8.2.95.dist-info → ultralytics-8.2.97.dist-info}/RECORD

@@ -6,12 +6,12 @@ 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=A26gwwdoIBXABxH3lBxaLcTi2QQ1KFSz5fZPbAy2uCc,23493
+tests/test_python.py,sha256=vkA0F9XgOSpU1BxI2Lzq69f6g-vi8PtOfmb_7P96ZUk,23560
 tests/test_solutions.py,sha256=p_2edhl96Ty3jwzSf02Q2m2mTu9skc0Z-eMcUuuXfLg,3300
-ultralytics/__init__.py,sha256=5oU02HAdvUjQ0lXUrbl1c97giPJZZfVE_bt735cUxjM,695
+ultralytics/__init__.py,sha256=4ko8wqP19EM9zJljwbpzSwRQRNGDBUI_jSGHJg5rmD0,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
+ultralytics/cfg/__init__.py,sha256=7FFk0HG4AvAre9CV70QMTtx1h74pSiNSJaxKSiuFkSo,33138
 ultralytics/cfg/default.yaml,sha256=xRKVF-Z9E3imXTU9OCK94kj3jGgYoo67VJQwuYlHiUU,8228
 ultralytics/cfg/datasets/Argoverse.yaml,sha256=FyeuJT5CHq_9d4hlfAf0kpZlnbUMO0S--UJ1yIqcdKk,3134
 ultralytics/cfg/datasets/DOTAv1.5.yaml,sha256=QVfp_Qp-4rukuicaB4qx86NxSHM8Mrzym8l_fIDo8gw,1195
@@ -99,15 +99,15 @@ ultralytics/data/explorer/gui/__init__.py,sha256=mHtJuK4hwF8cuV-VHDc7tp6u6D1gHz2
 ultralytics/data/explorer/gui/dash.py,sha256=vZ476NaUH4FKU08rAJ1K9WNyKtg0soMyJJxqg176yWc,10498
 ultralytics/engine/__init__.py,sha256=mHtJuK4hwF8cuV-VHDc7tp6u6D1gHz2Z7JI8grmQDTs,42
 ultralytics/engine/exporter.py,sha256=MtBFbJp3ifhn9sQXuQb7vxxOmtS_SOw7lnQhrq4H42c,57078
-ultralytics/engine/model.py,sha256=AB9tu7kJW-QiTAp0F_J8KQJ4FijsHXcYBTaVHb7aMrg,52281
+ultralytics/engine/model.py,sha256=1sWOBvLL2JIH8JuHoxwvr1MPfKFww0ORyLESx3Fs2c8,51582
 ultralytics/engine/predictor.py,sha256=MgMWHUJdRcVCaVmOyvdy2Gjk_EyRHv-ar0SSGxQe8F4,17471
-ultralytics/engine/results.py,sha256=x5Ptr5uGjEz63_N1DnfDg2ktNhLqT93oPyIPruuWp6w,70986
+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
+ultralytics/hub/session.py,sha256=ivTJpGEKEi7F55RloWN-Ks6oeB3ll74AWGAsBtAQOPM,16715
 ultralytics/hub/utils.py,sha256=I7NATG6O_QRw7EU7EHkdTVvbCkwKCyUe54BP60To_so,9715
 ultralytics/hub/google/__init__.py,sha256=uclNs-_5vAzQMgQKgl8eBvml1cx6IZYXRUhrF57v6_k,7504
 ultralytics/models/__init__.py,sha256=TT9iLCL_n9Y80dcUq0Fo-p-GRZCSU2vrWXM3CoMwqqE,265
@@ -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
@@ -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.95.dist-info/LICENSE,sha256=DZak_2itbUtvHzD3E7GNUYSRK6jdOJ-GqncQ2weavLA,34523
-ultralytics-8.2.95.dist-info/METADATA,sha256=q8F9Y4cjZoDo4lbelf2a4LE6Qu5wGAQy3MrzVw9b3ac,39504
-ultralytics-8.2.95.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
-ultralytics-8.2.95.dist-info/entry_points.txt,sha256=YM_wiKyTe9yRrsEfqvYolNO5ngwfoL4-NwgKzc8_7sI,93
-ultralytics-8.2.95.dist-info/top_level.txt,sha256=XP49TwiMw4QGsvTLSYiJhz1xF_k7ev5mQ8jJXaXi45Q,12
-ultralytics-8.2.95.dist-info/RECORD,,
+ultralytics-8.2.97.dist-info/LICENSE,sha256=DZak_2itbUtvHzD3E7GNUYSRK6jdOJ-GqncQ2weavLA,34523
+ultralytics-8.2.97.dist-info/METADATA,sha256=ZXllOjVWz8Z_-O8l8U7EAIr7Hy32uYtPLoMpa9-Vbs0,39504
+ultralytics-8.2.97.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+ultralytics-8.2.97.dist-info/entry_points.txt,sha256=YM_wiKyTe9yRrsEfqvYolNO5ngwfoL4-NwgKzc8_7sI,93
+ultralytics-8.2.97.dist-info/top_level.txt,sha256=XP49TwiMw4QGsvTLSYiJhz1xF_k7ev5mQ8jJXaXi45Q,12
+ultralytics-8.2.97.dist-info/RECORD,,