ultralytics 8.3.115__tar.gz → 8.3.116__tar.gz

{ultralytics-8.3.115/ultralytics.egg-info → ultralytics-8.3.116}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ultralytics
-Version: 8.3.115
+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.115 → ultralytics-8.3.116}/tests/test_python.py

@@ -128,7 +128,7 @@ def test_predict_img(model_name):
         Image.open(SOURCE),  # PIL
         np.zeros((320, 640, 3), dtype=np.uint8),  # numpy
     ]
-    assert len(model(batch, imgsz=32)) == len(batch)  # multiple sources in a batch
+    assert len(model(batch, imgsz=32, classes=0)) == len(batch)  # multiple sources in a batch
 
 
 @pytest.mark.parametrize("model", MODELS)

{ultralytics-8.3.115 → ultralytics-8.3.116}/ultralytics/__init__.py

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

{ultralytics-8.3.115 → ultralytics-8.3.116}/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-8.3.115 → ultralytics-8.3.116}/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-8.3.115 → ultralytics-8.3.116}/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-8.3.115 → ultralytics-8.3.116}/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-8.3.115 → ultralytics-8.3.116}/ultralytics/data/utils.py

@@ -483,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-8.3.115 → ultralytics-8.3.116}/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-8.3.115 → ultralytics-8.3.116}/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-8.3.115 → ultralytics-8.3.116}/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-8.3.115 → ultralytics-8.3.116}/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-8.3.115 → ultralytics-8.3.116}/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-8.3.115 → ultralytics-8.3.116}/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-8.3.115 → ultralytics-8.3.116}/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-8.3.115 → ultralytics-8.3.116}/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-8.3.115 → ultralytics-8.3.116}/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-8.3.115 → ultralytics-8.3.116}/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-8.3.115 → ultralytics-8.3.116}/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-8.3.115 → ultralytics-8.3.116}/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-8.3.115 → ultralytics-8.3.116}/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-8.3.115 → ultralytics-8.3.116}/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-8.3.115 → ultralytics-8.3.116}/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-8.3.115 → ultralytics-8.3.116}/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-8.3.115 → ultralytics-8.3.116}/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-8.3.115 → ultralytics-8.3.116}/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-8.3.115 → ultralytics-8.3.116}/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-8.3.115 → ultralytics-8.3.116}/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-8.3.115 → ultralytics-8.3.116}/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-8.3.115 → ultralytics-8.3.116/ultralytics.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ultralytics
-Version: 8.3.115
+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>