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

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}...")