ultralytics 8.3.191__py3-none-any.whl → 8.3.193__py3-none-any.whl

ultralytics/models/yolo/segment/val.py

@@ -63,7 +63,7 @@ class SegmentationValidator(DetectionValidator):
             (Dict[str, Any]): Preprocessed batch.
         """
         batch = super().preprocess(batch)
-        batch["masks"] = batch["masks"].to(self.device).float()
+        batch["masks"] = batch["masks"].to(self.device, non_blocking=True).float()
         return batch
 
     def init_metrics(self, model: torch.nn.Module) -> None:
@@ -133,8 +133,17 @@ class SegmentationValidator(DetectionValidator):
             (Dict[str, Any]): Prepared batch with processed annotations.
         """
         prepared_batch = super()._prepare_batch(si, batch)
-        midx = [si] if self.args.overlap_mask else batch["batch_idx"] == si
-        prepared_batch["masks"] = batch["masks"][midx]
+        nl = len(prepared_batch["cls"])
+        if self.args.overlap_mask:
+            masks = batch["masks"][si]
+            index = torch.arange(1, nl + 1, device=masks.device).view(nl, 1, 1)
+            masks = (masks == index).float()
+        else:
+            masks = batch["masks"][batch["batch_idx"] == si]
+        if nl and self.process is ops.process_mask_native:
+            masks = F.interpolate(masks[None], prepared_batch["imgsz"], mode="bilinear", align_corners=False)[0]
+            masks = masks.gt_(0.5)
+        prepared_batch["masks"] = masks
         return prepared_batch
 
     def _process_batch(self, preds: dict[str, torch.Tensor], batch: dict[str, Any]) -> dict[str, np.ndarray]:
@@ -158,20 +167,11 @@ class SegmentationValidator(DetectionValidator):
             >>> correct_preds = validator._process_batch(preds, batch)
         """
         tp = super()._process_batch(preds, batch)
-        gt_cls, gt_masks = batch["cls"], batch["masks"]
+        gt_cls = batch["cls"]
         if len(gt_cls) == 0 or len(preds["cls"]) == 0:
             tp_m = np.zeros((len(preds["cls"]), self.niou), dtype=bool)
         else:
-            pred_masks = preds["masks"]
-            if self.args.overlap_mask:
-                nl = len(gt_cls)
-                index = torch.arange(nl, device=gt_masks.device).view(nl, 1, 1) + 1
-                gt_masks = gt_masks.repeat(nl, 1, 1)  # shape(1,640,640) -> (n,640,640)
-                gt_masks = torch.where(gt_masks == index, 1.0, 0.0)
-            if gt_masks.shape[1:] != pred_masks.shape[1:]:
-                gt_masks = F.interpolate(gt_masks[None], pred_masks.shape[1:], mode="bilinear", align_corners=False)[0]
-                gt_masks = gt_masks.gt_(0.5)
-            iou = mask_iou(gt_masks.view(gt_masks.shape[0], -1), pred_masks.view(pred_masks.shape[0], -1))
+            iou = mask_iou(batch["masks"].flatten(1), preds["masks"].flatten(1))
             tp_m = self.match_predictions(preds["cls"], gt_cls, iou).cpu().numpy()
         tp.update({"tp_m": tp_m})  # update tp with mask IoU
         return tp

ultralytics/models/yolo/world/train.py

@@ -171,7 +171,7 @@ class WorldTrainer(DetectionTrainer):
 
         # Add text features
         texts = list(itertools.chain(*batch["texts"]))
-        txt_feats = torch.stack([self.text_embeddings[text] for text in texts]).to(self.device)
+        txt_feats = torch.stack([self.text_embeddings[text] for text in texts]).to(self.device, non_blocking=True)
         txt_feats = txt_feats / txt_feats.norm(p=2, dim=-1, keepdim=True)
         batch["txt_feats"] = txt_feats.reshape(len(batch["texts"]), -1, txt_feats.shape[-1])
         return batch

ultralytics/models/yolo/yoloe/train.py

@@ -197,7 +197,7 @@ class YOLOETrainerFromScratch(YOLOETrainer, WorldTrainerFromScratch):
         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)
+        txt_feats = torch.stack([self.text_embeddings[text] for text in texts]).to(self.device, non_blocking=True)
         txt_feats = txt_feats.reshape(len(batch["texts"]), -1, txt_feats.shape[-1])
         batch["txt_feats"] = txt_feats
         return batch
@@ -251,8 +251,7 @@ class YOLOEPEFreeTrainer(YOLOEPETrainer, YOLOETrainerFromScratch):
 
     def preprocess_batch(self, batch):
         """Preprocess a batch of images for YOLOE training, adjusting formatting and dimensions as needed."""
-        batch = DetectionTrainer.preprocess_batch(self, batch)
-        return batch
+        return DetectionTrainer.preprocess_batch(self, batch)
 
     def set_text_embeddings(self, datasets, batch: int):
         """
@@ -318,5 +317,5 @@ class YOLOEVPTrainer(YOLOETrainerFromScratch):
     def preprocess_batch(self, batch):
         """Preprocess a batch of images for YOLOE training, moving visual prompts to the appropriate device."""
         batch = super().preprocess_batch(batch)
-        batch["visuals"] = batch["visuals"].to(self.device)
+        batch["visuals"] = batch["visuals"].to(self.device, non_blocking=True)
         return batch

ultralytics/models/yolo/yoloe/val.py

@@ -102,7 +102,7 @@ class YOLOEDetectValidator(DetectionValidator):
         """Preprocess batch data, ensuring visuals are on the same device as images."""
         batch = super().preprocess(batch)
         if "visuals" in batch:
-            batch["visuals"] = batch["visuals"].to(batch["img"].device)
+            batch["visuals"] = batch["visuals"].to(batch["img"].device, non_blocking=True)
         return batch
 
     def get_vpe_dataloader(self, data: dict[str, Any]) -> torch.utils.data.DataLoader:
@@ -186,9 +186,9 @@ class YOLOEDetectValidator(DetectionValidator):
             self.device = select_device(self.args.device, verbose=False)
 
             if isinstance(model, (str, Path)):
-                from ultralytics.nn.tasks import attempt_load_weights
+                from ultralytics.nn.tasks import load_checkpoint
 
-                model = attempt_load_weights(model, device=self.device)
+                model, _ = load_checkpoint(model, device=self.device)  # model, ckpt
             model.eval().to(self.device)
             data = check_det_dataset(refer_data or self.args.data)
             names = [name.split("/", 1)[0] for name in list(data["names"].values())]

ultralytics/nn/__init__.py

@@ -5,18 +5,16 @@ from .tasks import (
     ClassificationModel,
     DetectionModel,
     SegmentationModel,
-    attempt_load_one_weight,
-    attempt_load_weights,
     guess_model_scale,
     guess_model_task,
+    load_checkpoint,
     parse_model,
     torch_safe_load,
     yaml_model_load,
 )
 
 __all__ = (
-    "attempt_load_one_weight",
-    "attempt_load_weights",
+    "load_checkpoint",
     "parse_model",
     "yaml_model_load",
     "guess_model_task",

ultralytics/nn/autobackend.py

@@ -203,9 +203,9 @@ class AutoBackend(nn.Module):
                     model = model.fuse(verbose=verbose)
                 model = model.to(device)
             else:  # pt file
-                from ultralytics.nn.tasks import attempt_load_one_weight
+                from ultralytics.nn.tasks import load_checkpoint
 
-                model, _ = attempt_load_one_weight(model, device=device, fuse=fuse)  # load model, ckpt
+                model, _ = load_checkpoint(model, device=device, fuse=fuse)  # load model, ckpt
 
             # Common PyTorch model processing
             if hasattr(model, "kpt_shape"):

ultralytics/nn/tasks.py

@@ -1483,61 +1483,12 @@ def torch_safe_load(weight, safe_only=False):
     return ckpt, file
 
 
-def attempt_load_weights(weights, device=None, inplace=True, fuse=False):
-    """
-    Load an ensemble of models weights=[a,b,c] or a single model weights=[a] or weights=a.
-
-    Args:
-        weights (str | List[str]): Model weights path(s).
-        device (torch.device, optional): Device to load model to.
-        inplace (bool): Whether to do inplace operations.
-        fuse (bool): Whether to fuse model.
-
-    Returns:
-        (torch.nn.Module): Loaded model.
-    """
-    ensemble = Ensemble()
-    for w in weights if isinstance(weights, list) else [weights]:
-        ckpt, w = torch_safe_load(w)  # load ckpt
-        args = {**DEFAULT_CFG_DICT, **ckpt["train_args"]} if "train_args" in ckpt else None  # combined args
-        model = (ckpt.get("ema") or ckpt["model"]).float()  # FP32 model
-
-        # Model compatibility updates
-        model.args = args  # attach args to model
-        model.pt_path = w  # attach *.pt file path to model
-        model.task = getattr(model, "task", guess_model_task(model))
-        if not hasattr(model, "stride"):
-            model.stride = torch.tensor([32.0])
-
-        # Append
-        ensemble.append((model.fuse().eval() if fuse and hasattr(model, "fuse") else model.eval()).to(device))
-
-    # Module updates
-    for m in ensemble.modules():
-        if hasattr(m, "inplace"):
-            m.inplace = inplace
-        elif isinstance(m, torch.nn.Upsample) and not hasattr(m, "recompute_scale_factor"):
-            m.recompute_scale_factor = None  # torch 1.11.0 compatibility
-
-    # Return model
-    if len(ensemble) == 1:
-        return ensemble[-1]
-
-    # Return ensemble
-    LOGGER.info(f"Ensemble created with {weights}\n")
-    for k in "names", "nc", "yaml":
-        setattr(ensemble, k, getattr(ensemble[0], k))
-    ensemble.stride = ensemble[int(torch.argmax(torch.tensor([m.stride.max() for m in ensemble])))].stride
-    assert all(ensemble[0].nc == m.nc for m in ensemble), f"Models differ in class counts {[m.nc for m in ensemble]}"
-    return ensemble
-
-
-def attempt_load_one_weight(weight, device=None, inplace=True, fuse=False):
+def load_checkpoint(weight, device=None, inplace=True, fuse=False):
     """
     Load a single model weights.
 
     Args:
-        weight (str): Model weight path.
+        weight (str | Path): Model weight path.
         device (torch.device, optional): Device to load model to.
         inplace (bool): Whether to do inplace operations.
         fuse (bool): Whether to fuse model.

ultralytics/utils/__init__.py

@@ -49,7 +49,7 @@ MACOS_VERSION = platform.mac_ver()[0] if MACOS else None
 NOT_MACOS14 = not (MACOS and MACOS_VERSION.startswith("14."))
 ARM64 = platform.machine() in {"arm64", "aarch64"}  # ARM64 booleans
 PYTHON_VERSION = platform.python_version()
-TORCH_VERSION = torch.__version__
+TORCH_VERSION = str(torch.__version__)  # Normalize torch.__version__ (PyTorch>1.9 returns TorchVersion objects)
 TORCHVISION_VERSION = importlib.metadata.version("torchvision")  # faster than importing torchvision
 IS_VSCODE = os.environ.get("TERM_PROGRAM", False) == "vscode"
 RKNN_CHIPS = frozenset(
@@ -132,6 +132,10 @@ os.environ["TF_CPP_MIN_LOG_LEVEL"] = "3"  # suppress verbose TF compiler warning
 os.environ["TORCH_CPP_LOG_LEVEL"] = "ERROR"  # suppress "NNPACK.cpp could not initialize NNPACK" warnings
 os.environ["KINETO_LOG_LEVEL"] = "5"  # suppress verbose PyTorch profiler output when computing FLOPs
 
+# Precompiled type tuples for faster isinstance() checks
+FLOAT_OR_INT = (float, int)
+STR_OR_PATH = (str, Path)
+
 
 class DataExportMixin:
     """

ultralytics/utils/checks.py

@@ -36,6 +36,7 @@ from ultralytics.utils import (
     PYTHON_VERSION,
     RKNN_CHIPS,
     ROOT,
+    TORCH_VERSION,
     TORCHVISION_VERSION,
     USER_CONFIG_DIR,
     WINDOWS,
@@ -464,7 +465,7 @@ def check_torchvision():
     }
 
     # Check major and minor versions
-    v_torch = ".".join(torch.__version__.split("+", 1)[0].split(".")[:2])
+    v_torch = ".".join(TORCH_VERSION.split("+", 1)[0].split(".")[:2])
     if v_torch in compatibility_table:
         compatible_versions = compatibility_table[v_torch]
         v_torchvision = ".".join(TORCHVISION_VERSION.split("+", 1)[0].split(".")[:2])

ultralytics/utils/plotting.py

@@ -893,7 +893,7 @@ def plot_results(
     assert len(files), f"No results.csv files found in {save_dir.resolve()}, nothing to plot."
     for f in files:
         try:
-            data = pl.read_csv(f)
+            data = pl.read_csv(f, infer_schema_length=None)
             s = [x.strip() for x in data.columns]
             x = data.select(data.columns[0]).to_numpy().flatten()
             for i, j in enumerate(index):
@@ -971,7 +971,7 @@ def plot_tune_results(csv_file: str = "tune_results.csv"):
 
     # Scatter plots for each hyperparameter
     csv_file = Path(csv_file)
-    data = pl.read_csv(csv_file)
+    data = pl.read_csv(csv_file, infer_schema_length=None)
     num_metrics_columns = 1
     keys = [x.strip() for x in data.columns][num_metrics_columns:]
     x = data.to_numpy()

ultralytics/utils/tal.py

@@ -3,12 +3,12 @@
 import torch
 import torch.nn as nn
 
-from . import LOGGER
+from . import LOGGER, TORCH_VERSION
 from .checks import check_version
 from .metrics import bbox_iou, probiou
 from .ops import xywhr2xyxyxyxy
 
-TORCH_1_10 = check_version(torch.__version__, "1.10.0")
+TORCH_1_10 = check_version(TORCH_VERSION, "1.10.0")
 
 
 class TaskAlignedAssigner(nn.Module):

ultralytics/utils/torch_utils.py

@@ -27,6 +27,7 @@ from ultralytics.utils import (
     LOGGER,
     NUM_THREADS,
     PYTHON_VERSION,
+    TORCH_VERSION,
     TORCHVISION_VERSION,
     WINDOWS,
     colorstr,
@@ -35,15 +36,15 @@ from ultralytics.utils.checks import check_version
 from ultralytics.utils.patches import torch_load
 
 # Version checks (all default to version>=min_version)
-TORCH_1_9 = check_version(torch.__version__, "1.9.0")
-TORCH_1_13 = check_version(torch.__version__, "1.13.0")
-TORCH_2_0 = check_version(torch.__version__, "2.0.0")
-TORCH_2_4 = check_version(torch.__version__, "2.4.0")
+TORCH_1_9 = check_version(TORCH_VERSION, "1.9.0")
+TORCH_1_13 = check_version(TORCH_VERSION, "1.13.0")
+TORCH_2_0 = check_version(TORCH_VERSION, "2.0.0")
+TORCH_2_4 = check_version(TORCH_VERSION, "2.4.0")
 TORCHVISION_0_10 = check_version(TORCHVISION_VERSION, "0.10.0")
 TORCHVISION_0_11 = check_version(TORCHVISION_VERSION, "0.11.0")
 TORCHVISION_0_13 = check_version(TORCHVISION_VERSION, "0.13.0")
 TORCHVISION_0_18 = check_version(TORCHVISION_VERSION, "0.18.0")
-if WINDOWS and check_version(torch.__version__, "==2.4.0"):  # reject version 2.4.0 on Windows
+if WINDOWS and check_version(TORCH_VERSION, "==2.4.0"):  # reject version 2.4.0 on Windows
     LOGGER.warning(
         "Known issue with torch==2.4.0 on Windows with CPU, recommend upgrading to torch>=2.4.1 to resolve "
         "https://github.com/ultralytics/ultralytics/issues/15049"
@@ -165,7 +166,7 @@ def select_device(device="", batch=0, newline=False, verbose=True):
     if isinstance(device, torch.device) or str(device).startswith(("tpu", "intel")):
         return device
 
-    s = f"Ultralytics {__version__} 🚀 Python-{PYTHON_VERSION} torch-{torch.__version__} "
+    s = f"Ultralytics {__version__} 🚀 Python-{PYTHON_VERSION} torch-{TORCH_VERSION} "
     device = str(device).lower()
     for remove in "cuda:", "none", "(", ")", "[", "]", "'", " ":
         device = device.replace(remove, "")  # to string, 'cuda:0' -> '0' and '(0, 1)' -> '0,1'

ultralytics/utils/tqdm.py

@@ -88,11 +88,11 @@ class TQDM:
         mininterval: float = 0.1,
         disable: bool | None = None,
         unit: str = "it",
-        unit_scale: bool = False,
+        unit_scale: bool = True,
         unit_divisor: int = 1000,
-        bar_format: str | None = None,
+        bar_format: str | None = None,  # kept for API compatibility; not used for formatting
         initial: int = 0,
-        **kwargs,  # Accept unused args for compatibility
+        **kwargs,
     ) -> None:
         """
         Initialize the TQDM progress bar with specified configuration options.
@@ -138,11 +138,8 @@ class TQDM:
         self.mininterval = max(mininterval, self.NONINTERACTIVE_MIN_INTERVAL) if self.noninteractive else mininterval
         self.initial = initial
 
-        # Set bar format based on whether we have a total
-        if self.total:
-            self.bar_format = bar_format or "{desc}: {percent:.0f}% {bar} {n}/{total} {rate} {elapsed}<{remaining}"
-        else:
-            self.bar_format = bar_format or "{desc}: {bar} {n} {rate} {elapsed}"
+        # Kept for API compatibility (unused for f-string formatting)
+        self.bar_format = bar_format
 
         self.file = file or sys.stdout
 
@@ -151,48 +148,31 @@ class TQDM:
         self.last_print_n = self.initial
         self.last_print_t = time.time()
         self.start_t = time.time()
-        self.last_rate = 0
+        self.last_rate = 0.0
         self.closed = False
+        self.is_bytes = unit_scale and unit in ("B", "bytes")
+        self.scales = (
+            [(1073741824, "GB/s"), (1048576, "MB/s"), (1024, "KB/s")]
+            if self.is_bytes
+            else [(1e9, f"G{self.unit}/s"), (1e6, f"M{self.unit}/s"), (1e3, f"K{self.unit}/s")]
+        )
 
-        # Display initial bar if we have total and not disabled
         if not self.disable and self.total and not self.noninteractive:
             self._display()
 
     def _format_rate(self, rate: float) -> str:
-        """Format rate with proper units and reasonable precision."""
+        """Format rate with units."""
         if rate <= 0:
             return ""
+        fallback = f"{rate:.1f}B/s" if self.is_bytes else f"{rate:.1f}{self.unit}/s"
+        return next((f"{rate / t:.1f}{u}" for t, u in self.scales if rate >= t), fallback)
 
-        # For bytes with scaling, use binary units
-        if self.unit in ("B", "bytes") and self.unit_scale:
-            return next(
-                (
-                    f"{rate / threshold:.1f}{unit}"
-                    for threshold, unit in [
-                        (1073741824, "GB/s"),
-                        (1048576, "MB/s"),
-                        (1024, "KB/s"),
-                    ]
-                    if rate >= threshold
-                ),
-                f"{rate:.1f}B/s",
-            )
-        # For other scalable units, use decimal units
-        if self.unit_scale and self.unit in ("it", "items", ""):
-            for threshold, prefix in [(1000000, "M"), (1000, "K")]:
-                if rate >= threshold:
-                    return f"{rate / threshold:.1f}{prefix}{self.unit}/s"
-
-        # Default formatting
-        precision = ".1f" if rate >= 1 else ".2f"
-        return f"{rate:{precision}}{self.unit}/s"
-
-    def _format_num(self, num: int) -> str:
+    def _format_num(self, num: int | float) -> str:
         """Format number with optional unit scaling."""
-        if not self.unit_scale or self.unit not in ("B", "bytes"):
+        if not self.unit_scale or not self.is_bytes:
             return str(num)
 
-        for unit in ["", "K", "M", "G", "T"]:
+        for unit in ("", "K", "M", "G", "T"):
             if abs(num) < self.unit_divisor:
                 return f"{num:3.1f}{unit}B" if unit else f"{num:.0f}B"
             num /= self.unit_divisor
@@ -224,8 +204,7 @@ class TQDM:
         """Check if display should update."""
         if self.noninteractive:
             return False
-
-        return True if self.total and self.n >= self.total else dt >= self.mininterval
+        return (self.total is not None and self.n >= self.total) or (dt >= self.mininterval)
 
     def _display(self, final: bool = False) -> None:
         """Display progress bar."""
@@ -240,8 +219,8 @@ class TQDM:
             return
 
         # Calculate rate (avoid crazy numbers)
-        if dt > self.MIN_RATE_CALC_INTERVAL:  # Only calculate rate if enough time has passed
-            rate = dn / dt
+        if dt > self.MIN_RATE_CALC_INTERVAL:
+            rate = dn / dt if dt else 0.0
             # Smooth rate for reasonable values, use raw rate for very high values
             if rate < self.MAX_SMOOTHED_RATE:
                 self.last_rate = self.RATE_SMOOTHING_FACTOR * rate + (1 - self.RATE_SMOOTHING_FACTOR) * self.last_rate
@@ -249,8 +228,8 @@ class TQDM:
         else:
             rate = self.last_rate
 
-        # At completion, use the overall rate for more accurate display
-        if self.n >= (self.total or float("inf")) and self.total and self.total > 0:
+        # At completion, use overall rate
+        if self.total and self.n >= self.total:
             overall_elapsed = current_time - self.start_t
             if overall_elapsed > 0:
                 rate = self.n / overall_elapsed
@@ -260,44 +239,41 @@ class TQDM:
         self.last_print_t = current_time
         elapsed = current_time - self.start_t
 
-        # Calculate remaining time
+        # Remaining time
         remaining_str = ""
-        if self.total and 0 < self.n < self.total and rate > 0:
-            remaining_str = self._format_time((self.total - self.n) / rate)
+        if self.total and 0 < self.n < self.total and elapsed > 0:
+            est_rate = rate or (self.n / elapsed)
+            remaining_str = f"<{self._format_time((self.total - self.n) / est_rate)}"
 
-        # Build progress components
+        # Numbers and percent
         if self.total:
             percent = (self.n / self.total) * 100
-            # For bytes with unit scaling, avoid repeating units: show "5.4/5.4MB" not "5.4MB/5.4MB"
-            n = self._format_num(self.n)
-            total = self._format_num(self.total)
-            if self.unit_scale and self.unit in ("B", "bytes"):
-                n = n.rstrip("KMGTPB")  # Remove unit suffix from current
+            n_str = self._format_num(self.n)
+            t_str = self._format_num(self.total)
+            if self.is_bytes:
+                # Collapse suffix only when identical (e.g. "5.4/5.4MB")
+                if n_str[-2] == t_str[-2]:
+                    n_str = n_str.rstrip("KMGTPB")  # Remove unit suffix from current if different than total
         else:
-            percent = 0
-            n = self._format_num(self.n)
-            total = "?"
+            percent = 0.0
+            n_str, t_str = self._format_num(self.n), "?"
 
         elapsed_str = self._format_time(elapsed)
+        rate_str = self._format_rate(rate) or (self._format_rate(self.n / elapsed) if elapsed > 0 else "")
 
-        # Use different format for completion
-        if self.total and self.n >= self.total:
-            format_str = self.bar_format.replace("<{remaining}", "")
+        bar = self._generate_bar()
+
+        # Compose progress line via f-strings (two shapes: with/without total)
+        if self.total:
+            if self.is_bytes and self.n >= self.total:
+                # Completed bytes: show only final size
+                progress_str = f"{self.desc}: {percent:.0f}% {bar} {t_str} {rate_str} {elapsed_str}"
+            else:
+                progress_str = (
+                    f"{self.desc}: {percent:.0f}% {bar} {n_str}/{t_str} {rate_str} {elapsed_str}{remaining_str}"
+                )
         else:
-            format_str = self.bar_format
-
-        # Format progress string
-        progress_str = format_str.format(
-            desc=self.desc,
-            percent=percent,
-            bar=self._generate_bar(),
-            n=n,
-            total=total,
-            rate=self._format_rate(rate) or (self._format_rate(self.n / elapsed) if elapsed > 0 else ""),
-            remaining=remaining_str,
-            elapsed=elapsed_str,
-            unit=self.unit,
-        )
+            progress_str = f"{self.desc}: {bar} {n_str} {rate_str} {elapsed_str}"
 
         # Write to output
         try:
@@ -335,7 +311,7 @@ class TQDM:
         if self.closed:
             return
 
-        self.closed = True  # Set before final display
+        self.closed = True
 
         if not self.disable:
             # Final display

ultralytics/utils/tuner.py

@@ -129,7 +129,7 @@ def run_ray_tune(
             {**train_args, **{"exist_ok": train_args.pop("resume", False)}},  # resume w/ same tune_dir
         ),
         name=train_args.pop("name", "tune"),  # runs/{task}/{tune_dir}
-    ).resolve()  # must be absolute dir
+    )  # must be absolute dir
     tune_dir.mkdir(parents=True, exist_ok=True)
     if tune.Tuner.can_restore(tune_dir):
         LOGGER.info(f"{colorstr('Tuner: ')} Resuming tuning run {tune_dir}...")

{ultralytics-8.3.191.dist-info → ultralytics-8.3.193.dist-info}/METADATA

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