ultralytics-opencv-headless 8.3.246__py3-none-any.whl

tests/__init__.py

@@ -0,0 +1,23 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+from ultralytics.cfg import TASK2DATA, TASK2MODEL, TASKS
+from ultralytics.utils import ASSETS, WEIGHTS_DIR, checks
+
+# Constants used in tests
+MODEL = WEIGHTS_DIR / "path with spaces" / "yolo11n.pt"  # test spaces in path
+CFG = "yolo11n.yaml"
+SOURCE = ASSETS / "bus.jpg"
+SOURCES_LIST = [ASSETS / "bus.jpg", ASSETS, ASSETS / "*", ASSETS / "**/*.jpg"]
+CUDA_IS_AVAILABLE = checks.cuda_is_available()
+CUDA_DEVICE_COUNT = checks.cuda_device_count()
+TASK_MODEL_DATA = [(task, WEIGHTS_DIR / TASK2MODEL[task], TASK2DATA[task]) for task in TASKS]
+MODELS = frozenset([*list(TASK2MODEL.values()), "yolo11n-grayscale.pt"])
+
+__all__ = (
+    "CFG",
+    "CUDA_DEVICE_COUNT",
+    "CUDA_IS_AVAILABLE",
+    "MODEL",
+    "SOURCE",
+    "SOURCES_LIST",
+)

tests/conftest.py

@@ -0,0 +1,59 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+import shutil
+from pathlib import Path
+
+
+def pytest_addoption(parser):
+    """Add custom command-line options to pytest."""
+    parser.addoption("--slow", action="store_true", default=False, help="Run slow tests")
+
+
+def pytest_collection_modifyitems(config, items):
+    """Modify the list of test items to exclude tests marked as slow if the --slow option is not specified.
+
+    Args:
+        config: The pytest configuration object that provides access to command-line options.
+        items (list): The list of collected pytest item objects to be modified based on the presence of --slow option.
+    """
+    if not config.getoption("--slow"):
+        # Remove the item entirely from the list of test items if it's marked as 'slow'
+        items[:] = [item for item in items if "slow" not in item.keywords]
+
+
+def pytest_sessionstart(session):
+    """Initialize session configurations for pytest.
+
+    This function is automatically called by pytest after the 'Session' object has been created but before performing
+    test collection. It sets the initial seeds for the test session.
+
+    Args:
+        session: The pytest session object.
+    """
+    from ultralytics.utils.torch_utils import init_seeds
+
+    init_seeds()
+
+
+def pytest_terminal_summary(terminalreporter, exitstatus, config):
+    """Cleanup operations after pytest session.
+
+    This function is automatically called by pytest at the end of the entire test session. It removes certain files and
+    directories used during testing.
+
+    Args:
+        terminalreporter: The terminal reporter object used for terminal output.
+        exitstatus (int): The exit status of the test run.
+        config: The pytest config object.
+    """
+    from ultralytics.utils import WEIGHTS_DIR
+
+    # Remove files
+    models = [path for x in {"*.onnx", "*.torchscript"} for path in WEIGHTS_DIR.rglob(x)]
+    for file in ["decelera_portrait_min.mov", "bus.jpg", "yolo11n.onnx", "yolo11n.torchscript", *models]:
+        Path(file).unlink(missing_ok=True)
+
+    # Remove directories
+    models = [path for x in {"*.mlpackage", "*_openvino_model"} for path in WEIGHTS_DIR.rglob(x)]
+    for directory in [WEIGHTS_DIR / "path with spaces", *models]:
+        shutil.rmtree(directory, ignore_errors=True)

tests/test_cli.py

@@ -0,0 +1,131 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+import subprocess
+from pathlib import Path
+
+import pytest
+from PIL import Image
+
+from tests import CUDA_DEVICE_COUNT, CUDA_IS_AVAILABLE, MODELS, TASK_MODEL_DATA
+from ultralytics.utils import ARM64, ASSETS, LINUX, WEIGHTS_DIR, checks
+from ultralytics.utils.torch_utils import TORCH_1_11
+
+
+def run(cmd: str) -> None:
+    """Execute a shell command using subprocess."""
+    subprocess.run(cmd.split(), check=True)
+
+
+def test_special_modes() -> None:
+    """Test various special command-line modes for YOLO functionality."""
+    run("yolo help")
+    run("yolo checks")
+    run("yolo version")
+    run("yolo settings reset")
+    run("yolo cfg")
+
+
+@pytest.mark.parametrize("task,model,data", TASK_MODEL_DATA)
+def test_train(task: str, model: str, data: str) -> None:
+    """Test YOLO training for different tasks, models, and datasets."""
+    run(f"yolo train {task} model={model} data={data} imgsz=32 epochs=1 cache=disk")
+
+
+@pytest.mark.parametrize("task,model,data", TASK_MODEL_DATA)
+def test_val(task: str, model: str, data: str) -> None:
+    """Test YOLO validation process for specified task, model, and data using a shell command."""
+    run(f"yolo val {task} model={model} data={data} imgsz=32 save_txt save_json visualize")
+
+
+@pytest.mark.parametrize("task,model,data", TASK_MODEL_DATA)
+def test_predict(task: str, model: str, data: str) -> None:
+    """Test YOLO prediction on provided sample assets for specified task and model."""
+    run(f"yolo {task} predict model={model} source={ASSETS} imgsz=32 save save_crop save_txt visualize")
+
+
+@pytest.mark.parametrize("model", MODELS)
+def test_export(model: str) -> None:
+    """Test exporting a YOLO model to TorchScript format."""
+    run(f"yolo export model={model} format=torchscript imgsz=32")
+
+
+@pytest.mark.skipif(not TORCH_1_11, reason="RTDETR requires torch>=1.11")
+def test_rtdetr(task: str = "detect", model: Path = WEIGHTS_DIR / "rtdetr-l.pt", data: str = "coco8.yaml") -> None:
+    """Test the RTDETR functionality within Ultralytics for detection tasks using specified model and data."""
+    # Add comma, spaces, fraction=0.25 args to test single-image training
+    run(f"yolo predict {task} model={model} source={ASSETS / 'bus.jpg'} imgsz=160 save save_crop save_txt")
+    run(f"yolo train {task} model={model} data={data} --imgsz= 160 epochs =1, cache = disk fraction=0.25")
+
+
+@pytest.mark.skipif(checks.IS_PYTHON_3_12, reason="MobileSAM with CLIP is not supported in Python 3.12")
+@pytest.mark.skipif(
+    checks.IS_PYTHON_3_8 and LINUX and ARM64,
+    reason="MobileSAM with CLIP is not supported in Python 3.8 and aarch64 Linux",
+)
+def test_fastsam(
+    task: str = "segment", model: str = WEIGHTS_DIR / "FastSAM-s.pt", data: str = "coco8-seg.yaml"
+) -> None:
+    """Test FastSAM model for segmenting objects in images using various prompts within Ultralytics."""
+    source = ASSETS / "bus.jpg"
+
+    run(f"yolo segment val {task} model={model} data={data} imgsz=32")
+    run(f"yolo segment predict model={model} source={source} imgsz=32 save save_crop save_txt")
+
+    from ultralytics import FastSAM
+    from ultralytics.models.sam import Predictor
+
+    # Create a FastSAM model
+    sam_model = FastSAM(model)  # or FastSAM-x.pt
+
+    # Run inference on an image
+    for s in (source, Image.open(source)):
+        everything_results = sam_model(s, device="cpu", retina_masks=True, imgsz=320, conf=0.4, iou=0.9)
+
+        # Remove small regions
+        _new_masks, _ = Predictor.remove_small_regions(everything_results[0].masks.data, min_area=20)
+
+        # Run inference with bboxes and points and texts prompt at the same time
+        sam_model(source, bboxes=[439, 437, 524, 709], points=[[200, 200]], labels=[1], texts="a photo of a dog")
+
+
+def test_mobilesam() -> None:
+    """Test MobileSAM segmentation with point prompts using Ultralytics."""
+    from ultralytics import SAM
+
+    # Load the model
+    model = SAM(WEIGHTS_DIR / "mobile_sam.pt")
+
+    # Source
+    source = ASSETS / "zidane.jpg"
+
+    # Predict a segment based on a 1D point prompt and 1D labels.
+    model.predict(source, points=[900, 370], labels=[1])
+
+    # Predict a segment based on 3D points and 2D labels (multiple points per object).
+    model.predict(source, points=[[[900, 370], [1000, 100]]], labels=[[1, 1]])
+
+    # Predict a segment based on a box prompt
+    model.predict(source, bboxes=[439, 437, 524, 709], save=True)
+
+    # Predict all
+    # model(source)
+
+
+# Slow Tests -----------------------------------------------------------------------------------------------------------
+@pytest.mark.slow
+@pytest.mark.parametrize("task,model,data", TASK_MODEL_DATA)
+@pytest.mark.skipif(not CUDA_IS_AVAILABLE, reason="CUDA is not available")
+@pytest.mark.skipif(CUDA_DEVICE_COUNT < 2, reason="DDP is not available")
+def test_train_gpu(task: str, model: str, data: str) -> None:
+    """Test YOLO training on GPU(s) for various tasks and models."""
+    run(f"yolo train {task} model={model} data={data} imgsz=32 epochs=1 device=0")  # single GPU
+    run(f"yolo train {task} model={model} data={data} imgsz=32 epochs=1 device=0,1")  # multi GPU
+
+
+@pytest.mark.parametrize(
+    "solution",
+    ["count", "blur", "workout", "heatmap", "isegment", "visioneye", "speed", "queue", "analytics", "trackzone"],
+)
+def test_solutions(solution: str) -> None:
+    """Test yolo solutions command-line modes."""
+    run(f"yolo solutions {solution} verbose=False")

tests/test_cuda.py

@@ -0,0 +1,216 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+import os
+from itertools import product
+from pathlib import Path
+
+import pytest
+import torch
+
+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, IS_JETSON, WEIGHTS_DIR
+from ultralytics.utils.autodevice import GPUInfo
+from ultralytics.utils.checks import check_amp
+from ultralytics.utils.torch_utils import TORCH_1_13
+
+# Try to find idle devices if CUDA is available
+DEVICES = []
+if CUDA_IS_AVAILABLE:
+    if IS_JETSON:
+        DEVICES = [0]  # NVIDIA Jetson only has one GPU and does not fully support pynvml library
+    else:
+        gpu_info = GPUInfo()
+        gpu_info.print_status()
+        autodevice_fraction = __import__("os").environ.get("YOLO_AUTODEVICE_FRACTION_FREE", 0.3)
+        if idle_gpus := gpu_info.select_idle_gpu(
+            count=2,
+            min_memory_fraction=autodevice_fraction,
+            min_util_fraction=autodevice_fraction,
+        ):
+            DEVICES = idle_gpus
+
+
+def test_checks():
+    """Validate CUDA settings against torch CUDA functions."""
+    assert torch.cuda.is_available() == CUDA_IS_AVAILABLE
+    assert torch.cuda.device_count() == CUDA_DEVICE_COUNT
+
+
+@pytest.mark.skipif(not DEVICES, reason="No CUDA devices available")
+def test_amp():
+    """Test AMP training checks."""
+    model = YOLO("yolo11n.pt").model.to(f"cuda:{DEVICES[0]}")
+    assert check_amp(model)
+
+
+@pytest.mark.slow
+@pytest.mark.skipif(not DEVICES, reason="No CUDA devices available")
+@pytest.mark.parametrize(
+    "task, dynamic, int8, half, batch, simplify, nms",
+    [  # generate all combinations except for exclusion cases
+        (task, dynamic, int8, half, batch, simplify, nms)
+        for task, dynamic, int8, half, batch, simplify, nms in product(
+            TASKS, [True, False], [False], [False], [1, 2], [True, False], [True, False]
+        )
+        if not (
+            (int8 and half) or (task == "classify" and nms) or (task == "obb" and nms and (not TORCH_1_13 or IS_JETSON))
+        )
+    ],
+)
+def test_export_onnx_matrix(task, dynamic, int8, half, batch, simplify, nms):
+    """Test YOLO exports to ONNX format with various configurations and parameters."""
+    file = YOLO(TASK2MODEL[task]).export(
+        format="onnx",
+        imgsz=32,
+        dynamic=dynamic,
+        int8=int8,
+        half=half,
+        batch=batch,
+        simplify=simplify,
+        nms=nms,
+        device=DEVICES[0],
+        # opset=20 if nms else None,  # fix ONNX Runtime errors with NMS
+    )
+    YOLO(file)([SOURCE] * batch, imgsz=64 if dynamic else 32, device=DEVICES[0])  # exported model inference
+    Path(file).unlink()  # cleanup
+
+
+@pytest.mark.slow
+@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
+        (task, dynamic, int8, half, batch)
+        # Note: tests reduced below pending compute availability expansion as GPU CI runner utilization is high
+        # for task, dynamic, int8, half, batch in product(TASKS, [True, False], [True, False], [True, False], [1, 2])
+        for task, dynamic, int8, half, batch in product(TASKS, [True], [True], [False], [2])
+        if not (int8 and half)  # exclude cases where both int8 and half are True
+    ],
+)
+def test_export_engine_matrix(task, dynamic, int8, half, batch):
+    """Test YOLO model export to TensorRT format for various configurations and run inference."""
+    file = YOLO(TASK2MODEL[task]).export(
+        format="engine",
+        imgsz=32,
+        dynamic=dynamic,
+        int8=int8,
+        half=half,
+        batch=batch,
+        data=TASK2DATA[task],
+        workspace=1,  # reduce workspace GB for less resource utilization during testing
+        simplify=True,
+        device=DEVICES[0],
+    )
+    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(missing_ok=True) if int8 else None  # cleanup INT8 cache
+
+
+@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 = tuple(DEVICES) if len(DEVICES) > 1 else DEVICES[0]
+    # NVIDIA Jetson only has one GPU and therefore skipping checks
+    if not IS_JETSON:
+        results = YOLO(MODEL).train(data="coco8.yaml", imgsz=64, epochs=1, device=device, batch=15)
+        results = YOLO(MODEL).train(data="coco128.yaml", imgsz=64, epochs=1, device=device, batch=15, val=False)
+        visible = eval(os.environ["CUDA_VISIBLE_DEVICES"])
+        assert visible == device, f"Passed GPUs '{device}', but used GPUs '{visible}'"
+        # Note DDP training returns None, single-GPU returns metrics
+        assert (results is None) if len(DEVICES) > 1 else (results is not None)
+
+
+@pytest.mark.slow
+@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)
+    assert str(model.device) == "cpu"
+
+    # 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)
+    assert str(model.device) == "cpu"
+
+    # 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 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.to(f"cuda:{DEVICES[0]}"), imgsz=128, amp=True)
+
+
+@pytest.mark.slow
+@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, 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 DEVICES, reason="No CUDA devices available")
+def test_predict_sam():
+    """Test SAM model predictions using different prompts."""
+    from ultralytics import SAM
+    from ultralytics.models.sam import Predictor as SAMPredictor
+
+    model = SAM(WEIGHTS_DIR / "sam2.1_b.pt")
+    model.info()
+
+    # 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])
+    predictor.reset_image()

tests/test_engine.py

@@ -0,0 +1,157 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+import sys
+from unittest import mock
+
+import torch
+
+from tests import MODEL
+from ultralytics import YOLO
+from ultralytics.cfg import get_cfg
+from ultralytics.engine.exporter import Exporter
+from ultralytics.models.yolo import classify, detect, segment
+from ultralytics.utils import ASSETS, DEFAULT_CFG, WEIGHTS_DIR
+
+
+def test_func(*args, **kwargs):
+    """Test function callback for evaluating YOLO model performance metrics."""
+    print("callback test passed")
+
+
+def test_export():
+    """Test model exporting functionality by adding a callback and verifying its execution."""
+    exporter = Exporter()
+    exporter.add_callback("on_export_start", test_func)
+    assert test_func in exporter.callbacks["on_export_start"], "callback test failed"
+    f = exporter(model=YOLO("yolo11n.yaml").model)
+    YOLO(f)(ASSETS)  # exported model inference
+
+
+def test_detect():
+    """Test YOLO object detection training, validation, and prediction functionality."""
+    overrides = {"data": "coco8.yaml", "model": "yolo11n.yaml", "imgsz": 32, "epochs": 1, "save": False}
+    cfg = get_cfg(DEFAULT_CFG)
+    cfg.data = "coco8.yaml"
+    cfg.imgsz = 32
+
+    # Trainer
+    trainer = detect.DetectionTrainer(overrides=overrides)
+    trainer.add_callback("on_train_start", test_func)
+    assert test_func in trainer.callbacks["on_train_start"], "callback test failed"
+    trainer.train()
+
+    # Validator
+    val = detect.DetectionValidator(args=cfg)
+    val.add_callback("on_val_start", test_func)
+    assert test_func in val.callbacks["on_val_start"], "callback test failed"
+    val(model=trainer.best)  # validate best.pt
+
+    # Predictor
+    pred = detect.DetectionPredictor(overrides={"imgsz": [64, 64]})
+    pred.add_callback("on_predict_start", test_func)
+    assert test_func in pred.callbacks["on_predict_start"], "callback test failed"
+    # Confirm there is no issue with sys.argv being empty
+    with mock.patch.object(sys, "argv", []):
+        result = pred(source=ASSETS, model=MODEL)
+        assert len(result), "predictor test failed"
+
+    # Test resume functionality
+    overrides["resume"] = trainer.last
+    trainer = detect.DetectionTrainer(overrides=overrides)
+    try:
+        trainer.train()
+    except Exception as e:
+        print(f"Expected exception caught: {e}")
+        return
+
+    raise Exception("Resume test failed!")
+
+
+def test_segment():
+    """Test image segmentation training, validation, and prediction pipelines using YOLO models."""
+    overrides = {
+        "data": "coco8-seg.yaml",
+        "model": "yolo11n-seg.yaml",
+        "imgsz": 32,
+        "epochs": 1,
+        "save": False,
+        "mask_ratio": 1,
+        "overlap_mask": False,
+    }
+    cfg = get_cfg(DEFAULT_CFG)
+    cfg.data = "coco8-seg.yaml"
+    cfg.imgsz = 32
+
+    # Trainer
+    trainer = segment.SegmentationTrainer(overrides=overrides)
+    trainer.add_callback("on_train_start", test_func)
+    assert test_func in trainer.callbacks["on_train_start"], "callback test failed"
+    trainer.train()
+
+    # Validator
+    val = segment.SegmentationValidator(args=cfg)
+    val.add_callback("on_val_start", test_func)
+    assert test_func in val.callbacks["on_val_start"], "callback test failed"
+    val(model=trainer.best)  # validate best.pt
+
+    # Predictor
+    pred = segment.SegmentationPredictor(overrides={"imgsz": [64, 64]})
+    pred.add_callback("on_predict_start", test_func)
+    assert test_func in pred.callbacks["on_predict_start"], "callback test failed"
+    result = pred(source=ASSETS, model=WEIGHTS_DIR / "yolo11n-seg.pt")
+    assert len(result), "predictor test failed"
+
+    # Test resume functionality
+    overrides["resume"] = trainer.last
+    trainer = segment.SegmentationTrainer(overrides=overrides)
+    try:
+        trainer.train()
+    except Exception as e:
+        print(f"Expected exception caught: {e}")
+        return
+
+    raise Exception("Resume test failed!")
+
+
+def test_classify():
+    """Test image classification including training, validation, and prediction phases."""
+    overrides = {"data": "imagenet10", "model": "yolo11n-cls.yaml", "imgsz": 32, "epochs": 1, "save": False}
+    cfg = get_cfg(DEFAULT_CFG)
+    cfg.data = "imagenet10"
+    cfg.imgsz = 32
+
+    # Trainer
+    trainer = classify.ClassificationTrainer(overrides=overrides)
+    trainer.add_callback("on_train_start", test_func)
+    assert test_func in trainer.callbacks["on_train_start"], "callback test failed"
+    trainer.train()
+
+    # Validator
+    val = classify.ClassificationValidator(args=cfg)
+    val.add_callback("on_val_start", test_func)
+    assert test_func in val.callbacks["on_val_start"], "callback test failed"
+    val(model=trainer.best)
+
+    # Predictor
+    pred = classify.ClassificationPredictor(overrides={"imgsz": [64, 64]})
+    pred.add_callback("on_predict_start", test_func)
+    assert test_func in pred.callbacks["on_predict_start"], "callback test failed"
+    result = pred(source=ASSETS, model=trainer.best)
+    assert len(result), "predictor test failed"
+
+
+def test_nan_recovery():
+    """Test NaN loss detection and recovery during training."""
+    nan_injected = [False]
+
+    def inject_nan(trainer):
+        """Inject NaN into loss during batch processing to test recovery mechanism."""
+        if trainer.epoch == 1 and trainer.tloss is not None and not nan_injected[0]:
+            trainer.tloss *= torch.tensor(float("nan"))
+            nan_injected[0] = True
+
+    overrides = {"data": "coco8.yaml", "model": "yolo11n.yaml", "imgsz": 32, "epochs": 3}
+    trainer = detect.DetectionTrainer(overrides=overrides)
+    trainer.add_callback("on_train_batch_end", inject_nan)
+    trainer.train()
+    assert nan_injected[0], "NaN injection failed"