ultralytics 8.3.3__py3-none-any.whl → 8.3.5__py3-none-any.whl

tests/test_solutions.py

@@ -19,7 +19,7 @@ def test_major_solutions():
     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(reg_pts=region_points, names=names, view_img=False)
+    # counter = solutions.ObjectCounter(reg_pts=region_points, names=names, view_img=False)
     heatmap = solutions.Heatmap(colormap=cv2.COLORMAP_PARULA, names=names, view_img=False)
     speed = solutions.SpeedEstimator(reg_pts=region_points, names=names, view_img=False)
     queue = solutions.QueueManager(names=names, reg_pts=region_points, view_img=False)
@@ -29,7 +29,7 @@ def test_major_solutions():
             break
         original_im0 = im0.copy()
         tracks = model.track(im0, persist=True, show=False)
-        _ = counter.start_counting(original_im0.copy(), tracks)
+        # _ = counter.start_counting(original_im0.copy(), tracks)
         _ = heatmap.generate_heatmap(original_im0.copy(), tracks)
         _ = speed.estimate_speed(original_im0.copy(), tracks)
         _ = queue.process_queue(original_im0.copy(), tracks)

ultralytics/__init__.py

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

ultralytics/cfg/default.yaml

@@ -1,7 +1,7 @@
 # Ultralytics YOLO 🚀, AGPL-3.0 license
 # Default training settings and hyperparameters for medium-augmentation COCO training
 
-task: detect # (str) YOLO task, i.e. detect, segment, classify, pose
+task: detect # (str) YOLO task, i.e. detect, segment, classify, pose, obb
 mode: train # (str) YOLO mode, i.e. train, val, predict, export, track, benchmark
 
 # Train settings -------------------------------------------------------------------------------------------------------

ultralytics/cfg/solutions/default.yaml

@@ -0,0 +1,12 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+
+# Configuration for Ultralytics Solutions
+
+model: "yolo11n.pt" # The Ultralytics YOLO11 model to be used (e.g., yolo11n.pt for YOLO11 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
+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

ultralytics/data/base.py

@@ -90,13 +90,15 @@ class BaseDataset(Dataset):
         self.ims, self.im_hw0, self.im_hw = [None] * self.ni, [None] * self.ni, [None] * self.ni
         self.npy_files = [Path(f).with_suffix(".npy") for f in self.im_files]
         self.cache = cache.lower() if isinstance(cache, str) else "ram" if cache is True else None
-        if (self.cache == "ram" and self.check_cache_ram()) or self.cache == "disk":
-            if self.cache == "ram" and hyp.deterministic:
+        if self.cache == "ram" and self.check_cache_ram():
+            if hyp.deterministic:
                 LOGGER.warning(
                     "WARNING ⚠️ cache='ram' may produce non-deterministic training results. "
                     "Consider cache='disk' as a deterministic alternative if your disk space allows."
                 )
             self.cache_images()
+        elif self.cache == "disk" and self.check_cache_disk():
+            self.cache_images()
 
         # Transforms
         self.transforms = self.build_transforms(hyp=hyp)
@@ -206,25 +208,55 @@ class BaseDataset(Dataset):
         if not f.exists():
             np.save(f.as_posix(), cv2.imread(self.im_files[i]), allow_pickle=False)
 
+    def check_cache_disk(self, safety_margin=0.5):
+        """Check image caching requirements vs available disk space."""
+        import shutil
+
+        b, gb = 0, 1 << 30  # bytes of cached images, bytes per gigabytes
+        n = min(self.ni, 30)  # extrapolate from 30 random images
+        for _ in range(n):
+            im_file = random.choice(self.im_files)
+            im = cv2.imread(im_file)
+            if im is None:
+                continue
+            b += im.nbytes
+            if not os.access(Path(im_file).parent, os.W_OK):
+                self.cache = None
+                LOGGER.info(f"{self.prefix}Skipping caching images to disk, directory not writeable ⚠️")
+                return False
+        disk_required = b * self.ni / n * (1 + safety_margin)  # bytes required to cache dataset to disk
+        total, used, free = shutil.disk_usage(Path(self.im_files[0]).parent)
+        if disk_required > free:
+            self.cache = None
+            LOGGER.info(
+                f"{self.prefix}{disk_required / gb:.1f}GB disk space required, "
+                f"with {int(safety_margin * 100)}% safety margin but only "
+                f"{free / gb:.1f}/{total / gb:.1f}GB free, not caching images to disk ⚠️"
+            )
+            return False
+        return True
+
     def check_cache_ram(self, safety_margin=0.5):
         """Check image caching requirements vs available memory."""
         b, gb = 0, 1 << 30  # bytes of cached images, bytes per gigabytes
         n = min(self.ni, 30)  # extrapolate from 30 random images
         for _ in range(n):
             im = cv2.imread(random.choice(self.im_files))  # sample image
+            if im is None:
+                continue
             ratio = self.imgsz / max(im.shape[0], im.shape[1])  # max(h, w)  # ratio
             b += im.nbytes * ratio**2
         mem_required = b * self.ni / n * (1 + safety_margin)  # GB required to cache dataset into RAM
         mem = psutil.virtual_memory()
-        success = mem_required < mem.available  # to cache or not to cache, that is the question
-        if not success:
+        if mem_required > mem.available:
             self.cache = None
             LOGGER.info(
                 f"{self.prefix}{mem_required / gb:.1f}GB RAM required to cache images "
                 f"with {int(safety_margin * 100)}% safety margin but only "
                 f"{mem.available / gb:.1f}/{mem.total / gb:.1f}GB available, not caching images ⚠️"
             )
-        return success
+            return False
+        return True
 
     def set_rectangle(self):
         """Sets the shape of bounding boxes for YOLO detections as rectangles."""

ultralytics/data/utils.py

@@ -216,7 +216,7 @@ def polygons2masks_overlap(imgsz, segments, downsample_ratio=1):
     ms = []
     for si in range(len(segments)):
         mask = polygon2mask(imgsz, [segments[si].reshape(-1)], downsample_ratio=downsample_ratio, color=1)
-        ms.append(mask)
+        ms.append(mask.astype(masks.dtype))
         areas.append(mask.sum())
     areas = np.asarray(areas)
     index = np.argsort(-areas)
@@ -452,12 +452,12 @@ class HUBDatasetStats:
         path = Path(path).resolve()
         LOGGER.info(f"Starting HUB dataset checks for {path}....")
 
-        self.task = task  # detect, segment, pose, classify
+        self.task = task  # detect, segment, pose, classify, obb
         if self.task == "classify":
             unzip_dir = unzip_file(path)
             data = check_cls_dataset(unzip_dir)
             data["path"] = unzip_dir
-        else:  # detect, segment, pose
+        else:  # detect, segment, pose, obb
             _, data_dir, yaml_path = self._unzip(Path(path))
             try:
                 # Load YAML with checks

ultralytics/engine/exporter.py

@@ -178,6 +178,16 @@ class Exporter:
         if fmt in {"mlmodel", "mlpackage", "mlprogram", "apple", "ios", "coreml"}:  # 'coreml' aliases
             fmt = "coreml"
         fmts = tuple(export_formats()["Argument"][1:])  # available export formats
+        if fmt not in fmts:
+            import difflib
+
+            # Get the closest match if format is invalid
+            matches = difflib.get_close_matches(fmt, fmts, n=1, cutoff=0.6)  # 60% similarity required to match
+            if matches:
+                LOGGER.warning(f"WARNING ⚠️ Invalid export format='{fmt}', updating to format='{matches[0]}'")
+                fmt = matches[0]
+            else:
+                raise ValueError(f"Invalid export format='{fmt}'. Valid formats are {fmts}")
         flags = [x == fmt for x in fmts]
         if sum(flags) != 1:
             raise ValueError(f"Invalid export format='{fmt}'. Valid formats are {fmts}")

ultralytics/engine/trainer.py

@@ -12,7 +12,7 @@ import os
 import subprocess
 import time
 import warnings
-from copy import deepcopy
+from copy import copy, deepcopy
 from datetime import datetime, timedelta
 from pathlib import Path
 
@@ -749,7 +749,7 @@ class BaseTrainer:
             self.train_loader.dataset.mosaic = False
         if hasattr(self.train_loader.dataset, "close_mosaic"):
             LOGGER.info("Closing dataloader mosaic")
-            self.train_loader.dataset.close_mosaic(hyp=self.args)
+            self.train_loader.dataset.close_mosaic(hyp=copy(self.args))
 
     def build_optimizer(self, model, name="auto", lr=0.001, momentum=0.9, decay=1e-5, iterations=1e5):
         """

ultralytics/engine/validator.py

@@ -119,6 +119,8 @@ class BaseValidator:
             self.args.plots &= trainer.stopper.possible_stop or (trainer.epoch == trainer.epochs - 1)
             model.eval()
         else:
+            if str(self.args.model).endswith(".yaml"):
+                LOGGER.warning("WARNING ⚠️ validating an untrained model YAML will result in 0 mAP.")
             callbacks.add_integration_callbacks(self)
             model = AutoBackend(
                 weights=model or self.args.model,

ultralytics/models/sam/predict.py

@@ -196,6 +196,7 @@ class Predictor(BasePredictor):
         bboxes = self.prompts.pop("bboxes", bboxes)
         points = self.prompts.pop("points", points)
         masks = self.prompts.pop("masks", masks)
+        labels = self.prompts.pop("labels", labels)
 
         if all(i is None for i in [bboxes, points, masks]):
             return self.generate(im, *args, **kwargs)

ultralytics/solutions/heatmap.py

@@ -19,10 +19,7 @@ class Heatmap:
     def __init__(
         self,
         names,
-        imw=0,
-        imh=0,
         colormap=cv2.COLORMAP_JET,
-        heatmap_alpha=0.5,
         view_img=False,
         view_in_counts=True,
         view_out_counts=True,
@@ -33,7 +30,6 @@ class Heatmap:
         region_thickness=5,
         line_dist_thresh=15,
         line_thickness=2,
-        decay_factor=0.99,
         shape="circle",
     ):
         """Initializes the heatmap class with default values for Visual, Image, track, count and heatmap parameters."""
@@ -46,8 +42,6 @@ class Heatmap:
         self.names = names  # Classes names
 
         # Image information
-        self.imw = imw
-        self.imh = imh
         self.im0 = None
         self.tf = line_thickness
         self.view_in_counts = view_in_counts
@@ -56,7 +50,6 @@ class Heatmap:
         # Heatmap colormap and heatmap np array
         self.colormap = colormap
         self.heatmap = None
-        self.heatmap_alpha = heatmap_alpha
 
         # Predict/track information
         self.boxes = []
@@ -79,9 +72,6 @@ class Heatmap:
         self.count_bg_color = count_bg_color
         self.cls_txtdisplay_gap = 50
 
-        # Decay factor
-        self.decay_factor = decay_factor
-
         # Check if environment supports imshow
         self.env_check = check_imshow(warn=True)
 
@@ -133,7 +123,7 @@ class Heatmap:
             self.heatmap = np.zeros((int(self.im0.shape[0]), int(self.im0.shape[1])), dtype=np.float32)
             self.initialized = True
 
-        self.heatmap *= self.decay_factor  # decay factor
+        self.heatmap *= 0.99  # decay factor
 
         self.extract_results(tracks)
         self.annotator = Annotator(self.im0, self.tf, None)
@@ -239,7 +229,7 @@ class Heatmap:
         # Normalize, apply colormap to heatmap and combine with original image
         heatmap_normalized = cv2.normalize(self.heatmap, None, 0, 255, cv2.NORM_MINMAX)
         heatmap_colored = cv2.applyColorMap(heatmap_normalized.astype(np.uint8), self.colormap)
-        self.im0 = cv2.addWeighted(self.im0, 1 - self.heatmap_alpha, heatmap_colored, self.heatmap_alpha, 0)
+        self.im0 = cv2.addWeighted(self.im0, 0.5, heatmap_colored, 0.5, 0)
 
         if self.env_check and self.view_img:
             self.display_frames()

ultralytics/solutions/object_counter.py

@@ -1,243 +1,129 @@
 # Ultralytics YOLO 🚀, AGPL-3.0 license
 
-from collections import defaultdict
+from shapely.geometry import LineString, Point
 
-import cv2
-
-from ultralytics.utils.checks import check_imshow, check_requirements
+from ultralytics.solutions.solutions import BaseSolution  # Import a parent class
 from ultralytics.utils.plotting import Annotator, colors
 
-check_requirements("shapely>=2.0.0")
 
-from shapely.geometry import LineString, Point, Polygon
+class ObjectCounter(BaseSolution):
+    """A class to manage the counting of objects in a real-time video stream based on their tracks."""
 
+    def __init__(self, **kwargs):
+        """Initialization function for Count class, a child class of BaseSolution class, can be used for counting the
+        objects.
+        """
+        super().__init__(**kwargs)
 
-class ObjectCounter:
-    """A class to manage the counting of objects in a real-time video stream based on their tracks."""
+        self.in_count = 0  # Counter for objects moving inward
+        self.out_count = 0  # Counter for objects moving outward
+        self.counted_ids = []  # List of IDs of objects that have been counted
+        self.classwise_counts = {}  # Dictionary for counts, categorized by object class
 
-    def __init__(
-        self,
-        names,
-        reg_pts=None,
-        line_thickness=2,
-        view_img=False,
-        view_in_counts=True,
-        view_out_counts=True,
-        draw_tracks=False,
-    ):
+        self.initialize_region()  # Setup region and counting areas
+
+        self.show_in = self.CFG["show_in"]
+        self.show_out = self.CFG["show_out"]
+
+    def count_objects(self, track_line, box, track_id, prev_position, cls):
         """
-        Initializes the ObjectCounter with various tracking and counting parameters.
+        Helper function to count objects within a polygonal region.
 
         Args:
-            names (dict): Dictionary of class names.
-            reg_pts (list): List of points defining the counting region.
-            line_thickness (int): Line thickness for bounding boxes.
-            view_img (bool): Flag to control whether to display the video stream.
-            view_in_counts (bool): Flag to control whether to display the in counts on the video stream.
-            view_out_counts (bool): Flag to control whether to display the out counts on the video stream.
-            draw_tracks (bool): Flag to control whether to draw the object tracks.
+            track_line (dict): last 30 frame track record
+            box (list): Bounding box data for specific track in current frame
+            track_id (int): track ID of the object
+            prev_position (tuple): last frame position coordinates of the track
+            cls (int): Class index for classwise count updates
         """
-        # Mouse events
-        self.is_drawing = False
-        self.selected_point = None
-
-        # Region & Line Information
-        self.reg_pts = [(20, 400), (1260, 400)] if reg_pts is None else reg_pts
-        self.counting_region = None
-
-        # Image and annotation Information
-        self.im0 = None
-        self.tf = line_thickness
-        self.view_img = view_img
-        self.view_in_counts = view_in_counts
-        self.view_out_counts = view_out_counts
-
-        self.names = names  # Classes names
-        self.window_name = "Ultralytics YOLOv8 Object Counter"
-
-        # Object counting Information
-        self.in_counts = 0
-        self.out_counts = 0
-        self.count_ids = []
-        self.class_wise_count = {}
-
-        # Tracks info
-        self.track_history = defaultdict(list)
-        self.draw_tracks = draw_tracks
-
-        # Check if environment supports imshow
-        self.env_check = check_imshow(warn=True)
-
-        # Initialize counting region
-        if len(self.reg_pts) == 2:
-            print("Line Counter Initiated.")
-            self.counting_region = LineString(self.reg_pts)
-        elif len(self.reg_pts) >= 3:
-            print("Polygon Counter Initiated.")
-            self.counting_region = Polygon(self.reg_pts)
-        else:
-            print("Invalid Region points provided, region_points must be 2 for lines or >= 3 for polygons.")
-            print("Using Line Counter Now")
-            self.counting_region = LineString(self.reg_pts)
-
-        # Define the counting line segment
-        self.counting_line_segment = LineString(
-            [
-                (self.reg_pts[0][0], self.reg_pts[0][1]),
-                (self.reg_pts[1][0], self.reg_pts[1][1]),
-            ]
-        )
-
-    def mouse_event_for_region(self, event, x, y, flags, params):
+        if prev_position is None or track_id in self.counted_ids:
+            return
+
+        centroid = self.r_s.centroid
+        dx = (box[0] - prev_position[0]) * (centroid.x - prev_position[0])
+        dy = (box[1] - prev_position[1]) * (centroid.y - prev_position[1])
+
+        if len(self.region) >= 3 and self.r_s.contains(Point(track_line[-1])):
+            self.counted_ids.append(track_id)
+            # For polygon region
+            if dx > 0:
+                self.in_count += 1
+                self.classwise_counts[self.names[cls]]["IN"] += 1
+            else:
+                self.out_count += 1
+                self.classwise_counts[self.names[cls]]["OUT"] += 1
+
+        elif len(self.region) < 3 and LineString([prev_position, box[:2]]).intersects(self.l_s):
+            self.counted_ids.append(track_id)
+            # For linear region
+            if dx > 0 and dy > 0:
+                self.in_count += 1
+                self.classwise_counts[self.names[cls]]["IN"] += 1
+            else:
+                self.out_count += 1
+                self.classwise_counts[self.names[cls]]["OUT"] += 1
+
+    def store_classwise_counts(self, cls):
         """
-        Handles mouse events for defining and moving the counting region in a real-time video stream.
+        Initialize class-wise counts if not already present.
 
         Args:
-            event (int): The type of mouse event (e.g., cv2.EVENT_MOUSEMOVE, cv2.EVENT_LBUTTONDOWN, etc.).
-            x (int): The x-coordinate of the mouse pointer.
-            y (int): The y-coordinate of the mouse pointer.
-            flags (int): Any associated event flags (e.g., cv2.EVENT_FLAG_CTRLKEY,  cv2.EVENT_FLAG_SHIFTKEY, etc.).
-            params (dict): Additional parameters for the function.
+            cls (int): Class index for classwise count updates
         """
-        if event == cv2.EVENT_LBUTTONDOWN:
-            for i, point in enumerate(self.reg_pts):
-                if (
-                    isinstance(point, (tuple, list))
-                    and len(point) >= 2
-                    and (abs(x - point[0]) < 10 and abs(y - point[1]) < 10)
-                ):
-                    self.selected_point = i
-                    self.is_drawing = True
-                    break
-
-        elif event == cv2.EVENT_MOUSEMOVE:
-            if self.is_drawing and self.selected_point is not None:
-                self.reg_pts[self.selected_point] = (x, y)
-                self.counting_region = Polygon(self.reg_pts)
-
-        elif event == cv2.EVENT_LBUTTONUP:
-            self.is_drawing = False
-            self.selected_point = None
-
-    def extract_and_process_tracks(self, tracks):
-        """Extracts and processes tracks for object counting in a video stream."""
-        # Annotator Init and region drawing
-        annotator = Annotator(self.im0, self.tf, self.names)
-
-        # Draw region or line
-        annotator.draw_region(reg_pts=self.reg_pts, color=(104, 0, 123), thickness=self.tf * 2)
-
-        # Extract tracks for OBB or object detection
-        track_data = tracks[0].obb or tracks[0].boxes
-
-        if track_data and track_data.id is not None:
-            boxes = track_data.xyxy.cpu()
-            clss = track_data.cls.cpu().tolist()
-            track_ids = track_data.id.int().cpu().tolist()
-
-            # Extract tracks
-            for box, track_id, cls in zip(boxes, track_ids, clss):
-                # Draw bounding box
-                annotator.box_label(box, label=self.names[cls], color=colors(int(track_id), True))
-
-                # Store class info
-                if self.names[cls] not in self.class_wise_count:
-                    self.class_wise_count[self.names[cls]] = {"IN": 0, "OUT": 0}
-
-                # Draw Tracks
-                track_line = self.track_history[track_id]
-                track_line.append((float((box[0] + box[2]) / 2), float((box[1] + box[3]) / 2)))
-                if len(track_line) > 30:
-                    track_line.pop(0)
-
-                # Draw track trails
-                if self.draw_tracks:
-                    annotator.draw_centroid_and_tracks(
-                        track_line,
-                        color=colors(int(track_id), True),
-                        track_thickness=self.tf,
-                    )
+        if self.names[cls] not in self.classwise_counts:
+            self.classwise_counts[self.names[cls]] = {"IN": 0, "OUT": 0}
 
-                prev_position = self.track_history[track_id][-2] if len(self.track_history[track_id]) > 1 else None
+    def display_counts(self, im0):
+        """
+        Helper function to display object counts on the frame.
 
-                # Count objects in any polygon
-                if len(self.reg_pts) >= 3:
-                    is_inside = self.counting_region.contains(Point(track_line[-1]))
-
-                    if prev_position is not None and is_inside and track_id not in self.count_ids:
-                        self.count_ids.append(track_id)
-
-                        if (box[0] - prev_position[0]) * (self.counting_region.centroid.x - prev_position[0]) > 0:
-                            self.in_counts += 1
-                            self.class_wise_count[self.names[cls]]["IN"] += 1
-                        else:
-                            self.out_counts += 1
-                            self.class_wise_count[self.names[cls]]["OUT"] += 1
-
-                # Count objects using line
-                elif len(self.reg_pts) == 2:
-                    if (
-                        prev_position is not None
-                        and track_id not in self.count_ids
-                        and LineString([(prev_position[0], prev_position[1]), (box[0], box[1])]).intersects(
-                            self.counting_line_segment
-                        )
-                    ):
-                        self.count_ids.append(track_id)
-
-                        # Determine the direction of movement (IN or OUT)
-                        dx = (box[0] - prev_position[0]) * (self.counting_region.centroid.x - prev_position[0])
-                        dy = (box[1] - prev_position[1]) * (self.counting_region.centroid.y - prev_position[1])
-                        if dx > 0 and dy > 0:
-                            self.in_counts += 1
-                            self.class_wise_count[self.names[cls]]["IN"] += 1
-                        else:
-                            self.out_counts += 1
-                            self.class_wise_count[self.names[cls]]["OUT"] += 1
-
-        labels_dict = {}
-
-        for key, value in self.class_wise_count.items():
-            if value["IN"] != 0 or value["OUT"] != 0:
-                if not self.view_in_counts and not self.view_out_counts:
-                    continue
-                elif not self.view_in_counts:
-                    labels_dict[str.capitalize(key)] = f"OUT {value['OUT']}"
-                elif not self.view_out_counts:
-                    labels_dict[str.capitalize(key)] = f"IN {value['IN']}"
-                else:
-                    labels_dict[str.capitalize(key)] = f"IN {value['IN']} OUT {value['OUT']}"
+        Args:
+            im0 (ndarray): The input image or frame
+        """
+        labels_dict = {
+            str.capitalize(key): f"{'IN ' + str(value['IN']) if self.show_in else ''} "
+            f"{'OUT ' + str(value['OUT']) if self.show_out else ''}".strip()
+            for key, value in self.classwise_counts.items()
+            if value["IN"] != 0 or value["OUT"] != 0
+        }
 
         if labels_dict:
-            annotator.display_analytics(self.im0, labels_dict, (104, 31, 17), (255, 255, 255), 10)
-
-    def display_frames(self):
-        """Displays the current frame with annotations and regions in a window."""
-        if self.env_check:
-            cv2.namedWindow(self.window_name)
-            if len(self.reg_pts) == 4:  # only add mouse event If user drawn region
-                cv2.setMouseCallback(self.window_name, self.mouse_event_for_region, {"region_points": self.reg_pts})
-            cv2.imshow(self.window_name, self.im0)
-            # Break Window
-            if cv2.waitKey(1) & 0xFF == ord("q"):
-                return
-
-    def start_counting(self, im0, tracks):
+            self.annotator.display_analytics(im0, labels_dict, (104, 31, 17), (255, 255, 255), 10)
+
+    def count(self, im0):
         """
-        Main function to start the object counting process.
+        Processes input data (frames or object tracks) and updates counts.
 
         Args:
-            im0 (ndarray): Current frame from the video stream.
-            tracks (list): List of tracks obtained from the object tracking process.
+            im0 (ndarray): The input image that will be used for processing
+        Returns
+            im0 (ndarray): The processed image for more usage
         """
-        self.im0 = im0  # store image
-        self.extract_and_process_tracks(tracks)  # draw region even if no objects
-
-        if self.view_img:
-            self.display_frames()
-        return self.im0
+        self.annotator = Annotator(im0, line_width=self.line_width)  # Initialize annotator
+        self.extract_tracks(im0)  # Extract tracks
+
+        self.annotator.draw_region(
+            reg_pts=self.region, color=(104, 0, 123), thickness=self.line_width * 2
+        )  # Draw region
+
+        # Iterate over bounding boxes, track ids and classes index
+        if self.track_data is not None and self.track_data.id is not None:
+            for box, track_id, cls in zip(self.boxes, self.track_ids, self.clss):
+                # Draw bounding box and counting region
+                self.annotator.box_label(box, label=self.names[cls], color=colors(track_id, True))
+                self.store_tracking_history(track_id, box)  # Store track history
+                self.store_classwise_counts(cls)  # store classwise counts in dict
+
+                # Draw centroid of objects
+                self.annotator.draw_centroid_and_tracks(
+                    self.track_line, color=colors(int(track_id), True), track_thickness=self.line_width
+                )
+
+                # store previous position of track for object counting
+                prev_position = self.track_history[track_id][-2] if len(self.track_history[track_id]) > 1 else None
+                self.count_objects(self.track_line, box, track_id, prev_position, cls)  # Perform object counting
 
+        self.display_counts(im0)  # Display the counts on the frame
+        self.display_output(im0)  # display output with base class function
 
-if __name__ == "__main__":
-    classes_names = {0: "person", 1: "car"}  # example class names
-    ObjectCounter(classes_names)
+        return im0  # return output image for more usage

ultralytics/solutions/solutions.py

@@ -0,0 +1,88 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+
+from collections import defaultdict
+from pathlib import Path
+
+import cv2
+from shapely.geometry import LineString, Polygon
+
+from ultralytics import YOLO
+from ultralytics.utils import yaml_load
+from ultralytics.utils.checks import check_imshow
+
+DEFAULT_SOL_CFG_PATH = Path(__file__).resolve().parents[1] / "cfg/solutions/default.yaml"
+
+
+class BaseSolution:
+    """A class to manage all the Ultralytics Solutions: https://docs.ultralytics.com/solutions/."""
+
+    def __init__(self, **kwargs):
+        """
+        Base initializer for all solutions.
+
+        Child classes should call this with necessary parameters.
+        """
+        # Load config and update with args
+        self.CFG = yaml_load(DEFAULT_SOL_CFG_PATH)
+        self.CFG.update(kwargs)
+        print("Ultralytics Solutions: ✅", self.CFG)
+
+        self.region = self.CFG["region"]  # Store region data for other classes usage
+        self.line_width = self.CFG["line_width"]  # Store line_width for usage
+
+        # Load Model and store classes names
+        self.model = YOLO(self.CFG["model"])
+        self.names = self.model.names
+
+        # Initialize environment and region setup
+        self.env_check = check_imshow(warn=True)
+        self.track_history = defaultdict(list)
+
+    def extract_tracks(self, im0):
+        """
+        Apply object tracking and extract tracks.
+
+        Args:
+            im0 (ndarray): The input image or frame
+        """
+        self.tracks = self.model.track(source=im0, persist=True, classes=self.CFG["classes"])
+
+        # Extract tracks for OBB or object detection
+        self.track_data = self.tracks[0].obb or self.tracks[0].boxes
+
+        if self.track_data and self.track_data.id is not None:
+            self.boxes = self.track_data.xyxy.cpu()
+            self.clss = self.track_data.cls.cpu().tolist()
+            self.track_ids = self.track_data.id.int().cpu().tolist()
+
+    def store_tracking_history(self, track_id, box):
+        """
+        Store object tracking history.
+
+        Args:
+            track_id (int): The track ID of the object
+            box (list): Bounding box coordinates of the object
+        """
+        # Store tracking history
+        self.track_line = self.track_history[track_id]
+        self.track_line.append(((box[0] + box[2]) / 2, (box[1] + box[3]) / 2))
+        if len(self.track_line) > 30:
+            self.track_line.pop(0)
+
+    def initialize_region(self):
+        """Initialize the counting region and line segment based on config."""
+        self.region = [(20, 400), (1260, 400)] if self.region is None else self.region
+        self.r_s = Polygon(self.region) if len(self.region) >= 3 else LineString(self.region)
+        self.l_s = LineString([(self.region[0][0], self.region[0][1]), (self.region[1][0], self.region[1][1])])
+
+    def display_output(self, im0):
+        """
+        Display the results of the processing, which could involve showing frames, printing counts, or saving results.
+
+        Args:
+            im0 (ndarray): The input image or frame
+        """
+        if self.CFG.get("show") and self.env_check:
+            cv2.imshow("Ultralytics Solutions", im0)
+            if cv2.waitKey(1) & 0xFF == ord("q"):
+                return

ultralytics/utils/__init__.py

@@ -61,8 +61,8 @@ HELP_MSG = """
         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)
+        model = YOLO("yolo11n.yaml")  # build a new model from scratch
+        model = YOLO("yolo11n.pt")  # load a pretrained model (recommended for training)
 
         # Use the model
         results = model.train(data="coco8.yaml", epochs=3)  # train the model
@@ -77,21 +77,21 @@ HELP_MSG = """
             yolo TASK MODE ARGS
 
             Where   TASK (optional) is one of [detect, segment, classify, pose, obb]
-                    MODE (required) is one of [train, val, predict, export, benchmark]
+                    MODE (required) is one of [train, val, predict, export, track, benchmark]
                     ARGS (optional) are any number of custom "arg=value" pairs like "imgsz=320" that override defaults.
                         See all ARGS at https://docs.ultralytics.com/usage/cfg or with "yolo cfg"
 
         - Train a detection model for 10 epochs with an initial learning_rate of 0.01
-            yolo detect train data=coco8.yaml model=yolov8n.pt epochs=10 lr0=0.01
+            yolo detect train data=coco8.yaml model=yolo11n.pt epochs=10 lr0=0.01
 
         - Predict a YouTube video using a pretrained segmentation model at image size 320:
-            yolo segment predict model=yolov8n-seg.pt source='https://youtu.be/LNwODJXcvt4' imgsz=320
+            yolo segment predict model=yolo11n-seg.pt source='https://youtu.be/LNwODJXcvt4' imgsz=320
 
         - Val a pretrained detection model at batch-size 1 and image size 640:
-            yolo detect val model=yolov8n.pt data=coco8.yaml batch=1 imgsz=640
+            yolo detect val model=yolo11n.pt data=coco8.yaml batch=1 imgsz=640
 
-        - Export a YOLOv8n classification model to ONNX format at image size 224 by 128 (no TASK required)
-            yolo export model=yolov8n-cls.pt format=onnx imgsz=224,128
+        - Export a YOLO11n classification model to ONNX format at image size 224 by 128 (no TASK required)
+            yolo export model=yolo11n-cls.pt format=onnx imgsz=224,128
 
         - Run special commands:
             yolo help
@@ -1030,6 +1030,7 @@ def set_sentry():
         sentry_sdk.init(
             dsn="https://888e5a0778212e1d0314c37d4b9aae5d@o4504521589325824.ingest.us.sentry.io/4504521592406016",
             debug=False,
+            auto_enabling_integrations=False,
             traces_sample_rate=1.0,
             release=__version__,
             environment="production",  # 'dev' or 'production'

ultralytics/utils/torch_utils.py

@@ -170,6 +170,8 @@ def select_device(device="", batch=0, newline=False, verbose=True):
     elif device:  # non-cpu device requested
         if device == "cuda":
             device = "0"
+        if "," in device:
+            device = ",".join([x for x in device.split(",") if x])  # remove sequential commas, i.e. "0,,1" -> "0,1"
         visible = os.environ.get("CUDA_VISIBLE_DEVICES", None)
         os.environ["CUDA_VISIBLE_DEVICES"] = device  # set environment variable - must be before assert is_available()
         if not (torch.cuda.is_available() and torch.cuda.device_count() >= len(device.split(","))):
@@ -191,7 +193,7 @@ def select_device(device="", batch=0, newline=False, verbose=True):
             )
 
     if not cpu and not mps and torch.cuda.is_available():  # prefer GPU if available
-        devices = device.split(",") if device else "0"  # range(torch.cuda.device_count())  # i.e. 0,1,6,7
+        devices = device.split(",") if device else "0"  # i.e. "0,1" -> ["0", "1"]
         n = len(devices)  # device count
         if n > 1:  # multi-GPU
             if batch < 1:

{ultralytics-8.3.3.dist-info → ultralytics-8.3.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ultralytics
-Version: 8.3.3
+Version: 8.3.5
 Summary: Ultralytics YOLO for SOTA object detection, multi-object tracking, instance segmentation, pose estimation and image classification.
 Author: Ayush Chaurasia
 Author-email: Glenn Jocher <glenn.jocher@ultralytics.com>, Jing Qiu <jing.qiu@ultralytics.com>
@@ -33,7 +33,7 @@ Classifier: Operating System :: Microsoft :: Windows
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: numpy<2.0.0,>=1.23.0
+Requires-Dist: numpy>=1.23.0
 Requires-Dist: matplotlib>=3.3.0
 Requires-Dist: opencv-python>=4.6.0
 Requires-Dist: pillow>=7.1.2
@@ -76,6 +76,7 @@ Requires-Dist: numpy==1.23.5; platform_machine == "aarch64" and extra == "export
 Requires-Dist: h5py!=3.11.0; platform_machine == "aarch64" and extra == "export"
 Requires-Dist: tensorstore>=0.1.63; (platform_machine == "aarch64" and python_version >= "3.9") and extra == "export"
 Requires-Dist: coremltools>=7.0; (platform_system != "Windows" and python_version <= "3.11") and extra == "export"
+Requires-Dist: scikit-learn>=1.3.2; (platform_system != "Windows" and python_version <= "3.11") and extra == "export"
 Provides-Extra: extra
 Requires-Dist: hub-sdk>=0.0.12; extra == "extra"
 Requires-Dist: ipython; extra == "extra"

{ultralytics-8.3.3.dist-info → ultralytics-8.3.5.dist-info}/RECORD

@@ -7,12 +7,12 @@ 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=eAaLf1wM7IJ6DjT7NEw6sRaeDuTX0ZgsTjrI33XFCXE,3300
-ultralytics/__init__.py,sha256=EBK5aoP9DP2M_QXggxoUlGqceIsrS3Pv0LXlAQforQU,693
+tests/test_solutions.py,sha256=Hjedlp6Qkqb4zyQ0y3DvfNValcguOMl8xbrDVpIFPfU,3304
+ultralytics/__init__.py,sha256=cPwEVFFgAAExxMMRGjRidE4mFdGDLx7Pr-tKFsQX5E4,693
 ultralytics/assets/bus.jpg,sha256=wCAZxJecGR63Od3ZRERe9Aja1Weayrb9Ug751DS_vGM,137419
 ultralytics/assets/zidane.jpg,sha256=Ftc4aeMmen1O0A3o6GCDO9FlfBslLpTAw0gnetx7bts,50427
 ultralytics/cfg/__init__.py,sha256=62PSSAa0W4-gAEcRNKoKbcxUWBeFNs0ss2O4XJQhOPY,33145
-ultralytics/cfg/default.yaml,sha256=tkBn3c6duKGFyENuULkWessAqaaxo9atuOxXq3XbItM,8314
+ultralytics/cfg/default.yaml,sha256=ul49zgSzTegMmc8CFeu9tXkWNvQhETdZMa9EgDNSnY4,8319
 ultralytics/cfg/datasets/Argoverse.yaml,sha256=FyeuJT5CHq_9d4hlfAf0kpZlnbUMO0S--UJ1yIqcdKk,3134
 ultralytics/cfg/datasets/DOTAv1.5.yaml,sha256=QVfp_Qp-4rukuicaB4qx86NxSHM8Mrzym8l_fIDo8gw,1195
 ultralytics/cfg/datasets/DOTAv1.yaml,sha256=sxe2P7nY-cCPufH3G1pymnQVtNoGH1y0ETG5CyWfK9g,1165
@@ -86,31 +86,32 @@ 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=Z3hzSeoEhsVuGGc2WMVRAYukuXFGqKjAIefL6JS8P8k,599
 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
 ultralytics/data/annotator.py,sha256=PniOxH2MScWKp539vuufk69uG1JsltDB5OMCUhxn2QY,2489
 ultralytics/data/augment.py,sha256=YCLrwx1mRGeidggo_7GeINay8KdxACqREHJofZeaTHA,120430
-ultralytics/data/base.py,sha256=zi_1nnJb29gBqY3jrvbMCwh6RPpXhr08DQ2BQ2_dhTo,13835
+ultralytics/data/base.py,sha256=ZCIhAyFfxXVp5fVnYD8mwbksNALJTayBKIR5FKGV7ZM,15168
 ultralytics/data/build.py,sha256=AfMmz0sHIYmwry_90tEJFRk_kz0S3SolScVXqYHiT08,7261
 ultralytics/data/converter.py,sha256=DjJ0atku2aKW0iS1PZPNX8V6WTrZ-CHZT6hopE1HSjI,21385
 ultralytics/data/dataset.py,sha256=IS07ulk7rXPZ-SW_rjYF9mS-TxPXOY9bbo5jqfcwPqM,22874
 ultralytics/data/loaders.py,sha256=JF2Z_ESK6RweavOuYWejYSGJwmqINb5hNwwCb3AAf0M,24094
 ultralytics/data/split_dota.py,sha256=yOtypHoY5HvIVBKZgFXdfj2tuCLLEBnMwNfAeG94Eik,10680
-ultralytics/data/utils.py,sha256=GVTtZlFE8Q9RlNJ19Er_CdxenjeDbvQerU1jKOs76S4,31042
+ultralytics/data/utils.py,sha256=FQhceOiQOuhyDKCeX-ovEBBr2fO7cFbcVaAUp-nk3CM,31072
 ultralytics/data/explorer/__init__.py,sha256=-Y3m1ZedepOQUv_KW82zaGxvU_PSHcuwUTFqG9BhAr4,113
 ultralytics/data/explorer/explorer.py,sha256=JWmLHHhp68h2q3vx4poBou5RYoAX3R89yihR50YLDb0,18881
 ultralytics/data/explorer/utils.py,sha256=EvvukQiQUTBrsZznmMnyEX2EqTuwZo_Geyc8yfi8NIA,7085
 ultralytics/data/explorer/gui/__init__.py,sha256=mHtJuK4hwF8cuV-VHDc7tp6u6D1gHz2Z7JI8grmQDTs,42
 ultralytics/data/explorer/gui/dash.py,sha256=vZ476NaUH4FKU08rAJ1K9WNyKtg0soMyJJxqg176yWc,10498
 ultralytics/engine/__init__.py,sha256=mHtJuK4hwF8cuV-VHDc7tp6u6D1gHz2Z7JI8grmQDTs,42
-ultralytics/engine/exporter.py,sha256=BFYvv763kbEm5q0-AYIh979vL0ccU4RNvON2w8qtm1s,57019
+ultralytics/engine/exporter.py,sha256=qhuPMBjBDVj9Qaa2qJYR954a-YS4BJtVN9jJeyFzyOg,57527
 ultralytics/engine/model.py,sha256=TDuy9JzzyvOaq5aKVljL_MFRKBDMCFwaLo3JD_d45CU,51462
 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=lBMKJDpu8owE0eeNkAsYszbAROk-WOB3vlhoGB1Vicc,36971
+ultralytics/engine/trainer.py,sha256=O2xCZ6mriLfPhU2IRe8XCCyZiI5A_AknjpQw3O5bAIE,36983
 ultralytics/engine/tuner.py,sha256=gPqDTHH7vRB2O3YyH26m1BjVKbXxuA2XAlPRzTKFZsc,11838
-ultralytics/engine/validator.py,sha256=483Ad87Irk7IBlJNLu2SQAJsb7YriALTX9GIgriCmRg,14650
+ultralytics/engine/validator.py,sha256=2C_qXI36Z9rLOpmS0YR8Qe3ka4p23YiH2w5ai7-XBwE,14811
 ultralytics/hub/__init__.py,sha256=3SKvZ5aRina3h94xMPQIB3D4maF62qFcyIqPPHRHNAc,5644
 ultralytics/hub/auth.py,sha256=kDLakGa2NbzvMAeXc2UdzZ65r0AH-XeM_JfsDY97WGk,5545
 ultralytics/hub/session.py,sha256=2KznO5kX14HFZ2-Ct9LoG312sdHuigQSLZb58MGvbJY,16411
@@ -135,7 +136,7 @@ ultralytics/models/sam/__init__.py,sha256=o4_D6y8YJlOXIK7Lwo9RHnIJJ9xoFNi4zK99QS
 ultralytics/models/sam/amg.py,sha256=GrmO_8YfIDt_QkPEMF_WFjPZkhwhf7iwx7ig8JgOUnE,8709
 ultralytics/models/sam/build.py,sha256=np9vP7AETCZA2Wdds-uj2eQKVnpHQaVpRrE2-U2uMTI,12153
 ultralytics/models/sam/model.py,sha256=2KFUp8SHiqOgwUjkdqdau0oduJwKQxm4N9GHWjdhUFo,7382
-ultralytics/models/sam/predict.py,sha256=unsoNrEx6pexKD28-HTpALa02PtNtE4e2ERdzs9qbYw,38556
+ultralytics/models/sam/predict.py,sha256=_spP0uYNFzUnybwBvzZhF3iEMwvAi6bxryRdUwxwweM,38608
 ultralytics/models/sam/modules/__init__.py,sha256=mHtJuK4hwF8cuV-VHDc7tp6u6D1gHz2Z7JI8grmQDTs,42
 ultralytics/models/sam/modules/blocks.py,sha256=Q-KwhFbdyZhl1tjG_kP2LcQkZbzoNt618i-NRrKNx2Y,45919
 ultralytics/models/sam/modules/decoders.py,sha256=mODsqnTN_CjE3H0Sh9cd8PfTnHANPjGB1bjqHxfezSg,25830
@@ -187,10 +188,11 @@ ultralytics/solutions/__init__.py,sha256=6RDeXWO1QSaMgCq8YrWXaj2xvPw2sJwJL_a0dgj
 ultralytics/solutions/ai_gym.py,sha256=MgD_4DciCqXquM2Y6yjIIRkGWIg3rNfSuXrFqYzOCaI,4719
 ultralytics/solutions/analytics.py,sha256=bGuZes11D7DNiTsHdwu6PJ0QA0vCiqMMAtZ7NyEkshY,11568
 ultralytics/solutions/distance_calculation.py,sha256=o_DAHk4JX8n2Vt7E68MX67mREOBZuy5skbXtVZ6iu_4,5228
-ultralytics/solutions/heatmap.py,sha256=oEVivA4KAK6z0wA5Ca_a2qTckQN8tCt9MCpsPREeNnk,10375
-ultralytics/solutions/object_counter.py,sha256=U66uvv_6QSol4-LY1E9JOZnYRYbek5Kz3N7Cgzh6FuA,9982
+ultralytics/solutions/heatmap.py,sha256=mSssM7bZa_MTx5404tQPL0TMZRguowQa4DSAbcpivRM,10090
+ultralytics/solutions/object_counter.py,sha256=lBSWW0Ev6FOeV1MQNESBpub9Wzyulb9s1VBGbRRd8Sk,5485
 ultralytics/solutions/parking_management.py,sha256=VgYyhoSEo7fnPegIhNUqnFL0jlMEevALx0QQbzJ3vGI,9049
 ultralytics/solutions/queue_management.py,sha256=yKPGc2-fN-lMpNddkxjN7xYGIJwMdoU-VIDRxQ1KPow,4869
+ultralytics/solutions/solutions.py,sha256=bIt32FLj4ny5kG43bUKZiwyh-7qye6NOApxAvioklIA,3248
 ultralytics/solutions/speed_estimation.py,sha256=c9OPGpDU9x6Dj4SobNc-sO90EZTPTGeKkW5u6C6Zj7g,4623
 ultralytics/solutions/streamlit_inference.py,sha256=qA2EtwUC7ADOQ8P-zs3VPyrIoRArhcZz9CxkFbH63bw,5699
 ultralytics/trackers/__init__.py,sha256=j72IgH2dZHQArMPK4YwcV5ieIw94fYvlGdQjB9cOQKw,227
@@ -202,7 +204,7 @@ ultralytics/trackers/utils/__init__.py,sha256=mHtJuK4hwF8cuV-VHDc7tp6u6D1gHz2Z7J
 ultralytics/trackers/utils/gmc.py,sha256=VcURuY041qGCeWUGMxHZBr10T16LtcMqyv7AmTfE1MY,14557
 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=R2VpuwIfwpTSTX2T_MFdW1tNdX27FZW5XAH984tjR1Q,48834
+ultralytics/utils/__init__.py,sha256=pdYHDaJMacya7WWq5RNEw-UmidG3i0kQyWrbFNnAVtc,48887
 ultralytics/utils/autobatch.py,sha256=AXboYfNSnTGsYj5FmgGYPQd0crfkeleyms6QXQfZGQ4,4194
 ultralytics/utils/benchmarks.py,sha256=8FYp5WPzcxcDaeg8ol2sgzRBHVGYatEO7f3MrmPF6nI,25097
 ultralytics/utils/checks.py,sha256=tiwVY1SCf7AlDOUQDh6fJlmhQ3CxQEqLUrXRvwRBoKs,28998
@@ -217,7 +219,7 @@ ultralytics/utils/ops.py,sha256=dsXNdyrYx_p6io6zezig9p84dxS7U-10vceHNVu2IL0,3288
 ultralytics/utils/patches.py,sha256=J-iOwIRbfUs-inBZerhnXby5tUKjYcOIyvhLTS352JE,3270
 ultralytics/utils/plotting.py,sha256=Sqs9Q7mhenCsFed_oyw_64wgvd0TTae9L3Lc4g2_lSI,62296
 ultralytics/utils/tal.py,sha256=ECsu95xEqOItmxMDN4YTD3FsUiIsQNWy0pZC3TfvFfk,16877
-ultralytics/utils/torch_utils.py,sha256=tqOyNnUZbLBOIueSWwljZua65cz6_RvClxYv8gNHIw0,29673
+ultralytics/utils/torch_utils.py,sha256=RsTzm3__J4K1OUaxqc32O9WT6azcl4hPNkDdxhEp3q4,29792
 ultralytics/utils/triton.py,sha256=gg1finxno_tY2Ge9PMhmu7PI9wvoFZoiicdT4Bhqv3w,3936
 ultralytics/utils/tuner.py,sha256=AtEtK6pOt9xVTyx864OpNRVxNdAxz5aKHzveiXwkD1A,6250
 ultralytics/utils/callbacks/__init__.py,sha256=YrWqC3BVVaTLob4iCPR6I36mUxIUOpPJW7B_LjT78Qw,214
@@ -231,9 +233,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.3.3.dist-info/LICENSE,sha256=DZak_2itbUtvHzD3E7GNUYSRK6jdOJ-GqncQ2weavLA,34523
-ultralytics-8.3.3.dist-info/METADATA,sha256=K4q0V89-JTwWjGWue29_CsVQH9AhLpZVmt3b61x-iMc,34574
-ultralytics-8.3.3.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
-ultralytics-8.3.3.dist-info/entry_points.txt,sha256=YM_wiKyTe9yRrsEfqvYolNO5ngwfoL4-NwgKzc8_7sI,93
-ultralytics-8.3.3.dist-info/top_level.txt,sha256=XP49TwiMw4QGsvTLSYiJhz1xF_k7ev5mQ8jJXaXi45Q,12
-ultralytics-8.3.3.dist-info/RECORD,,
+ultralytics-8.3.5.dist-info/LICENSE,sha256=DZak_2itbUtvHzD3E7GNUYSRK6jdOJ-GqncQ2weavLA,34523
+ultralytics-8.3.5.dist-info/METADATA,sha256=vRIip27lGy6ai-vDDQrkLt_2hjxmd6TbIeur2uCcNdI,34685
+ultralytics-8.3.5.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+ultralytics-8.3.5.dist-info/entry_points.txt,sha256=YM_wiKyTe9yRrsEfqvYolNO5ngwfoL4-NwgKzc8_7sI,93
+ultralytics-8.3.5.dist-info/top_level.txt,sha256=XP49TwiMw4QGsvTLSYiJhz1xF_k7ev5mQ8jJXaXi45Q,12
+ultralytics-8.3.5.dist-info/RECORD,,