ultralytics 8.3.114__py3-none-any.whl → 8.3.116__py3-none-any.whl

ultralytics/__init__.py

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

ultralytics/data/augment.py

@@ -1027,10 +1027,9 @@ class RandomPerspective:
             border (Tuple[int, int]): Border dimensions for the transformed image.
 
         Returns:
-            (Tuple[np.ndarray, np.ndarray, float]): A tuple containing:
-                - np.ndarray: Transformed image.
-                - np.ndarray: 3x3 transformation matrix.
-                - float: Scale factor applied during the transformation.
+            img (np.ndarray): Transformed image.
+            M (np.ndarray): 3x3 transformation matrix.
+            s (float): Scale factor applied during the transformation.
 
         Examples:
             >>> import numpy as np
@@ -1124,9 +1123,8 @@ class RandomPerspective:
             M (np.ndarray): Affine transformation matrix with shape (3, 3).
 
         Returns:
-            (Tuple[np.ndarray, np.ndarray]): A tuple containing:
-                - New bounding boxes with shape (N, 4) in xyxy format.
-                - Transformed and clipped segments with shape (N, M, 2).
+            bboxes (np.ndarray): New bounding boxes with shape (N, 4) in xyxy format.
+            segments (np.ndarray): Transformed and clipped segments with shape (N, M, 2).
 
         Examples:
             >>> segments = np.random.rand(10, 500, 2)  # 10 segments with 500 points each

ultralytics/data/base.py

@@ -208,9 +208,9 @@ class BaseDataset(Dataset):
             rect_mode (bool, optional): Whether to use rectangular resizing.
 
         Returns:
-            (np.ndarray): Loaded image.
-            (tuple): Original image dimensions (h, w).
-            (tuple): Resized image dimensions (h, w).
+            (np.ndarray): Loaded image as a NumPy array.
+            (Tuple[int, int]): Original image dimensions in (height, width) format.
+            (Tuple[int, int]): Resized image dimensions in (height, width) format.
 
         Raises:
             FileNotFoundError: If the image file is not found.

ultralytics/data/build.py

@@ -187,13 +187,12 @@ def check_source(source):
         source (str | int | Path | List | Tuple | np.ndarray | PIL.Image | torch.Tensor): The input source to check.
 
     Returns:
-        (tuple): A tuple containing:
-            - source: The processed source.
-            - webcam (bool): Whether the source is a webcam.
-            - screenshot (bool): Whether the source is a screenshot.
-            - from_img (bool): Whether the source is an image or list of images.
-            - in_memory (bool): Whether the source is an in-memory object.
-            - tensor (bool): Whether the source is a torch.Tensor.
+        source (str | int | Path | List | Tuple | np.ndarray | PIL.Image | torch.Tensor): The processed source.
+        webcam (bool): Whether the source is a webcam.
+        screenshot (bool): Whether the source is a screenshot.
+        from_img (bool): Whether the source is an image or list of images.
+        in_memory (bool): Whether the source is an in-memory object.
+        tensor (bool): Whether the source is a torch.Tensor.
 
     Raises:
         TypeError: If the source type is unsupported.

ultralytics/data/dataset.py

@@ -386,7 +386,7 @@ class YOLOMultiModalDataset(YOLODataset):
         Return category names for the dataset.
 
         Returns:
-            (Tuple[str]): List of class names.
+            (Set[str]): List of class names.
         """
         names = self.data["names"].values()
         return {n.strip() for name in names for n in name.split("/")}  # category names

ultralytics/data/utils.py

@@ -47,7 +47,7 @@ def img2label_paths(img_paths):
     return [sb.join(x.rsplit(sa, 1)).rsplit(".", 1)[0] + ".txt" for x in img_paths]
 
 
-def check_file_speeds(files, threshold_ms=10, max_files=5, prefix=""):
+def check_file_speeds(files, threshold_ms=10, threshold_mb=50, max_files=5, prefix=""):
     """
     Check dataset file access speed and provide performance feedback.
 
@@ -57,6 +57,7 @@ def check_file_speeds(files, threshold_ms=10, max_files=5, prefix=""):
     Args:
         files (list): List of file paths to check for access speed.
         threshold_ms (float, optional): Threshold in milliseconds for ping time warnings.
+        threshold_mb (float, optional): Threshold in megabytes per second for read speed warnings.
         max_files (int, optional): The maximum number of files to check.
         prefix (str, optional): Prefix string to add to log messages.
 
@@ -112,7 +113,7 @@ def check_file_speeds(files, threshold_ms=10, max_files=5, prefix=""):
     else:
         speed_msg = ""
 
-    if avg_ping < threshold_ms:
+    if avg_ping < threshold_ms or avg_speed < threshold_mb:
         LOGGER.info(f"{prefix}Fast image access ✅ ({ping_msg}{speed_msg}{size_msg})")
     else:
         LOGGER.warning(
@@ -482,6 +483,7 @@ def check_cls_dataset(dataset, split=""):
 
     Returns:
         (dict): A dictionary containing the following keys:
+
             - 'train' (Path): The directory path containing the training set of the dataset.
             - 'val' (Path): The directory path containing the validation set of the dataset.
             - 'test' (Path): The directory path containing the test set of the dataset.

ultralytics/engine/exporter.py

@@ -105,7 +105,7 @@ from ultralytics.utils.checks import (
 from ultralytics.utils.downloads import attempt_download_asset, get_github_assets, safe_download
 from ultralytics.utils.export import export_engine, export_onnx
 from ultralytics.utils.files import file_size, spaces_in_path
-from ultralytics.utils.ops import Profile, nms_rotated, xywh2xyxy
+from ultralytics.utils.ops import Profile, nms_rotated
 from ultralytics.utils.torch_utils import TORCH_1_13, get_latest_opset, select_device
 
 
@@ -113,7 +113,7 @@ def export_formats():
     """Return a dictionary of Ultralytics YOLO export formats."""
     x = [
         ["PyTorch", "-", ".pt", True, True, []],
-        ["TorchScript", "torchscript", ".torchscript", True, True, ["batch", "optimize", "nms"]],
+        ["TorchScript", "torchscript", ".torchscript", True, True, ["batch", "optimize", "half", "nms"]],
         ["ONNX", "onnx", ".onnx", True, True, ["batch", "dynamic", "half", "opset", "simplify", "nms"]],
         [
             "OpenVINO",
@@ -384,6 +384,7 @@ class Exporter:
                 m.export = True
                 m.format = self.args.format
                 m.max_det = self.args.max_det
+                m.xyxy = self.args.nms
             elif isinstance(m, C2f) and not is_tf_format:
                 # EdgeTPU does not support FlexSplitV while split provides cleaner ONNX graph
                 m.forward = m.forward_split
@@ -1532,11 +1533,6 @@ class NMSModel(torch.nn.Module):
                 # Explicit length otherwise reshape error, hardcoded to `self.args.max_det * 5`
                 mask = score.topk(min(self.args.max_det * 5, score.shape[0])).indices
             box, score, cls, extra = box[mask], score[mask], cls[mask], extra[mask]
-            if not self.obb:
-                box = xywh2xyxy(box)
-                if self.is_tf:
-                    # TFlite bug returns less boxes
-                    box = torch.nn.functional.pad(box, (0, 0, 0, mask.shape[0] - box.shape[0]))
             nmsbox = box.clone()
             # `8` is the minimum value experimented to get correct NMS results for obb
             multiplier = 8 if self.obb else 1

ultralytics/engine/results.py

@@ -299,8 +299,8 @@ class Results(SimpleClass):
         Return the number of detections in the Results object.
 
         Returns:
-            (int): The number of detections, determined by the length of the first non-empty attribute
-                (boxes, masks, probs, keypoints, or obb).
+            (int): The number of detections, determined by the length of the first non-empty
+                attribute in (masks, probs, keypoints, or obb).
 
         Examples:
             >>> results = Results(orig_img, path, names, boxes=torch.rand(5, 4))
@@ -779,9 +779,9 @@ class Results(SimpleClass):
             decimals (int): Number of decimal places to round the output values to.
 
         Returns:
-            (List[Dict]): A list of dictionaries, each containing summarized information for a single
-                detection or classification result. The structure of each dictionary varies based on the
-                task type (classification or detection) and available information (boxes, masks, keypoints).
+            (List[Dict]): A list of dictionaries, each containing summarized information for a single detection
+                or classification result. The structure of each dictionary varies based on the task type
+                (classification or detection) and available information (boxes, masks, keypoints).
 
         Examples:
             >>> results = model("image.jpg")

ultralytics/models/sam/modules/utils.py

@@ -16,9 +16,8 @@ def select_closest_cond_frames(frame_idx, cond_frame_outputs, max_cond_frame_num
         max_cond_frame_num (int): Maximum number of conditioning frames to select.
 
     Returns:
-        (Tuple[Dict[int, Any], Dict[int, Any]]): A tuple containing two dictionaries:
-            - selected_outputs: Selected items from cond_frame_outputs.
-            - unselected_outputs: Items not selected from cond_frame_outputs.
+        selected_outputs (Dict[int, Any]): Selected items from cond_frame_outputs.
+        unselected_outputs (Dict[int, Any]): Items not selected from cond_frame_outputs.
 
     Examples:
         >>> frame_idx = 5
@@ -235,9 +234,8 @@ def window_partition(x, window_size):
         window_size (int): Size of each window.
 
     Returns:
-        (Tuple[torch.Tensor, Tuple[int, int]]): A tuple containing:
-            - windows (torch.Tensor): Partitioned windows with shape (B * num_windows, window_size, window_size, C).
-            - (Hp, Wp) (Tuple[int, int]): Padded height and width before partition.
+        windows (torch.Tensor): Partitioned windows with shape (B * num_windows, window_size, window_size, C).
+        padded_h_w (Tuple[int, int]): Padded height and width before partition.
 
     Examples:
         >>> x = torch.randn(1, 16, 16, 3)

ultralytics/models/utils/loss.py

@@ -32,7 +32,16 @@ class DETRLoss(nn.Module):
     """
 
     def __init__(
-        self, nc=80, loss_gain=None, aux_loss=True, use_fl=True, use_vfl=False, use_uni_match=False, uni_match_ind=0
+        self,
+        nc=80,
+        loss_gain=None,
+        aux_loss=True,
+        use_fl=True,
+        use_vfl=False,
+        use_uni_match=False,
+        uni_match_ind=0,
+        gamma=1.5,
+        alpha=0.25,
     ):
         """
         Initialize DETR loss function with customizable components and gains.
@@ -48,6 +57,8 @@ class DETRLoss(nn.Module):
             use_vfl (bool): Whether to use VarifocalLoss.
             use_uni_match (bool): Whether to use fixed layer for auxiliary branch label assignment.
             uni_match_ind (int): Index of fixed layer for uni_match.
+            gamma (float): The focusing parameter that controls how much the loss focuses on hard-to-classify examples.
+            alpha (float): The balancing factor used to address class imbalance.
         """
         super().__init__()
 
@@ -57,8 +68,8 @@ class DETRLoss(nn.Module):
         self.matcher = HungarianMatcher(cost_gain={"class": 2, "bbox": 5, "giou": 2})
         self.loss_gain = loss_gain
         self.aux_loss = aux_loss
-        self.fl = FocalLoss() if use_fl else None
-        self.vfl = VarifocalLoss() if use_vfl else None
+        self.fl = FocalLoss(gamma, alpha) if use_fl else None
+        self.vfl = VarifocalLoss(gamma, alpha) if use_vfl else None
 
         self.use_uni_match = use_uni_match
         self.uni_match_ind = uni_match_ind

ultralytics/models/yolo/model.py

@@ -144,7 +144,7 @@ class YOLOWorld(Model):
 class YOLOE(Model):
     """YOLOE object detection and segmentation model."""
 
-    def __init__(self, model="yoloe-v8s-seg.pt", task=None, verbose=False) -> None:
+    def __init__(self, model="yoloe-11s-seg.pt", task=None, verbose=False) -> None:
         """
         Initialize YOLOE model with a pre-trained model file.
 
@@ -197,7 +197,7 @@ class YOLOE(Model):
             (torch.Tensor): Visual positional embeddings.
 
         Examples:
-            >>> model = YOLOE("yoloe-v8s.pt")
+            >>> model = YOLOE("yoloe-11s-seg.pt")
             >>> img = torch.rand(1, 3, 640, 640)
             >>> visual_features = model.model.backbone(img)
             >>> pe = model.get_visual_pe(img, visual_features)
@@ -220,7 +220,7 @@ class YOLOE(Model):
             AssertionError: If the model is not an instance of YOLOEModel.
 
         Examples:
-            >>> model = YOLOE("yoloe-v8s.pt")
+            >>> model = YOLOE("yoloe-11s-seg.pt")
             >>> model.set_vocab(["person", "car", "dog"], ["person", "car", "dog"])
         """
         assert isinstance(self.model, YOLOEModel)
@@ -304,7 +304,7 @@ class YOLOE(Model):
             (List | generator): List of Results objects or generator of Results objects if stream=True.
 
         Examples:
-            >>> model = YOLOE("yoloe-v8s-seg.pt")
+            >>> model = YOLOE("yoloe-11s-seg.pt")
             >>> results = model.predict("path/to/image.jpg")
             >>> # With visual prompts
             >>> prompts = {"bboxes": [[10, 20, 100, 200]], "cls": ["person"]}

ultralytics/models/yolo/segment/predict.py

@@ -59,7 +59,7 @@ class SegmentationPredictor(DetectionPredictor):
                    Each Results object includes both bounding boxes and segmentation masks.
 
         Examples:
-            >>> predictor = SegmentationPredictor(overrides=dict(model="yolov8n-seg.pt"))
+            >>> predictor = SegmentationPredictor(overrides=dict(model="yolo11n-seg.pt"))
             >>> results = predictor.postprocess(preds, img, orig_img)
         """
         # Extract protos - tuple if PyTorch model or array if exported

ultralytics/nn/modules/conv.py

@@ -447,9 +447,8 @@ class RepConv(nn.Module):
         Calculate equivalent kernel and bias by fusing convolutions.
 
         Returns:
-            (tuple): Tuple containing:
-                - Equivalent kernel (torch.Tensor)
-                - Equivalent bias (torch.Tensor)
+            (torch.Tensor): Equivalent kernel
+            (torch.Tensor): Equivalent bias
         """
         kernel3x3, bias3x3 = self._fuse_bn_tensor(self.conv1)
         kernel1x1, bias1x1 = self._fuse_bn_tensor(self.conv2)
@@ -480,9 +479,8 @@ class RepConv(nn.Module):
             branch (Conv | nn.BatchNorm2d | None): Branch to fuse.
 
         Returns:
-            (tuple): Tuple containing:
-                - Fused kernel (torch.Tensor)
-                - Fused bias (torch.Tensor)
+            (torch.Tensor): Fused kernel
+            (torch.Tensor): Fused bias
         """
         if branch is None:
             return 0, 0

ultralytics/nn/modules/head.py

@@ -32,6 +32,7 @@ class Detect(nn.Module):
     anchors = torch.empty(0)  # init
     strides = torch.empty(0)  # init
     legacy = False  # backward compatibility for v3/v5/v8/v9 models
+    xyxy = False  # xyxy or xywh output
 
     def __init__(self, nc=80, ch=()):
         """Initialize the YOLO detection layer with specified number of classes and channels."""
@@ -83,9 +84,10 @@ class Detect(nn.Module):
             x (List[torch.Tensor]): Input feature maps from different levels.
 
         Returns:
-            (dict | tuple): If in training mode, returns a dictionary containing the outputs of both one2many and
-                one2one detections. If not in training mode, returns processed detections or a tuple with
-                processed detections and raw outputs.
+            (dict | tuple):
+
+                - If in training mode, returns a dictionary containing outputs of both one2many and one2one detections.
+                - If not in training mode, returns processed detections or a tuple with processed detections and raw outputs.
         """
         x_detach = [xi.detach() for xi in x]
         one2one = [
@@ -156,7 +158,7 @@ class Detect(nn.Module):
 
     def decode_bboxes(self, bboxes, anchors, xywh=True):
         """Decode bounding boxes."""
-        return dist2bbox(bboxes, anchors, xywh=xywh and (not self.end2end), dim=1)
+        return dist2bbox(bboxes, anchors, xywh=xywh and not (self.end2end or self.xyxy), dim=1)
 
     @staticmethod
     def postprocess(preds: torch.Tensor, max_det: int, nc: int = 80):

ultralytics/solutions/ai_gym.py

@@ -103,12 +103,13 @@ class AIGym(BaseSolution):
                     self.stage[ind] = "up"
 
                 # Display angle, count, and stage text
-                annotator.plot_angle_and_count_and_stage(
-                    angle_text=self.angle[ind],  # angle text for display
-                    count_text=self.count[ind],  # count text for workouts
-                    stage_text=self.stage[ind],  # stage position text
-                    center_kpt=k[int(self.kpts[1])],  # center keypoint for display
-                )
+                if self.show_labels:
+                    annotator.plot_angle_and_count_and_stage(
+                        angle_text=self.angle[ind],  # angle text for display
+                        count_text=self.count[ind],  # count text for workouts
+                        stage_text=self.stage[ind],  # stage position text
+                        center_kpt=k[int(self.kpts[1])],  # center keypoint for display
+                    )
         plot_im = annotator.result()
         self.display_output(plot_im)  # Display output image, if environment support display
 

ultralytics/solutions/distance_calculation.py

@@ -95,8 +95,8 @@ class DistanceCalculation(BaseSolution):
 
         pixels_distance = 0
         # Iterate over bounding boxes, track ids and classes index
-        for box, track_id, cls in zip(self.boxes, self.track_ids, self.clss):
-            annotator.box_label(box, color=colors(int(cls), True), label=self.names[int(cls)])
+        for box, track_id, cls, conf in zip(self.boxes, self.track_ids, self.clss, self.confs):
+            annotator.box_label(box, color=colors(int(cls), True), label=self.adjust_box_label(cls, conf, track_id))
 
             # Update selected boxes if they're being tracked
             if len(self.selected_boxes) == 2:

ultralytics/solutions/object_blurrer.py

@@ -72,7 +72,7 @@ class ObjectBlurrer(BaseSolution):
         annotator = SolutionAnnotator(im0, self.line_width)
 
         # Iterate over bounding boxes and classes
-        for box, cls in zip(self.boxes, self.clss):
+        for box, cls, conf in zip(self.boxes, self.clss, self.confs):
             # Crop and blur the detected object
             blur_obj = cv2.blur(
                 im0[int(box[1]) : int(box[3]), int(box[0]) : int(box[2])],
@@ -80,7 +80,9 @@ class ObjectBlurrer(BaseSolution):
             )
             # Update the blurred area in the original image
             im0[int(box[1]) : int(box[3]), int(box[0]) : int(box[2])] = blur_obj
-            annotator.box_label(box, label=self.names[cls], color=colors(cls, True))  # Annotate bounding box
+            annotator.box_label(
+                box, label=self.adjust_box_label(cls, conf), color=colors(cls, True)
+            )  # Annotate bounding box
 
         plot_im = annotator.result()
         self.display_output(plot_im)  # Display the output using the base class function

ultralytics/solutions/object_counter.py

@@ -179,9 +179,9 @@ class ObjectCounter(BaseSolution):
         )  # Draw region
 
         # Iterate over bounding boxes, track ids and classes index
-        for box, track_id, cls in zip(self.boxes, self.track_ids, self.clss):
+        for box, track_id, cls, conf in zip(self.boxes, self.track_ids, self.clss, self.confs):
             # Draw bounding box and counting region
-            self.annotator.box_label(box, label=self.names[cls], color=colors(cls, True))
+            self.annotator.box_label(box, label=self.adjust_box_label(cls, conf, track_id), color=colors(cls, True))
             self.store_tracking_history(track_id, box)  # Store track history
             self.store_classwise_counts(cls)  # Store classwise counts in dict
 

ultralytics/solutions/queue_management.py

@@ -64,9 +64,9 @@ class QueueManager(BaseSolution):
         annotator = SolutionAnnotator(im0, line_width=self.line_width)  # Initialize annotator
         annotator.draw_region(reg_pts=self.region, color=self.rect_color, thickness=self.line_width * 2)  # Draw region
 
-        for box, track_id, cls in zip(self.boxes, self.track_ids, self.clss):
+        for box, track_id, cls, conf in zip(self.boxes, self.track_ids, self.clss, self.confs):
             # Draw bounding box and counting region
-            annotator.box_label(box, label=self.names[cls], color=colors(track_id, True))
+            annotator.box_label(box, label=self.adjust_box_label(cls, conf, track_id), color=colors(track_id, True))
             self.store_tracking_history(track_id, box)  # Store track history
 
             # Cache frequently accessed attributes

ultralytics/solutions/region_counter.py

@@ -96,8 +96,8 @@ class RegionCounter(BaseSolution):
 
         # Process bounding boxes & check containment
         if points:
-            for point, cls, track_id, box in zip(points, self.clss, self.track_ids, self.boxes):
-                annotator.box_label(box, label=self.names[cls], color=colors(track_id, True))
+            for point, cls, track_id, box, conf in zip(points, self.clss, self.track_ids, self.boxes, self.confs):
+                annotator.box_label(box, label=self.adjust_box_label(cls, conf, track_id), color=colors(track_id, True))
 
                 for region in self.counting_regions:
                     if region["prepared_polygon"].contains(point):

ultralytics/solutions/solutions.py

@@ -82,12 +82,14 @@ class BaseSolution:
         self.region = self.CFG["region"]  # Store region data for other classes usage
         self.line_width = self.CFG["line_width"] if self.CFG["line_width"] not in (None, 0) else 2  # Store line_width
 
-        # Load Model and store classes names
+        # Load Model and store additional information (classes, show_conf, show_label)
         if self.CFG["model"] is None:
             self.CFG["model"] = "yolo11n.pt"
         self.model = YOLO(self.CFG["model"])
         self.names = self.model.names
         self.classes = self.CFG["classes"]
+        self.show_conf = self.CFG["show_conf"]
+        self.show_labels = self.CFG["show_labels"]
 
         self.track_add_args = {  # Tracker additional arguments for advance configuration
             k: self.CFG[k] for k in ["iou", "conf", "device", "max_det", "half", "tracker", "device", "verbose"]
@@ -105,6 +107,25 @@ class BaseSolution:
         self.env_check = check_imshow(warn=True)
         self.track_history = defaultdict(list)
 
+    def adjust_box_label(self, cls, conf, track_id=None):
+        """
+        Generates a formatted label for a bounding box.
+
+        This method constructs a label string for a bounding box using the class index and confidence score.
+        Optionally includes the track ID if provided. The label format adapts based on the display settings
+        defined in `self.show_conf` and `self.show_labels`.
+
+        Args:
+            cls (int): The class index of the detected object.
+            conf (float): The confidence score of the detection.
+            track_id (int, optional): The unique identifier for the tracked object. Defaults to None.
+
+        Returns:
+            (str or None): The formatted label string if `self.show_labels` is True; otherwise, None.
+        """
+        name = ("" if track_id is None else f"{track_id} ") + self.names[cls]
+        return (f"{name} {conf:.2f}" if self.show_conf else name) if self.show_labels else None
+
     def extract_tracks(self, im0):
         """
         Applies object tracking and extracts tracks from an input image or frame.
@@ -128,9 +149,10 @@ class BaseSolution:
             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()
+            self.confs = self.track_data.conf.cpu().tolist()
         else:
             self.LOGGER.warning("no tracks found!")
-            self.boxes, self.clss, self.track_ids = [], [], []
+            self.boxes, self.clss, self.track_ids, self.confs = [], [], [], []
 
     def store_tracking_history(self, track_id, box):
         """

ultralytics/solutions/speed_estimation.py

@@ -73,7 +73,7 @@ class SpeedEstimator(BaseSolution):
         # Draw speed estimation region
         annotator.draw_region(reg_pts=self.region, color=(104, 0, 123), thickness=self.line_width * 2)
 
-        for box, track_id, cls in zip(self.boxes, self.track_ids, self.clss):
+        for box, track_id, cls, conf in zip(self.boxes, self.track_ids, self.clss, self.confs):
             self.store_tracking_history(track_id, box)  # Store track history
 
             # Initialize tracking data for new objects
@@ -82,8 +82,11 @@ class SpeedEstimator(BaseSolution):
             if track_id not in self.trk_pp:
                 self.trk_pp[track_id] = self.track_line[-1]
 
-            # Prepare label with speed if available, otherwise use class name
-            speed_label = f"{int(self.spd[track_id])} km/h" if track_id in self.spd else self.names[int(cls)]
+            speed_label = (
+                f"{int(self.spd[track_id])} km/h"
+                if track_id in self.spd and self.show_labels
+                else self.adjust_box_label(cls, conf, track_id)
+            )
             annotator.box_label(box, label=speed_label, color=colors(track_id, True))  # Draw bounding box
 
             # Determine if object is crossing the speed estimation region

ultralytics/solutions/trackzone.py

@@ -76,8 +76,10 @@ class TrackZone(BaseSolution):
         cv2.polylines(im0, [self.region], isClosed=True, color=(255, 255, 255), thickness=self.line_width * 2)
 
         # Iterate over boxes, track ids, classes indexes list and draw bounding boxes
-        for box, track_id, cls in zip(self.boxes, self.track_ids, self.clss):
-            annotator.box_label(box, label=f"{self.names[cls]}:{track_id}", color=colors(track_id, True))
+        for box, track_id, cls, conf in zip(self.boxes, self.track_ids, self.clss, self.confs):
+            annotator.box_label(
+                box, label=self.adjust_box_label(cls, conf, track_id=track_id), color=colors(track_id, True)
+            )
 
         plot_im = annotator.result()
         self.display_output(plot_im)  # display output with base class function

ultralytics/solutions/vision_eye.py

@@ -57,9 +57,9 @@ class VisionEye(BaseSolution):
         self.extract_tracks(im0)  # Extract tracks (bounding boxes, classes, and masks)
         annotator = SolutionAnnotator(im0, self.line_width)
 
-        for cls, t_id, box in zip(self.clss, self.track_ids, self.boxes):
+        for cls, t_id, box, conf in zip(self.clss, self.track_ids, self.boxes, self.confs):
             # Annotate the image with bounding boxes, labels, and vision mapping
-            annotator.box_label(box, label=self.names[cls], color=colors(int(t_id), True))
+            annotator.box_label(box, label=self.adjust_box_label(cls, conf, t_id), color=colors(int(t_id), True))
             annotator.visioneye(box, self.vision_point)
 
         plot_im = annotator.result()

ultralytics/utils/__init__.py

@@ -1261,7 +1261,7 @@ class SettingsManager(JSONDict):
             "For help see https://docs.ultralytics.com/quickstart/#ultralytics-settings."
         )
 
-        with torch_distributed_zero_first(RANK):
+        with torch_distributed_zero_first(LOCAL_RANK):
             super().__init__(self.file)
 
             if not self.file.exists() or not self:  # Check if file doesn't exist or is empty

ultralytics/utils/checks.py

@@ -87,7 +87,7 @@ def parse_version(version="0.0.0") -> tuple:
         version (str): Version string, i.e. '2.0.1+cpu'
 
     Returns:
-        (tuple): Tuple of integers representing the numeric part of the version, i.e. (2, 0, 1)
+        (Tuple[int, int, int]): Tuple of integers representing the numeric part of the version, i.e. (2, 0, 1)
     """
     try:
         return tuple(map(int, re.findall(r"\d+", version)[:3]))  # '2.0.1+cpu' -> (2, 0, 1)

ultralytics/utils/loss.py

@@ -18,16 +18,21 @@ class VarifocalLoss(nn.Module):
     Varifocal loss by Zhang et al.
 
     https://arxiv.org/abs/2008.13367.
+
+    Args:
+        gamma (float): The focusing parameter that controls how much the loss focuses on hard-to-classify examples.
+        alpha (float): The balancing factor used to address class imbalance.
     """
 
-    def __init__(self):
+    def __init__(self, gamma=2.0, alpha=0.75):
         """Initialize the VarifocalLoss class."""
         super().__init__()
+        self.gamma = gamma
+        self.alpha = alpha
 
-    @staticmethod
-    def forward(pred_score, gt_score, label, alpha=0.75, gamma=2.0):
+    def forward(self, pred_score, gt_score, label):
         """Compute varifocal loss between predictions and ground truth."""
-        weight = alpha * pred_score.sigmoid().pow(gamma) * (1 - label) + gt_score * label
+        weight = self.alpha * pred_score.sigmoid().pow(self.gamma) * (1 - label) + gt_score * label
         with autocast(enabled=False):
             loss = (
                 (F.binary_cross_entropy_with_logits(pred_score.float(), gt_score.float(), reduction="none") * weight)
@@ -38,14 +43,21 @@ class VarifocalLoss(nn.Module):
 
 
 class FocalLoss(nn.Module):
-    """Wraps focal loss around existing loss_fcn(), i.e. criteria = FocalLoss(nn.BCEWithLogitsLoss(), gamma=1.5)."""
+    """
+    Wraps focal loss around existing loss_fcn(), i.e. criteria = FocalLoss(nn.BCEWithLogitsLoss(), gamma=1.5).
 
-    def __init__(self):
+    Args:
+        gamma (float): The focusing parameter that controls how much the loss focuses on hard-to-classify examples.
+        alpha (float): The balancing factor used to address class imbalance.
+    """
+
+    def __init__(self, gamma=1.5, alpha=0.25):
         """Initialize FocalLoss class with no parameters."""
         super().__init__()
+        self.gamma = gamma
+        self.alpha = alpha
 
-    @staticmethod
-    def forward(pred, label, gamma=1.5, alpha=0.25):
+    def forward(self, pred, label):
         """Calculate focal loss with modulating factors for class imbalance."""
         loss = F.binary_cross_entropy_with_logits(pred, label, reduction="none")
         # p_t = torch.exp(-loss)
@@ -54,10 +66,10 @@ class FocalLoss(nn.Module):
         # TF implementation https://github.com/tensorflow/addons/blob/v0.7.1/tensorflow_addons/losses/focal_loss.py
         pred_prob = pred.sigmoid()  # prob from logits
         p_t = label * pred_prob + (1 - label) * (1 - pred_prob)
-        modulating_factor = (1.0 - p_t) ** gamma
+        modulating_factor = (1.0 - p_t) ** self.gamma
         loss *= modulating_factor
-        if alpha > 0:
-            alpha_factor = label * alpha + (1 - label) * (1 - alpha)
+        if self.alpha > 0:
+            alpha_factor = label * self.alpha + (1 - label) * (1 - self.alpha)
             loss *= alpha_factor
         return loss.mean(1).sum()
 

ultralytics/utils/ops.py

@@ -300,7 +300,7 @@ def non_max_suppression(
 
         # Filter by class
         if classes is not None:
-            x = x[(x[:, 5:6] == classes).any(1)]
+            filt = (x[:, 5:6] == classes).any(1)
             x, xk = x[filt], xk[filt]
 
         # Check shape

ultralytics/utils/patches.py

@@ -31,7 +31,8 @@ def imread(filename: str, flags: int = cv2.IMREAD_COLOR):
     if filename.endswith((".tiff", ".tif")):
         success, frames = cv2.imdecodemulti(file_bytes, cv2.IMREAD_UNCHANGED)
         if success:
-            return np.stack(frames, axis=2)  # or np.asarray(frames).transpose(1,2,0)
+            # handle RGB images in tif/tiff format
+            return frames[0] if len(frames) == 1 and frames[0].ndim == 3 else np.stack(frames, axis=2)
         return None
     else:
         return cv2.imdecode(file_bytes, flags)

{ultralytics-8.3.114.dist-info → ultralytics-8.3.116.dist-info}/METADATA

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

@@ -1,4 +1,4 @@
-ultralytics/__init__.py,sha256=WBfQJaKm6-2YTizBGkwFR26SwOipY7Xf-o89_L_k6GE,730
+ultralytics/__init__.py,sha256=hJZgj-05JvXpxDaasqblynp1_3OTO8h2asjqrJKG8wg,730
 ultralytics/assets/bus.jpg,sha256=wCAZxJecGR63Od3ZRERe9Aja1Weayrb9Ug751DS_vGM,137419
 ultralytics/assets/zidane.jpg,sha256=Ftc4aeMmen1O0A3o6GCDO9FlfBslLpTAw0gnetx7bts,50427
 ultralytics/cfg/__init__.py,sha256=-66Vtli1XqcRUJ9F_gYyEoKTO3gDMmOrDDnUEa5G84s,39646
@@ -95,24 +95,24 @@ ultralytics/cfg/trackers/botsort.yaml,sha256=8fM3y4TXKKT_5aWsqmQw5JEgwNlBGlRaf8L
 ultralytics/cfg/trackers/bytetrack.yaml,sha256=6u-tiZlk16EqEwkNXaMrza6PAQmWj_ypgv26LGCtPDg,886
 ultralytics/data/__init__.py,sha256=nAXaL1puCc7z_NjzQNlJnhbVhT9Fla2u7Dsqo7q1dAc,644
 ultralytics/data/annotator.py,sha256=VEwb11FsEZm75qlEp8XDHFGKW0_rGsEaFDaBVd771Kw,2902
-ultralytics/data/augment.py,sha256=WBVuxXW1Mzu7V-LaSopoFEiu8S2r0kM5zMpFVyzcWF0,125280
-ultralytics/data/base.py,sha256=efummc7-4ha3O2J-ZoUOK9-HO-8Glh3h0W2oEwh4WBg,18503
-ultralytics/data/build.py,sha256=56pavLie6PDFEVYChMxnGQGtGsxozYZRpFqC70DRGls,9650
+ultralytics/data/augment.py,sha256=JgUva2YddmLs-p2lFqTHXIl1t_66Oz6wH-X5fYLYouY,125171
+ultralytics/data/base.py,sha256=TpOmVPC6O-3JOrYQcWCeVVsnpCvpicatjH70M9VRxgM,18578
+ultralytics/data/build.py,sha256=FVIkgLGv5n1C7SRDrQiKOMDcI7V59WmEihKslzvEISg,9651
 ultralytics/data/converter.py,sha256=znXH2XTdo0Q4NDHMny1ydVBvrxKn2kbbwI-X5bn1MlQ,26890
-ultralytics/data/dataset.py,sha256=3hcnCBBb5C_m4l5E1m2uf_2hQFhMv31FmvTfvWed8ek,34760
+ultralytics/data/dataset.py,sha256=y7A786pqR_fDU9lSeMFkXHK6biXzDyIjR2Hvu1xZk14,34758
 ultralytics/data/loaders.py,sha256=kl3gHkcIcNHqLKuQ5fyAlDo9WYBsCPjLcnFbRpk6KVw,28494
 ultralytics/data/split.py,sha256=6LHB1z8woXurWjXfM-Zm2thRr1KXvzR18CFJA-SDUvE,4677
 ultralytics/data/split_dota.py,sha256=p8eVGht9tABSVbf9vwvxA_AQYEva3IGHePKlMeNrn64,11872
-ultralytics/data/utils.py,sha256=yzYHZor0E1JU5RjC5dKYSqQx1uYHorDtzZK_Qi2dz6E,35124
+ultralytics/data/utils.py,sha256=HET4rbj4iUcjen0t8E_Qo_9S9RGPVQRYL-j0KI0qflI,35269
 ultralytics/data/scripts/download_weights.sh,sha256=0y8XtZxOru7dVThXDFUXLHBuICgOIqZNUwpyL4Rh6lg,595
 ultralytics/data/scripts/get_coco.sh,sha256=UuJpJeo3qQpTHVINeOpmP0NYmg8PhEFE3A8J3jKrnPw,1768
 ultralytics/data/scripts/get_coco128.sh,sha256=qmRQl_hOKrsdHrTrnyQuFIH01oDz3lfaz138OgGfLt8,650
 ultralytics/data/scripts/get_imagenet.sh,sha256=hr42H16bM47iT27rgS7MpEo-GeOZAYUQXgr0B2cwn48,1705
 ultralytics/engine/__init__.py,sha256=lm6MckFYCPTbqIoX7w0s_daxdjNeBeKW6DXppv1-QUM,70
-ultralytics/engine/exporter.py,sha256=KeOF8LH0sgQdPd4jSny5ggATMf1AOebcTGdibLvS0AA,73663
+ultralytics/engine/exporter.py,sha256=DloC0wjWHzxbF5v2ue0_R9gNXwkUo6gRR2zc73ILbEc,73454
 ultralytics/engine/model.py,sha256=wS1cwgv0iyhsslMAZYMGlYDWitDIRW96d7MxwW-Sw5o,52817
 ultralytics/engine/predictor.py,sha256=YJ5l-0qIpr6JAJxowswtZ0IqmXBqVTvAA9vR40v0sCM,21752
-ultralytics/engine/results.py,sha256=C3j-kyjoMxn7bb8tK_kaYrOWB8-7qDYZ-_hSh1LPWMA,79742
+ultralytics/engine/results.py,sha256=MZkhI0CCOkBQPR-EzswymVqvqeyk35EkESGUQ_08r8k,79738
 ultralytics/engine/trainer.py,sha256=O6Cl-27Wd8w7WJGfG3rIx7LDgF-_qb9gF_j8oBeUV24,38839
 ultralytics/engine/tuner.py,sha256=oyjnbAExddGTBN-sm7tXFtxSgjZOZ5M81EIJSzpmqno,12581
 ultralytics/engine/validator.py,sha256=jfV81wuFDgrVVXEcPzgOpxAPrAZn-1LgpKwu9l_1-ts,17050
@@ -149,12 +149,12 @@ ultralytics/models/sam/modules/memory_attention.py,sha256=2HWCr7GrXMRX_V3RTfz44i
 ultralytics/models/sam/modules/sam.py,sha256=PJxBIfJdJTe-NLWZZgmSWbnvHhyQjzr7gXNarjqBNJE,52628
 ultralytics/models/sam/modules/tiny_encoder.py,sha256=p6386bsmIwgZq1wfV7h6dcnI6955SBO2bBrp0HwjnYQ,40837
 ultralytics/models/sam/modules/transformer.py,sha256=YRhoriZ-j37kxq19kArfv2DSOz2Jj9DAbs2mcOBVORw,14674
-ultralytics/models/sam/modules/utils.py,sha256=EOOBeS6Mm1P13ultPYwOyJ0Vm2IY3NyH9DM3SgZCbFU,16436
+ultralytics/models/sam/modules/utils.py,sha256=3PatFjbgO1uasMZXXLJw23CrjuYTW7BS9NM4aXom-zY,16294
 ultralytics/models/utils/__init__.py,sha256=lm6MckFYCPTbqIoX7w0s_daxdjNeBeKW6DXppv1-QUM,70
-ultralytics/models/utils/loss.py,sha256=nAzhm4oMJqI3-ejAB9jXIHebTd8H_l3a8-NJcIiJEvo,19665
+ultralytics/models/utils/loss.py,sha256=4IiyDbxBCm7vRvZuIvXbr0_rCvjOratbqLx4KYaGouw,19986
 ultralytics/models/utils/ops.py,sha256=SuBnwwgUTqByNHpufobGLW72yO2cyfZFi14KAFWSjjw,13613
 ultralytics/models/yolo/__init__.py,sha256=or0j5xvcM0usMlsFTYhNAOcQUri7reD0cD9JR5b7zDk,307
-ultralytics/models/yolo/model.py,sha256=mNsz_eqpMMxpvWgx-OF0StxGNxslIR8LQJ7QQ8DvjKw,14357
+ultralytics/models/yolo/model.py,sha256=AJ_IXhU58XDRQvtvEW2SqYdlNx6j9GfPVx-wifTp0Fo,14365
 ultralytics/models/yolo/classify/__init__.py,sha256=9--HVaNOfI1K7rn_rRqclL8FUAnpfeBrRqEQIaQw2xM,383
 ultralytics/models/yolo/classify/predict.py,sha256=JV9szginTQ9Lpob0FozhKMiEIu1vVaYg4YItuVK2AFM,4081
 ultralytics/models/yolo/classify/train.py,sha256=rv2CJv9fzvtHf2q4l5g0RsjplWKeLpz637kKqjtrLNY,9737
@@ -172,7 +172,7 @@ ultralytics/models/yolo/pose/predict.py,sha256=Q3eOti-wjEeiTpChTdb_kY_CgkwEYMGbB
 ultralytics/models/yolo/pose/train.py,sha256=W9ThNoqawpZOTgX8TZfcdPY1_zxFjB-GryToUUTGf-k,5942
 ultralytics/models/yolo/pose/val.py,sha256=PO2Tdlntbx41q_7U4vZ0L_J9-tiqNq5cHCzBJ7HmOUo,18303
 ultralytics/models/yolo/segment/__init__.py,sha256=3IThhZ1wlkY9FvmWm9cE-5-ZyE6F1FgzAtQ6jOOFzzw,275
-ultralytics/models/yolo/segment/predict.py,sha256=0m2itdoUbSlfGq_-tjC6XG_SsCWXtiCUoi4tWxQD6qY,5410
+ultralytics/models/yolo/segment/predict.py,sha256=mIC3aHI7Jg4dU1k2UZnjVj4unE-5TWi_rh7P0AEyJmA,5410
 ultralytics/models/yolo/segment/train.py,sha256=7DN9UpvNeEPHUNlDOZSnxem4bPfo_e5UgMLyyKT6FWo,5359
 ultralytics/models/yolo/segment/val.py,sha256=cXJM1JNuzDraU0SJQRIdzNxabd0bfcxiRE8wozHZChY,18415
 ultralytics/models/yolo/world/__init__.py,sha256=nlh8I6t8hMGz_vZg8QSlsUW1R-2eKvn9CGUoPPQEGhA,131
@@ -190,28 +190,28 @@ ultralytics/nn/text_model.py,sha256=H6OiLe0FOyZY4pd7-ixRTxaBgx3lOc2GmGTmrFnoJd0,
 ultralytics/nn/modules/__init__.py,sha256=dXLtIk9rt944WfsTdpgEdWOg3HQEHdwQztuZ6WNJygs,3144
 ultralytics/nn/modules/activation.py,sha256=PvXZkA9AzEntR575JkFORdmtcRwATyy0lje-uHA5_8w,2210
 ultralytics/nn/modules/block.py,sha256=jGPMLa-FWYall7FmWvSLIduc2qu-A-lOcBjCaHqe4nk,66667
-ultralytics/nn/modules/conv.py,sha256=WeiLrtWYdfrhQPgDEKbimJmQMgzaOgFG87y6-jaeg_o,21459
-ultralytics/nn/modules/head.py,sha256=vVEDu4OkKsgRlGThMUKcE2nOtcmGxW66fkXMQoL1tRc,38388
+ultralytics/nn/modules/conv.py,sha256=nxbfAxmvo6A9atuxY3LXTtzMXhihZapCSg1F5mI4sIA,21361
+ultralytics/nn/modules/head.py,sha256=FbFB-e44Zvxgzdfy0FqeGWUn0DDahmEZvD1W_N2olcM,38442
 ultralytics/nn/modules/transformer.py,sha256=tC80QKFaLtWZo0zVNTuORX4pOu6HVs2wS0vSM-3h5W4,28227
 ultralytics/nn/modules/utils.py,sha256=rn8yTObZGkQoqVzjbZWLaHiytppG4ffjMME4Lw60glM,6092
 ultralytics/solutions/__init__.py,sha256=pjNYva0qnw-4hf_tTLx_dgIfg24XrYLLp3kygPj95rs,1113
-ultralytics/solutions/ai_gym.py,sha256=oOexy2cT59u9X6ROCwoaV3Nl2zT2xJ_trShAoSyR8Hk,5702
+ultralytics/solutions/ai_gym.py,sha256=QRrZGMka83NY4B9gU3N2GxTaomo0WmTMNLxkNZTxo9U,5763
 ultralytics/solutions/analytics.py,sha256=O8dXdDTpHPRlz2vAGMvef1NfWUXBvoYt2G_TQI_UjoQ,11983
-ultralytics/solutions/distance_calculation.py,sha256=n6bPNJ7YbPKAaHWsra6CQQtrDR0SEvSC14BRWTITyBU,5711
+ultralytics/solutions/distance_calculation.py,sha256=E13siGlQTqaGCk0xULk5Q86PwxiBAL4XWp83kQPb0YE,5751
 ultralytics/solutions/heatmap.py,sha256=dagbZ0Vn4UdywNyiAypYW5v1uzOWf521QrkzmqyeCEc,5626
 ultralytics/solutions/instance_segmentation.py,sha256=HxzFf752PwjAjZhrf8BzI-gEey_f9mjxTOqJsLHSIB8,3498
-ultralytics/solutions/object_blurrer.py,sha256=2RaUJ6DptdcIg__mhoegkfPpj2ymL0nsBjGX9Y_FkVY,3889
-ultralytics/solutions/object_counter.py,sha256=QXBRBEv_a0uiOYYzsNdu0VAH62rg97v1EiSHy60O1q4,9999
+ultralytics/solutions/object_blurrer.py,sha256=OCLHCZul8cQOxK-HTV48rCWmgr_na8x9F9jf8FSAQgk,3954
+ultralytics/solutions/object_counter.py,sha256=7u8OkFye91R9tf1Ar19ttXhKcoB6ziyi0pZfbHaQJ5U,10044
 ultralytics/solutions/object_cropper.py,sha256=RNk_v_XRXm9Ye2TsKG5CPd3TDsRaiODWpy8MvYqkSLs,3382
 ultralytics/solutions/parking_management.py,sha256=SiVxRl44OxxYUXIzNOxOBqtaFJSRRpD_gTsNyvB1n5o,13277
-ultralytics/solutions/queue_management.py,sha256=cUzAMMeWijowkdiuaSUZRr0S3I5MTHkCQOLjOqS0JN0,4299
-ultralytics/solutions/region_counter.py,sha256=5CFtrWxQC8a-6puaxjYXaJAmYE9vTFUxNSd-XYeiRkU,5373
+ultralytics/solutions/queue_management.py,sha256=p1-cuI_rs4ygtlBryXjE65NYG2bnZXhp3ylggFnWcRs,4344
+ultralytics/solutions/region_counter.py,sha256=Zn35YRXNzhBk27D9MLOHBYe2L1o6H2ey3mEwCXofB_E,5418
 ultralytics/solutions/security_alarm.py,sha256=mbUtqoLgjAWz9k3pjMoEZY_PR-lhjiic1NK90FhEJkw,6250
-ultralytics/solutions/solutions.py,sha256=UaDZN_wAmV-XeRh57ca9TuqX-7sZUU-TmrpL1BqYuEc,31522
-ultralytics/solutions/speed_estimation.py,sha256=3UFtGXKNUy1jt6GS4wg4hvkQoQ4KkOHXjzMpmSHodx0,5126
+ultralytics/solutions/solutions.py,sha256=n3AHRcQ4VXHjCxnaxrJiAE8QzJg-zuKnKM7i7O_0Hko,32695
+ultralytics/solutions/speed_estimation.py,sha256=qZjpLnx-12QBVV3QjW8J7azWMv6Kj7BvssNEHZapV6k,5173
 ultralytics/solutions/streamlit_inference.py,sha256=M0ppTFInqSPrdytZBLH8x-XoA7zFc7PaRQ51wHG9ppU,9846
-ultralytics/solutions/trackzone.py,sha256=05XVTQVCGHFAuFNPzyv0VXKQSJKiyWkU6zkXVo4_dxw,3792
-ultralytics/solutions/vision_eye.py,sha256=cFjex7mau20Ww4Cuq9lbaAidVTByXk7nhZ0KVHqUzBY,2924
+ultralytics/solutions/trackzone.py,sha256=efko4U8zT8lyNLLo9zF543rTXHefeYthxf9GV3c2TiU,3860
+ultralytics/solutions/vision_eye.py,sha256=DHf3pQzNqP71oYx3QXflvcGsg4nEYJCD1SOdSOxiWBk,2965
 ultralytics/trackers/__init__.py,sha256=Zlu_Ig5osn7hqch_g5Be_e4pwZUkeeTQiesJCi0pFGI,255
 ultralytics/trackers/basetrack.py,sha256=LYvWB5d7Woyrz_RlxaopjV07RQKH3sff_lZJfMcMxcA,4450
 ultralytics/trackers/bot_sort.py,sha256=vu3gtJnaVZ3O_Z-YBHypY2IxOZgMf63tucRGPgcf5Es,11296
@@ -221,20 +221,20 @@ ultralytics/trackers/utils/__init__.py,sha256=lm6MckFYCPTbqIoX7w0s_daxdjNeBeKW6D
 ultralytics/trackers/utils/gmc.py,sha256=dz3I5LbIv7h1__Xg7rGHecQFE32VFTe54tUnxb8F0Z8,14466
 ultralytics/trackers/utils/kalman_filter.py,sha256=A0CqOnnaKH6kr0XwuHzyHmIU6aJAjJYxF9jVlNBKZHo,21326
 ultralytics/trackers/utils/matching.py,sha256=7eIufSdeN7cXuFMjvcfvz0Ldq84m4YKZl5IGxBR8IIo,7169
-ultralytics/utils/__init__.py,sha256=oH-D2pJrrOzZuYNUrnBlJhwnSz5WUcud8_pAZs1M8KA,50423
+ultralytics/utils/__init__.py,sha256=ZtidK2cfc4G3z9EfG2oDuJRjWaf9rIl2CnWyz5vP2q8,50429
 ultralytics/utils/autobatch.py,sha256=VZTIKLWeFZFwBHJmbiCn3MaxoFp89hLR0DSCR_iLXJg,4913
 ultralytics/utils/benchmarks.py,sha256=L7rpcnVAnk2doGNJMhXcDqypPLiz0taZ3bDv850IZkU,30404
-ultralytics/utils/checks.py,sha256=lE1V-lkvEd8sUYKYfgt3YJoqWd3dJT5-1DeHAQTMm88,32541
+ultralytics/utils/checks.py,sha256=5J5az856JIBdWkVjnwd6mCPWKhvwUTrWJPd1ZI27puw,32556
 ultralytics/utils/dist.py,sha256=e-DK_YowV7D9rDGQyWR9Kaosxp2eWe2EogSWnnUMthc,4098
 ultralytics/utils/downloads.py,sha256=Bxg9i0coiQTaYztYtc1tXKH3qpg8lV-ywXPSbT121hU,22125
 ultralytics/utils/errors.py,sha256=vY9h2evFSrHnZdHJVVrmm8Zzw4qVDLyo9DeYW5g0dFk,1573
 ultralytics/utils/export.py,sha256=mTkebwilsT1jwIfTLgAQdkbrnZr9Sm96W-Vi7B1j5wQ,8817
 ultralytics/utils/files.py,sha256=0K4O1cgqRiXaDw7EQK13TqA5SME_RrvfDVQSPetNr5w,8042
 ultralytics/utils/instance.py,sha256=UOEsXR9V-bXNRk6BTonASBEgeMqvzzAk4S7VdXZJUAM,18090
-ultralytics/utils/loss.py,sha256=us3lwmSlIwEzoMztNjpet7Kb1r1-sMGyESykqgYPDVo,36945
+ultralytics/utils/loss.py,sha256=iIDVMX2nKRGi6oEv1mu86ewZtNphNK-KWkqWF5bDo6A,37477
 ultralytics/utils/metrics.py,sha256=uv5O-2Ft8wYfTvDedFxiUqMZ6Nr2CL6I9ybGZiK3e2s,53773
-ultralytics/utils/ops.py,sha256=Fkbd91djIdf8npXRTLzUQMWsNak3aQKANFTTnOxl77Y,34783
-ultralytics/utils/patches.py,sha256=qArRoYscf7jph-OwIYJAAkOB5bAM6pcktgXKc76A8HE,4860
+ultralytics/utils/ops.py,sha256=8VoH9Gw20DmJsK5IFRLxpq9At61ESuzD99gwu4XcJLg,34783
+ultralytics/utils/patches.py,sha256=6rVT-l8WDp_Py3O-gZdv9t3PnrYRRkrX_lF3mZ1XS8c,4928
 ultralytics/utils/plotting.py,sha256=5QPK1y-gm4T1mK3sjfRZhIUJAyP05D1cJ7h9wHPTifU,46616
 ultralytics/utils/tal.py,sha256=P5nPoR9qNnFuDIda0fsn8WP6m1V8r7EbvXUuhNRFFTA,20805
 ultralytics/utils/torch_utils.py,sha256=OqH2yNSghs0JSq16Br_PDBnVed5ZRs0C58zDZDk_bqA,38888
@@ -251,9 +251,9 @@ ultralytics/utils/callbacks/neptune.py,sha256=JaI95Cj2kIjUhlEEOiDN0-Drc-fDelLhNI
 ultralytics/utils/callbacks/raytune.py,sha256=A8amUGpux7dYES-L1iSeMoMXBySGWCD1aUqT7vcG-pU,1284
 ultralytics/utils/callbacks/tensorboard.py,sha256=jgYnym3cUQFAgN1GzTyO7l3jINtfAh8zhrllDvnLuVQ,5339
 ultralytics/utils/callbacks/wb.py,sha256=iDRFXI4IIDm8R5OI89DMTmjs8aHLo1HRCLkOFKdaMG4,7507
-ultralytics-8.3.114.dist-info/licenses/LICENSE,sha256=DZak_2itbUtvHzD3E7GNUYSRK6jdOJ-GqncQ2weavLA,34523
-ultralytics-8.3.114.dist-info/METADATA,sha256=tMAyCuNauy-ZB4hDNUQT3FJ453ZeCRGXTc5G2MddF3Y,37354
-ultralytics-8.3.114.dist-info/WHEEL,sha256=pxyMxgL8-pra_rKaQ4drOZAegBVuX-G_4nRHjjgWbmo,91
-ultralytics-8.3.114.dist-info/entry_points.txt,sha256=YM_wiKyTe9yRrsEfqvYolNO5ngwfoL4-NwgKzc8_7sI,93
-ultralytics-8.3.114.dist-info/top_level.txt,sha256=XP49TwiMw4QGsvTLSYiJhz1xF_k7ev5mQ8jJXaXi45Q,12
-ultralytics-8.3.114.dist-info/RECORD,,
+ultralytics-8.3.116.dist-info/licenses/LICENSE,sha256=DZak_2itbUtvHzD3E7GNUYSRK6jdOJ-GqncQ2weavLA,34523
+ultralytics-8.3.116.dist-info/METADATA,sha256=G56kvxZhZ2tX9R0P3vpTXGSRtQG0fa_JgobxETJLc5k,37354
+ultralytics-8.3.116.dist-info/WHEEL,sha256=SmOxYU7pzNKBqASvQJ7DjX3XGUF92lrGhMb3R6_iiqI,91
+ultralytics-8.3.116.dist-info/entry_points.txt,sha256=YM_wiKyTe9yRrsEfqvYolNO5ngwfoL4-NwgKzc8_7sI,93
+ultralytics-8.3.116.dist-info/top_level.txt,sha256=XP49TwiMw4QGsvTLSYiJhz1xF_k7ev5mQ8jJXaXi45Q,12
+ultralytics-8.3.116.dist-info/RECORD,,

{ultralytics-8.3.114.dist-info → ultralytics-8.3.116.dist-info}/WHEEL

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