dgenerate-ultralytics-headless 8.3.242__py3-none-any.whl → 8.3.243__py3-none-any.whl

{dgenerate_ultralytics_headless-8.3.242.dist-info → dgenerate_ultralytics_headless-8.3.243.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dgenerate-ultralytics-headless
-Version: 8.3.242
+Version: 8.3.243
 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>
@@ -50,7 +50,7 @@ Requires-Dist: ipython; extra == "dev"
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: pytest-cov; extra == "dev"
 Requires-Dist: coverage[toml]; extra == "dev"
-Requires-Dist: zensical>=0.0.9; python_version >= "3.10" and extra == "dev"
+Requires-Dist: zensical>=0.0.15; python_version >= "3.10" and extra == "dev"
 Requires-Dist: mkdocs-ultralytics-plugin>=0.2.4; extra == "dev"
 Requires-Dist: minijinja>=2.0.0; extra == "dev"
 Provides-Extra: export

{dgenerate_ultralytics_headless-8.3.242.dist-info → dgenerate_ultralytics_headless-8.3.243.dist-info}/RECORD

@@ -1,4 +1,4 @@
-dgenerate_ultralytics_headless-8.3.242.dist-info/licenses/LICENSE,sha256=DZak_2itbUtvHzD3E7GNUYSRK6jdOJ-GqncQ2weavLA,34523
+dgenerate_ultralytics_headless-8.3.243.dist-info/licenses/LICENSE,sha256=DZak_2itbUtvHzD3E7GNUYSRK6jdOJ-GqncQ2weavLA,34523
 tests/__init__.py,sha256=bCox_hLdGRFYGLb2kd722VdNP2zEXNYNuLLYtqZSrbw,804
 tests/conftest.py,sha256=mOy9lGpNp7lk1hHl6_pVE0f9cU-72gnkoSm4TO-CNZU,2318
 tests/test_cli.py,sha256=GhIFHi-_WIJpDgoGNRi0DnjbfwP1wHbklBMnkCM-P_4,5464
@@ -8,7 +8,7 @@ tests/test_exports.py,sha256=UCLbjUnK8ZNldnJodrAxftUrwzO6ZNQxr7j64nDl9io,14137
 tests/test_integrations.py,sha256=6QgSh9n0J04RdUYz08VeVOnKmf4S5MDEQ0chzS7jo_c,6220
 tests/test_python.py,sha256=viMvRajIbDZdm64hRRg9i8qZ1sU9frwB69e56mxwEXk,29266
 tests/test_solutions.py,sha256=CIaphpmOXgz9AE9xcm1RWODKrwGfZLCc84IggGXArNM,14122
-ultralytics/__init__.py,sha256=oh5fizpewk5bLr7va83-trIOFOSneeHfFNRuV8zsHBw,1302
+ultralytics/__init__.py,sha256=UOIrYdbdS134a26TB2-qzRTQUcvvSJ2MpF96UESJcH4,1302
 ultralytics/py.typed,sha256=la67KBlbjXN-_-DfGNcdOcjYumVpKG_Tkw-8n5dnGB4,8
 ultralytics/assets/bus.jpg,sha256=wCAZxJecGR63Od3ZRERe9Aja1Weayrb9Ug751DS_vGM,137419
 ultralytics/assets/zidane.jpg,sha256=Ftc4aeMmen1O0A3o6GCDO9FlfBslLpTAw0gnetx7bts,50427
@@ -254,7 +254,7 @@ ultralytics/utils/__init__.py,sha256=JfvODTB4mG_JOhTeCiPtq0iCEgiCh14hJf195rnOhLQ
 ultralytics/utils/autobatch.py,sha256=jiE4m_--H9UkXFDm_FqzcZk_hSTCGpS72XdVEKgZwAo,5114
 ultralytics/utils/autodevice.py,sha256=rXlPuo-iX-vZ4BabmMGEGh9Uxpau4R7Zlt1KCo9Xfyc,8892
 ultralytics/utils/benchmarks.py,sha256=S_W4S4pe2ktSRdSuWb6m09UEFQmZhmjl943bbo67hOI,32277
-ultralytics/utils/checks.py,sha256=hbM2pS7ffIbbTmeTe2AbQ-tCMM2H5WvkDMCpaeU8kbU,38203
+ultralytics/utils/checks.py,sha256=9RGHIs4_heSFSL2YHRw0M3gLob6G9wQV3a24A0pTWrc,38411
 ultralytics/utils/cpu.py,sha256=OksKOlX93AsbSsFuoYvLXRXgpkOibrZSwQyW6lipt4Q,3493
 ultralytics/utils/dist.py,sha256=hOuY1-unhQAY-uWiZw3LWw36d1mqJuYK75NdlwB4oKE,4131
 ultralytics/utils/downloads.py,sha256=IyiGjjXqOyf1B0qLMk7vE6sSQ8s232OhKS8aj9XbTgs,22883
@@ -263,8 +263,8 @@ ultralytics/utils/events.py,sha256=6vqs_iSxoXIhQ804sOjApNZmXwNW9FUFtjaHPY8ta10,4
 ultralytics/utils/files.py,sha256=BdaRwEKqzle4glSj8n_jq6bDjTCAs_H1SN06ZOQ9qFU,8190
 ultralytics/utils/git.py,sha256=UdqeIiiEzg1qkerAZrg5YtTYPuJYwrpxW9N_6Pq6s8U,5501
 ultralytics/utils/instance.py,sha256=11mhefvTI9ftMqSirXuiViAi0Fxlo6v84qvNxfRNUoE,18862
-ultralytics/utils/logger.py,sha256=2G7_wAteN26SWaqm3VJgDc2XYcotz5uWolQllvMcLoI,16821
-ultralytics/utils/loss.py,sha256=JWkxM6IsJQwmlCsTc0bUQWPBH80UIDoItyUlSgF9Ukw,39579
+ultralytics/utils/logger.py,sha256=US4pLBmRQNI31KEeqqKdBEXDLS1eE5J5hWR0xPDaGJI,18966
+ultralytics/utils/loss.py,sha256=t-z7qkvqF8OtuRHrj2wmvClZV2CCumIRi9jnqkc9i_A,39573
 ultralytics/utils/metrics.py,sha256=apVQLSML4TKwreFwRtWPQ1R5_fpp7vPDuI1q3cTY24w,68674
 ultralytics/utils/nms.py,sha256=zv1rOzMF6WU8Kdk41VzNf1H1EMt_vZHcbDFbg3mnN2o,14248
 ultralytics/utils/ops.py,sha256=mbrqv36ovUp9FMIqClTHikOOViYEJ058CH-qDLkWbSw,25797
@@ -283,7 +283,7 @@ ultralytics/utils/callbacks/dvc.py,sha256=YT0Sa5P8Huj8Fn9jM2P6MYzUY3PIVxsa5BInVi
 ultralytics/utils/callbacks/hub.py,sha256=fVLqqr3ZM6hoYFlVMEeejfq1MWDrkWCskPFOG3HGILQ,4159
 ultralytics/utils/callbacks/mlflow.py,sha256=wCXjQgdufp9LYujqMzLZOmIOur6kvrApHNeo9dA7t_g,5323
 ultralytics/utils/callbacks/neptune.py,sha256=_vt3cMwDHCR-LyT3KtRikGpj6AG11oQ-skUUUUdZ74o,4391
-ultralytics/utils/callbacks/platform.py,sha256=a7T_8htoBB0uX1WIc392UJnhDjxkRyQMvhPYKR6wUTU,2008
+ultralytics/utils/callbacks/platform.py,sha256=oWz8OvdgO3rCKe6VvqNOhwStS07ddJkvPy1O72SqYEc,9271
 ultralytics/utils/callbacks/raytune.py,sha256=Y0dFyNZVRuFovSh7nkgUIHTQL3xIXOACElgHuYbg_5I,1278
 ultralytics/utils/callbacks/tensorboard.py,sha256=PTJYvD2gqRUN8xw5VoTjvKnu2adukLfvhMlDgTnTiFU,4952
 ultralytics/utils/callbacks/wb.py,sha256=ghmL3gigOa-z_F54-TzMraKw9MAaYX-Wk4H8dLoRvX8,7705
@@ -291,8 +291,8 @@ ultralytics/utils/export/__init__.py,sha256=Cfh-PwVfTF_lwPp-Ss4wiX4z8Sm1XRPklsqd
 ultralytics/utils/export/engine.py,sha256=23-lC6dNsmz5vprSJzaN7UGNXrFlVedNcqhlOH_IXes,9956
 ultralytics/utils/export/imx.py,sha256=F3b334IZdwjF8PdP1s6QI3Ndd82_2e77clj8aGLzIDo,12856
 ultralytics/utils/export/tensorflow.py,sha256=igYzwbdblb9YgfV4Jgl5lMvynuVRcF51dAzI7j-BBI0,9966
-dgenerate_ultralytics_headless-8.3.242.dist-info/METADATA,sha256=wnKuuyVhvPwKkTBQIjfDNWO5aCY8kAFUK1ijt1MtEfY,38798
-dgenerate_ultralytics_headless-8.3.242.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-dgenerate_ultralytics_headless-8.3.242.dist-info/entry_points.txt,sha256=YM_wiKyTe9yRrsEfqvYolNO5ngwfoL4-NwgKzc8_7sI,93
-dgenerate_ultralytics_headless-8.3.242.dist-info/top_level.txt,sha256=XP49TwiMw4QGsvTLSYiJhz1xF_k7ev5mQ8jJXaXi45Q,12
-dgenerate_ultralytics_headless-8.3.242.dist-info/RECORD,,
+dgenerate_ultralytics_headless-8.3.243.dist-info/METADATA,sha256=HxU9hZqOz-XaKXszDolkAQLJ7LUbbtjns1jw2HVWAoM,38799
+dgenerate_ultralytics_headless-8.3.243.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+dgenerate_ultralytics_headless-8.3.243.dist-info/entry_points.txt,sha256=YM_wiKyTe9yRrsEfqvYolNO5ngwfoL4-NwgKzc8_7sI,93
+dgenerate_ultralytics_headless-8.3.243.dist-info/top_level.txt,sha256=XP49TwiMw4QGsvTLSYiJhz1xF_k7ev5mQ8jJXaXi45Q,12
+dgenerate_ultralytics_headless-8.3.243.dist-info/RECORD,,

ultralytics/__init__.py

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

ultralytics/utils/callbacks/platform.py

@@ -1,73 +1,290 @@
 # Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
 
-from ultralytics.utils import RANK, SETTINGS
+import os
+import platform
+import socket
+import sys
+from concurrent.futures import ThreadPoolExecutor
+from pathlib import Path
+from time import time
+
+from ultralytics.utils import ENVIRONMENT, GIT, LOGGER, PYTHON_VERSION, RANK, SETTINGS, TESTS_RUNNING
+
+_last_upload = 0  # Rate limit model uploads
+_console_logger = None  # Global console logger instance
+_system_logger = None  # Cached system logger instance
+
+try:
+    assert not TESTS_RUNNING  # do not log pytest
+    assert SETTINGS.get("platform", False) is True or os.getenv("ULTRALYTICS_API_KEY") or SETTINGS.get("api_key")
+    _api_key = os.getenv("ULTRALYTICS_API_KEY") or SETTINGS.get("api_key")
+    assert _api_key  # verify API key is present
+
+    import requests
+
+    from ultralytics.utils.logger import ConsoleLogger, SystemLogger
+    from ultralytics.utils.torch_utils import model_info_for_loggers
+
+    _executor = ThreadPoolExecutor(max_workers=10)  # Bounded thread pool for async operations
+
+except (AssertionError, ImportError):
+    _api_key = None
+
+
+def _send(event, data, project, name):
+    """Send event to Platform endpoint."""
+    try:
+        requests.post(
+            "https://alpha.ultralytics.com/api/webhooks/training/metrics",
+            json={"event": event, "project": project, "name": name, "data": data},
+            headers={"Authorization": f"Bearer {_api_key}"},
+            timeout=10,
+        ).raise_for_status()
+    except Exception as e:
+        LOGGER.debug(f"Platform: Failed to send {event}: {e}")
+
+
+def _send_async(event, data, project, name):
+    """Send event asynchronously using bounded thread pool."""
+    _executor.submit(_send, event, data, project, name)
+
+
+def _upload_model(model_path, project, name):
+    """Upload model checkpoint to Platform via signed URL."""
+    try:
+        model_path = Path(model_path)
+        if not model_path.exists():
+            return None
+
+        # Get signed upload URL
+        response = requests.post(
+            "https://alpha.ultralytics.com/api/webhooks/models/upload",
+            json={"project": project, "name": name, "filename": model_path.name},
+            headers={"Authorization": f"Bearer {_api_key}"},
+            timeout=10,
+        )
+        response.raise_for_status()
+        data = response.json()
+
+        # Upload to GCS
+        with open(model_path, "rb") as f:
+            requests.put(
+                data["uploadUrl"],
+                data=f,
+                headers={"Content-Type": "application/octet-stream"},
+                timeout=600,  # 10 min timeout for large models
+            ).raise_for_status()
+
+        LOGGER.info(f"Platform: Model uploaded to '{project}'")
+        return data.get("gcsPath")
+
+    except Exception as e:
+        LOGGER.debug(f"Platform: Failed to upload model: {e}")
+        return None
+
+
+def _upload_model_async(model_path, project, name):
+    """Upload model asynchronously using bounded thread pool."""
+    _executor.submit(_upload_model, model_path, project, name)
+
+
+def _get_environment_info():
+    """Collect comprehensive environment info using existing ultralytics utilities."""
+    import torch
+
+    from ultralytics import __version__
+    from ultralytics.utils.torch_utils import get_cpu_info, get_gpu_info
+
+    env = {
+        "ultralyticsVersion": __version__,
+        "hostname": socket.gethostname(),
+        "os": platform.platform(),
+        "environment": ENVIRONMENT,
+        "pythonVersion": PYTHON_VERSION,
+        "pythonExecutable": sys.executable,
+        "cpuCount": os.cpu_count() or 0,
+        "cpu": get_cpu_info(),
+        "command": " ".join(sys.argv),
+    }
+
+    # Git info using cached GIT singleton (no subprocess calls)
+    try:
+        if GIT.is_repo:
+            if GIT.origin:
+                env["gitRepository"] = GIT.origin
+            if GIT.branch:
+                env["gitBranch"] = GIT.branch
+            if GIT.commit:
+                env["gitCommit"] = GIT.commit[:12]  # Short hash
+    except Exception:
+        pass
+
+    # GPU info
+    try:
+        if torch.cuda.is_available():
+            env["gpuCount"] = torch.cuda.device_count()
+            env["gpuType"] = get_gpu_info(0) if torch.cuda.device_count() > 0 else None
+    except Exception:
+        pass
+
+    return env
 
 
 def on_pretrain_routine_start(trainer):
-    """Initialize and start console logging immediately at the very beginning."""
-    if RANK in {-1, 0}:
-        from ultralytics.utils.logger import DEFAULT_LOG_PATH, ConsoleLogger, SystemLogger
+    """Initialize Platform logging at training start."""
+    global _console_logger, _last_upload
+
+    if RANK not in {-1, 0} or not trainer.args.project:
+        return
+
+    # Initialize upload timer to now so first checkpoint waits 15 min from training start
+    _last_upload = time()
+
+    project, name = str(trainer.args.project), str(trainer.args.name or "train")
+    LOGGER.info(f"Platform: Streaming to project '{project}' as '{name}'")
 
-        trainer.system_logger = SystemLogger()
-        trainer.console_logger = ConsoleLogger(DEFAULT_LOG_PATH)
-        trainer.console_logger.start_capture()
+    # Create callback to send console output to Platform
+    def send_console_output(content, line_count, chunk_id):
+        """Send batched console output to Platform webhook."""
+        _send_async("console_output", {"chunkId": chunk_id, "content": content, "lineCount": line_count}, project, name)
 
+    # Start console capture with batching (5 lines or 5 seconds)
+    _console_logger = ConsoleLogger(batch_size=5, flush_interval=5.0, on_flush=send_console_output)
+    _console_logger.start_capture()
 
-def on_pretrain_routine_end(trainer):
-    """Handle pre-training routine completion event."""
-    pass
+    # Gather model info for richer metadata
+    model_info = {}
+    try:
+        info = model_info_for_loggers(trainer)
+        model_info = {
+            "parameters": info.get("model/parameters", 0),
+            "gflops": info.get("model/GFLOPs", 0),
+            "classes": getattr(trainer.model, "yaml", {}).get("nc", 0),  # number of classes
+        }
+    except Exception:
+        pass
+
+    # Collect environment info (W&B-style metadata)
+    environment = _get_environment_info()
+
+    _send_async(
+        "training_started",
+        {
+            "trainArgs": {k: str(v) for k, v in vars(trainer.args).items()},
+            "epochs": trainer.epochs,
+            "device": str(trainer.device),
+            "modelInfo": model_info,
+            "environment": environment,
+        },
+        project,
+        name,
+    )
 
 
 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
+    """Log training and system metrics at epoch end."""
+    global _system_logger
+
+    if RANK not in {-1, 0} or not trainer.args.project:
+        return
+
+    project, name = str(trainer.args.project), str(trainer.args.name or "train")
+    metrics = {**trainer.label_loss_items(trainer.tloss, prefix="train"), **trainer.metrics}
+
+    if trainer.optimizer and trainer.optimizer.param_groups:
+        metrics["lr"] = trainer.optimizer.param_groups[0]["lr"]
+    if trainer.epoch == 0:
+        try:
+            metrics.update(model_info_for_loggers(trainer))
+        except Exception:
+            pass
+
+    # Get system metrics (cache SystemLogger for efficiency)
+    system = {}
+    try:
+        if _system_logger is None:
+            _system_logger = SystemLogger()
+        system = _system_logger.get_metrics(rates=True)
+    except Exception:
+        pass
+
+    _send_async(
+        "epoch_end",
+        {
+            "epoch": trainer.epoch,
+            "metrics": metrics,
+            "system": system,
+            "fitness": trainer.fitness,
+            "best_fitness": trainer.best_fitness,
+        },
+        project,
+        name,
+    )
 
 
 def on_model_save(trainer):
-    """Handle model checkpoint save event."""
-    pass
+    """Upload model checkpoint (rate limited to every 15 min)."""
+    global _last_upload
 
+    if RANK not in {-1, 0} or not trainer.args.project:
+        return
 
-def on_train_end(trainer):
-    """Stop console capture and finalize logs."""
-    if logger := getattr(trainer, "console_logger", None):
-        logger.stop_capture()
+    # Rate limit to every 15 minutes (900 seconds)
+    if time() - _last_upload < 900:
+        return
 
+    model_path = trainer.best if trainer.best and Path(trainer.best).exists() else trainer.last
+    if not model_path:
+        return
 
-def on_train_start(trainer):
-    """Handle training start event."""
-    pass
+    project, name = str(trainer.args.project), str(trainer.args.name or "train")
+    _upload_model_async(model_path, project, name)
+    _last_upload = time()
 
 
-def on_val_start(validator):
-    """Handle validation start event."""
-    pass
+def on_train_end(trainer):
+    """Log final results and upload best model."""
+    global _console_logger
+
+    if RANK not in {-1, 0} or not trainer.args.project:
+        return
 
+    project, name = str(trainer.args.project), str(trainer.args.name or "train")
 
-def on_predict_start(predictor):
-    """Handle prediction start event."""
-    pass
+    # Stop console capture and flush remaining output
+    if _console_logger:
+        _console_logger.stop_capture()
+        _console_logger = None
 
+    # Upload best model (blocking to ensure it completes)
+    model_path = None
+    if trainer.best and Path(trainer.best).exists():
+        model_path = _upload_model(trainer.best, project, name)
 
-def on_export_start(exporter):
-    """Handle model export start event."""
-    pass
+    # Send training complete
+    _send(
+        "training_complete",
+        {
+            "results": {
+                "metrics": {**trainer.metrics, "fitness": trainer.fitness},
+                "bestEpoch": getattr(trainer, "best_epoch", trainer.epoch),
+                "bestFitness": trainer.best_fitness,
+                "modelPath": model_path or str(trainer.best) if trainer.best else None,
+            }
+        },
+        project,
+        name,
+    )
+    LOGGER.info(f"Platform: Training complete, results uploaded to '{project}'")
 
 
 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
+    if _api_key
     else {}
 )

ultralytics/utils/checks.py

@@ -418,6 +418,11 @@ def check_requirements(requirements=ROOT.parent / "requirements.txt", exclude=()
         >>> check_requirements([("onnxruntime", "onnxruntime-gpu"), "numpy"])
     """
     prefix = colorstr("red", "bold", "requirements:")
+
+    if os.environ.get("ULTRALYTICS_SKIP_REQUIREMENTS_CHECKS", "0") == "1":
+        LOGGER.info(f"{prefix} ULTRALYTICS_SKIP_REQUIREMENTS_CHECKS=1 detected, skipping requirements check.")
+        return True
+
     if isinstance(requirements, Path):  # requirements.txt file
         file = requirements.resolve()
         assert file.exists(), f"{prefix} {file} not found, check failed."

ultralytics/utils/logger.py

@@ -1,7 +1,6 @@
 # Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
 
 import logging
-import queue
 import shutil
 import sys
 import threading
@@ -12,72 +11,81 @@ from pathlib import Path
 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.
+    """Console output capture with batched streaming to file, API, or custom callback.
 
-    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.
+    Captures stdout/stderr output and streams it with intelligent deduplication and configurable batching.
 
     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.
+        destination (str | Path | None): Target destination for streaming (URL, Path, or None for callback-only).
+        batch_size (int): Number of lines to batch before flushing (default: 1 for immediate).
+        flush_interval (float): Seconds between automatic flushes (default: 5.0).
+        on_flush (callable | None): Optional callback function called with batched content on flush.
         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:
+        File logging (immediate):
         >>> logger = ConsoleLogger("training.log")
         >>> logger.start_capture()
         >>> print("This will be logged")
         >>> logger.stop_capture()
 
-        API streaming:
-        >>> logger = ConsoleLogger("https://api.example.com/logs")
+        API streaming with batching:
+        >>> logger = ConsoleLogger("https://api.example.com/logs", batch_size=10)
+        >>> logger.start_capture()
+
+        Custom callback with batching:
+        >>> def my_handler(content, line_count, chunk_id):
+        ...     print(f"Received {line_count} lines")
+        >>> logger = ConsoleLogger(on_flush=my_handler, batch_size=5)
         >>> logger.start_capture()
-        >>> # All output streams to API
-        >>> logger.stop_capture()
     """
 
-    def __init__(self, destination):
-        """Initialize with API endpoint or local file path.
+    def __init__(self, destination=None, batch_size=1, flush_interval=5.0, on_flush=None):
+        """Initialize console logger with optional batching.
 
         Args:
-            destination (str | Path): API endpoint URL (http/https) or local file path for streaming output.
+            destination (str | Path | None): API endpoint URL (http/https), local file path, or None.
+            batch_size (int): Lines to accumulate before flush (1 = immediate, higher = batched).
+            flush_interval (float): Max seconds between flushes when batching.
+            on_flush (callable | None): Callback(content: str, line_count: int, chunk_id: int) for custom handling.
         """
         self.destination = destination
         self.is_api = isinstance(destination, str) and destination.startswith(("http://", "https://"))
-        if not self.is_api:
+        if destination is not None and not self.is_api:
             self.destination = Path(destination)
 
-        # Console capture
+        # Batching configuration
+        self.batch_size = max(1, batch_size)
+        self.flush_interval = flush_interval
+        self.on_flush = on_flush
+
+        # Console capture state
         self.original_stdout = sys.stdout
         self.original_stderr = sys.stderr
-        self.log_queue = queue.Queue(maxsize=1000)
         self.active = False
-        self.worker_thread = None
+        self._log_handler = None  # Track handler for cleanup
+
+        # Buffer for batching
+        self.buffer = []
+        self.buffer_lock = threading.Lock()
+        self.flush_thread = None
+        self.chunk_id = 0
 
-        # State tracking
+        # Deduplication state
         self.last_line = ""
         self.last_time = 0.0
-        self.last_progress_line = ""  # Track last progress line for deduplication
+        self.last_progress_line = ""  # Track progress sequence key for deduplication
         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:
+        """Start capturing console output and redirect stdout/stderr.
+
+        Notes:
+            In DDP training, only activates on rank 0/-1 to prevent duplicate logging.
+        """
+        if self.active or RANK not in {-1, 0}:
             return
 
         self.active = True
@@ -86,23 +94,35 @@ class ConsoleLogger:
 
         # Hook Ultralytics logger
         try:
-            handler = self._LogHandler(self._queue_log)
-            logging.getLogger("ultralytics").addHandler(handler)
+            self._log_handler = self._LogHandler(self._queue_log)
+            logging.getLogger("ultralytics").addHandler(self._log_handler)
         except Exception:
             pass
 
-        self.worker_thread = threading.Thread(target=self._stream_worker, daemon=True)
-        self.worker_thread.start()
+        # Start background flush thread for batched mode
+        if self.batch_size > 1:
+            self.flush_thread = threading.Thread(target=self._flush_worker, daemon=True)
+            self.flush_thread.start()
 
     def stop_capture(self):
-        """Stop capturing console output and restore original stdout/stderr."""
+        """Stop capturing console output and flush remaining buffer."""
         if not self.active:
             return
 
         self.active = False
         sys.stdout = self.original_stdout
         sys.stderr = self.original_stderr
-        self.log_queue.put(None)
+
+        # Remove logging handler to prevent memory leak
+        if self._log_handler:
+            try:
+                logging.getLogger("ultralytics").removeHandler(self._log_handler)
+            except Exception:
+                pass
+            self._log_handler = None
+
+        # Final flush
+        self._flush_buffer()
 
     def _queue_log(self, text):
         """Queue console text with deduplication and timestamp processing."""
@@ -126,12 +146,34 @@ class ConsoleLogger:
             if "─" in line:  # Has thin lines but no thick lines
                 continue
 
-            # Deduplicate completed progress bars only if they match the previous progress line
+            # Only show 100% completion lines for progress bars
             if " ━━" in line:
-                progress_core = line.split(" ━━")[0].strip()
-                if progress_core == self.last_progress_line and self.last_was_progress:
+                is_complete = "100%" in line
+
+                # Skip ALL non-complete progress lines
+                if not is_complete:
+                    continue
+
+                # Extract sequence key to deduplicate multiple 100% lines for same sequence
+                parts = line.split()
+                seq_key = ""
+                if parts:
+                    # Check for epoch pattern (X/Y at start)
+                    if "/" in parts[0] and parts[0].replace("/", "").isdigit():
+                        seq_key = parts[0]  # e.g., "1/3"
+                    elif parts[0] == "Class" and len(parts) > 1:
+                        seq_key = f"{parts[0]}_{parts[1]}"  # e.g., "Class_train:" or "Class_val:"
+                    elif parts[0] in ("train:", "val:"):
+                        seq_key = parts[0]  # Phase identifier
+
+                # Skip if we already showed 100% for this sequence
+                if seq_key and self.last_progress_line == f"{seq_key}:done":
                     continue
-                self.last_progress_line = progress_core
+
+                # Mark this sequence as done
+                if seq_key:
+                    self.last_progress_line = f"{seq_key}:done"
+
                 self.last_was_progress = True
             else:
                 # Skip empty line after progress bar
@@ -152,48 +194,62 @@ class ConsoleLogger:
                 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
+            # Add to buffer and check if flush needed
+            should_flush = False
+            with self.buffer_lock:
+                self.buffer.append(line)
+                if len(self.buffer) >= self.batch_size:
+                    should_flush = True
 
-    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."""
+            # Flush outside lock to avoid deadlock
+            if should_flush:
+                self._flush_buffer()
+
+    def _flush_worker(self):
+        """Background worker that flushes buffer periodically."""
         while self.active:
+            time.sleep(self.flush_interval)
+            if self.active:
+                self._flush_buffer()
+
+    def _flush_buffer(self):
+        """Flush buffered lines to destination and/or callback."""
+        with self.buffer_lock:
+            if not self.buffer:
+                return
+            lines = self.buffer.copy()
+            self.buffer.clear()
+            self.chunk_id += 1
+            chunk_id = self.chunk_id  # Capture under lock to avoid race
+
+        content = "\n".join(lines)
+        line_count = len(lines)
+
+        # Call custom callback if provided
+        if self.on_flush:
             try:
-                log_text = self.log_queue.get(timeout=1)
-                if log_text is None:
-                    break
-                self._write_log(log_text)
-            except queue.Empty:
-                continue
+                self.on_flush(content, line_count, chunk_id)
+            except Exception:
+                pass  # Silently ignore callback errors to avoid flooding stderr
+
+        # Write to destination (file or API)
+        if self.destination is not None:
+            self._write_destination(content)
 
-    def _write_log(self, text):
-        """Write log to API endpoint or local file destination."""
+    def _write_destination(self, content):
+        """Write content to file or API destination."""
         try:
             if self.is_api:
-                import requests  # scoped as slow import
+                import requests
 
-                payload = {"timestamp": datetime.now().isoformat(), "message": text.strip()}
+                payload = {"timestamp": datetime.now().isoformat(), "message": content}
                 requests.post(str(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)
+                    f.write(content + "\n")
         except Exception as e:
-            print(f"Platform logging error: {e}", file=self.original_stderr)
+            print(f"Console logger write error: {e}", file=self.original_stderr)
 
     class _ConsoleCapture:
         """Lightweight stdout/stderr capture."""

ultralytics/utils/loss.py

@@ -498,7 +498,7 @@ class v8PoseLoss(v8DetectionLoss):
 
     def __call__(self, preds: Any, batch: dict[str, torch.Tensor]) -> tuple[torch.Tensor, torch.Tensor]:
         """Calculate the total loss and detach it for pose estimation."""
-        loss = torch.zeros(5, device=self.device)  # box, cls, dfl, kpt_location, kpt_visibility
+        loss = torch.zeros(5, device=self.device)  # box, pose, kobj, cls, dfl
         feats, pred_kpts = preds if isinstance(preds[0], list) else preds[1]
         pred_distri, pred_scores = torch.cat([xi.view(feats[0].shape[0], self.no, -1) for xi in feats], 2).split(
             (self.reg_max * 4, self.nc), 1
@@ -560,7 +560,7 @@ class v8PoseLoss(v8DetectionLoss):
         loss[3] *= self.hyp.cls  # cls gain
         loss[4] *= self.hyp.dfl  # dfl gain
 
-        return loss * batch_size, loss.detach()  # loss(box, cls, dfl)
+        return loss * batch_size, loss.detach()  # loss(box, pose, kobj, cls, dfl)
 
     @staticmethod
     def kpts_decode(anchor_points: torch.Tensor, pred_kpts: torch.Tensor) -> torch.Tensor: