ultralytics 8.3.125__py3-none-any.whl → 8.3.126__py3-none-any.whl

tests/test_cuda.py

@@ -10,8 +10,18 @@ from tests import CUDA_DEVICE_COUNT, CUDA_IS_AVAILABLE, MODEL, SOURCE
 from ultralytics import YOLO
 from ultralytics.cfg import TASK2DATA, TASK2MODEL, TASKS
 from ultralytics.utils import ASSETS, WEIGHTS_DIR
+from ultralytics.utils.autodevice import GPUInfo
 from ultralytics.utils.checks import check_amp
 
+# Try to find idle devices if CUDA is available
+DEVICES = []
+if CUDA_IS_AVAILABLE:
+    gpu_info = GPUInfo()
+    gpu_info.print_status()
+    idle_gpus = gpu_info.select_idle_gpu(count=2, min_memory_mb=2048)
+    if idle_gpus:
+        DEVICES = idle_gpus
+
 
 def test_checks():
     """Validate CUDA settings against torch CUDA functions."""
@@ -19,16 +29,16 @@ def test_checks():
     assert torch.cuda.device_count() == CUDA_DEVICE_COUNT
 
 
-@pytest.mark.skipif(not CUDA_IS_AVAILABLE, reason="CUDA is not available")
+@pytest.mark.skipif(not DEVICES, reason="No CUDA devices available")
 def test_amp():
     """Test AMP training checks."""
-    model = YOLO("yolo11n.pt").model.cuda()
+    model = YOLO("yolo11n.pt").model.to(f"cuda:{DEVICES[0]}")
     assert check_amp(model)
 
 
 @pytest.mark.slow
 @pytest.mark.skipif(True, reason="CUDA export tests disabled pending additional Ultralytics GPU server availability")
-@pytest.mark.skipif(not CUDA_IS_AVAILABLE, reason="CUDA is not available")
+@pytest.mark.skipif(not DEVICES, reason="No CUDA devices available")
 @pytest.mark.parametrize(
     "task, dynamic, int8, half, batch",
     [  # generate all combinations but exclude those where both int8 and half are True
@@ -40,16 +50,7 @@ def test_amp():
     ],
 )
 def test_export_engine_matrix(task, dynamic, int8, half, batch):
-    """
-    Test YOLO model export to TensorRT format for various configurations and run inference.
-
-    Args:
-        task (str): Task type like 'detect', 'segment', etc.
-        dynamic (bool): Whether to use dynamic input size.
-        int8 (bool): Whether to use INT8 precision.
-        half (bool): Whether to use FP16 precision.
-        batch (int): Batch size for export.
-    """
+    """Test YOLO model export to TensorRT format for various configurations and run inference."""
     file = YOLO(TASK2MODEL[task]).export(
         format="engine",
         imgsz=32,
@@ -60,105 +61,109 @@ def test_export_engine_matrix(task, dynamic, int8, half, batch):
         data=TASK2DATA[task],
         workspace=1,  # reduce workspace GB for less resource utilization during testing
         simplify=True,  # use 'onnxslim'
+        device=DEVICES[0],
     )
-    YOLO(file)([SOURCE] * batch, imgsz=64 if dynamic else 32)  # exported model inference
+    YOLO(file)([SOURCE] * batch, imgsz=64 if dynamic else 32, device=DEVICES[0])  # exported model inference
     Path(file).unlink()  # cleanup
     Path(file).with_suffix(".cache").unlink() if int8 else None  # cleanup INT8 cache
 
 
-@pytest.mark.skipif(not CUDA_IS_AVAILABLE, reason="CUDA is not available")
+@pytest.mark.skipif(not DEVICES, reason="No CUDA devices available")
 def test_train():
     """Test model training on a minimal dataset using available CUDA devices."""
-    device = 0 if CUDA_DEVICE_COUNT == 1 else [0, 1]
+    device = DEVICES if len(DEVICES) > 1 else DEVICES[0]
     YOLO(MODEL).train(data="coco8.yaml", imgsz=64, epochs=1, device=device)  # requires imgsz>=64
 
 
 @pytest.mark.slow
-@pytest.mark.skipif(not CUDA_IS_AVAILABLE, reason="CUDA is not available")
+@pytest.mark.skipif(not DEVICES, reason="No CUDA devices available")
 def test_predict_multiple_devices():
     """Validate model prediction consistency across CPU and CUDA devices."""
     model = YOLO("yolo11n.pt")
+
+    # Test CPU
     model = model.cpu()
     assert str(model.device) == "cpu"
-    _ = model(SOURCE)  # CPU inference
+    _ = model(SOURCE)
     assert str(model.device) == "cpu"
 
-    model = model.to("cuda:0")
-    assert str(model.device) == "cuda:0"
-    _ = model(SOURCE)  # CUDA inference
-    assert str(model.device) == "cuda:0"
+    # Test CUDA
+    cuda_device = f"cuda:{DEVICES[0]}"
+    model = model.to(cuda_device)
+    assert str(model.device) == cuda_device
+    _ = model(SOURCE)
+    assert str(model.device) == cuda_device
 
+    # Test CPU again
     model = model.cpu()
     assert str(model.device) == "cpu"
-    _ = model(SOURCE)  # CPU inference
+    _ = model(SOURCE)
     assert str(model.device) == "cpu"
 
-    model = model.cuda()
-    assert str(model.device) == "cuda:0"
-    _ = model(SOURCE)  # CUDA inference
-    assert str(model.device) == "cuda:0"
+    # Test CUDA again
+    model = model.to(cuda_device)
+    assert str(model.device) == cuda_device
+    _ = model(SOURCE)
+    assert str(model.device) == cuda_device
 
 
-@pytest.mark.skipif(not CUDA_IS_AVAILABLE, reason="CUDA is not available")
+@pytest.mark.skipif(not DEVICES, reason="No CUDA devices available")
 def test_autobatch():
     """Check optimal batch size for YOLO model training using autobatch utility."""
     from ultralytics.utils.autobatch import check_train_batch_size
 
-    check_train_batch_size(YOLO(MODEL).model.cuda(), imgsz=128, amp=True)
+    check_train_batch_size(YOLO(MODEL).model.to(f"cuda:{DEVICES[0]}"), imgsz=128, amp=True)
 
 
 @pytest.mark.slow
-@pytest.mark.skipif(not CUDA_IS_AVAILABLE, reason="CUDA is not available")
+@pytest.mark.skipif(not DEVICES, reason="No CUDA devices available")
 def test_utils_benchmarks():
     """Profile YOLO models for performance benchmarks."""
     from ultralytics.utils.benchmarks import ProfileModels
 
     # Pre-export a dynamic engine model to use dynamic inference
-    YOLO(MODEL).export(format="engine", imgsz=32, dynamic=True, batch=1)
-    ProfileModels([MODEL], imgsz=32, half=False, min_time=1, num_timed_runs=3, num_warmup_runs=1).run()
+    YOLO(MODEL).export(format="engine", imgsz=32, dynamic=True, batch=1, device=DEVICES[0])
+    ProfileModels(
+        [MODEL],
+        imgsz=32,
+        half=False,
+        min_time=1,
+        num_timed_runs=3,
+        num_warmup_runs=1,
+        device=DEVICES[0],
+    ).run()
 
 
-@pytest.mark.skipif(not CUDA_IS_AVAILABLE, reason="CUDA is not available")
+@pytest.mark.skipif(not DEVICES, reason="No CUDA devices available")
 def test_predict_sam():
-    """Test SAM model predictions using different prompts, including bounding boxes and point annotations."""
+    """Test SAM model predictions using different prompts."""
     from ultralytics import SAM
     from ultralytics.models.sam import Predictor as SAMPredictor
 
-    # Load a model
     model = SAM(WEIGHTS_DIR / "sam2.1_b.pt")
-
-    # Display model information (optional)
     model.info()
 
-    # Run inference
-    model(SOURCE, device=0)
-
-    # Run inference with bboxes prompt
-    model(SOURCE, bboxes=[439, 437, 524, 709], device=0)
-
-    # Run inference with no labels
-    model(ASSETS / "zidane.jpg", points=[900, 370], device=0)
-
-    # Run inference with 1D points and 1D labels
-    model(ASSETS / "zidane.jpg", points=[900, 370], labels=[1], device=0)
-
-    # Run inference with 2D points and 1D labels
-    model(ASSETS / "zidane.jpg", points=[[900, 370]], labels=[1], device=0)
-
-    # Run inference with multiple 2D points and 1D labels
-    model(ASSETS / "zidane.jpg", points=[[400, 370], [900, 370]], labels=[1, 1], device=0)
-
-    # Run inference with 3D points and 2D labels (multiple points per object)
-    model(ASSETS / "zidane.jpg", points=[[[900, 370], [1000, 100]]], labels=[[1, 1]], device=0)
-
-    # Create SAMPredictor
-    overrides = dict(conf=0.25, task="segment", mode="predict", imgsz=1024, model=WEIGHTS_DIR / "mobile_sam.pt")
-    predictor = SAMPredictor(overrides=overrides)
-
-    # Set image
-    predictor.set_image(ASSETS / "zidane.jpg")  # set with image file
+    # Run inference with various prompts
+    model(SOURCE, device=DEVICES[0])
+    model(SOURCE, bboxes=[439, 437, 524, 709], device=DEVICES[0])
+    model(ASSETS / "zidane.jpg", points=[900, 370], device=DEVICES[0])
+    model(ASSETS / "zidane.jpg", points=[900, 370], labels=[1], device=DEVICES[0])
+    model(ASSETS / "zidane.jpg", points=[[900, 370]], labels=[1], device=DEVICES[0])
+    model(ASSETS / "zidane.jpg", points=[[400, 370], [900, 370]], labels=[1, 1], device=DEVICES[0])
+    model(ASSETS / "zidane.jpg", points=[[[900, 370], [1000, 100]]], labels=[[1, 1]], device=DEVICES[0])
+
+    # Test predictor
+    predictor = SAMPredictor(
+        overrides=dict(
+            conf=0.25,
+            task="segment",
+            mode="predict",
+            imgsz=1024,
+            model=WEIGHTS_DIR / "mobile_sam.pt",
+            device=DEVICES[0],
+        )
+    )
+    predictor.set_image(ASSETS / "zidane.jpg")
     # predictor(bboxes=[439, 437, 524, 709])
     # predictor(points=[900, 370], labels=[1])
-
-    # Reset image
     predictor.reset_image()

ultralytics/__init__.py

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

ultralytics/cfg/default.yaml

@@ -17,7 +17,7 @@ imgsz: 640 # (int | list) input images size as int for train and val modes, or l
 save: True # (bool) save train checkpoints and predict results
 save_period: -1 # (int) Save checkpoint every x epochs (disabled if < 1)
 cache: False # (bool) True/ram, disk or False. Use cache for data loading
-device: # (int | str | list, optional) device to run on, i.e. cuda device=0 or device=0,1,2,3 or device=cpu
+device: # (int | str | list) device: CUDA device=0 or [0,1,2,3] or "cpu/mps" or -1 or [-1,-1] to auto-select idle GPUs
 workers: 8 # (int) number of worker threads for data loading (per RANK if DDP)
 project: # (str, optional) project name
 name: # (str, optional) experiment name, results saved to 'project/name' directory

ultralytics/engine/trainer.py

@@ -105,6 +105,7 @@ class BaseTrainer:
         self.args = get_cfg(cfg, overrides)
         self.check_resume(overrides)
         self.device = select_device(self.args.device, self.args.batch)
+        self.args.device = str(self.device)  # ensure -1 is updated to selected CUDA device
         self.validator = None
         self.metrics = None
         self.plots = {}

ultralytics/utils/__init__.py

@@ -182,6 +182,10 @@ class TQDM(rich.tqdm if TQDM_RICH else tqdm.tqdm):
         kwargs.setdefault("bar_format", TQDM_BAR_FORMAT)  # override default value if passed
         super().__init__(*args, **kwargs)
 
+    def __iter__(self):
+        """Return self as iterator to satisfy Iterable interface."""
+        return super().__iter__()
+
 
 class SimpleClass:
     """

ultralytics/utils/autodevice.py

@@ -0,0 +1,175 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+
+from ultralytics.utils import LOGGER
+from ultralytics.utils.checks import check_requirements
+
+
+class GPUInfo:
+    """
+    Manages NVIDIA GPU information via pynvml with robust error handling.
+
+    Provides methods to query detailed GPU statistics (utilization, memory, temp, power) and select the most idle
+    GPUs based on configurable criteria. It safely handles the absence or initialization failure of the pynvml
+    library by logging warnings and disabling related features, preventing application crashes.
+
+    Includes fallback logic using `torch.cuda` for basic device counting if NVML is unavailable during GPU
+    selection. Manages NVML initialization and shutdown internally.
+
+    Attributes:
+        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]): 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.
+    """
+
+    def __init__(self):
+        """Initializes GPUInfo, attempting to import and initialize pynvml."""
+        self.pynvml = None
+        self.nvml_available = False
+        self.gpu_stats = []
+
+        try:
+            check_requirements("pynvml>=12.0.0")
+            self.pynvml = __import__("pynvml")
+            self.pynvml.nvmlInit()
+            self.nvml_available = True
+            self.refresh_stats()
+        except Exception as e:
+            LOGGER.warning(f"Failed to initialize pynvml, GPU stats disabled: {e}")
+
+    def __del__(self):
+        """Ensures NVML is shut down when the object is garbage collected."""
+        self.shutdown()
+
+    def shutdown(self):
+        """Shuts down NVML if it was initialized."""
+        if self.nvml_available and self.pynvml:
+            try:
+                self.pynvml.nvmlShutdown()
+            except Exception:
+                pass
+            self.nvml_available = False
+
+    def refresh_stats(self):
+        """Refreshes the internal gpu_stats list by querying NVML."""
+        self.gpu_stats = []
+        if not self.nvml_available or not self.pynvml:
+            return
+
+        try:
+            device_count = self.pynvml.nvmlDeviceGetCount()
+            for i in range(device_count):
+                self.gpu_stats.append(self._get_device_stats(i))
+        except Exception as e:
+            LOGGER.warning(f"Error during device query: {e}")
+            self.gpu_stats = []
+
+    def _get_device_stats(self, index):
+        """Gets stats for a single GPU device."""
+        handle = self.pynvml.nvmlDeviceGetHandleByIndex(index)
+        memory = self.pynvml.nvmlDeviceGetMemoryInfo(handle)
+        util = self.pynvml.nvmlDeviceGetUtilizationRates(handle)
+
+        def safe_get(func, *args, default=-1, divisor=1):
+            try:
+                val = func(*args)
+                return val // divisor if divisor != 1 and isinstance(val, (int, float)) else val
+            except Exception:
+                return default
+
+        temp_type = getattr(self.pynvml, "NVML_TEMPERATURE_GPU", -1)
+
+        return {
+            "index": index,
+            "name": self.pynvml.nvmlDeviceGetName(handle),
+            "utilization": util.gpu if util else -1,
+            "memory_used": memory.used >> 20 if memory else -1,
+            "memory_total": memory.total >> 20 if memory else -1,
+            "memory_free": memory.free >> 20 if memory else -1,
+            "temperature": safe_get(self.pynvml.nvmlDeviceGetTemperature, handle, temp_type),
+            "power_draw": safe_get(self.pynvml.nvmlDeviceGetPowerUsage, handle, divisor=1000),
+            "power_limit": safe_get(self.pynvml.nvmlDeviceGetEnforcedPowerLimit, handle, divisor=1000),
+        }
+
+    def print_status(self):
+        """Prints GPU status in a compact table format using current stats."""
+        self.refresh_stats()
+        if not self.gpu_stats:
+            LOGGER.warning("No GPU stats available.")
+            return
+
+        stats = self.gpu_stats
+        name_len = max(len(gpu.get("name", "N/A")) for gpu in stats)
+        hdr = f"{'Idx':<3} {'Name':<{name_len}} {'Util':>6} {'Mem (MiB)':>15} {'Temp':>5} {'Pwr (W)':>10}"
+        LOGGER.info(f"\n--- GPU Status ---\n{hdr}\n{'-' * len(hdr)}")
+
+        for gpu in stats:
+            u = f"{gpu['utilization']:>5}%" if gpu["utilization"] >= 0 else " N/A "
+            m = f"{gpu['memory_used']:>6}/{gpu['memory_total']:<6}" if gpu["memory_used"] >= 0 else " N/A / N/A "
+            t = f"{gpu['temperature']}C" if gpu["temperature"] >= 0 else " N/A "
+            p = f"{gpu['power_draw']:>3}/{gpu['power_limit']:<3}" if gpu["power_draw"] >= 0 else " N/A "
+
+            LOGGER.info(f"{gpu.get('index'):<3d} {gpu.get('name', 'N/A'):<{name_len}} {u:>6} {m:>15} {t:>5} {p:>10}")
+
+        LOGGER.info(f"{'-' * len(hdr)}\n")
+
+    def select_idle_gpu(self, count=1, min_memory_mb=0):
+        """
+        Selects the 'count' most idle GPUs based on utilization and free memory.
+
+        Args:
+            count (int): The number of idle GPUs to select. Defaults to 1.
+            min_memory_mb (int): Minimum free memory required (MiB). Defaults to 0.
+
+        Returns:
+            (list[int]): Indices of the selected GPUs, sorted by idleness.
+
+        Notes:
+             Returns fewer than 'count' if not enough qualify or exist.
+             Returns basic CUDA indices if NVML fails. Empty list if no GPUs found.
+        """
+        LOGGER.info(f"Searching for {count} idle GPUs with >= {min_memory_mb} MiB free memory...")
+
+        if count <= 0:
+            return []
+
+        self.refresh_stats()
+        if not self.gpu_stats:
+            LOGGER.warning("NVML stats unavailable.")
+            return []
+
+        # Filter and sort eligible GPUs
+        eligible_gpus = [
+            gpu
+            for gpu in self.gpu_stats
+            if gpu.get("memory_free", -1) >= min_memory_mb and gpu.get("utilization", -1) != -1
+        ]
+        eligible_gpus.sort(key=lambda x: (x.get("utilization", 101), -x.get("memory_free", 0)))
+
+        # Select top 'count' indices
+        selected = [gpu["index"] for gpu in eligible_gpus[:count]]
+
+        if selected:
+            LOGGER.info(f"Selected idle CUDA devices {selected}")
+        else:
+            LOGGER.warning(f"No GPUs met criteria (Util != -1, Free Mem >= {min_memory_mb} MiB).")
+
+        return selected
+
+
+if __name__ == "__main__":
+    required_free_mem = 2048  # Require 2GB free VRAM
+    num_gpus_to_select = 1
+
+    gpu_info = GPUInfo()
+    gpu_info.print_status()
+
+    selected = gpu_info.select_idle_gpu(count=num_gpus_to_select, min_memory_mb=required_free_mem)
+    if selected:
+        print(f"\n==> Using selected GPU indices: {selected}")
+        devices = [f"cuda:{idx}" for idx in selected]
+        print(f"    Target devices: {devices}")

ultralytics/utils/benchmarks.py

@@ -399,7 +399,7 @@ class ProfileModels:
             imgsz (int): Size of the image used during profiling.
             half (bool): Flag to indicate whether to use FP16 half-precision for TensorRT profiling.
             trt (bool): Flag to indicate whether to profile using TensorRT.
-            device (torch.device | None): Device used for profiling. If None, it is determined automatically.
+            device (torch.device | str | None): Device used for profiling. If None, it is determined automatically.
 
         Notes:
             FP16 'half' argument option removed for ONNX as slower on CPU than FP32.
@@ -417,7 +417,7 @@ class ProfileModels:
         self.imgsz = imgsz
         self.half = half
         self.trt = trt  # run TensorRT profiling
-        self.device = device or torch.device(0 if torch.cuda.is_available() else "cpu")
+        self.device = device if isinstance(device, torch.device) else select_device(device)
 
     def run(self):
         """

ultralytics/utils/checks.py

@@ -608,7 +608,7 @@ def check_yolo(verbose=True, device=""):
 
     Args:
         verbose (bool): Whether to print verbose information.
-        device (str): Device to use for YOLO.
+        device (str | torch.device): Device to use for YOLO.
     """
     import psutil
 
@@ -810,7 +810,7 @@ def print_args(args: Optional[dict] = None, show_file=True, show_func=False):
     except ValueError:
         file = Path(file).stem
     s = (f"{file}: " if show_file else "") + (f"{func}: " if show_func else "")
-    LOGGER.info(colorstr(s) + ", ".join(f"{k}={strip_auth(v)}" for k, v in args.items()))
+    LOGGER.info(colorstr(s) + ", ".join(f"{k}={strip_auth(v)}" for k, v in sorted(args.items())))
 
 
 def cuda_device_count() -> int:

ultralytics/utils/torch_utils.py

@@ -136,9 +136,9 @@ def select_device(device="", batch=0, newline=False, verbose=True):
         device (str | torch.device, optional): Device string or torch.device object.
             Options are 'None', 'cpu', or 'cuda', or '0' or '0,1,2,3'. Defaults to an empty string, which auto-selects
             the first available GPU, or CPU if no GPU is available.
-        batch (int, optional): Batch size being used in your model. Defaults to 0.
-        newline (bool, optional): If True, adds a newline at the end of the log string. Defaults to False.
-        verbose (bool, optional): If True, logs the device information. Defaults to True.
+        batch (int, optional): Batch size being used in your model.
+        newline (bool, optional): If True, adds a newline at the end of the log string.
+        verbose (bool, optional): If True, logs the device information.
 
     Returns:
         (torch.device): Selected device.
@@ -157,13 +157,26 @@ def select_device(device="", batch=0, newline=False, verbose=True):
     Note:
         Sets the 'CUDA_VISIBLE_DEVICES' environment variable for specifying which GPUs to use.
     """
-    if isinstance(device, torch.device) or str(device).startswith("tpu") or str(device).startswith("intel"):
+    if isinstance(device, torch.device) or str(device).startswith(("tpu", "intel")):
         return device
 
     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'
+
+    # Auto-select GPUs
+    if "-1" in device:
+        from ultralytics.utils.autodevice import GPUInfo
+
+        # Replace each -1 with a selected GPU or remove it
+        parts = device.split(",")
+        selected = GPUInfo().select_idle_gpu(count=parts.count("-1"), min_memory_mb=2048)
+        for i in range(len(parts)):
+            if parts[i] == "-1":
+                parts[i] = str(selected.pop(0)) if selected else ""
+        device = ",".join(p for p in parts if p)
+
     cpu = device == "cpu"
     mps = device in {"mps", "mps:0"}  # Apple Metal Performance Shaders (MPS)
     if cpu or mps:
@@ -200,7 +213,7 @@ def select_device(device="", batch=0, newline=False, verbose=True):
             if batch < 1:
                 raise ValueError(
                     "AutoBatch with batch<1 not supported for Multi-GPU training, "
-                    "please specify a valid batch size, i.e. batch=16."
+                    f"please specify a valid batch size multiple of GPU count {n}, i.e. batch={n * 8}."
                 )
             if batch >= 0 and batch % n != 0:  # check batch_size is divisible by device_count
                 raise ValueError(

{ultralytics-8.3.125.dist-info → ultralytics-8.3.126.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ultralytics
-Version: 8.3.125
+Version: 8.3.126
 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.125.dist-info → ultralytics-8.3.126.dist-info}/RECORD

@@ -1,17 +1,17 @@
 tests/__init__.py,sha256=xnMhv3O_DF1YrW4zk__ZywQzAaoTDjPKPoiI1Ktss1w,670
 tests/conftest.py,sha256=rsIAipRKfrVNoTaJ1LdpYue8AbcJ_fr3d3WIlM_6uXY,2982
 tests/test_cli.py,sha256=PtMFl5Lp_6ygBbYDJ1ndofz2k7ZYupMPEAiZw6aZVm8,5450
-tests/test_cuda.py,sha256=vCpPMAkEUQrQMVe4oMwGZQVOiuujEAkZ2zturNXFF-4,6256
+tests/test_cuda.py,sha256=vMjegc23QlEzMdpzav2JEjXR1n8W-lYZ-KLGiLiwLok,6167
 tests/test_engine.py,sha256=aGqZ8P7QO5C_nOa1b4FOyk92Ysdk5WiP-ST310Vyxys,4962
 tests/test_exports.py,sha256=dhZn86LdbapW15RthQF870LGxDjC1MUZhlGdBgPmgIQ,9716
 tests/test_integrations.py,sha256=dQteeRsRVuT_p5-T88-7jqT65Zm9iAXkyKg-KQ1_TQ8,6341
 tests/test_python.py,sha256=hkOJc0Ejin3Bywyw0BT4pPex5hwwfbmw0K5ChRtvdvw,25398
 tests/test_solutions.py,sha256=BIvg9zW0a_ggEmrPKgB_Y0MncveH-eYuN5KlqdJ6nHs,5726
-ultralytics/__init__.py,sha256=4QZuLQ9zDL-596BL2iVx4dIiVPri_412418f6UrtZDQ,730
+ultralytics/__init__.py,sha256=HfUbgU67v26Obhd8l6aWhYnTG8W_ycy0mBgszTdxe6E,730
 ultralytics/assets/bus.jpg,sha256=wCAZxJecGR63Od3ZRERe9Aja1Weayrb9Ug751DS_vGM,137419
 ultralytics/assets/zidane.jpg,sha256=Ftc4aeMmen1O0A3o6GCDO9FlfBslLpTAw0gnetx7bts,50427
 ultralytics/cfg/__init__.py,sha256=We3ti0mvUQrGRmUPcufDGboW0YAO3nSRYuoWxGagk3M,39462
-ultralytics/cfg/default.yaml,sha256=ceGQ1n6gAhImYs5xwn4uWrX4jzQffVbNnKcWOScy-k0,8296
+ultralytics/cfg/default.yaml,sha256=oFG6llJO-Py5H-cR9qs-7FieJamroDLwpbrkhmfROOM,8307
 ultralytics/cfg/datasets/Argoverse.yaml,sha256=_xlEDIJ9XkUo0v_iNL7FW079BoSeZtKSuLteKTtGbA8,3275
 ultralytics/cfg/datasets/DOTAv1.5.yaml,sha256=SHND_CFkojxw5iQD5Mcgju2kCZIl0gW2ajuzv1cqoL0,1224
 ultralytics/cfg/datasets/DOTAv1.yaml,sha256=j_DvXVQzZ4dQmf8I7oPX4v9xO3WZXztxV4Xo9VhUTsM,1194
@@ -121,7 +121,7 @@ ultralytics/engine/exporter.py,sha256=aaZ_-np1q0klWtDXp6CxVjyiZ0DDXx-8Pqg4jZSByu
 ultralytics/engine/model.py,sha256=37qGh6aqqPTUyMfpsvBQMaZ1Av7eJDe6mfRl9GvlfKg,52860
 ultralytics/engine/predictor.py,sha256=YJ5l-0qIpr6JAJxowswtZ0IqmXBqVTvAA9vR40v0sCM,21752
 ultralytics/engine/results.py,sha256=-JPBn_YMyZv6HhdlyhjRIZCcMf41LTyWID7JrEP64rc,79632
-ultralytics/engine/trainer.py,sha256=1J_by51vXccnF-uCB_40eUsuPLDexCEWv4775v7RrAQ,38859
+ultralytics/engine/trainer.py,sha256=sQCtjCI7_qOvXp4z-OPIQB1Nnqgeoi8YAIJAiCs_OOY,38951
 ultralytics/engine/tuner.py,sha256=zEW1UpLlZ6N4xbvS7MxICkshRlaFgLNfuADA0VfRpao,12629
 ultralytics/engine/validator.py,sha256=jfV81wuFDgrVVXEcPzgOpxAPrAZn-1LgpKwu9l_1-ts,17050
 ultralytics/hub/__init__.py,sha256=wDtAUKdfqob95tfFHgDJFXcsNSDSdoIQkJTm-CfIUTI,6616
@@ -230,10 +230,11 @@ ultralytics/trackers/utils/__init__.py,sha256=lm6MckFYCPTbqIoX7w0s_daxdjNeBeKW6D
 ultralytics/trackers/utils/gmc.py,sha256=dz3I5LbIv7h1__Xg7rGHecQFE32VFTe54tUnxb8F0Z8,14466
 ultralytics/trackers/utils/kalman_filter.py,sha256=A0CqOnnaKH6kr0XwuHzyHmIU6aJAjJYxF9jVlNBKZHo,21326
 ultralytics/trackers/utils/matching.py,sha256=7eIufSdeN7cXuFMjvcfvz0Ldq84m4YKZl5IGxBR8IIo,7169
-ultralytics/utils/__init__.py,sha256=mmLPuinPhaSyvSfDdsyADIjlJQ2ow5z3OhYFo2NxwE0,52679
+ultralytics/utils/__init__.py,sha256=YSBOQcgak2v6l03EHPjkpzH-ZtjVXrg2_4o0BF1cqDQ,52807
 ultralytics/utils/autobatch.py,sha256=kg05q2qKg74y_Uq2vvr01i3KhLfpVR7sT0IXBt3_kyI,4921
-ultralytics/utils/benchmarks.py,sha256=Tcmq8e04Gw5nNtV4vXIWnr7zfV21PQ6Tqg_0srbt-fc,30162
-ultralytics/utils/checks.py,sha256=NtDOmKMmsiOiOecjBoaLFQLp2K_kr7LFFO-gxSBDgYU,32688
+ultralytics/utils/autodevice.py,sha256=OrLSk34UpW0I5ndxnkQEIWBxL--CvAON_W9Qw51zOGA,7233
+ultralytics/utils/benchmarks.py,sha256=1Y6R1DxdSOzeHRsKKgMOab_bdtEWF9z32HOU2hqgzss,30172
+ultralytics/utils/checks.py,sha256=Z87AuJ3C5JcTVYdhAn31BFErmF48bRyMc4_WZ9ku5-E,32711
 ultralytics/utils/dist.py,sha256=aytW0JEkcA5ZTZucV92ot7Bn-apiej8aLk3QNWicjAc,4103
 ultralytics/utils/downloads.py,sha256=Rn8xDwn2bzgBqiYz3Xn0rm3MWjk4T-QUd2Ajlu1EpQ4,22312
 ultralytics/utils/errors.py,sha256=vY9h2evFSrHnZdHJVVrmm8Zzw4qVDLyo9DeYW5g0dFk,1573
@@ -246,7 +247,7 @@ ultralytics/utils/ops.py,sha256=YFwPrKlPcgEmgAWqnJVR0Ccx5NQgp5e3P-YYHwVSP0k,3477
 ultralytics/utils/patches.py,sha256=6rVT-l8WDp_Py3O-gZdv9t3PnrYRRkrX_lF3mZ1XS8c,4928
 ultralytics/utils/plotting.py,sha256=8n9G1RvFAv4fk09iqZt7D-VXUqfAHoOTBcGXE7BHEE0,46807
 ultralytics/utils/tal.py,sha256=P5nPoR9qNnFuDIda0fsn8WP6m1V8r7EbvXUuhNRFFTA,20805
-ultralytics/utils/torch_utils.py,sha256=SOdT9asxyQ-MEJGZQIH_Va9jcbonjISeHOwiFg1gRYE,39180
+ultralytics/utils/torch_utils.py,sha256=2SJxxg8Qr0YqOoQ-8qAYn6VrzZdQMObqiw3CJZ-rAY0,39611
 ultralytics/utils/triton.py,sha256=xK9Db_ZUVDnIK1u76S2G-6ulIBsLfj9HN_YOaSrnMuU,5304
 ultralytics/utils/tuner.py,sha256=0Bp7l5dWZe1RzdvAIa11wQoX6eoAaoNRcA-EAnpofbk,6755
 ultralytics/utils/callbacks/__init__.py,sha256=hzL63Rce6VkZhP4Lcim9LKjadixaQG86nKqPhk7IkS0,242
@@ -260,9 +261,9 @@ ultralytics/utils/callbacks/neptune.py,sha256=JaI95Cj2kIjUhlEEOiDN0-Drc-fDelLhNI
 ultralytics/utils/callbacks/raytune.py,sha256=A8amUGpux7dYES-L1iSeMoMXBySGWCD1aUqT7vcG-pU,1284
 ultralytics/utils/callbacks/tensorboard.py,sha256=jgYnym3cUQFAgN1GzTyO7l3jINtfAh8zhrllDvnLuVQ,5339
 ultralytics/utils/callbacks/wb.py,sha256=iDRFXI4IIDm8R5OI89DMTmjs8aHLo1HRCLkOFKdaMG4,7507
-ultralytics-8.3.125.dist-info/licenses/LICENSE,sha256=DZak_2itbUtvHzD3E7GNUYSRK6jdOJ-GqncQ2weavLA,34523
-ultralytics-8.3.125.dist-info/METADATA,sha256=Z_UvZKfIDM36rzOfTtP77x_sD2rdAApQONjqSwDs6KI,37180
-ultralytics-8.3.125.dist-info/WHEEL,sha256=GHB6lJx2juba1wDgXDNlMTyM13ckjBMKf-OnwgKOCtA,91
-ultralytics-8.3.125.dist-info/entry_points.txt,sha256=YM_wiKyTe9yRrsEfqvYolNO5ngwfoL4-NwgKzc8_7sI,93
-ultralytics-8.3.125.dist-info/top_level.txt,sha256=XP49TwiMw4QGsvTLSYiJhz1xF_k7ev5mQ8jJXaXi45Q,12
-ultralytics-8.3.125.dist-info/RECORD,,
+ultralytics-8.3.126.dist-info/licenses/LICENSE,sha256=DZak_2itbUtvHzD3E7GNUYSRK6jdOJ-GqncQ2weavLA,34523
+ultralytics-8.3.126.dist-info/METADATA,sha256=zkgsqHwnXIUCbSDzK_gK_HunHRJAQvvvIgix7NOzXgw,37180
+ultralytics-8.3.126.dist-info/WHEEL,sha256=GHB6lJx2juba1wDgXDNlMTyM13ckjBMKf-OnwgKOCtA,91
+ultralytics-8.3.126.dist-info/entry_points.txt,sha256=YM_wiKyTe9yRrsEfqvYolNO5ngwfoL4-NwgKzc8_7sI,93
+ultralytics-8.3.126.dist-info/top_level.txt,sha256=XP49TwiMw4QGsvTLSYiJhz1xF_k7ev5mQ8jJXaXi45Q,12
+ultralytics-8.3.126.dist-info/RECORD,,