dgenerate-ultralytics-headless 8.3.194__py3-none-any.whl → 8.3.196__py3-none-any.whl

ultralytics/utils/__init__.py

@@ -857,7 +857,7 @@ def get_ubuntu_version():
 
 def get_user_config_dir(sub_dir="Ultralytics"):
     """
-    Return the appropriate config directory based on the environment operating system.
+    Return a writable config dir, preferring YOLO_CONFIG_DIR and being OS-aware.
 
     Args:
         sub_dir (str): The name of the subdirectory to create.
@@ -865,27 +865,38 @@ def get_user_config_dir(sub_dir="Ultralytics"):
     Returns:
         (Path): The path to the user config directory.
     """
-    if WINDOWS:
-        path = Path.home() / "AppData" / "Roaming" / sub_dir
-    elif MACOS:  # macOS
-        path = Path.home() / "Library" / "Application Support" / sub_dir
+    if env_dir := os.getenv("YOLO_CONFIG_DIR"):
+        p = Path(env_dir).expanduser() / sub_dir
     elif LINUX:
-        path = Path.home() / ".config" / sub_dir
+        p = Path(os.getenv("XDG_CONFIG_HOME", Path.home() / ".config")) / sub_dir
+    elif WINDOWS:
+        p = Path.home() / "AppData" / "Roaming" / sub_dir
+    elif MACOS:
+        p = Path.home() / "Library" / "Application Support" / sub_dir
     else:
         raise ValueError(f"Unsupported operating system: {platform.system()}")
 
-    # GCP and AWS lambda fix, only /tmp is writeable
-    if not is_dir_writeable(path.parent):
-        LOGGER.warning(
-            f"user config directory '{path}' is not writeable, defaulting to '/tmp' or CWD. "
-            "Alternatively you can define a YOLO_CONFIG_DIR environment variable for this path."
-        )
-        path = Path("/tmp") / sub_dir if is_dir_writeable("/tmp") else Path().cwd() / sub_dir
-
-    # Create the subdirectory if it does not exist
-    path.mkdir(parents=True, exist_ok=True)
+    if p.exists():  # already created → trust it
+        return p
+    if is_dir_writeable(p.parent):  # create if possible
+        p.mkdir(parents=True, exist_ok=True)
+        return p
+
+    # Fallbacks for Docker, GCP/AWS functions where only /tmp is writeable
+    for alt in [Path("/tmp") / sub_dir, Path.cwd() / sub_dir]:
+        if alt.exists():
+            return alt
+        if is_dir_writeable(alt.parent):
+            alt.mkdir(parents=True, exist_ok=True)
+            LOGGER.warning(
+                f"user config directory '{p}' is not writeable, using '{alt}'. Set YOLO_CONFIG_DIR to override."
+            )
+            return alt
 
-    return path
+    # Last fallback → CWD
+    p = Path.cwd() / sub_dir
+    p.mkdir(parents=True, exist_ok=True)
+    return p
 
 
 # Define constants (required below)
@@ -899,7 +910,7 @@ IS_JUPYTER = is_jupyter()
 IS_PIP_PACKAGE = is_pip_package()
 IS_RASPBERRYPI = is_raspberrypi()
 GIT = GitRepo()
-USER_CONFIG_DIR = Path(os.getenv("YOLO_CONFIG_DIR") or get_user_config_dir())  # Ultralytics settings dir
+USER_CONFIG_DIR = get_user_config_dir()  # Ultralytics settings dir
 SETTINGS_FILE = USER_CONFIG_DIR / "settings.json"
 
 
@@ -1383,7 +1394,7 @@ class SettingsManager(JSONDict):
 
 def deprecation_warn(arg, new_arg=None):
     """Issue a deprecation warning when a deprecated argument is used, suggesting an updated argument."""
-    msg = f"'{arg}' is deprecated and will be removed in in the future."
+    msg = f"'{arg}' is deprecated and will be removed in the future."
     if new_arg is not None:
         msg += f" Use '{new_arg}' instead."
     LOGGER.warning(msg)

ultralytics/utils/autodevice.py

@@ -23,7 +23,7 @@ class GPUInfo:
         pynvml (module | None): The `pynvml` module if successfully imported and initialized, otherwise `None`.
         nvml_available (bool): Indicates if `pynvml` is ready for use. True if import and `nvmlInit()` succeeded,
             False otherwise.
-        gpu_stats (List[Dict[str, Any]]): A list of dictionaries, each holding stats for one GPU. Populated on
+        gpu_stats (list[dict[str, Any]]): A list of dictionaries, each holding stats for one GPU. Populated on
             initialization and by `refresh_stats()`. Keys include: 'index', 'name', 'utilization' (%),
             'memory_used' (MiB), 'memory_total' (MiB), 'memory_free' (MiB), 'temperature' (C), 'power_draw' (W),
             'power_limit' (W or 'N/A'). Empty if NVML is unavailable or queries fail.
@@ -146,7 +146,7 @@ class GPUInfo:
             min_util_fraction (float): Minimum free utilization rate required from 0.0 - 1.0.
 
         Returns:
-            (List[int]): Indices of the selected GPUs, sorted by idleness (lowest utilization first).
+            (list[int]): Indices of the selected GPUs, sorted by idleness (lowest utilization first).
 
         Notes:
              Returns fewer than 'count' if not enough qualify or exist.

ultralytics/utils/benchmarks.py

@@ -226,10 +226,10 @@ class RF100Benchmark:
     This class provides functionality to benchmark YOLO models on the RF100 dataset collection.
 
     Attributes:
-        ds_names (List[str]): Names of datasets used for benchmarking.
-        ds_cfg_list (List[Path]): List of paths to dataset configuration files.
+        ds_names (list[str]): Names of datasets used for benchmarking.
+        ds_cfg_list (list[Path]): List of paths to dataset configuration files.
         rf (Roboflow): Roboflow instance for accessing datasets.
-        val_metrics (List[str]): Metrics used for validation.
+        val_metrics (list[str]): Metrics used for validation.
 
     Methods:
         set_key: Set Roboflow API key for accessing datasets.
@@ -270,8 +270,8 @@ class RF100Benchmark:
             ds_link_txt (str): Path to the file containing dataset links.
 
         Returns:
-            ds_names (List[str]): List of dataset names.
-            ds_cfg_list (List[Path]): List of paths to dataset configuration files.
+            ds_names (list[str]): List of dataset names.
+            ds_cfg_list (list[Path]): List of paths to dataset configuration files.
 
         Examples:
             >>> benchmark = RF100Benchmark()
@@ -372,7 +372,7 @@ class ProfileModels:
     This class profiles the performance of different models, returning results such as model speed and FLOPs.
 
     Attributes:
-        paths (List[str]): Paths of the models to profile.
+        paths (list[str]): Paths of the models to profile.
         num_timed_runs (int): Number of timed runs for the profiling.
         num_warmup_runs (int): Number of warmup runs before profiling.
         min_time (float): Minimum number of seconds to profile for.
@@ -414,7 +414,7 @@ class ProfileModels:
         Initialize the ProfileModels class for profiling models.
 
         Args:
-            paths (List[str]): List of paths of the models to be profiled.
+            paths (list[str]): List of paths of the models to be profiled.
             num_timed_runs (int): Number of timed runs for the profiling.
             num_warmup_runs (int): Number of warmup runs before the actual profiling starts.
             min_time (float): Minimum time in seconds for profiling a model.
@@ -446,7 +446,7 @@ class ProfileModels:
         Profile YOLO models for speed and accuracy across various formats including ONNX and TensorRT.
 
         Returns:
-            (List[dict]): List of dictionaries containing profiling results for each model.
+            (list[dict]): List of dictionaries containing profiling results for each model.
 
         Examples:
             Profile models and print results
@@ -501,7 +501,7 @@ class ProfileModels:
         Return a list of paths for all relevant model files given by the user.
 
         Returns:
-            (List[Path]): List of Path objects for the model files.
+            (list[Path]): List of Path objects for the model files.
         """
         files = []
         for path in self.paths:
@@ -707,7 +707,7 @@ class ProfileModels:
         Print a formatted table of model profiling results.
 
         Args:
-            table_rows (List[str]): List of formatted table row strings.
+            table_rows (list[str]): List of formatted table row strings.
         """
         gpu = torch.cuda.get_device_name(0) if torch.cuda.is_available() else "GPU"
         headers = [

ultralytics/utils/callbacks/clearml.py

@@ -19,7 +19,7 @@ def _log_debug_samples(files, title: str = "Debug Samples") -> None:
     Log files (images) as debug samples in the ClearML task.
 
     Args:
-        files (List[Path]): A list of file paths in PosixPath format.
+        files (list[Path]): A list of file paths in PosixPath format.
         title (str): A title that groups together images with the same values.
     """
     import re

ultralytics/utils/callbacks/comet.py

@@ -163,7 +163,7 @@ def _scale_bounding_box_to_original_image_shape(
         ratio_pad (tuple): Ratio and padding information for scaling.
 
     Returns:
-        (List[float]): Scaled bounding box coordinates in xywh format with top-left corner adjustment.
+        (list[float]): Scaled bounding box coordinates in xywh format with top-left corner adjustment.
     """
     resized_image_height, resized_image_width = resized_image_shape
 
@@ -297,7 +297,7 @@ def _extract_segmentation_annotation(segmentation_raw: str, decode: Callable) ->
         decode (Callable): Function to decode the compressed segmentation data.
 
     Returns:
-        (List[List[Any]] | None): List of polygon points or None if extraction fails.
+        (list[list[Any]] | None): List of polygon points or None if extraction fails.
     """
     try:
         mask = decode(segmentation_raw)
@@ -322,7 +322,7 @@ def _fetch_annotations(img_idx, image_path, batch, prediction_metadata_map, clas
         class_map (dict): Additional class mapping for label conversion.
 
     Returns:
-        (List | None): List of annotation dictionaries or None if no annotations exist.
+        (list | None): List of annotation dictionaries or None if no annotations exist.
     """
     ground_truth_annotations = _format_ground_truth_annotations_for_detection(
         img_idx, image_path, batch, class_label_map
@@ -365,9 +365,9 @@ def _log_images(experiment, image_paths, curr_step: int | None, annotations=None
 
     Args:
         experiment (comet_ml.CometExperiment): The Comet ML experiment to log images to.
-        image_paths (List[Path]): List of paths to images that will be logged.
+        image_paths (list[Path]): List of paths to images that will be logged.
         curr_step (int): Current training step/iteration for tracking in the experiment timeline.
-        annotations (List[List[dict]], optional): Nested list of annotation dictionaries for each image. Each
+        annotations (list[list[dict]], optional): Nested list of annotation dictionaries for each image. Each
             annotation contains visualization data like bounding boxes, labels, and confidence scores.
     """
     if annotations:

ultralytics/utils/callbacks/tensorboard.py

@@ -70,14 +70,14 @@ def _log_tensorboard_graph(trainer) -> None:
         # Try simple method first (YOLO)
         try:
             trainer.model.eval()  # place in .eval() mode to avoid BatchNorm statistics changes
-            WRITER.add_graph(torch.jit.trace(torch_utils.de_parallel(trainer.model), im, strict=False), [])
+            WRITER.add_graph(torch.jit.trace(torch_utils.unwrap_model(trainer.model), im, strict=False), [])
             LOGGER.info(f"{PREFIX}model graph visualization added ✅")
             return
 
         except Exception:
             # Fallback to TorchScript export steps (RTDETR)
             try:
-                model = deepcopy(torch_utils.de_parallel(trainer.model))
+                model = deepcopy(torch_utils.unwrap_model(trainer.model))
                 model.eval()
                 model = model.fuse(verbose=False)
                 for m in model.modules():

ultralytics/utils/checks.py

@@ -60,7 +60,7 @@ def parse_requirements(file_path=ROOT.parent / "requirements.txt", package=""):
         package (str, optional): Python package to use instead of requirements.txt file.
 
     Returns:
-        requirements (List[SimpleNamespace]): List of parsed requirements as SimpleNamespace objects with `name` and
+        requirements (list[SimpleNamespace]): List of parsed requirements as SimpleNamespace objects with `name` and
             `specifier` attributes.
 
     Examples:
@@ -120,14 +120,14 @@ def check_imgsz(imgsz, stride=32, min_dim=1, max_dim=2, floor=0):
     stride, update it to the nearest multiple of the stride that is greater than or equal to the given floor value.
 
     Args:
-        imgsz (int | List[int]): Image size.
+        imgsz (int | list[int]): Image size.
         stride (int): Stride value.
         min_dim (int): Minimum number of dimensions.
         max_dim (int): Maximum number of dimensions.
         floor (int): Minimum allowed value for image size.
 
     Returns:
-        (List[int] | int): Updated image size.
+        (list[int] | int): Updated image size.
     """
     # Convert stride to integer if it is a tensor
     stride = int(stride.max() if isinstance(stride, torch.Tensor) else stride)
@@ -363,7 +363,7 @@ def check_requirements(requirements=ROOT.parent / "requirements.txt", exclude=()
     Check if installed dependencies meet Ultralytics YOLO models requirements and attempt to auto-update if needed.
 
     Args:
-        requirements (Path | str | List[str]): Path to a requirements.txt file, a single package requirement as a
+        requirements (Path | str | list[str]): Path to a requirements.txt file, a single package requirement as a
             string, or a list of package requirements as strings.
         exclude (tuple): Tuple of package names to exclude from checking.
         install (bool): If True, attempt to auto-update packages that don't meet requirements.
@@ -452,6 +452,8 @@ def check_torchvision():
     to the compatibility table based on: https://github.com/pytorch/vision#installation.
     """
     compatibility_table = {
+        "2.9": ["0.24"],
+        "2.8": ["0.23"],
         "2.7": ["0.22"],
         "2.6": ["0.21"],
         "2.5": ["0.20"],
@@ -483,7 +485,7 @@ def check_suffix(file="yolo11n.pt", suffix=".pt", msg=""):
     Check file(s) for acceptable suffix.
 
     Args:
-        file (str | List[str]): File or list of files to check.
+        file (str | list[str]): File or list of files to check.
         suffix (str | tuple): Acceptable suffix or tuple of suffixes.
         msg (str): Additional message to display in case of error.
     """

ultralytics/utils/cpu.py

@@ -0,0 +1,90 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+from __future__ import annotations
+
+import platform
+import re
+import subprocess
+import sys
+from pathlib import Path
+
+
+class CPUInfo:
+    """
+    Provide cross-platform CPU brand and model information.
+
+    Query platform-specific sources to retrieve a human-readable CPU descriptor and normalize it for consistent
+    presentation across macOS, Linux, and Windows. If platform-specific probing fails, generic platform identifiers are
+    used to ensure a stable string is always returned.
+
+    Methods:
+        name: Return the normalized CPU name using platform-specific sources with robust fallbacks.
+        _clean: Normalize and prettify common vendor brand strings and frequency patterns.
+        __str__: Return the normalized CPU name for string contexts.
+
+    Examples:
+        >>> CPUInfo.name()
+        'Apple M4 Pro'
+        >>> str(CPUInfo())
+        'Intel Core i7-9750H 2.60GHz'
+    """
+
+    @staticmethod
+    def name() -> str:
+        """Return a normalized CPU model string from platform-specific sources."""
+        try:
+            if sys.platform == "darwin":
+                # Query macOS sysctl for the CPU brand string
+                s = subprocess.run(
+                    ["sysctl", "-n", "machdep.cpu.brand_string"], capture_output=True, text=True
+                ).stdout.strip()
+                if s:
+                    return CPUInfo._clean(s)
+            elif sys.platform.startswith("linux"):
+                # Parse /proc/cpuinfo for the first "model name" entry
+                p = Path("/proc/cpuinfo")
+                if p.exists():
+                    for line in p.read_text(errors="ignore").splitlines():
+                        if "model name" in line:
+                            return CPUInfo._clean(line.split(":", 1)[1])
+            elif sys.platform.startswith("win"):
+                try:
+                    import winreg as wr
+
+                    with wr.OpenKey(wr.HKEY_LOCAL_MACHINE, r"HARDWARE\DESCRIPTION\System\CentralProcessor\0") as k:
+                        val, _ = wr.QueryValueEx(k, "ProcessorNameString")
+                        if val:
+                            return CPUInfo._clean(val)
+                except Exception:
+                    # Fall through to generic platform fallbacks on Windows registry access failure
+                    pass
+            # Generic platform fallbacks
+            s = platform.processor() or getattr(platform.uname(), "processor", "") or platform.machine()
+            return CPUInfo._clean(s or "Unknown CPU")
+        except Exception:
+            # Ensure a string is always returned even on unexpected failures
+            s = platform.processor() or platform.machine() or ""
+            return CPUInfo._clean(s or "Unknown CPU")
+
+    @staticmethod
+    def _clean(s: str) -> str:
+        """Normalize and prettify a raw CPU descriptor string."""
+        s = re.sub(r"\s+", " ", s.strip())
+        s = s.replace("(TM)", "").replace("(tm)", "").replace("(R)", "").replace("(r)", "").strip()
+        # Normalize common Intel pattern to 'Model Freq'
+        m = re.search(r"(Intel.*?i\d[\w-]*) CPU @ ([\d.]+GHz)", s, re.I)
+        if m:
+            return f"{m.group(1)} {m.group(2)}"
+        # Normalize common AMD Ryzen pattern to 'Model Freq'
+        m = re.search(r"(AMD.*?Ryzen.*?[\w-]*) CPU @ ([\d.]+GHz)", s, re.I)
+        if m:
+            return f"{m.group(1)} {m.group(2)}"
+        return s
+
+    def __str__(self) -> str:
+        """Return the normalized CPU name."""
+        return self.name()
+
+
+if __name__ == "__main__":
+    print(CPUInfo.name())

ultralytics/utils/dist.py

@@ -85,7 +85,7 @@ def generate_ddp_command(world_size: int, trainer):
         trainer (ultralytics.engine.trainer.BaseTrainer): The trainer containing configuration for distributed training.
 
     Returns:
-        cmd (List[str]): The command to execute for distributed training.
+        cmd (list[str]): The command to execute for distributed training.
         file (str): Path to the temporary file created for DDP training.
     """
     import __main__  # noqa local import to avoid https://github.com/Lightning-AI/pytorch-lightning/issues/15218

ultralytics/utils/downloads.py

@@ -411,7 +411,7 @@ def get_github_assets(
 
     Returns:
         tag (str): The release tag.
-        assets (List[str]): A list of asset names.
+        assets (list[str]): A list of asset names.
 
     Examples:
         >>> tag, assets = get_github_assets(repo="ultralytics/assets", version="latest")
@@ -503,7 +503,7 @@ def download(
     Supports concurrent downloads if multiple threads are specified.
 
     Args:
-        url (str | List[str]): The URL or list of URLs of the files to be downloaded.
+        url (str | list[str]): The URL or list of URLs of the files to be downloaded.
         dir (Path, optional): The directory where the files will be saved.
         unzip (bool, optional): Flag to unzip the files after downloading.
         delete (bool, optional): Flag to delete the zip files after extraction.

ultralytics/utils/export.py

@@ -27,9 +27,9 @@ def export_onnx(
         im (torch.Tensor): Example input tensor for the model.
         onnx_file (str): Path to save the exported ONNX file.
         opset (int): ONNX opset version to use for export.
-        input_names (List[str]): List of input tensor names.
-        output_names (List[str]): List of output tensor names.
-        dynamic (bool | Dict, optional): Whether to enable dynamic axes.
+        input_names (list[str]): List of input tensor names.
+        output_names (list[str]): List of output tensor names.
+        dynamic (bool | dict, optional): Whether to enable dynamic axes.
 
     Notes:
         Setting `do_constant_folding=True` may cause issues with DNN inference for torch>=1.12.
@@ -71,10 +71,10 @@ def export_engine(
         half (bool, optional): Enable FP16 precision.
         int8 (bool, optional): Enable INT8 precision.
         dynamic (bool, optional): Enable dynamic input shapes.
-        shape (Tuple[int, int, int, int], optional): Input shape (batch, channels, height, width).
+        shape (tuple[int, int, int, int], optional): Input shape (batch, channels, height, width).
         dla (int, optional): DLA core to use (Jetson devices only).
         dataset (ultralytics.data.build.InfiniteDataLoader, optional): Dataset for INT8 calibration.
-        metadata (Dict, optional): Metadata to include in the engine file.
+        metadata (dict, optional): Metadata to include in the engine file.
         verbose (bool, optional): Enable verbose logging.
         prefix (str, optional): Prefix for log messages.
 

ultralytics/utils/instance.py

@@ -146,7 +146,7 @@ class Bboxes:
         Concatenate a list of Bboxes objects into a single Bboxes object.
 
         Args:
-            boxes_list (List[Bboxes]): A list of Bboxes objects to concatenate.
+            boxes_list (list[Bboxes]): A list of Bboxes objects to concatenate.
             axis (int, optional): The axis along which to concatenate the bounding boxes.
 
         Returns:
@@ -458,7 +458,7 @@ class Instances:
         Concatenate a list of Instances objects into a single Instances object.
 
         Args:
-            instances_list (List[Instances]): A list of Instances objects to concatenate.
+            instances_list (list[Instances]): A list of Instances objects to concatenate.
             axis (int, optional): The axis along which the arrays will be concatenated.
 
         Returns:

ultralytics/utils/loss.py

@@ -11,7 +11,7 @@ import torch.nn.functional as F
 from ultralytics.utils.metrics import OKS_SIGMA
 from ultralytics.utils.ops import crop_mask, xywh2xyxy, xyxy2xywh
 from ultralytics.utils.tal import RotatedTaskAlignedAssigner, TaskAlignedAssigner, dist2bbox, dist2rbox, make_anchors
-from ultralytics.utils.torch_utils import autocast
+from ultralytics.utils.torch_utils import autocast, disable_dynamo
 
 from .metrics import bbox_iou, probiou
 from .tal import bbox2dist
@@ -215,6 +215,7 @@ class v8DetectionLoss:
         self.assigner = TaskAlignedAssigner(topk=tal_topk, num_classes=self.nc, alpha=0.5, beta=6.0)
         self.bbox_loss = BboxLoss(m.reg_max).to(device)
         self.proj = torch.arange(m.reg_max, dtype=torch.float, device=device)
+        disable_dynamo(self.__class__)  # exclude from compile
 
     def preprocess(self, targets: torch.Tensor, batch_size: int, scale_tensor: torch.Tensor) -> torch.Tensor:
         """Preprocess targets by converting to tensor format and scaling coordinates."""
@@ -260,7 +261,7 @@ class v8DetectionLoss:
 
         # Targets
         targets = torch.cat((batch["batch_idx"].view(-1, 1), batch["cls"].view(-1, 1), batch["bboxes"]), 1)
-        targets = self.preprocess(targets.to(self.device), batch_size, scale_tensor=imgsz[[1, 0, 1, 0]])
+        targets = self.preprocess(targets, batch_size, scale_tensor=imgsz[[1, 0, 1, 0]])
         gt_labels, gt_bboxes = targets.split((1, 4), 2)  # cls, xyxy
         mask_gt = gt_bboxes.sum(2, keepdim=True).gt_(0.0)
 
@@ -287,9 +288,14 @@ class v8DetectionLoss:
 
         # Bbox loss
         if fg_mask.sum():
-            target_bboxes /= stride_tensor
             loss[0], loss[2] = self.bbox_loss(
-                pred_distri, pred_bboxes, anchor_points, target_bboxes, target_scores, target_scores_sum, fg_mask
+                pred_distri,
+                pred_bboxes,
+                anchor_points,
+                target_bboxes / stride_tensor,
+                target_scores,
+                target_scores_sum,
+                fg_mask,
             )
 
         loss[0] *= self.hyp.box  # box gain
@@ -329,7 +335,7 @@ class v8SegmentationLoss(v8DetectionLoss):
         try:
             batch_idx = batch["batch_idx"].view(-1, 1)
             targets = torch.cat((batch_idx, batch["cls"].view(-1, 1), batch["bboxes"]), 1)
-            targets = self.preprocess(targets.to(self.device), batch_size, scale_tensor=imgsz[[1, 0, 1, 0]])
+            targets = self.preprocess(targets, batch_size, scale_tensor=imgsz[[1, 0, 1, 0]])
             gt_labels, gt_bboxes = targets.split((1, 4), 2)  # cls, xyxy
             mask_gt = gt_bboxes.sum(2, keepdim=True).gt_(0.0)
         except RuntimeError as e:
@@ -388,7 +394,7 @@ class v8SegmentationLoss(v8DetectionLoss):
         loss[2] *= self.hyp.cls  # cls gain
         loss[3] *= self.hyp.dfl  # dfl gain
 
-        return loss * batch_size, loss.detach()  # loss(box, cls, dfl)
+        return loss * batch_size, loss.detach()  # loss(box, seg, cls, dfl)
 
     @staticmethod
     def single_mask_loss(
@@ -516,7 +522,7 @@ class v8PoseLoss(v8DetectionLoss):
         batch_size = pred_scores.shape[0]
         batch_idx = batch["batch_idx"].view(-1, 1)
         targets = torch.cat((batch_idx, batch["cls"].view(-1, 1), batch["bboxes"]), 1)
-        targets = self.preprocess(targets.to(self.device), batch_size, scale_tensor=imgsz[[1, 0, 1, 0]])
+        targets = self.preprocess(targets, batch_size, scale_tensor=imgsz[[1, 0, 1, 0]])
         gt_labels, gt_bboxes = targets.split((1, 4), 2)  # cls, xyxy
         mask_gt = gt_bboxes.sum(2, keepdim=True).gt_(0.0)
 
@@ -704,7 +710,7 @@ class v8OBBLoss(v8DetectionLoss):
             targets = torch.cat((batch_idx, batch["cls"].view(-1, 1), batch["bboxes"].view(-1, 5)), 1)
             rw, rh = targets[:, 4] * imgsz[0].item(), targets[:, 5] * imgsz[1].item()
             targets = targets[(rw >= 2) & (rh >= 2)]  # filter rboxes of tiny size to stabilize training
-            targets = self.preprocess(targets.to(self.device), batch_size, scale_tensor=imgsz[[1, 0, 1, 0]])
+            targets = self.preprocess(targets, batch_size, scale_tensor=imgsz[[1, 0, 1, 0]])
             gt_labels, gt_bboxes = targets.split((1, 5), 2)  # cls, xywhr
             mask_gt = gt_bboxes.sum(2, keepdim=True).gt_(0.0)
         except RuntimeError as e: