dgenerate-ultralytics-headless 8.3.182__py3-none-any.whl → 8.3.184__py3-none-any.whl

{dgenerate_ultralytics_headless-8.3.182.dist-info → dgenerate_ultralytics_headless-8.3.184.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dgenerate-ultralytics-headless
-Version: 8.3.182
+Version: 8.3.184
 Summary: Automatically built Ultralytics package with python-opencv-headless dependency instead of python-opencv
 Author-email: Glenn Jocher <glenn.jocher@ultralytics.com>, Jing Qiu <jing.qiu@ultralytics.com>
 Maintainer-email: Ultralytics <hello@ultralytics.com>

{dgenerate_ultralytics_headless-8.3.182.dist-info → dgenerate_ultralytics_headless-8.3.184.dist-info}/RECORD

@@ -1,14 +1,14 @@
-dgenerate_ultralytics_headless-8.3.182.dist-info/licenses/LICENSE,sha256=DZak_2itbUtvHzD3E7GNUYSRK6jdOJ-GqncQ2weavLA,34523
+dgenerate_ultralytics_headless-8.3.184.dist-info/licenses/LICENSE,sha256=DZak_2itbUtvHzD3E7GNUYSRK6jdOJ-GqncQ2weavLA,34523
 tests/__init__.py,sha256=b4KP5_q-2IO8Br8YHOSLYnn7IwZS81l_vfEF2YPa2lM,894
 tests/conftest.py,sha256=LXtQJcFNWPGuzauTGkiXgsvVC3llJKfg22WcmhRzuQc,2593
 tests/test_cli.py,sha256=EMf5gTAopOnIz8VvzaM-Qb044o7D0flnUHYQ-2ffOM4,5670
-tests/test_cuda.py,sha256=-nQsfF3lGfqLm6cIeu_BCiXqLj7HzpL7R1GzPEc6z2I,8128
+tests/test_cuda.py,sha256=7RAMC1DoXpsRvH0Jfyo9cqHkaJZWcWeqniCW5BW87hY,8228
 tests/test_engine.py,sha256=Jpt2KVrltrEgh2-3Ykouz-2Z_2fza0eymL5ectRXadM,4922
 tests/test_exports.py,sha256=CY-4xVZlVM16vdyIC0mSR3Ix59aiZm1qjFGIhSNmB20,11007
 tests/test_integrations.py,sha256=kl_AKmE_Qs1GB0_91iVwbzNxofm_hFTt0zzU6JF-pg4,6323
-tests/test_python.py,sha256=-qvdeg-hEcKU5mWSDEU24iFZ-i8FAwQRznSXpkp6WQ4,27928
+tests/test_python.py,sha256=JbOB6pbTkoQtPCjkl_idagV0_W2QLWGbsh2IvGmru0M,28274
 tests/test_solutions.py,sha256=tuf6n_fsI8KvSdJrnc-cqP2qYdiYqCWuVrx0z9dOz3Q,13213
-ultralytics/__init__.py,sha256=NmFp8Z3Rk0s1QZu4IuBv2wLLf-Pc5DLFdycD5Y49Keg,730
+ultralytics/__init__.py,sha256=kmDSXeMJ22pJg_A2qaxP4Tfo1tvv2GgD4p-GFyVa2iI,730
 ultralytics/py.typed,sha256=la67KBlbjXN-_-DfGNcdOcjYumVpKG_Tkw-8n5dnGB4,8
 ultralytics/assets/bus.jpg,sha256=wCAZxJecGR63Od3ZRERe9Aja1Weayrb9Ug751DS_vGM,137419
 ultralytics/assets/zidane.jpg,sha256=Ftc4aeMmen1O0A3o6GCDO9FlfBslLpTAw0gnetx7bts,50427
@@ -110,7 +110,7 @@ ultralytics/data/annotator.py,sha256=uAgd7K-yudxiwdNqHz0ubfFg5JsfNlae4cgxdvCMyuY
 ultralytics/data/augment.py,sha256=Ps1s-ug_oXdyAz4Jyur6OmxzRlyzwP3VP-3hDalSxj8,132959
 ultralytics/data/base.py,sha256=mRcuehK1thNuuzQGL6D1AaZkod71oHRdYTod_zdQZQg,19688
 ultralytics/data/build.py,sha256=TfMLSPMbE2hGZVMLl178NTFrihC1-50jNOt1ex9elxw,11480
-ultralytics/data/converter.py,sha256=dExElV0vWd4EmDtZaFMC0clEmLdjRDIdFiXf01PUvQA,27134
+ultralytics/data/converter.py,sha256=G5IDSk9kJAERNeJC2G3FwV_CGZ6EKV9oyuf-uKbAmzA,32084
 ultralytics/data/dataset.py,sha256=GhoFzBiuGvTr_5-3pzgWu6D_3aQVwW-hcS7kCo8XscM,36752
 ultralytics/data/loaders.py,sha256=u9sExTGPy1iiqVd_p29zVoEkQ3C36g2rE0FEbYPET0A,31767
 ultralytics/data/split.py,sha256=F6O73bAbESj70FQZzqkydXQeXgPXGHGiC06b5MkLHjQ,5109
@@ -125,7 +125,7 @@ ultralytics/engine/exporter.py,sha256=Vr7K8Yf3wyf91ZvDpRosAohwa_W0oe4qW-JvqigCPf
 ultralytics/engine/model.py,sha256=877u2n0ISz2COOYtEMUqQe0E-HHB4Atb2DuH1XCE98k,53530
 ultralytics/engine/predictor.py,sha256=iXnUB-tvBHtVpKbB-5EKs1wSREBIerdUxWx39MaFYuk,22485
 ultralytics/engine/results.py,sha256=QcHcbPVlLBiy_APwABr-T5K65HR8Bl1rRzxawjjP76E,71873
-ultralytics/engine/trainer.py,sha256=28FeqASvQRxCaK96SXDM-BfPJjqy5KNiWhf8v6GXTug,39785
+ultralytics/engine/trainer.py,sha256=JtYRZ9vIB07VM2_Saqn7Jeu9s1W_hqG_um2EwjNckSU,40255
 ultralytics/engine/tuner.py,sha256=sfQ8_yzgLNcGlKyz9b2vAzyggGZXiQzdZ5tKstyqjHM,12825
 ultralytics/engine/validator.py,sha256=g0StH6WOn95zBN-hULDAR5Uug1pU2YkaeNH3zzq3SVg,16573
 ultralytics/hub/__init__.py,sha256=ulPtceI3hqud03mvqoXccBaa1e4nveYwC9cddyuBUlo,6599
@@ -194,7 +194,7 @@ ultralytics/models/yolo/yoloe/__init__.py,sha256=6SLytdJtwu37qewf7CobG7C7Wl1m-xt
 ultralytics/models/yolo/yoloe/predict.py,sha256=GmQxCQe7sLomAujde53jQzquzryNn6fEjS4Oalf3mPs,7124
 ultralytics/models/yolo/yoloe/train.py,sha256=XYpQYSnSD8vi_9VSj_S5oIsNUEqm3e66vPT8rNFI_HY,14086
 ultralytics/models/yolo/yoloe/train_seg.py,sha256=aCV7M8oQOvODFnU4piZdJh3tIrBJYAzZfRVRx1vRgxo,4956
-ultralytics/models/yolo/yoloe/val.py,sha256=yebPkxwKKt__cY05Zbh1YXg4_BKzzpcDc3Cv3FJ5SAA,9769
+ultralytics/models/yolo/yoloe/val.py,sha256=2NuERI3B3WeED658Cat1xL2SVpORUHlCHCWI3L8pJJc,9784
 ultralytics/nn/__init__.py,sha256=rjociYD9lo_K-d-1s6TbdWklPLjTcEHk7OIlRDJstIE,615
 ultralytics/nn/autobackend.py,sha256=UM9ObXeLB0lgak1Q5oSi2IA-R_Owr6NdJNBAsA3mSbo,41790
 ultralytics/nn/tasks.py,sha256=vw_TNacAv-RN24rusFzKuYL6qRBD7cve8EpB7gOlU_8,72505
@@ -236,7 +236,7 @@ ultralytics/trackers/utils/__init__.py,sha256=lm6MckFYCPTbqIoX7w0s_daxdjNeBeKW6D
 ultralytics/trackers/utils/gmc.py,sha256=9IvCf5MhBYY9ppVHykN02_oBWHmE98R8EaYFKaykdV0,14032
 ultralytics/trackers/utils/kalman_filter.py,sha256=PPmM0lwBMdT_hGojvfLoUsBUFMBBMNRAxKbMcQa3wJ0,21619
 ultralytics/trackers/utils/matching.py,sha256=uSYtywqi1lE_uNN1FwuBFPyISfDQXHMu8K5KH69nrRI,7160
-ultralytics/utils/__init__.py,sha256=KyczXn2SLR0g8xkCVpfNaPkhDCQ4A8vLt99teYu7mss,59437
+ultralytics/utils/__init__.py,sha256=aplfwLydgiAC4DQt3AO4gNh2U58z16ss5UTQkRd5Jz0,59643
 ultralytics/utils/autobatch.py,sha256=33m8YgggLIhltDqMXZ5OE-FGs2QiHrl2-LfgY1mI4cw,5119
 ultralytics/utils/autodevice.py,sha256=AvgXFt8c1Cg4icKh0Hbhhz8UmVQ2Wjyfdfkeb2C8zck,8855
 ultralytics/utils/benchmarks.py,sha256=btsi_B0mfLPfhE8GrsBpi79vl7SRam0YYngNFAsY8Ak,31035
@@ -247,8 +247,9 @@ ultralytics/utils/errors.py,sha256=XT9Ru7ivoBgofK6PlnyigGoa7Fmf5nEhyHtnD-8TRXI,1
 ultralytics/utils/export.py,sha256=LK-wlTlyb_zIKtSvOmfmvR70RcUU9Ct9UBDt5wn9_rY,9880
 ultralytics/utils/files.py,sha256=ZCbLGleiF0f-PqYfaxMFAWop88w7U1hpreHXl8b2ko0,8238
 ultralytics/utils/instance.py,sha256=dC83rHvQXciAED3rOiScFs3BOX9OI06Ey1mj9sjUKvs,19070
+ultralytics/utils/logger.py,sha256=wt1IWdfJGa6nZDLj54UBlupRJvcHW3QnkN7017avXf8,15142
 ultralytics/utils/loss.py,sha256=fbOWc3Iu0QOJiWbi-mXWA9-1otTYlehtmUsI7os7ydM,39799
-ultralytics/utils/metrics.py,sha256=tQjYxPd0dSzjucVyI1evIISunyYRkABXMXVQo64mAUE,68756
+ultralytics/utils/metrics.py,sha256=Q0cD4J1_7WRElv_En6YUM94l4SjE7XTF9LdZUMvrGys,68853
 ultralytics/utils/ops.py,sha256=8d60fbpntrexK3gPoLUS6mWAYGrtrQaQCOYyRJsCjuI,34521
 ultralytics/utils/patches.py,sha256=PPWiKzwGbCvuawLzDKVR8tWOQAlZbJBi8g_-A6eTCYA,6536
 ultralytics/utils/plotting.py,sha256=4TG_J8rz9VVPrOXbdjRHPJZVgJrFYVmEYE0BcVDdolc,47745
@@ -257,18 +258,19 @@ ultralytics/utils/torch_utils.py,sha256=D76Pvmw5OKh-vd4aJkOMO0dSLbM5WzGr7Hmds54h
 ultralytics/utils/triton.py,sha256=M7qe4RztiADBJQEWQKaIQsp94ERFJ_8_DUHDR6TXEOM,5410
 ultralytics/utils/tuner.py,sha256=bHr09Fz-0-t0ei55gX5wJh-obyiAQoicP7HUVM2I8qA,6826
 ultralytics/utils/callbacks/__init__.py,sha256=hzL63Rce6VkZhP4Lcim9LKjadixaQG86nKqPhk7IkS0,242
-ultralytics/utils/callbacks/base.py,sha256=OJ6z4AYVCtXO-w6PSDRiwo1Tc2RYes-BzwKTsr9g_h0,6821
+ultralytics/utils/callbacks/base.py,sha256=dGir0vkJY4jjprW63e23Qy4kHUT5dOINPii6HnwJuPg,6893
 ultralytics/utils/callbacks/clearml.py,sha256=xr5mZT_cY6AY_drbdCXFt-Dp2fOjRELxLDhDoRhNPg8,6067
 ultralytics/utils/callbacks/comet.py,sha256=Ytv-dalpMBH36qsYIpU_VruREa9BVwFJzYDacZslEQU,25394
 ultralytics/utils/callbacks/dvc.py,sha256=NV0DXMQ1B5Sk5fmh60QFUGkifrAz-vwit5qhdfsyqXc,7511
-ultralytics/utils/callbacks/hub.py,sha256=1RmGiCaog1GoTya9OAyGELbQ2Lk5X3EWh7RYMxns0so,4177
+ultralytics/utils/callbacks/hub.py,sha256=IZ8lldLfxI0SvMnG9aWGWj59JFSks_x11L2is26ajd0,4123
 ultralytics/utils/callbacks/mlflow.py,sha256=6K8I5zij1yq3TUW9c5BBQNqdzz3IXugQjwKoBOvV6ag,5344
 ultralytics/utils/callbacks/neptune.py,sha256=j8pecmlcsM8FGzLKWoBw5xUsi5t8E5HuxY7TR5Um_O8,4612
+ultralytics/utils/callbacks/platform.py,sha256=gdbEuedXEs1VjdU0IiedjPFwttZJUiI0dJoImU3G_Gc,1999
 ultralytics/utils/callbacks/raytune.py,sha256=S6Bq16oQDQ8BQgnZzA0zJHGN_BBr8iAM_WtGoLiEcwg,1283
 ultralytics/utils/callbacks/tensorboard.py,sha256=MDPBW7aDes-66OE6YqKXXvqA_EocjzEMHWGM-8z9vUQ,5281
 ultralytics/utils/callbacks/wb.py,sha256=Tm_-aRr2CN32MJkY9tylpMBJkb007-MSRNSQ7rDJ5QU,7521
-dgenerate_ultralytics_headless-8.3.182.dist-info/METADATA,sha256=9mclDbKNmjy6iHAfrNiWQ6ub-pJajkvFPmjeHl25Ios,38727
-dgenerate_ultralytics_headless-8.3.182.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-dgenerate_ultralytics_headless-8.3.182.dist-info/entry_points.txt,sha256=YM_wiKyTe9yRrsEfqvYolNO5ngwfoL4-NwgKzc8_7sI,93
-dgenerate_ultralytics_headless-8.3.182.dist-info/top_level.txt,sha256=XP49TwiMw4QGsvTLSYiJhz1xF_k7ev5mQ8jJXaXi45Q,12
-dgenerate_ultralytics_headless-8.3.182.dist-info/RECORD,,
+dgenerate_ultralytics_headless-8.3.184.dist-info/METADATA,sha256=s5PJHuylLREG_7dPoVmmgQTYS3b9dpzn5UkOtI6eaTw,38727
+dgenerate_ultralytics_headless-8.3.184.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+dgenerate_ultralytics_headless-8.3.184.dist-info/entry_points.txt,sha256=YM_wiKyTe9yRrsEfqvYolNO5ngwfoL4-NwgKzc8_7sI,93
+dgenerate_ultralytics_headless-8.3.184.dist-info/top_level.txt,sha256=XP49TwiMw4QGsvTLSYiJhz1xF_k7ev5mQ8jJXaXi45Q,12
+dgenerate_ultralytics_headless-8.3.184.dist-info/RECORD,,

tests/test_cuda.py

@@ -67,7 +67,7 @@ def test_export_onnx_matrix(task, dynamic, int8, half, batch, simplify, nms):
         half=half,
         batch=batch,
         simplify=simplify,
-        nms=nms,
+        nms=nms and task != "obb",  # disable NMS for OBB task for now on T4 instance
         device=DEVICES[0],
     )
     YOLO(file)([SOURCE] * batch, imgsz=64 if dynamic else 32, device=DEVICES[0])  # exported model inference
@@ -163,7 +163,7 @@ def test_autobatch():
 
 
 @pytest.mark.slow
-@pytest.mark.skipif(not DEVICES, reason="No CUDA devices available")
+@pytest.mark.skipif(True, reason="Skip for now since T4 instance does not support TensorRT > 10.0")
 def test_utils_benchmarks():
     """Profile YOLO models for performance benchmarks."""
     from ultralytics.utils.benchmarks import ProfileModels

tests/test_python.py

@@ -228,6 +228,15 @@ def test_train_scratch():
     model(SOURCE)
 
 
+@pytest.mark.skipif(not ONLINE, reason="environment is offline")
+def test_train_ndjson():
+    """Test training the YOLO model using NDJSON format dataset."""
+    model = YOLO(WEIGHTS_DIR / "yolo11n.pt")
+    model.train(
+        data="https://github.com/ultralytics/assets/releases/download/v0.0.0/coco8-ndjson.ndjson", epochs=1, imgsz=32
+    )
+
+
 @pytest.mark.parametrize("scls", [False, True])
 def test_train_pretrained(scls):
     """Test training of the YOLO model starting from a pre-trained checkpoint."""

ultralytics/__init__.py

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

ultralytics/data/converter.py

@@ -1,5 +1,6 @@
 # Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
 
+import asyncio
 import json
 import random
 import shutil
@@ -12,7 +13,8 @@ import cv2
 import numpy as np
 from PIL import Image
 
-from ultralytics.utils import DATASETS_DIR, LOGGER, NUM_THREADS, TQDM
+from ultralytics.utils import DATASETS_DIR, LOGGER, NUM_THREADS, TQDM, YAML
+from ultralytics.utils.checks import check_file, check_requirements
 from ultralytics.utils.downloads import download, zip_directory
 from ultralytics.utils.files import increment_path
 
@@ -754,3 +756,113 @@ def convert_to_multispectral(path: Union[str, Path], n_channels: int = 10, repla
         multispectral = f(target_wavelengths)
         cv2.imwritemulti(str(output_path), np.clip(multispectral, 0, 255).astype(np.uint8).transpose(2, 0, 1))
         LOGGER.info(f"Converted {output_path}")
+
+
+async def convert_ndjson_to_yolo(ndjson_path: Union[str, Path], output_path: Optional[Union[str, Path]] = None) -> Path:
+    """
+    Convert NDJSON dataset format to Ultralytics YOLO11 dataset structure.
+
+    This function converts datasets stored in NDJSON (Newline Delimited JSON) format to the standard YOLO
+    format with separate directories for images and labels. It supports parallel processing for efficient
+    conversion of large datasets and can download images from URLs if they don't exist locally.
+
+    The NDJSON format consists of:
+    - First line: Dataset metadata with class names and configuration
+    - Subsequent lines: Individual image records with annotations and optional URLs
+
+    Args:
+        ndjson_path (Union[str, Path]): Path to the input NDJSON file containing dataset information.
+        output_path (Optional[Union[str, Path]], optional): Directory where the converted YOLO dataset
+            will be saved. If None, uses the parent directory of the NDJSON file. Defaults to None.
+
+    Returns:
+        (Path): Path to the generated data.yaml file that can be used for YOLO training.
+
+    Examples:
+        Convert a local NDJSON file:
+        >>> yaml_path = convert_ndjson_to_yolo("dataset.ndjson")
+        >>> print(f"Dataset converted to: {yaml_path}")
+
+        Convert with custom output directory:
+        >>> yaml_path = convert_ndjson_to_yolo("dataset.ndjson", output_path="./converted_datasets")
+
+        Use with YOLO training
+        >>> from ultralytics import YOLO
+        >>> model = YOLO("yolo11n.pt")
+        >>> model.train(data="https://github.com/ultralytics/assets/releases/download/v0.0.0/coco8-ndjson.ndjson")
+    """
+    check_requirements("aiohttp")
+    import aiohttp
+
+    ndjson_path = Path(check_file(ndjson_path))
+    output_path = Path(output_path or DATASETS_DIR)
+    with open(ndjson_path) as f:
+        lines = [json.loads(line.strip()) for line in f if line.strip()]
+
+    dataset_record, image_records = lines[0], lines[1:]
+    dataset_dir = output_path / ndjson_path.stem
+    splits = {record["split"] for record in image_records}
+
+    # Create directories and prepare YAML structure
+    dataset_dir.mkdir(parents=True, exist_ok=True)
+    data_yaml = dict(dataset_record)
+    data_yaml["names"] = {int(k): v for k, v in dataset_record.get("class_names", {}).items()}
+    data_yaml.pop("class_names")
+
+    for split in sorted(splits):
+        (dataset_dir / "images" / split).mkdir(parents=True, exist_ok=True)
+        (dataset_dir / "labels" / split).mkdir(parents=True, exist_ok=True)
+        data_yaml[split] = f"images/{split}"
+
+    async def process_record(session, semaphore, record):
+        """Process single image record with async session."""
+        async with semaphore:
+            split, original_name = record["split"], record["file"]
+            label_path = dataset_dir / "labels" / split / f"{Path(original_name).stem}.txt"
+            image_path = dataset_dir / "images" / split / original_name
+
+            annotations = record.get("annotations", {})
+            lines_to_write = []
+            for key in annotations.keys():
+                lines_to_write = [" ".join(map(str, item)) for item in annotations[key]]
+                break
+            if "classification" in annotations:
+                lines_to_write = [str(cls) for cls in annotations["classification"]]
+
+            label_path.write_text("\n".join(lines_to_write) + "\n" if lines_to_write else "")
+
+            if http_url := record.get("url"):
+                if not image_path.exists():
+                    try:
+                        async with session.get(http_url, timeout=aiohttp.ClientTimeout(total=30)) as response:
+                            response.raise_for_status()
+                            with open(image_path, "wb") as f:
+                                async for chunk in response.content.iter_chunked(8192):
+                                    f.write(chunk)
+                        return True
+                    except Exception as e:
+                        LOGGER.warning(f"Failed to download {http_url}: {e}")
+                        return False
+            return True
+
+    # Process all images with async downloads
+    semaphore = asyncio.Semaphore(64)
+    async with aiohttp.ClientSession() as session:
+        pbar = TQDM(
+            total=len(image_records),
+            desc=f"Converting {ndjson_path.name} → {dataset_dir} ({len(image_records)} images)",
+        )
+
+        async def tracked_process(record):
+            result = await process_record(session, semaphore, record)
+            pbar.update(1)
+            return result
+
+        await asyncio.gather(*[tracked_process(record) for record in image_records])
+        pbar.close()
+
+    # Write data.yaml
+    yaml_path = dataset_dir / "data.yaml"
+    YAML.save(yaml_path, data_yaml)
+
+    return yaml_path

ultralytics/engine/trainer.py

@@ -174,6 +174,8 @@ class BaseTrainer:
         self.callbacks = _callbacks or callbacks.get_default_callbacks()
         if RANK in {-1, 0}:
             callbacks.add_integration_callbacks(self)
+            # Start console logging immediately at trainer initialization
+            self.run_callbacks("on_pretrain_routine_start")
 
     def add_callback(self, event: str, callback):
         """Append the given callback to the event's callback list."""
@@ -249,8 +251,6 @@ class BaseTrainer:
 
     def _setup_train(self, world_size):
         """Build dataloaders and optimizer on correct rank process."""
-        # Model
-        self.run_callbacks("on_pretrain_routine_start")
         ckpt = self.setup_model()
         self.model = self.model.to(self.device)
         self.set_model_attributes()
@@ -598,6 +598,15 @@ class BaseTrainer:
         try:
             if self.args.task == "classify":
                 data = check_cls_dataset(self.args.data)
+            elif self.args.data.rsplit(".", 1)[-1] == "ndjson":
+                # Convert NDJSON to YOLO format
+                import asyncio
+
+                from ultralytics.data.converter import convert_ndjson_to_yolo
+
+                yaml_path = asyncio.run(convert_ndjson_to_yolo(self.args.data))
+                self.args.data = str(yaml_path)
+                data = check_det_dataset(self.args.data)
             elif self.args.data.rsplit(".", 1)[-1] in {"yaml", "yml"} or self.args.task in {
                 "detect",
                 "segment",

ultralytics/models/yolo/yoloe/val.py

@@ -181,7 +181,7 @@ class YOLOEDetectValidator(DetectionValidator):
         else:
             if refer_data is not None:
                 assert load_vp, "Refer data is only used for visual prompt validation."
-            self.device = select_device(self.args.device)
+            self.device = select_device(self.args.device, verbose=False)
 
             if isinstance(model, (str, Path)):
                 from ultralytics.nn.tasks import attempt_load_weights

ultralytics/utils/__init__.py

@@ -170,6 +170,7 @@ class TQDM(rich.tqdm if TQDM_RICH else tqdm.tqdm):
         Notes:
             - The progress bar is disabled if VERBOSE is False or if 'disable' is explicitly set to True in kwargs.
             - The default bar format is set to TQDM_BAR_FORMAT unless overridden in kwargs.
+            - In GitHub Actions, progress bars only update at completion to keep CI logs clean.
 
         Examples:
             >>> from ultralytics.utils import TQDM
@@ -178,6 +179,8 @@ class TQDM(rich.tqdm if TQDM_RICH else tqdm.tqdm):
             ...     pass
         """
         warnings.filterwarnings("ignore", category=tqdm.TqdmExperimentalWarning)  # suppress tqdm.rich warning
+        if is_github_action_running():
+            kwargs["mininterval"] = 60  # only update every 60 seconds
         kwargs["disable"] = not VERBOSE or kwargs.get("disable", False) or LOGGER.getEffectiveLevel() > 20
         kwargs.setdefault("bar_format", TQDM_BAR_FORMAT)  # override default value if passed
         super().__init__(*args, **kwargs)

ultralytics/utils/callbacks/base.py

@@ -209,10 +209,11 @@ def add_integration_callbacks(instance):
         >>> trainer = BaseTrainer()
         >>> add_integration_callbacks(trainer)
     """
-    # Load HUB callbacks
     from .hub import callbacks as hub_cb
+    from .platform import callbacks as platform_cb
 
-    callbacks_list = [hub_cb]
+    # Load Ultralytics callbacks
+    callbacks_list = [hub_cb, platform_cb]
 
     # Load training callbacks
     if "Trainer" in instance.__class__.__name__:

ultralytics/utils/callbacks/hub.py

@@ -106,4 +106,4 @@ callbacks = (
     }
     if SETTINGS["hub"] is True
     else {}
-)  # verify hub is enabled before registering callbacks
+)

ultralytics/utils/callbacks/platform.py

@@ -0,0 +1,72 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+from ultralytics.utils import RANK, SETTINGS
+from ultralytics.utils.logger import DEFAULT_LOG_PATH, ConsoleLogger, SystemLogger
+
+
+def on_pretrain_routine_start(trainer):
+    """Initialize and start console logging immediately at the very beginning."""
+    if RANK in {-1, 0}:
+        trainer.system_logger = SystemLogger()
+        trainer.console_logger = ConsoleLogger(DEFAULT_LOG_PATH)
+        trainer.console_logger.start_capture()
+
+
+def on_pretrain_routine_end(trainer):
+    """Handle pre-training routine completion event."""
+    pass
+
+
+def on_fit_epoch_end(trainer):
+    """Handle end of training epoch event and collect system metrics."""
+    if RANK in {-1, 0} and hasattr(trainer, "system_logger"):
+        system_metrics = trainer.system_logger.get_metrics()
+        print(system_metrics)  # for debug
+
+
+def on_model_save(trainer):
+    """Handle model checkpoint save event."""
+    pass
+
+
+def on_train_end(trainer):
+    """Stop console capture and finalize logs."""
+    if logger := getattr(trainer, "console_logger", None):
+        logger.stop_capture()
+
+
+def on_train_start(trainer):
+    """Handle training start event."""
+    pass
+
+
+def on_val_start(validator):
+    """Handle validation start event."""
+    pass
+
+
+def on_predict_start(predictor):
+    """Handle prediction start event."""
+    pass
+
+
+def on_export_start(exporter):
+    """Handle model export start event."""
+    pass
+
+
+callbacks = (
+    {
+        "on_pretrain_routine_start": on_pretrain_routine_start,
+        "on_pretrain_routine_end": on_pretrain_routine_end,
+        "on_fit_epoch_end": on_fit_epoch_end,
+        "on_model_save": on_model_save,
+        "on_train_end": on_train_end,
+        "on_train_start": on_train_start,
+        "on_val_start": on_val_start,
+        "on_predict_start": on_predict_start,
+        "on_export_start": on_export_start,
+    }
+    if SETTINGS.get("platform", False) is True  # disabled for debugging
+    else {}
+)

ultralytics/utils/logger.py

@@ -0,0 +1,408 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+import logging
+import queue
+import shutil
+import sys
+import threading
+import time
+from datetime import datetime
+from pathlib import Path
+
+import psutil
+import requests
+
+from ultralytics.utils import MACOS, RANK
+from ultralytics.utils.checks import check_requirements
+
+# Initialize default log file
+DEFAULT_LOG_PATH = Path("train.log")
+if RANK in {-1, 0} and DEFAULT_LOG_PATH.exists():
+    DEFAULT_LOG_PATH.unlink(missing_ok=True)
+
+
+class ConsoleLogger:
+    """
+    Console output capture with API/file streaming and deduplication.
+
+    Captures stdout/stderr output and streams it to either an API endpoint or local file, with intelligent
+    deduplication to reduce noise from repetitive console output.
+
+    Attributes:
+        destination (str | Path): Target destination for streaming (URL or Path object).
+        is_api (bool): Whether destination is an API endpoint (True) or local file (False).
+        original_stdout: Reference to original sys.stdout for restoration.
+        original_stderr: Reference to original sys.stderr for restoration.
+        log_queue (queue.Queue): Thread-safe queue for buffering log messages.
+        active (bool): Whether console capture is currently active.
+        worker_thread (threading.Thread): Background thread for processing log queue.
+        last_line (str): Last processed line for deduplication.
+        last_time (float): Timestamp of last processed line.
+        last_progress_line (str): Last progress bar line for progress deduplication.
+        last_was_progress (bool): Whether the last line was a progress bar.
+
+    Examples:
+        Basic file logging:
+        >>> logger = ConsoleLogger("training.log")
+        >>> logger.start_capture()
+        >>> print("This will be logged")
+        >>> logger.stop_capture()
+
+        API streaming:
+        >>> logger = ConsoleLogger("https://api.example.com/logs")
+        >>> logger.start_capture()
+        >>> # All output streams to API
+        >>> logger.stop_capture()
+    """
+
+    def __init__(self, destination):
+        """
+        Initialize with API endpoint or local file path.
+
+        Args:
+            destination (str | Path): API endpoint URL (http/https) or local file path for streaming output.
+        """
+        self.destination = destination
+        self.is_api = isinstance(destination, str) and destination.startswith(("http://", "https://"))
+        if not self.is_api:
+            self.destination = Path(destination)
+
+        # Console capture
+        self.original_stdout = sys.stdout
+        self.original_stderr = sys.stderr
+        self.log_queue = queue.Queue(maxsize=1000)
+        self.active = False
+        self.worker_thread = None
+
+        # State tracking
+        self.last_line = ""
+        self.last_time = 0.0
+        self.last_progress_line = ""  # Track 100% progress lines separately
+        self.last_was_progress = False  # Track if last line was a progress bar
+
+    def start_capture(self):
+        """Start capturing console output and redirect stdout/stderr to custom capture objects."""
+        if self.active:
+            return
+
+        self.active = True
+        sys.stdout = self._ConsoleCapture(self.original_stdout, self._queue_log)
+        sys.stderr = self._ConsoleCapture(self.original_stderr, self._queue_log)
+
+        # Hook Ultralytics logger
+        try:
+            handler = self._LogHandler(self._queue_log)
+            logging.getLogger("ultralytics").addHandler(handler)
+        except Exception:
+            pass
+
+        self.worker_thread = threading.Thread(target=self._stream_worker, daemon=True)
+        self.worker_thread.start()
+
+    def stop_capture(self):
+        """Stop capturing console output and restore original stdout/stderr."""
+        if not self.active:
+            return
+
+        self.active = False
+        sys.stdout = self.original_stdout
+        sys.stderr = self.original_stderr
+        self.log_queue.put(None)
+
+    def _queue_log(self, text):
+        """Queue console text with deduplication and timestamp processing."""
+        if not self.active:
+            return
+
+        current_time = time.time()
+
+        # Handle carriage returns and process lines
+        if "\r" in text:
+            text = text.split("\r")[-1]
+
+        lines = text.split("\n")
+        if lines and lines[-1] == "":
+            lines.pop()
+
+        for line in lines:
+            line = line.rstrip()
+
+            # Handle progress bars - only show 100% completions
+            if ("it/s" in line and ("%|" in line or "━" in line)) or (
+                "100%" in line and ("it/s" in line or "[" in line)
+            ):
+                if "100%" not in line:
+                    continue
+                # Dedupe 100% lines by core content (strip timing)
+                progress_core = line.split("[")[0].split("]")[0].strip()
+                if progress_core == self.last_progress_line:
+                    continue
+                self.last_progress_line = progress_core
+                self.last_was_progress = True
+            else:
+                # Skip empty line after progress bar
+                if not line and self.last_was_progress:
+                    self.last_was_progress = False
+                    continue
+                self.last_was_progress = False
+
+            # General deduplication
+            if line == self.last_line and current_time - self.last_time < 0.1:
+                continue
+
+            self.last_line = line
+            self.last_time = current_time
+
+            # Add timestamp if needed
+            if not line.startswith("[20"):
+                timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+                line = f"[{timestamp}] {line}"
+
+            # Queue with overflow protection
+            if not self._safe_put(f"{line}\n"):
+                continue  # Skip if queue handling fails
+
+    def _safe_put(self, item):
+        """Safely put item in queue with overflow handling."""
+        try:
+            self.log_queue.put_nowait(item)
+            return True
+        except queue.Full:
+            try:
+                self.log_queue.get_nowait()  # Drop oldest
+                self.log_queue.put_nowait(item)
+                return True
+            except queue.Empty:
+                return False
+
+    def _stream_worker(self):
+        """Background worker for streaming logs to destination."""
+        while self.active:
+            try:
+                log_text = self.log_queue.get(timeout=1)
+                if log_text is None:
+                    break
+                self._write_log(log_text)
+            except queue.Empty:
+                continue
+
+    def _write_log(self, text):
+        """Write log to API endpoint or local file destination."""
+        try:
+            if self.is_api:
+                payload = {"timestamp": datetime.now().isoformat(), "message": text.strip()}
+                requests.post(self.destination, json=payload, timeout=5)
+            else:
+                self.destination.parent.mkdir(parents=True, exist_ok=True)
+                with self.destination.open("a", encoding="utf-8") as f:
+                    f.write(text)
+        except Exception as e:
+            print(f"Platform logging error: {e}", file=self.original_stderr)
+
+    class _ConsoleCapture:
+        """Lightweight stdout/stderr capture."""
+
+        __slots__ = ("original", "callback")
+
+        def __init__(self, original, callback):
+            self.original = original
+            self.callback = callback
+
+        def write(self, text):
+            self.original.write(text)
+            self.callback(text)
+
+        def flush(self):
+            self.original.flush()
+
+    class _LogHandler(logging.Handler):
+        """Lightweight logging handler."""
+
+        __slots__ = ("callback",)
+
+        def __init__(self, callback):
+            super().__init__()
+            self.callback = callback
+
+        def emit(self, record):
+            self.callback(self.format(record) + "\n")
+
+
+class SystemLogger:
+    """
+    Log dynamic system metrics for training monitoring.
+
+    Captures real-time system metrics including CPU, RAM, disk I/O, network I/O, and NVIDIA GPU statistics for
+    training performance monitoring and analysis.
+
+    Attributes:
+        pynvml: NVIDIA pynvml module instance if successfully imported, None otherwise.
+        nvidia_initialized (bool): Whether NVIDIA GPU monitoring is available and initialized.
+        process (psutil.Process): Current psutil.Process instance for process-specific metrics.
+        net_start: Initial network I/O counters for calculating cumulative usage.
+        disk_start: Initial disk I/O counters for calculating cumulative usage.
+
+    Examples:
+        Basic usage:
+        >>> logger = SystemLogger()
+        >>> metrics = logger.get_metrics()
+        >>> print(f"CPU: {metrics['cpu']}%, RAM: {metrics['ram']}%")
+        >>> if metrics["gpus"]:
+        ...     gpu0 = metrics["gpus"]["0"]
+        ...     print(f"GPU0: {gpu0['usage']}% usage, {gpu0['temp']}°C")
+
+        Training loop integration:
+        >>> system_logger = SystemLogger()
+        >>> for epoch in range(epochs):
+        ...     # Training code here
+        ...     metrics = system_logger.get_metrics()
+        ...     # Log to database/file
+    """
+
+    def __init__(self):
+        """Initialize the system logger."""
+        self.pynvml = None
+        self.nvidia_initialized = self._init_nvidia()
+        self.process = psutil.Process()
+        self.net_start = psutil.net_io_counters()
+        self.disk_start = psutil.disk_io_counters()
+
+    def _init_nvidia(self):
+        """Initialize NVIDIA GPU monitoring with pynvml."""
+        try:
+            assert not MACOS
+            check_requirements("pynvml>=12.0.0")
+            self.pynvml = __import__("pynvml")
+            self.pynvml.nvmlInit()
+            return True
+        except Exception:
+            return False
+
+    def get_metrics(self):
+        """
+        Get current system metrics.
+
+        Collects comprehensive system metrics including CPU usage, RAM usage, disk I/O statistics,
+        network I/O statistics, and GPU metrics (if available). Example output:
+
+        ```json
+        {
+            'cpu': 45.2,
+            'ram': 78.9,
+            'disk': {'read_mb': 156.7, 'write_mb': 89.3, 'used_gb': 256.8},
+            'network': {'recv_mb': 157.2, 'sent_mb': 89.1},
+            'gpus': {
+                0: {'usage': 95.6, 'memory': 85.4, 'temp': 72, 'power': 285},
+                1: {'usage': 94.1, 'memory': 82.7, 'temp': 70, 'power': 278}
+            }
+        }
+        ```
+
+        - cpu (float): CPU usage percentage (0-100%)
+        - ram (float): RAM usage percentage (0-100%)
+        - disk (dict):
+            - read_mb (float): Cumulative disk read in MB since initialization
+            - write_mb (float): Cumulative disk write in MB since initialization
+            - used_gb (float): Total disk space used in GB
+        - network (dict):
+            - recv_mb (float): Cumulative network received in MB since initialization
+            - sent_mb (float): Cumulative network sent in MB since initialization
+        - gpus (dict): GPU metrics by device index (e.g., 0, 1) containing:
+            - usage (int): GPU utilization percentage (0-100%)
+            - memory (float): CUDA memory usage percentage (0-100%)
+            - temp (int): GPU temperature in degrees Celsius
+            - power (int): GPU power consumption in watts
+
+        Returns:
+            (dict): System metrics containing 'cpu', 'ram', 'disk', 'network', 'gpus' with respective usage data.
+        """
+        net = psutil.net_io_counters()
+        disk = psutil.disk_io_counters()
+        memory = psutil.virtual_memory()
+        disk_usage = shutil.disk_usage("/")
+
+        metrics = {
+            "cpu": round(psutil.cpu_percent(), 3),
+            "ram": round(memory.percent, 3),
+            "disk": {
+                "read_mb": round((disk.read_bytes - self.disk_start.read_bytes) / (1 << 20), 3),
+                "write_mb": round((disk.write_bytes - self.disk_start.write_bytes) / (1 << 20), 3),
+                "used_gb": round(disk_usage.used / (1 << 30), 3),
+            },
+            "network": {
+                "recv_mb": round((net.bytes_recv - self.net_start.bytes_recv) / (1 << 20), 3),
+                "sent_mb": round((net.bytes_sent - self.net_start.bytes_sent) / (1 << 20), 3),
+            },
+            "gpus": {},
+        }
+
+        # Add GPU metrics (NVIDIA only)
+        if self.nvidia_initialized:
+            metrics["gpus"].update(self._get_nvidia_metrics())
+
+        return metrics
+
+    def _get_nvidia_metrics(self):
+        """Get NVIDIA GPU metrics including utilization, memory, temperature, and power."""
+        gpus = {}
+        if not self.nvidia_initialized or not self.pynvml:
+            return gpus
+        try:
+            device_count = self.pynvml.nvmlDeviceGetCount()
+            for i in range(device_count):
+                handle = self.pynvml.nvmlDeviceGetHandleByIndex(i)
+                util = self.pynvml.nvmlDeviceGetUtilizationRates(handle)
+                memory = self.pynvml.nvmlDeviceGetMemoryInfo(handle)
+                temp = self.pynvml.nvmlDeviceGetTemperature(handle, self.pynvml.NVML_TEMPERATURE_GPU)
+                power = self.pynvml.nvmlDeviceGetPowerUsage(handle) // 1000
+
+                gpus[str(i)] = {
+                    "usage": round(util.gpu, 3),
+                    "memory": round((memory.used / memory.total) * 100, 3),
+                    "temp": temp,
+                    "power": power,
+                }
+        except Exception:
+            pass
+        return gpus
+
+
+if __name__ == "__main__":
+    print("SystemLogger Real-time Metrics Monitor")
+    print("Press Ctrl+C to stop\n")
+
+    logger = SystemLogger()
+
+    try:
+        while True:
+            metrics = logger.get_metrics()
+
+            # Clear screen (works on most terminals)
+            print("\033[H\033[J", end="")
+
+            # Display system metrics
+            print(f"CPU: {metrics['cpu']:5.1f}%")
+            print(f"RAM: {metrics['ram']:5.1f}%")
+            print(f"Disk Read: {metrics['disk']['read_mb']:8.1f} MB")
+            print(f"Disk Write: {metrics['disk']['write_mb']:7.1f} MB")
+            print(f"Disk Used: {metrics['disk']['used_gb']:8.1f} GB")
+            print(f"Net Recv: {metrics['network']['recv_mb']:9.1f} MB")
+            print(f"Net Sent: {metrics['network']['sent_mb']:9.1f} MB")
+
+            # Display GPU metrics if available
+            if metrics["gpus"]:
+                print("\nGPU Metrics:")
+                for gpu_id, gpu_data in metrics["gpus"].items():
+                    print(
+                        f"  GPU {gpu_id}: {gpu_data['usage']:3}% | "
+                        f"Mem: {gpu_data['memory']:5.1f}% | "
+                        f"Temp: {gpu_data['temp']:2}°C | "
+                        f"Power: {gpu_data['power']:3}W"
+                    )
+            else:
+                print("\nGPU: No NVIDIA GPUs detected")
+
+            time.sleep(1)
+
+    except KeyboardInterrupt:
+        print("\n\nStopped monitoring.")

ultralytics/utils/metrics.py

@@ -1152,7 +1152,9 @@ class DetMetrics(SimpleClass, DataExportMixin):
     @property
     def results_dict(self) -> Dict[str, float]:
         """Return dictionary of computed performance metrics and statistics."""
-        return dict(zip(self.keys + ["fitness"], self.mean_results() + [self.fitness]))
+        keys = self.keys + ["fitness"]
+        values = ((float(x) if hasattr(x, "item") else x) for x in (self.mean_results() + [self.fitness]))
+        return dict(zip(keys, values))
 
     @property
     def curves(self) -> List[str]: