ultralytics 8.3.119__tar.gz → 8.3.121__tar.gz

{ultralytics-8.3.119/ultralytics.egg-info → ultralytics-8.3.121}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ultralytics
-Version: 8.3.119
+Version: 8.3.121
 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.119 → ultralytics-8.3.121}/ultralytics/__init__.py

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

{ultralytics-8.3.119 → ultralytics-8.3.121}/ultralytics/data/augment.py

@@ -439,7 +439,7 @@ class BaseMixTransform:
             >>> indexes = transform.get_indexes()
             >>> print(indexes)  # [3, 18, 7, 2]
         """
-        raise NotImplementedError
+        return random.randint(0, len(self.dataset) - 1)
 
     @staticmethod
     def _update_label_text(labels):
@@ -877,7 +877,6 @@ class MixUp(BaseMixTransform):
         p (float): Probability of applying MixUp augmentation.
 
     Methods:
-        get_indexes: Returns a random index from the dataset.
         _mix_transform: Applies MixUp augmentation to the input labels.
 
     Examples:
@@ -906,24 +905,6 @@ class MixUp(BaseMixTransform):
         """
         super().__init__(dataset=dataset, pre_transform=pre_transform, p=p)
 
-    def get_indexes(self):
-        """
-        Get a random index from the dataset.
-
-        This method returns a single random index from the dataset, which is used to select an image for MixUp
-        augmentation.
-
-        Returns:
-            (int): A random integer index within the range of the dataset length.
-
-        Examples:
-            >>> mixup = MixUp(dataset)
-            >>> index = mixup.get_indexes()
-            >>> print(index)
-            42
-        """
-        return random.randint(0, len(self.dataset) - 1)
-
     def _mix_transform(self, labels):
         """
         Applies MixUp augmentation to the input labels.
@@ -961,9 +942,9 @@ class CutMix(BaseMixTransform):
         pre_transform (Callable | None): Optional transform to apply before CutMix.
         p (float): Probability of applying CutMix augmentation.
         beta (float): Beta distribution parameter for sampling the mixing ratio (default=1.0).
+        num_areas (int): Number of areas to try to cut and mix (default=3).
 
     Methods:
-        get_indexes: Returns a random index from the dataset.
         _mix_transform: Applies CutMix augmentation to the input labels.
         _rand_bbox: Generates random bounding box coordinates for the cut region.
 
@@ -974,7 +955,7 @@ class CutMix(BaseMixTransform):
         >>> augmented_labels = cutmix(original_labels)
     """
 
-    def __init__(self, dataset, pre_transform=None, p=0.0, beta=1.0) -> None:
+    def __init__(self, dataset, pre_transform=None, p=0.0, beta=1.0, num_areas=3) -> None:
         """
         Initializes the CutMix augmentation object.
 
@@ -983,31 +964,26 @@ class CutMix(BaseMixTransform):
             pre_transform (Callable | None): Optional transform to apply before CutMix.
             p (float): Probability of applying CutMix augmentation.
             beta (float): Beta distribution parameter for sampling the mixing ratio (default=1.0).
+            num_areas (int): Number of areas to try to cut and mix (default=3).
         """
         super().__init__(dataset=dataset, pre_transform=pre_transform, p=p)
         self.beta = beta
+        self.num_areas = num_areas
 
-    def get_indexes(self):
-        """
-        Get a random index from the dataset.
-
-        Returns:
-            (int): A random integer index within the range of the dataset length.
-        """
-        return random.randint(0, len(self.dataset) - 1)
-
-    def _rand_bbox(self, width, height, lam):
+    def _rand_bbox(self, width, height):
         """
         Generates random bounding box coordinates for the cut region.
 
         Args:
             width (int): Width of the image.
             height (int): Height of the image.
-            lam (float): Mixing ratio from the Beta distribution.
 
         Returns:
             (tuple): (x1, y1, x2, y2) coordinates of the bounding box.
         """
+        # Sample mixing ratio from Beta distribution
+        lam = np.random.beta(self.beta, self.beta)
+
         cut_ratio = np.sqrt(1.0 - lam)
         cut_w = int(width * cut_ratio)
         cut_h = int(height * cut_ratio)
@@ -1038,25 +1014,37 @@ class CutMix(BaseMixTransform):
             >>> cutter = CutMix(dataset)
             >>> mixed_labels = cutter._mix_transform(labels)
         """
-        # Sample mixing ratio from Beta distribution
-        lam = np.random.beta(self.beta, self.beta)
-
         # Get a random second image
-        labels2 = labels["mix_labels"][0]
-        img2 = labels2["img"]
         h, w = labels["img"].shape[:2]
 
-        # Generate random bounding box
-        x1, y1, x2, y2 = self._rand_bbox(w, h, lam)
+        cut_areas = np.asarray([self._rand_bbox(w, h) for _ in range(self.num_areas)], dtype=np.float32)
+        ioa1 = bbox_ioa(cut_areas, labels["instances"].bboxes)  # (self.num_areas, num_boxes)
+        idx = np.nonzero(ioa1.sum(axis=1) <= 0)[0]
+        if len(idx) == 0:
+            return labels
+
+        labels2 = labels.pop("mix_labels")[0]
+        area = cut_areas[np.random.choice(idx)]  # randomle select one
+        ioa2 = bbox_ioa(area[None], labels2["instances"].bboxes).squeeze(0)
+        indexes2 = np.nonzero(ioa2 >= (0.01 if len(labels["instances"].segments) else 0.1))[0]
+        if len(indexes2) == 0:
+            return labels
+
+        instances2 = labels2["instances"][indexes2]
+        instances2.convert_bbox("xyxy")
+        instances2.denormalize(w, h)
 
         # Apply CutMix
-        labels["img"][y1:y2, x1:x2] = img2[y1:y2, x1:x2]
+        x1, y1, x2, y2 = area.astype(np.int32)
+        labels["img"][y1:y2, x1:x2] = labels2["img"][y1:y2, x1:x2]
 
-        # Adjust lambda to match the actual area ratio
-        lam = 1 - ((x2 - x1) * (y2 - y1) / (w * h))
+        # Restrain instances2 to the random bounding border
+        instances2.add_padding(-x1, -y1)
+        instances2.clip(x2 - x1, y2 - y1)
+        instances2.add_padding(x1, y1)
 
-        labels["cls"] = np.concatenate([labels["cls"], labels2["cls"]], axis=0)
-        labels["instances"] = Instances.concatenate([labels["instances"], labels2["instances"]], axis=0)
+        labels["cls"] = np.concatenate([labels["cls"], labels2["cls"][indexes2]], axis=0)
+        labels["instances"] = Instances.concatenate([labels["instances"], instances2], axis=0)
         return labels
 
 
@@ -1766,7 +1754,6 @@ class CopyPaste(BaseMixTransform):
         p (float): Probability of applying Copy-Paste augmentation.
 
     Methods:
-        get_indexes: Returns a random index from the dataset.
         _mix_transform: Applies Copy-Paste augmentation to the input labels.
         __call__: Applies the Copy-Paste transformation to images and annotations.
 
@@ -1783,10 +1770,6 @@ class CopyPaste(BaseMixTransform):
         assert mode in {"flip", "mixup"}, f"Expected `mode` to be `flip` or `mixup`, but got {mode}."
         self.mode = mode
 
-    def get_indexes(self):
-        """Returns a list of random indexes from the dataset for CopyPaste augmentation."""
-        return random.randint(0, len(self.dataset) - 1)
-
     def _mix_transform(self, labels):
         """Applies Copy-Paste augmentation to combine objects from another image into the current image."""
         labels2 = labels["mix_labels"][0]

{ultralytics-8.3.119 → ultralytics-8.3.121}/ultralytics/data/dataset.py

@@ -443,7 +443,7 @@ class GroundingDataset(YOLODataset):
         """
         assert task in {"detect", "segment"}, "GroundingDataset currently only supports `detect` and `segment` tasks"
         self.json_file = json_file
-        super().__init__(*args, task=task, data={}, **kwargs)
+        super().__init__(*args, task=task, data={"channels": 3}, **kwargs)
 
     def get_img_files(self, img_path):
         """

{ultralytics-8.3.119 → ultralytics-8.3.121}/ultralytics/engine/exporter.py

@@ -636,6 +636,8 @@ class Exporter:
         if self.args.int8:
             fq = str(self.file).replace(self.file.suffix, f"_int8_openvino_model{os.sep}")
             fq_ov = str(Path(fq) / self.file.with_suffix(".xml").name)
+            # INT8 requires nncf, nncf requires packaging>=23.2 https://github.com/openvinotoolkit/nncf/issues/3463
+            check_requirements("packaging>=23.2")  # must be installed first to build nncf wheel
             check_requirements("nncf>=2.14.0")
             import nncf
 

{ultralytics-8.3.119 → ultralytics-8.3.121}/ultralytics/models/utils/loss.py

@@ -58,7 +58,7 @@ class DETRLoss(nn.Module):
             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.
+            alpha (float | list): The balancing factor used to address class imbalance.
         """
         super().__init__()
 

{ultralytics-8.3.119 → ultralytics-8.3.121}/ultralytics/models/yolo/world/train_world.py

@@ -3,7 +3,7 @@
 from ultralytics.data import YOLOConcatDataset, build_grounding, build_yolo_dataset
 from ultralytics.data.utils import check_det_dataset
 from ultralytics.models.yolo.world import WorldTrainer
-from ultralytics.utils import DEFAULT_CFG
+from ultralytics.utils import DEFAULT_CFG, LOGGER
 from ultralytics.utils.torch_utils import de_parallel
 
 
@@ -93,14 +93,14 @@ class WorldTrainerFromScratch(WorldTrainer):
         """
         gs = max(int(de_parallel(self.model).stride.max() if self.model else 0), 32)
         if mode != "train":
-            return build_yolo_dataset(self.args, img_path, batch, self.data, mode=mode, rect=mode == "val", stride=gs)
-        dataset = [
-            build_yolo_dataset(self.args, im_path, batch, self.data, stride=gs, multi_modal=True)
+            return build_yolo_dataset(self.args, img_path, batch, self.data, mode=mode, rect=False, stride=gs)
+        datasets = [
+            build_yolo_dataset(self.args, im_path, batch, self.training_data[im_path], stride=gs, multi_modal=True)
             if isinstance(im_path, str)
             else build_grounding(self.args, im_path["img_path"], im_path["json_file"], batch, stride=gs)
             for im_path in img_path
         ]
-        return YOLOConcatDataset(dataset) if len(dataset) > 1 else dataset[0]
+        return YOLOConcatDataset(datasets) if len(datasets) > 1 else datasets[0]
 
     def get_dataset(self):
         """
@@ -140,8 +140,20 @@ class WorldTrainerFromScratch(WorldTrainer):
         # NOTE: to make training work properly, set `nc` and `names`
         final_data["nc"] = data["val"][0]["nc"]
         final_data["names"] = data["val"][0]["names"]
+        # NOTE: add path with lvis path
+        final_data["path"] = data["val"][0]["path"]
         final_data["channels"] = data["val"][0]["channels"]
         self.data = final_data
+        if self.args.single_cls:  # consistent with base trainer
+            LOGGER.info("Overriding class names with single class.")
+            self.data["names"] = {0: "object"}
+            self.data["nc"] = 1
+        self.training_data = {}
+        for d in data["train"]:
+            if self.args.single_cls:
+                d["names"] = {0: "object"}
+                d["nc"] = 1
+            self.training_data[d["train"]] = d
         return final_data["train"], final_data["val"][0]
 
     def plot_training_labels(self):

{ultralytics-8.3.119 → ultralytics-8.3.121}/ultralytics/models/yolo/yoloe/__init__.py

@@ -1,7 +1,7 @@
 # Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
 
 from .predict import YOLOEVPDetectPredictor, YOLOEVPSegPredictor
-from .train import YOLOEPEFreeTrainer, YOLOEPETrainer, YOLOETrainer, YOLOEVPTrainer
+from .train import YOLOEPEFreeTrainer, YOLOEPETrainer, YOLOETrainer, YOLOETrainerFromScratch, YOLOEVPTrainer
 from .train_seg import YOLOEPESegTrainer, YOLOESegTrainer, YOLOESegTrainerFromScratch, YOLOESegVPTrainer
 from .val import YOLOEDetectValidator, YOLOESegValidator
 
@@ -18,4 +18,5 @@ __all__ = [
     "YOLOEPEFreeTrainer",
     "YOLOEVPDetectPredictor",
     "YOLOEVPSegPredictor",
+    "YOLOETrainerFromScratch",
 ]

{ultralytics-8.3.119 → ultralytics-8.3.121}/ultralytics/models/yolo/yoloe/train.py

@@ -6,14 +6,14 @@ from pathlib import Path
 
 import torch
 
-from ultralytics.data import YOLOConcatDataset, build_grounding, build_yolo_dataset
+from ultralytics.data import YOLOConcatDataset, build_yolo_dataset
 from ultralytics.data.augment import LoadVisualPrompt
-from ultralytics.data.utils import check_det_dataset
 from ultralytics.models.yolo.detect import DetectionTrainer, DetectionValidator
 from ultralytics.nn.tasks import YOLOEModel
 from ultralytics.utils import DEFAULT_CFG, LOGGER, RANK
 from ultralytics.utils.torch_utils import de_parallel
 
+from ..world.train_world import WorldTrainerFromScratch
 from .val import YOLOEDetectValidator
 
 
@@ -92,11 +92,6 @@ class YOLOETrainer(DetectionTrainer):
             self.args, img_path, batch, self.data, mode=mode, rect=mode == "val", stride=gs, multi_modal=mode == "train"
         )
 
-    def preprocess_batch(self, batch):
-        """Process batch for training, moving text features to the appropriate device."""
-        batch = super().preprocess_batch(batch)
-        return batch
-
 
 class YOLOEPETrainer(DetectionTrainer):
     """Fine-tune YOLOE model in linear probing way."""
@@ -144,30 +139,9 @@ class YOLOEPETrainer(DetectionTrainer):
         return model
 
 
-class YOLOETrainerFromScratch(YOLOETrainer):
+class YOLOETrainerFromScratch(YOLOETrainer, WorldTrainerFromScratch):
     """Train YOLOE models from scratch."""
 
-    def __init__(self, cfg=DEFAULT_CFG, overrides=None, _callbacks=None):
-        """
-        Initialize the YOLOETrainerFromScratch class.
-
-        This class extends YOLOETrainer to train YOLOE models from scratch. It inherits all functionality from
-        the parent class while providing specialized initialization for training without pre-trained weights.
-
-        Args:
-            cfg (dict, optional): Configuration dictionary with training parameters. Defaults to DEFAULT_CFG.
-            overrides (dict, optional): Dictionary of parameter overrides for configuration.
-            _callbacks (list, optional): List of callback functions to be executed during training.
-
-        Examples:
-            >>> from ultralytics.models.yoloe.train import YOLOETrainerFromScratch
-            >>> trainer = YOLOETrainerFromScratch()
-            >>> trainer.train()
-        """
-        if overrides is None:
-            overrides = {}
-        super().__init__(cfg, overrides, _callbacks)
-
     def build_dataset(self, img_path, mode="train", batch=None):
         """
         Build YOLO Dataset for training or validation.
@@ -183,17 +157,12 @@ class YOLOETrainerFromScratch(YOLOETrainer):
         Returns:
             (YOLOConcatDataset | Dataset): The constructed dataset for training or validation.
         """
-        gs = max(int(de_parallel(self.model).stride.max() if self.model else 0), 32)
-        if mode != "train":
-            return build_yolo_dataset(self.args, img_path, batch, self.data, mode=mode, rect=False, stride=gs)
-        datasets = [
-            build_yolo_dataset(self.args, im_path, batch, self.training_data[im_path], stride=gs, multi_modal=True)
-            if isinstance(im_path, str)
-            else build_grounding(self.args, im_path["img_path"], im_path["json_file"], batch, stride=gs)
-            for im_path in img_path
-        ]
-        self.set_text_embeddings(datasets, batch)  # cache text embeddings to accelerate training
-        return YOLOConcatDataset(datasets) if len(datasets) > 1 else datasets[0]
+        datasets = WorldTrainerFromScratch.build_dataset(self, img_path, mode, batch)
+        if mode == "train":
+            self.set_text_embeddings(
+                datasets.datasets if hasattr(datasets, "datasets") else [datasets], batch
+            )  # cache text embeddings to accelerate training
+        return datasets
 
     def set_text_embeddings(self, datasets, batch):
         """
@@ -225,7 +194,7 @@ class YOLOETrainerFromScratch(YOLOETrainer):
 
     def preprocess_batch(self, batch):
         """Process batch for training, moving text features to the appropriate device."""
-        batch = super().preprocess_batch(batch)
+        batch = DetectionTrainer.preprocess_batch(self, batch)
 
         texts = list(itertools.chain(*batch["texts"]))
         txt_feats = torch.stack([self.text_embeddings[text] for text in texts]).to(self.device)
@@ -246,6 +215,7 @@ class YOLOETrainerFromScratch(YOLOETrainer):
             (dict): Dictionary mapping text samples to their embeddings.
         """
         if cache_path.exists():
+            LOGGER.info(f"Reading existed cache from '{cache_path}'")
             return torch.load(cache_path)
         assert self.model is not None
         txt_feats = self.model.get_text_pe(texts, batch, without_reprta=True)
@@ -253,77 +223,6 @@ class YOLOETrainerFromScratch(YOLOETrainer):
         torch.save(txt_map, cache_path)
         return txt_map
 
-    def get_dataset(self):
-        """
-        Get train and validation paths from data dictionary.
-
-        Processes the data configuration to extract paths for training and validation datasets,
-        handling both YOLO detection datasets and grounding datasets.
-
-        Returns:
-            (str): Train dataset path.
-            (str): Validation dataset path.
-
-        Raises:
-            AssertionError: If train or validation datasets are not found, or if validation has multiple datasets.
-        """
-        final_data = {}
-        data_yaml = self.args.data
-        assert data_yaml.get("train", False), "train dataset not found"  # object365.yaml
-        assert data_yaml.get("val", False), "validation dataset not found"  # lvis.yaml
-        data = {k: [check_det_dataset(d) for d in v.get("yolo_data", [])] for k, v in data_yaml.items()}
-        assert len(data["val"]) == 1, f"Only support validating on 1 dataset for now, but got {len(data['val'])}."
-        val_split = "minival" if "lvis" in data["val"][0]["val"] else "val"
-        for d in data["val"]:
-            if d.get("minival") is None:  # for lvis dataset
-                continue
-            d["minival"] = str(d["path"] / d["minival"])
-        for s in ["train", "val"]:
-            final_data[s] = [d["train" if s == "train" else val_split] for d in data[s]]
-            # save grounding data if there's one
-            grounding_data = data_yaml[s].get("grounding_data")
-            if grounding_data is None:
-                continue
-            grounding_data = grounding_data if isinstance(grounding_data, list) else [grounding_data]
-            for g in grounding_data:
-                assert isinstance(g, dict), f"Grounding data should be provided in dict format, but got {type(g)}"
-            final_data[s] += grounding_data
-        # NOTE: to make training work properly, set `nc` and `names`
-        final_data["nc"] = data["val"][0]["nc"]
-        final_data["names"] = data["val"][0]["names"]
-        # NOTE: add path with lvis path
-        final_data["path"] = data["val"][0]["path"]
-        self.data = final_data
-        if self.args.single_cls:  # consistent with base trainer
-            LOGGER.info("Overriding class names with single class.")
-            self.data["names"] = {0: "object"}
-            self.data["nc"] = 1
-        self.training_data = {}
-        for d in data["train"]:
-            if self.args.single_cls:
-                d["names"] = {0: "object"}
-                d["nc"] = 1
-            self.training_data[d["train"]] = d
-        return final_data["train"], final_data["val"][0]
-
-    def plot_training_labels(self):
-        """Do not plot labels for YOLO-World training."""
-        pass
-
-    def final_eval(self):
-        """
-        Perform final evaluation on the validation dataset.
-
-        Configures the validator with the appropriate dataset and split before running evaluation.
-
-        Returns:
-            (dict): Evaluation metrics.
-        """
-        val = self.args.data["val"]["yolo_data"][0]
-        self.validator.args.data = val
-        self.validator.args.split = "minival" if isinstance(val, str) and "lvis" in val else "val"
-        return super().final_eval()
-
 
 class YOLOEPEFreeTrainer(YOLOEPETrainer, YOLOETrainerFromScratch):
     """Train prompt-free YOLOE model."""
@@ -337,7 +236,7 @@ class YOLOEPEFreeTrainer(YOLOEPETrainer, YOLOETrainerFromScratch):
 
     def preprocess_batch(self, batch):
         """Preprocesses a batch of images for YOLOE training, adjusting formatting and dimensions as needed."""
-        batch = super(YOLOETrainer, self).preprocess_batch(batch)
+        batch = DetectionTrainer.preprocess_batch(self, batch)
         return batch
 
     def set_text_embeddings(self, datasets, batch):

{ultralytics-8.3.119 → ultralytics-8.3.121}/ultralytics/models/yolo/yoloe/train_seg.py

@@ -5,7 +5,7 @@ from copy import copy, deepcopy
 
 from ultralytics.models.yolo.segment import SegmentationTrainer
 from ultralytics.nn.tasks import YOLOESegModel
-from ultralytics.utils import DEFAULT_CFG, RANK
+from ultralytics.utils import RANK
 
 from .train import YOLOETrainer, YOLOETrainerFromScratch, YOLOEVPTrainer
 from .val import YOLOESegValidator
@@ -24,22 +24,6 @@ class YOLOESegTrainer(YOLOETrainer, SegmentationTrainer):
         _callbacks (list): List of callback functions for training events.
     """
 
-    def __init__(self, cfg=DEFAULT_CFG, overrides=None, _callbacks=None):
-        """
-        Initialize the YOLOESegTrainer class.
-
-        This class combines YOLOETrainer and SegmentationTrainer to provide training functionality
-        specifically for YOLOE segmentation models.
-
-        Args:
-            cfg (Dict): Configuration dictionary with training parameters.
-            overrides (Dict, optional): Dictionary with parameter overrides.
-            _callbacks (List, optional): List of callback functions for training events.
-        """
-        if overrides is None:
-            overrides = {}
-        super().__init__(cfg, overrides, _callbacks)
-
     def get_model(self, cfg=None, weights=None, verbose=True):
         """
         Return YOLOESegModel initialized with specified config and weights.

{ultralytics-8.3.119 → ultralytics-8.3.121}/ultralytics/trackers/bot_sort.py

@@ -17,7 +17,7 @@ from .utils.kalman_filter import KalmanFilterXYWH
 
 class BOTrack(STrack):
     """
-    An extended version of the STrack class for YOLOv8, adding object tracking features.
+    An extended version of the STrack class for YOLO, adding object tracking features.
 
     This class extends the STrack class to include additional functionalities for object tracking, such as feature
     smoothing, Kalman filter prediction, and reactivation of tracks.
@@ -150,7 +150,7 @@ class BOTrack(STrack):
 
 class BOTSORT(BYTETracker):
     """
-    An extended version of the BYTETracker class for YOLOv8, designed for object tracking with ReID and GMC algorithm.
+    An extended version of the BYTETracker class for YOLO, designed for object tracking with ReID and GMC algorithm.
 
     Attributes:
         proximity_thresh (float): Threshold for spatial proximity (IoU) between tracks and detections.
@@ -163,7 +163,7 @@ class BOTSORT(BYTETracker):
         get_kalmanfilter: Return an instance of KalmanFilterXYWH for object tracking.
         init_track: Initialize track with detections, scores, and classes.
         get_dists: Get distances between tracks and detections using IoU and (optionally) ReID.
-        multi_predict: Predict and track multiple objects with YOLOv8 model.
+        multi_predict: Predict and track multiple objects with a YOLO model.
         reset: Reset the BOTSORT tracker to its initial state.
 
     Examples:
@@ -173,7 +173,7 @@ class BOTSORT(BYTETracker):
         >>> bot_sort.multi_predict(tracks)
 
     Note:
-        The class is designed to work with the YOLOv8 object detection model and supports ReID only if enabled via args.
+        The class is designed to work with a YOLO object detection model and supports ReID only if enabled via args.
     """
 
     def __init__(self, args, frame_rate=30):
@@ -197,7 +197,7 @@ class BOTSORT(BYTETracker):
         self.appearance_thresh = args.appearance_thresh
         self.encoder = (
             (lambda feats, s: [f.cpu().numpy() for f in feats])  # native features do not require any model
-            if self.args.model == "auto"
+            if args.with_reid and self.args.model == "auto"
             else ReID(args.model)
             if args.with_reid
             else None

{ultralytics-8.3.119 → ultralytics-8.3.121}/ultralytics/utils/downloads.py

@@ -320,9 +320,10 @@ def safe_download(
         LOGGER.info(f"{desc}...")
         f.parent.mkdir(parents=True, exist_ok=True)  # make directory if missing
         check_disk_space(url, path=f.parent)
+        curl_installed = shutil.which("curl")
         for i in range(retry + 1):
             try:
-                if curl or i > 0:  # curl download with retry, continue
+                if (curl or i > 0) and curl_installed:  # curl download with retry, continue
                     s = "sS" * (not progress)  # silent
                     r = subprocess.run(["curl", "-#", f"-{s}L", url, "-o", f, "--retry", "3", "-C", "-"]).returncode
                     assert r == 0, f"Curl return value {r}"

{ultralytics-8.3.119 → ultralytics-8.3.121}/ultralytics/utils/export.py

@@ -167,7 +167,7 @@ def export_engine(
                 trt.IInt8Calibrator.__init__(self)
                 self.dataset = dataset
                 self.data_iter = iter(dataset)
-                self.algo = trt.CalibrationAlgoType.ENTROPY_CALIBRATION_2
+                self.algo = trt.CalibrationAlgoType.MINMAX_CALIBRATION
                 self.batch = dataset.batch_size
                 self.cache = Path(cache)
 

{ultralytics-8.3.119 → ultralytics-8.3.121}/ultralytics/utils/loss.py

@@ -48,14 +48,14 @@ class FocalLoss(nn.Module):
 
     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.
+        alpha (float | list): 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
+        self.alpha = torch.tensor(alpha)
 
     def forward(self, pred, label):
         """Calculate focal loss with modulating factors for class imbalance."""
@@ -68,7 +68,8 @@ class FocalLoss(nn.Module):
         p_t = label * pred_prob + (1 - label) * (1 - pred_prob)
         modulating_factor = (1.0 - p_t) ** self.gamma
         loss *= modulating_factor
-        if self.alpha > 0:
+        if (self.alpha > 0).any():
+            self.alpha = self.alpha.to(device=pred.device, dtype=pred.dtype)
             alpha_factor = label * self.alpha + (1 - label) * (1 - self.alpha)
             loss *= alpha_factor
         return loss.mean(1).sum()
@@ -794,15 +795,16 @@ class TVPSegmentLoss(TVPDetectLoss):
 
     def __init__(self, model):
         """Initialize TVPSegmentLoss with task-prompt and visual-prompt criteria using the provided model."""
+        super().__init__(model)
         self.vp_criterion = v8SegmentationLoss(model)
 
     def __call__(self, preds, batch):
         """Calculate the loss for text-visual prompt segmentation."""
         feats, pred_masks, proto = preds if len(preds) == 3 else preds[1]
-        assert self.tp_criterion.reg_max == self.vp_criterion.reg_max
+        assert self.ori_reg_max == self.vp_criterion.reg_max  # TODO: remove it
 
-        if self.tp_criterion.reg_max * 4 + self.tp_criterion.nc == feats[0].shape[1]:
-            loss = torch.zeros(4, device=self.tp_criterion.device, requires_grad=True)
+        if self.ori_reg_max * 4 + self.ori_nc == feats[0].shape[1]:
+            loss = torch.zeros(4, device=self.vp_criterion.device, requires_grad=True)
             return loss, loss.detach()
 
         vp_feats = self._get_vp_features(feats)

{ultralytics-8.3.119 → ultralytics-8.3.121/ultralytics.egg-info}/PKG-INFO

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