ultralytics 8.3.8__py3-none-any.whl → 8.3.9__py3-none-any.whl

tests/test_solutions.py

@@ -14,24 +14,21 @@ WORKOUTS_SOLUTION_DEMO = "https://github.com/ultralytics/assets/releases/downloa
 def test_major_solutions():
     """Test the object counting, heatmap, speed estimation and queue management solution."""
     safe_download(url=MAJOR_SOLUTIONS_DEMO)
-    model = YOLO("yolo11n.pt")
-    names = model.names
     cap = cv2.VideoCapture("solutions_ci_demo.mp4")
     assert cap.isOpened(), "Error reading video file"
     region_points = [(20, 400), (1080, 404), (1080, 360), (20, 360)]
     counter = solutions.ObjectCounter(region=region_points, model="yolo11n.pt", show=False)
     heatmap = solutions.Heatmap(colormap=cv2.COLORMAP_PARULA, model="yolo11n.pt", show=False)
-    speed = solutions.SpeedEstimator(reg_pts=region_points, names=names, view_img=False)
+    speed = solutions.SpeedEstimator(region=region_points, model="yolo11n.pt", show=False)
     queue = solutions.QueueManager(region=region_points, model="yolo11n.pt", show=False)
     while cap.isOpened():
         success, im0 = cap.read()
         if not success:
             break
         original_im0 = im0.copy()
-        tracks = model.track(im0, persist=True, show=False)
         _ = counter.count(original_im0.copy())
         _ = heatmap.generate_heatmap(original_im0.copy())
-        _ = speed.estimate_speed(original_im0.copy(), tracks)
+        _ = speed.estimate_speed(original_im0.copy())
         _ = queue.process_queue(original_im0.copy())
     cap.release()
     cv2.destroyAllWindows()

ultralytics/__init__.py

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

ultralytics/cfg/solutions/default.yaml

@@ -2,15 +2,15 @@
 
 # Configuration for Ultralytics Solutions
 
-model: "yolo11n.pt" # The Ultralytics YOLO11 model to be used (e.g., yolo11n.pt for YOLO11 nano version)
+model: "yolo11n.pt" # The Ultralytics YOLO11 model to be used (e.g., yolo11n.pt for YOLO11 nano version and yolov8n.pt for YOLOv8 nano version)
 
-region: # Object counting, queue or speed estimation region points
-line_width: 2 # Thickness of the lines used to draw regions on the image/video frames
-show: True # Flag to control whether to display output image or not
+region: # Object counting, queue or speed estimation region points. Default region points are [(20, 400), (1080, 404), (1080, 360), (20, 360)]
+line_width: 2 # Width of the annotator used to draw regions on the image/video frames + bounding boxes and tracks drawing. Default value is 2.
+show: True # Flag to control whether to display output image or not, you can set this as False i.e. when deploying it on some embedded devices.
 show_in: True # Flag to display objects moving *into* the defined region
 show_out: True # Flag to display objects moving *out of* the defined region
-classes: # To count specific classes
-up_angle: 145.0 # Workouts up_angle for counts, 145.0 is default value
-down_angle: 90 # Workouts down_angle for counts, 90 is default value
-kpts: [6, 8, 10] # Keypoints for workouts monitoring
-colormap: # Colormap for heatmap
+classes: # To count specific classes. i.e, if you want to detect, track and count the person with COCO model, you can use classes=0, Default its None
+up_angle: 145.0 # Workouts up_angle for counts, 145.0 is default value. You can adjust it for different workouts, based on position of keypoints.
+down_angle: 90 # Workouts down_angle for counts, 90 is default value. You can change it for different workouts, based on position of keypoints.
+kpts: [6, 8, 10] # Keypoints for workouts monitoring, i.e. If you want to consider keypoints for pushups that have mostly values of [6, 8, 10].
+colormap: # Colormap for heatmap, Only OPENCV supported colormaps can be used. By default COLORMAP_PARULA will be used for visualization.

ultralytics/engine/trainer.py

@@ -469,11 +469,9 @@ class BaseTrainer:
 
         if RANK in {-1, 0}:
             # Do final val with best.pt
-            epochs = epoch - self.start_epoch + 1  # total training epochs
-            seconds = time.time() - self.train_time_start  # total training seconds
-            LOGGER.info(f"\n{epochs} epochs completed in {seconds / 3600:.3f} hours.")
+            seconds = time.time() - self.train_time_start
+            LOGGER.info(f"\n{epoch - self.start_epoch + 1} epochs completed in {seconds / 3600:.3f} hours.")
             self.final_eval()
-            self.validator.metrics.training = {"epochs": epochs, "seconds": seconds}  # add training speed
             if self.args.plots:
                 self.plot_metrics()
             self.run_callbacks("on_train_end")
@@ -504,7 +502,7 @@ class BaseTrainer:
         """Read results.csv into a dict using pandas."""
         import pandas as pd  # scope for faster 'import ultralytics'
 
-        return {k.strip(): v for k, v in pd.read_csv(self.csv).to_dict(orient="list").items()}
+        return pd.read_csv(self.csv).to_dict(orient="list")
 
     def save_model(self):
         """Save model training checkpoints with additional metadata."""
@@ -654,10 +652,11 @@ class BaseTrainer:
     def save_metrics(self, metrics):
         """Saves training metrics to a CSV file."""
         keys, vals = list(metrics.keys()), list(metrics.values())
-        n = len(metrics) + 1  # number of cols
-        s = "" if self.csv.exists() else (("%23s," * n % tuple(["epoch"] + keys)).rstrip(",") + "\n")  # header
+        n = len(metrics) + 2  # number of cols
+        s = "" if self.csv.exists() else (("%s," * n % tuple(["epoch", "time"] + keys)).rstrip(",") + "\n")  # header
+        t = time.time() - self.train_time_start
         with open(self.csv, "a") as f:
-            f.write(s + ("%23.5g," * n % tuple([self.epoch + 1] + vals)).rstrip(",") + "\n")
+            f.write(s + ("%.6g," * n % tuple([self.epoch + 1, t] + vals)).rstrip(",") + "\n")
 
     def plot_metrics(self):
         """Plot and display metrics visually."""

ultralytics/nn/autobackend.py

@@ -265,8 +265,8 @@ class AutoBackend(nn.Module):
                         if -1 in tuple(model.get_tensor_shape(name)):
                             dynamic = True
                             context.set_input_shape(name, tuple(model.get_tensor_profile_shape(name, 0)[1]))
-                            if dtype == np.float16:
-                                fp16 = True
+                        if dtype == np.float16:
+                            fp16 = True
                     else:
                         output_names.append(name)
                     shape = tuple(context.get_tensor_shape(name))

ultralytics/nn/tasks.py

@@ -1061,10 +1061,10 @@ def parse_model(d, ch, verbose=True):  # model_dict, input_channels(3)
 
         m_ = nn.Sequential(*(m(*args) for _ in range(n))) if n > 1 else m(*args)  # module
         t = str(m)[8:-2].replace("__main__.", "")  # module type
-        m.np = sum(x.numel() for x in m_.parameters())  # number params
+        m_.np = sum(x.numel() for x in m_.parameters())  # number params
         m_.i, m_.f, m_.type = i, f, t  # attach index, 'from' index, type
         if verbose:
-            LOGGER.info(f"{i:>3}{str(f):>20}{n_:>3}{m.np:10.0f}  {t:<45}{str(args):<30}")  # print
+            LOGGER.info(f"{i:>3}{str(f):>20}{n_:>3}{m_.np:10.0f}  {t:<45}{str(args):<30}")  # print
         save.extend(x % i for x in ([f] if isinstance(f, int) else f) if x != -1)  # append to savelist
         layers.append(m_)
         if i == 0:

ultralytics/solutions/speed_estimation.py

@@ -1,116 +1,76 @@
 # Ultralytics YOLO 🚀, AGPL-3.0 license
 
-from collections import defaultdict
 from time import time
 
-import cv2
 import numpy as np
 
-from ultralytics.utils.checks import check_imshow
+from ultralytics.solutions.solutions import BaseSolution, LineString
 from ultralytics.utils.plotting import Annotator, colors
 
 
-class SpeedEstimator:
+class SpeedEstimator(BaseSolution):
     """A class to estimate the speed of objects in a real-time video stream based on their tracks."""
 
-    def __init__(self, names, reg_pts=None, view_img=False, line_thickness=2, spdl_dist_thresh=10):
-        """
-        Initializes the SpeedEstimator with the given parameters.
-
-        Args:
-            names (dict): Dictionary of class names.
-            reg_pts (list, optional): List of region points for speed estimation. Defaults to [(20, 400), (1260, 400)].
-            view_img (bool, optional): Whether to display the image with annotations. Defaults to False.
-            line_thickness (int, optional): Thickness of the lines for drawing boxes and tracks. Defaults to 2.
-            spdl_dist_thresh (int, optional): Distance threshold for speed calculation. Defaults to 10.
-        """
-        # Region information
-        self.reg_pts = reg_pts if reg_pts is not None else [(20, 400), (1260, 400)]
+    def __init__(self, **kwargs):
+        """Initializes the SpeedEstimator with the given parameters."""
+        super().__init__(**kwargs)
 
-        self.names = names  # Classes names
+        self.initialize_region()  # Initialize speed region
 
-        # Tracking information
-        self.trk_history = defaultdict(list)
-
-        self.view_img = view_img  # bool for displaying inference
-        self.tf = line_thickness  # line thickness for annotator
         self.spd = {}  # set for speed data
         self.trkd_ids = []  # list for already speed_estimated and tracked ID's
-        self.spdl = spdl_dist_thresh  # Speed line distance threshold
         self.trk_pt = {}  # set for tracks previous time
         self.trk_pp = {}  # set for tracks previous point
 
-        # Check if the environment supports imshow
-        self.env_check = check_imshow(warn=True)
-
-    def estimate_speed(self, im0, tracks):
+    def estimate_speed(self, im0):
         """
         Estimates the speed of objects based on tracking data.
 
         Args:
-            im0 (ndarray): Image.
-            tracks (list): List of tracks obtained from the object tracking process.
-
-        Returns:
-            (ndarray): The image with annotated boxes and tracks.
+            im0 (ndarray): The input image that will be used for processing
+        Returns
+            im0 (ndarray): The processed image for more usage
         """
-        if tracks[0].boxes.id is None:
-            return im0
+        self.annotator = Annotator(im0, line_width=self.line_width)  # Initialize annotator
+        self.extract_tracks(im0)  # Extract tracks
 
-        boxes = tracks[0].boxes.xyxy.cpu()
-        clss = tracks[0].boxes.cls.cpu().tolist()
-        t_ids = tracks[0].boxes.id.int().cpu().tolist()
-        annotator = Annotator(im0, line_width=self.tf)
-        annotator.draw_region(reg_pts=self.reg_pts, color=(255, 0, 255), thickness=self.tf * 2)
+        self.annotator.draw_region(
+            reg_pts=self.region, color=(104, 0, 123), thickness=self.line_width * 2
+        )  # Draw region
 
-        for box, t_id, cls in zip(boxes, t_ids, clss):
-            track = self.trk_history[t_id]
-            bbox_center = (float((box[0] + box[2]) / 2), float((box[1] + box[3]) / 2))
-            track.append(bbox_center)
+        for box, track_id, cls in zip(self.boxes, self.track_ids, self.clss):
+            self.store_tracking_history(track_id, box)  # Store track history
 
-            if len(track) > 30:
-                track.pop(0)
+            # Check if track_id is already in self.trk_pp or trk_pt initialize if not
+            if track_id not in self.trk_pt:
+                self.trk_pt[track_id] = 0
+            if track_id not in self.trk_pp:
+                self.trk_pp[track_id] = self.track_line[-1]
 
-            trk_pts = np.hstack(track).astype(np.int32).reshape((-1, 1, 2))
+            speed_label = f"{int(self.spd[track_id])} km/h" if track_id in self.spd else self.names[int(cls)]
+            self.annotator.box_label(box, label=speed_label, color=colors(track_id, True))  # Draw bounding box
 
-            if t_id not in self.trk_pt:
-                self.trk_pt[t_id] = 0
+            # Draw tracks of objects
+            self.annotator.draw_centroid_and_tracks(
+                self.track_line, color=colors(int(track_id), True), track_thickness=self.line_width
+            )
 
-            speed_label = f"{int(self.spd[t_id])} km/h" if t_id in self.spd else self.names[int(cls)]
-            bbox_color = colors(int(t_id), True)
-
-            annotator.box_label(box, speed_label, bbox_color)
-            cv2.polylines(im0, [trk_pts], isClosed=False, color=bbox_color, thickness=self.tf)
-            cv2.circle(im0, (int(track[-1][0]), int(track[-1][1])), self.tf * 2, bbox_color, -1)
-
-            # Calculation of object speed
-            if not self.reg_pts[0][0] < track[-1][0] < self.reg_pts[1][0]:
-                return
-            if self.reg_pts[1][1] - self.spdl < track[-1][1] < self.reg_pts[1][1] + self.spdl:
-                direction = "known"
-            elif self.reg_pts[0][1] - self.spdl < track[-1][1] < self.reg_pts[0][1] + self.spdl:
+            # Calculate object speed and direction based on region intersection
+            if LineString([self.trk_pp[track_id], self.track_line[-1]]).intersects(self.l_s):
                 direction = "known"
             else:
                 direction = "unknown"
 
-            if self.trk_pt.get(t_id) != 0 and direction != "unknown" and t_id not in self.trkd_ids:
-                self.trkd_ids.append(t_id)
-
-                time_difference = time() - self.trk_pt[t_id]
+            # Perform speed calculation and tracking updates if direction is valid
+            if direction == "known" and track_id not in self.trkd_ids:
+                self.trkd_ids.append(track_id)
+                time_difference = time() - self.trk_pt[track_id]
                 if time_difference > 0:
-                    self.spd[t_id] = np.abs(track[-1][1] - self.trk_pp[t_id][1]) / time_difference
-
-            self.trk_pt[t_id] = time()
-            self.trk_pp[t_id] = track[-1]
-
-        if self.view_img and self.env_check:
-            cv2.imshow("Ultralytics Speed Estimation", im0)
-            if cv2.waitKey(1) & 0xFF == ord("q"):
-                return
+                    self.spd[track_id] = np.abs(self.track_line[-1][1] - self.trk_pp[track_id][1]) / time_difference
 
-        return im0
+            self.trk_pt[track_id] = time()
+            self.trk_pp[track_id] = self.track_line[-1]
 
+        self.display_output(im0)  # display output with base class function
 
-if __name__ == "__main__":
-    names = {0: "person", 1: "car"}  # example class names
-    speed_estimator = SpeedEstimator(names)
+        return im0  # return output image for more usage

ultralytics/utils/autobatch.py

@@ -67,7 +67,7 @@ def autobatch(model, imgsz=640, fraction=0.60, batch_size=DEFAULT_CFG.batch):
     LOGGER.info(f"{prefix}{d} ({properties.name}) {t:.2f}G total, {r:.2f}G reserved, {a:.2f}G allocated, {f:.2f}G free")
 
     # Profile batch sizes
-    batch_sizes = [1, 2, 4, 8, 16]
+    batch_sizes = [1, 2, 4, 8, 16] if t < 16 else [1, 2, 4, 8, 16, 32, 64]
     try:
         img = [torch.empty(b, 3, imgsz, imgsz) for b in batch_sizes]
         results = profile(img, model, n=1, device=device)

ultralytics/utils/callbacks/clearml.py

@@ -68,9 +68,9 @@ def on_pretrain_routine_start(trainer):
             PatchedMatplotlib.update_current_task(None)
         else:
             task = Task.init(
-                project_name=trainer.args.project or "YOLOv8",
+                project_name=trainer.args.project or "Ultralytics",
                 task_name=trainer.args.name,
-                tags=["YOLOv8"],
+                tags=["Ultralytics"],
                 output_uri=True,
                 reuse_last_task_id=False,
                 auto_connect_frameworks={"pytorch": False, "matplotlib": False},

ultralytics/utils/callbacks/comet.py

@@ -15,7 +15,7 @@ try:
     # Ensures certain logging functions only run for supported tasks
     COMET_SUPPORTED_TASKS = ["detect"]
 
-    # Names of plots created by YOLOv8 that are logged to Comet
+    # Names of plots created by Ultralytics that are logged to Comet
     EVALUATION_PLOT_NAMES = "F1_curve", "P_curve", "R_curve", "PR_curve", "confusion_matrix"
     LABEL_PLOT_NAMES = "labels", "labels_correlogram"
 
@@ -31,8 +31,8 @@ def _get_comet_mode():
 
 
 def _get_comet_model_name():
-    """Returns the model name for Comet from the environment variable 'COMET_MODEL_NAME' or defaults to 'YOLOv8'."""
-    return os.getenv("COMET_MODEL_NAME", "YOLOv8")
+    """Returns the model name for Comet from the environment variable COMET_MODEL_NAME or defaults to 'Ultralytics'."""
+    return os.getenv("COMET_MODEL_NAME", "Ultralytics")
 
 
 def _get_eval_batch_logging_interval():
@@ -110,7 +110,7 @@ def _fetch_trainer_metadata(trainer):
 
 def _scale_bounding_box_to_original_image_shape(box, resized_image_shape, original_image_shape, ratio_pad):
     """
-    YOLOv8 resizes images during training and the label values are normalized based on this resized shape.
+    YOLO resizes images during training and the label values are normalized based on this resized shape.
 
     This function rescales the bounding box labels to the original image shape.
     """

ultralytics/utils/callbacks/mlflow.py

@@ -71,7 +71,7 @@ def on_pretrain_routine_end(trainer):
     mlflow.set_tracking_uri(uri)
 
     # Set experiment and run names
-    experiment_name = os.environ.get("MLFLOW_EXPERIMENT_NAME") or trainer.args.project or "/Shared/YOLOv8"
+    experiment_name = os.environ.get("MLFLOW_EXPERIMENT_NAME") or trainer.args.project or "/Shared/Ultralytics"
     run_name = os.environ.get("MLFLOW_RUN") or trainer.args.name
     mlflow.set_experiment(experiment_name)
 

ultralytics/utils/callbacks/neptune.py

@@ -52,7 +52,11 @@ def on_pretrain_routine_start(trainer):
     """Callback function called before the training routine starts."""
     try:
         global run
-        run = neptune.init_run(project=trainer.args.project or "YOLOv8", name=trainer.args.name, tags=["YOLOv8"])
+        run = neptune.init_run(
+            project=trainer.args.project or "Ultralytics",
+            name=trainer.args.name,
+            tags=["Ultralytics"],
+        )
         run["Configuration/Hyperparameters"] = {k: "" if v is None else v for k, v in vars(trainer.args).items()}
     except Exception as e:
         LOGGER.warning(f"WARNING ⚠️ NeptuneAI installed but not initialized correctly, not logging this run. {e}")

ultralytics/utils/callbacks/wb.py

@@ -109,7 +109,7 @@ def _log_plots(plots, step):
 
 def on_pretrain_routine_start(trainer):
     """Initiate and start project if module is present."""
-    wb.run or wb.init(project=trainer.args.project or "YOLOv8", name=trainer.args.name, config=vars(trainer.args))
+    wb.run or wb.init(project=trainer.args.project or "Ultralytics", name=trainer.args.name, config=vars(trainer.args))
 
 
 def on_fit_epoch_end(trainer):

{ultralytics-8.3.8.dist-info → ultralytics-8.3.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ultralytics
-Version: 8.3.8
+Version: 8.3.9
 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.8.dist-info → ultralytics-8.3.9.dist-info}/RECORD

@@ -7,8 +7,8 @@ tests/test_explorer.py,sha256=9EeMtt4-K3-MeGnAc7NemTg3uTo-Xr6AYJlTJZJJeF8,2572
 tests/test_exports.py,sha256=fpTKEVBUGLF3WiZPNKRs-IEcIY4cfxgvgKjUNfodjww,8042
 tests/test_integrations.py,sha256=f5-QCUk1SU_-qn4mBCZwS3GN3tXEBIIXo4z2EhExbHw,6126
 tests/test_python.py,sha256=I1RRdCwLdrc3jX06huVxct8HX8ccQOmQgVpuEflRl0U,23560
-tests/test_solutions.py,sha256=kJzvUiOTmFVeM_90_7vwvhrREGrN2aGwcBi-F-a13NU,3126
-ultralytics/__init__.py,sha256=xqr6W7SxucuDpDIAK7_hCzACbw8DLZQHjSo-7vDqXBo,752
+tests/test_solutions.py,sha256=dpxWGKO-aJ3Yff4KR7BQGajX9VyFdGTWEtcbmFC3WwE,3005
+ultralytics/__init__.py,sha256=kKW4tliZreJmH3V6DWiiMAz_zr3td0m2oDNptee7Y5U,752
 ultralytics/assets/bus.jpg,sha256=wCAZxJecGR63Od3ZRERe9Aja1Weayrb9Ug751DS_vGM,137419
 ultralytics/assets/zidane.jpg,sha256=Ftc4aeMmen1O0A3o6GCDO9FlfBslLpTAw0gnetx7bts,50427
 ultralytics/cfg/__init__.py,sha256=N-XONBXwmD3vzoE4icBXznkV8LOLmf6ak6mRdGPucvw,33146
@@ -86,7 +86,7 @@ ultralytics/cfg/models/v9/yolov9e.yaml,sha256=dhaR47WxuLOrZWDCceS4bQG00sQdrMc8FQ
 ultralytics/cfg/models/v9/yolov9m.yaml,sha256=l6CmivzNu44sRVmkQXk4-tXflbV1nWnk5MSc8su2vhs,1311
 ultralytics/cfg/models/v9/yolov9s.yaml,sha256=lPWcu-6ub1kCBD6zIDFwthYZ3RvdJfODWKy3vEQWRjo,1291
 ultralytics/cfg/models/v9/yolov9t.yaml,sha256=qL__kr6GoefpQWP4jV0jdzwTp46bdFUcqtPRnfDbkY8,1275
-ultralytics/cfg/solutions/default.yaml,sha256=H4pXUoA-IafiHL6NNNTyWXrlHAjMRqaItGK1U5amNE4,825
+ultralytics/cfg/solutions/default.yaml,sha256=CByxINYMyoGzGKdurDk2GhYc8XOa8Z6H7CZx7uZSPpc,1532
 ultralytics/cfg/trackers/botsort.yaml,sha256=8B0xNbnG_E-9DCUpap72PWkUgBb1AjuApEn7gHiVngE,916
 ultralytics/cfg/trackers/bytetrack.yaml,sha256=8vpTZ2x9mhRXJymoJvs1G8kTXo_HxbSwHup2FQALT3A,721
 ultralytics/data/__init__.py,sha256=VGe-ATG7j35F4A4r8Jmzffjlhve4JAJPgRa5ahKTU18,616
@@ -109,7 +109,7 @@ ultralytics/engine/exporter.py,sha256=DeHW_T_Zd3A21BLQYV1-FnS5EcmepMOy9nrussYNie
 ultralytics/engine/model.py,sha256=Vtkza7cQrxvowb0PqGFhp7eC3cXRIKj6OUaR5d9w1-U,51464
 ultralytics/engine/predictor.py,sha256=MgMWHUJdRcVCaVmOyvdy2Gjk_EyRHv-ar0SSGxQe8F4,17471
 ultralytics/engine/results.py,sha256=8RJlN8J-_9w-mrDZm9wC-DZJTPBS7v1c_r_R173QyRM,75043
-ultralytics/engine/trainer.py,sha256=ZCEXUPbJG_8Hzn2mLergk3WV-41ei0LT84Tspk0le30,37147
+ultralytics/engine/trainer.py,sha256=6dGOEZvMo3o97SLpKlcR5XmhWhUHh05uLYpj3jNn0jU,36981
 ultralytics/engine/tuner.py,sha256=gPqDTHH7vRB2O3YyH26m1BjVKbXxuA2XAlPRzTKFZsc,11838
 ultralytics/engine/validator.py,sha256=2C_qXI36Z9rLOpmS0YR8Qe3ka4p23YiH2w5ai7-XBwE,14811
 ultralytics/hub/__init__.py,sha256=3SKvZ5aRina3h94xMPQIB3D4maF62qFcyIqPPHRHNAc,5644
@@ -175,8 +175,8 @@ ultralytics/models/yolo/world/__init__.py,sha256=3VTH0q4NOt2EWRom15yCymvmvm0Etp2
 ultralytics/models/yolo/world/train.py,sha256=gaDrAmLJpg9qDtmL5evA5HsV2yb4RTRSfk2EDYrHdRg,3686
 ultralytics/models/yolo/world/train_world.py,sha256=IsnCEVt6DcM9lUskCKmIN-M8MM79xLpwTRqRoAHUnZ4,4857
 ultralytics/nn/__init__.py,sha256=4BPLHY89xEM_al5uK0aOmFgiML6CMGEZbezxOvTjOEs,587
-ultralytics/nn/autobackend.py,sha256=lyOXfZC4jgSebv52YpHlrfUNKp_kVBmIvydb9k0OKFQ,31607
-ultralytics/nn/tasks.py,sha256=O4i5JywqZZ2llESZ39PbojhsQcbFV5Yc1G5moiS80bM,48397
+ultralytics/nn/autobackend.py,sha256=aBW_Z8XnSsD-vW7Ek873dyKX9h55XHIYwTG22M3eOIk,31599
+ultralytics/nn/tasks.py,sha256=ssBZR4LY4rvaxYawXq5-yWSBAZ9oCz6BgxWYXB2YD68,48399
 ultralytics/nn/modules/__init__.py,sha256=xhW2BennT9U_VaMXVpRu-bdLgp1BXt9L8mkIUBE3idU,2625
 ultralytics/nn/modules/activation.py,sha256=chhn469wnRHEs5BMGNBYXwPYZc_7-urspTT8fnBd-xA,895
 ultralytics/nn/modules/block.py,sha256=thcIPcnGRRxDDDswywJsfzbewr9XfTrzl_UvSl-bJ3c,41832
@@ -193,7 +193,7 @@ ultralytics/solutions/object_counter.py,sha256=1Nsivk-cyGBM1G6eWe11_vdDWTdbJwaUF
 ultralytics/solutions/parking_management.py,sha256=VgYyhoSEo7fnPegIhNUqnFL0jlMEevALx0QQbzJ3vGI,9049
 ultralytics/solutions/queue_management.py,sha256=5d1RURQiqffAoET8S66gHimK0l3gKNAfuPO5U6_08jc,2716
 ultralytics/solutions/solutions.py,sha256=qWKGlwlH9858GfAdZkcu_QXbrzjTFStDvg16Eky0oyo,3541
-ultralytics/solutions/speed_estimation.py,sha256=c9OPGpDU9x6Dj4SobNc-sO90EZTPTGeKkW5u6C6Zj7g,4623
+ultralytics/solutions/speed_estimation.py,sha256=2jLTEdnSF3Mm3Z7QJVPCUq84-7L6ELIJIR_sPFBW_cU,3164
 ultralytics/solutions/streamlit_inference.py,sha256=qA2EtwUC7ADOQ8P-zs3VPyrIoRArhcZz9CxkFbH63bw,5699
 ultralytics/trackers/__init__.py,sha256=j72IgH2dZHQArMPK4YwcV5ieIw94fYvlGdQjB9cOQKw,227
 ultralytics/trackers/basetrack.py,sha256=dXnXW3cxxd7lPm20JJCNO2voCIrQ4vhbNI1g4YEgn-Y,4423
@@ -205,7 +205,7 @@ ultralytics/trackers/utils/gmc.py,sha256=VcURuY041qGCeWUGMxHZBr10T16LtcMqyv7AmTf
 ultralytics/trackers/utils/kalman_filter.py,sha256=cH9zD3fwkuezP97H9mw8cSBN7a8hHKx_Sx1j7t3oYGs,21349
 ultralytics/trackers/utils/matching.py,sha256=3Ie1WNNRZ4_q3365F03XD7Nr9juZB_08mw4yUKC3w74,7162
 ultralytics/utils/__init__.py,sha256=du1Y1LMU0jQn_zWWnAIx9U8wn6Vh7ce-k7qMwi6y0po,48698
-ultralytics/utils/autobatch.py,sha256=1ZDy3vvUDKkxROHnxT3_vI4MJ52l9ap7SiuQvG4B-8k,4290
+ultralytics/utils/autobatch.py,sha256=BO9MCRtrLDtrDQaxqV0BdjaYsgXf-q07Y3_VdGp4URY,4330
 ultralytics/utils/benchmarks.py,sha256=8FYp5WPzcxcDaeg8ol2sgzRBHVGYatEO7f3MrmPF6nI,25097
 ultralytics/utils/checks.py,sha256=7oWc91HqQdH9EHuHysxk_ZltiRrGt6eq-pUf0TkA3gU,29579
 ultralytics/utils/dist.py,sha256=NDFga-uKxkBX2zLxFHSene_cCiGQJoyOeCXcN9JIOIk,2358
@@ -224,18 +224,18 @@ ultralytics/utils/triton.py,sha256=gg1finxno_tY2Ge9PMhmu7PI9wvoFZoiicdT4Bhqv3w,3
 ultralytics/utils/tuner.py,sha256=AtEtK6pOt9xVTyx864OpNRVxNdAxz5aKHzveiXwkD1A,6250
 ultralytics/utils/callbacks/__init__.py,sha256=YrWqC3BVVaTLob4iCPR6I36mUxIUOpPJW7B_LjT78Qw,214
 ultralytics/utils/callbacks/base.py,sha256=PHjQ6RITwC2dylCQTB0bdPgAsHjxVeuDb5N1NPTbHGc,5775
-ultralytics/utils/callbacks/clearml.py,sha256=M9Fi1OfdWqcm8uVkauuX3zJIYhNh6Tp7Jo4CfA0u0nw,5923
-ultralytics/utils/callbacks/comet.py,sha256=ATWjZJigLy8lJVYjlwyCha-lJ-QlMfXw-zE9PA7UxqY,13743
+ultralytics/utils/callbacks/clearml.py,sha256=qbLbqzMVWAnjqg5YUM-Ue6CmGueFCvqKpHFKlw-MyVc,5933
+ultralytics/utils/callbacks/comet.py,sha256=DS5w9fgo0eWfjRuIywTlKEv2LY4eOKklEq-DyoIQn7U,13754
 ultralytics/utils/callbacks/dvc.py,sha256=WIClMsuvhiiyrwRv5BsZLxjsxYNJ3Y8Vq7zN0Bthtro,5045
 ultralytics/utils/callbacks/hub.py,sha256=EPewsLigFQc9ucTX2exKSlKBiaBNhYYyGC_nR2ragJo,3997
-ultralytics/utils/callbacks/mlflow.py,sha256=_bUzHyPb0npne0WFlGzlGCy-X5sxGQhC_xA3dZbF08I,5391
-ultralytics/utils/callbacks/neptune.py,sha256=5Z3ua5YBTUS56FH8VQKQG1aaIo9fH8GEyzC5q7p4ipQ,3756
+ultralytics/utils/callbacks/mlflow.py,sha256=mkl_rK0Gy02cXnQUYmzmLE5W97fMgfEb7IlgOAdnjHg,5396
+ultralytics/utils/callbacks/neptune.py,sha256=IbGQfEltamUKXJt93uSLQFn8c2rYh3DMTgVE1xsnmUI,3813
 ultralytics/utils/callbacks/raytune.py,sha256=ODVYzy-CoM4Uge0zjkh3Hnh9nF2M0vhDrSenXnvcizw,705
 ultralytics/utils/callbacks/tensorboard.py,sha256=bv4fkkesdgmZv_E2MU6wuaMBwEV5iI2G53RHPyD9quw,4170
-ultralytics/utils/callbacks/wb.py,sha256=9-fjQIdLjr3b73DTE3rHO171KvbH1VweJ-bmbv-rqTw,6747
-ultralytics-8.3.8.dist-info/LICENSE,sha256=DZak_2itbUtvHzD3E7GNUYSRK6jdOJ-GqncQ2weavLA,34523
-ultralytics-8.3.8.dist-info/METADATA,sha256=omBKv11I1DidGjRCYOu07_VBN1yVEDB8Ccx2jNIw5Rk,34699
-ultralytics-8.3.8.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
-ultralytics-8.3.8.dist-info/entry_points.txt,sha256=YM_wiKyTe9yRrsEfqvYolNO5ngwfoL4-NwgKzc8_7sI,93
-ultralytics-8.3.8.dist-info/top_level.txt,sha256=XP49TwiMw4QGsvTLSYiJhz1xF_k7ev5mQ8jJXaXi45Q,12
-ultralytics-8.3.8.dist-info/RECORD,,
+ultralytics/utils/callbacks/wb.py,sha256=upfbF8-LLXueUvulLaMDmKDhKCl_PWbNa_87PQ0L0Rc,6752
+ultralytics-8.3.9.dist-info/LICENSE,sha256=DZak_2itbUtvHzD3E7GNUYSRK6jdOJ-GqncQ2weavLA,34523
+ultralytics-8.3.9.dist-info/METADATA,sha256=zlSN3Ydf1s9RX4F0F_V0apmc-8fAwWBctBKsKeej9Tg,34699
+ultralytics-8.3.9.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+ultralytics-8.3.9.dist-info/entry_points.txt,sha256=YM_wiKyTe9yRrsEfqvYolNO5ngwfoL4-NwgKzc8_7sI,93
+ultralytics-8.3.9.dist-info/top_level.txt,sha256=XP49TwiMw4QGsvTLSYiJhz1xF_k7ev5mQ8jJXaXi45Q,12
+ultralytics-8.3.9.dist-info/RECORD,,