ultralytics 8.3.104__py3-none-any.whl → 8.3.106__py3-none-any.whl

tests/test_cuda.py

@@ -1,164 +0,0 @@
-# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
-
-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, WEIGHTS_DIR
-from ultralytics.utils.checks import check_amp
-
-
-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 CUDA_IS_AVAILABLE, reason="CUDA is not available")
-def test_amp():
-    """Test AMP training checks."""
-    model = YOLO("yolo11n.pt").model.cuda()
-    assert check_amp(model)
-
-
-@pytest.mark.slow
-@pytest.mark.skipif(True, reason="CUDA export tests disabled pending additional Ultralytics GPU server availability")
-@pytest.mark.skipif(not CUDA_IS_AVAILABLE, reason="CUDA is not available")
-@pytest.mark.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.
-
-    Args:
-        task (str): Task type like 'detect', 'segment', etc.
-        dynamic (bool): Whether to use dynamic input size.
-        int8 (bool): Whether to use INT8 precision.
-        half (bool): Whether to use FP16 precision.
-        batch (int): Batch size for export.
-    """
-    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,  # use 'onnxslim'
-    )
-    YOLO(file)([SOURCE] * batch, imgsz=64 if dynamic else 32)  # exported model inference
-    Path(file).unlink()  # cleanup
-    Path(file).with_suffix(".cache").unlink() if int8 else None  # cleanup INT8 cache
-
-
-@pytest.mark.skipif(not CUDA_IS_AVAILABLE, reason="CUDA is not available")
-def test_train():
-    """Test model training on a minimal dataset using available CUDA devices."""
-    device = 0 if CUDA_DEVICE_COUNT == 1 else [0, 1]
-    YOLO(MODEL).train(data="coco8.yaml", imgsz=64, epochs=1, device=device)  # requires imgsz>=64
-
-
-@pytest.mark.slow
-@pytest.mark.skipif(not CUDA_IS_AVAILABLE, reason="CUDA is not available")
-def test_predict_multiple_devices():
-    """Validate model prediction consistency across CPU and CUDA devices."""
-    model = YOLO("yolo11n.pt")
-    model = model.cpu()
-    assert str(model.device) == "cpu"
-    _ = model(SOURCE)  # CPU inference
-    assert str(model.device) == "cpu"
-
-    model = model.to("cuda:0")
-    assert str(model.device) == "cuda:0"
-    _ = model(SOURCE)  # CUDA inference
-    assert str(model.device) == "cuda:0"
-
-    model = model.cpu()
-    assert str(model.device) == "cpu"
-    _ = model(SOURCE)  # CPU inference
-    assert str(model.device) == "cpu"
-
-    model = model.cuda()
-    assert str(model.device) == "cuda:0"
-    _ = model(SOURCE)  # CUDA inference
-    assert str(model.device) == "cuda:0"
-
-
-@pytest.mark.skipif(not CUDA_IS_AVAILABLE, reason="CUDA is not available")
-def test_autobatch():
-    """Check optimal batch size for YOLO model training using autobatch utility."""
-    from ultralytics.utils.autobatch import check_train_batch_size
-
-    check_train_batch_size(YOLO(MODEL).model.cuda(), imgsz=128, amp=True)
-
-
-@pytest.mark.slow
-@pytest.mark.skipif(not CUDA_IS_AVAILABLE, reason="CUDA is not available")
-def test_utils_benchmarks():
-    """Profile YOLO models for performance benchmarks."""
-    from ultralytics.utils.benchmarks import ProfileModels
-
-    # Pre-export a dynamic engine model to use dynamic inference
-    YOLO(MODEL).export(format="engine", imgsz=32, dynamic=True, batch=1)
-    ProfileModels([MODEL], imgsz=32, half=False, min_time=1, num_timed_runs=3, num_warmup_runs=1).profile()
-
-
-@pytest.mark.skipif(not CUDA_IS_AVAILABLE, reason="CUDA is not available")
-def test_predict_sam():
-    """Test SAM model predictions using different prompts, including bounding boxes and point annotations."""
-    from ultralytics import SAM
-    from ultralytics.models.sam import Predictor as SAMPredictor
-
-    # Load a model
-    model = SAM(WEIGHTS_DIR / "sam2.1_b.pt")
-
-    # Display model information (optional)
-    model.info()
-
-    # Run inference
-    model(SOURCE, device=0)
-
-    # Run inference with bboxes prompt
-    model(SOURCE, bboxes=[439, 437, 524, 709], device=0)
-
-    # Run inference with no labels
-    model(ASSETS / "zidane.jpg", points=[900, 370], device=0)
-
-    # Run inference with 1D points and 1D labels
-    model(ASSETS / "zidane.jpg", points=[900, 370], labels=[1], device=0)
-
-    # Run inference with 2D points and 1D labels
-    model(ASSETS / "zidane.jpg", points=[[900, 370]], labels=[1], device=0)
-
-    # Run inference with multiple 2D points and 1D labels
-    model(ASSETS / "zidane.jpg", points=[[400, 370], [900, 370]], labels=[1, 1], device=0)
-
-    # Run inference with 3D points and 2D labels (multiple points per object)
-    model(ASSETS / "zidane.jpg", points=[[[900, 370], [1000, 100]]], labels=[[1, 1]], device=0)
-
-    # Create SAMPredictor
-    overrides = dict(conf=0.25, task="segment", mode="predict", imgsz=1024, model=WEIGHTS_DIR / "mobile_sam.pt")
-    predictor = SAMPredictor(overrides=overrides)
-
-    # Set image
-    predictor.set_image(ASSETS / "zidane.jpg")  # set with image file
-    # predictor(bboxes=[439, 437, 524, 709])
-    # predictor(points=[900, 370], labels=[1])
-
-    # Reset image
-    predictor.reset_image()

tests/test_engine.py

@@ -1,131 +0,0 @@
-# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
-
-import sys
-from unittest import mock
-
-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):  # noqa
-    """Test function callback for evaluating YOLO model performance metrics."""
-    print("callback test passed")
-
-
-def test_export():
-    """Tests the model exporting function by adding a callback and asserting 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"
-
-    overrides["resume"] = trainer.last
-    trainer = detect.DetectionTrainer(overrides=overrides)
-    try:
-        trainer.train()
-    except Exception as e:
-        print(f"Expected exception caught: {e}")
-        return
-
-    Exception("Resume test failed!")
-
-
-def test_segment():
-    """Tests 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}
-    cfg = get_cfg(DEFAULT_CFG)
-    cfg.data = "coco8-seg.yaml"
-    cfg.imgsz = 32
-    # YOLO(CFG_SEG).train(**overrides)  # works
-
-    # 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
-    overrides["resume"] = trainer.last
-    trainer = segment.SegmentationTrainer(overrides=overrides)
-    try:
-        trainer.train()
-    except Exception as e:
-        print(f"Expected exception caught: {e}")
-        return
-
-    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
-    # YOLO(CFG_SEG).train(**overrides)  # works
-
-    # 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"

tests/test_exports.py

@@ -1,231 +0,0 @@
-# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
-
-import io
-import shutil
-import uuid
-from contextlib import redirect_stderr, redirect_stdout
-from itertools import product
-from pathlib import Path
-
-import pytest
-
-from tests import MODEL, SOURCE
-from ultralytics import YOLO
-from ultralytics.cfg import TASK2DATA, TASK2MODEL, TASKS
-from ultralytics.utils import (
-    ARM64,
-    IS_RASPBERRYPI,
-    LINUX,
-    MACOS,
-    WINDOWS,
-    checks,
-)
-from ultralytics.utils.torch_utils import TORCH_1_9, TORCH_1_13
-
-
-def test_export_torchscript():
-    """Test YOLO model exporting to TorchScript format for compatibility and correctness."""
-    file = YOLO(MODEL).export(format="torchscript", optimize=False, imgsz=32)
-    YOLO(file)(SOURCE, imgsz=32)  # exported model inference
-
-
-def test_export_onnx():
-    """Test YOLO model export to ONNX format with dynamic axes."""
-    file = YOLO(MODEL).export(format="onnx", dynamic=True, imgsz=32)
-    YOLO(file)(SOURCE, imgsz=32)  # exported model inference
-
-
-@pytest.mark.skipif(not TORCH_1_13, reason="OpenVINO requires torch>=1.13")
-def test_export_openvino():
-    """Test YOLO exports to OpenVINO format for model inference compatibility."""
-    file = YOLO(MODEL).export(format="openvino", imgsz=32)
-    YOLO(file)(SOURCE, imgsz=32)  # exported model inference
-
-
-@pytest.mark.slow
-@pytest.mark.skipif(not TORCH_1_13, reason="OpenVINO requires torch>=1.13")
-@pytest.mark.parametrize(
-    "task, dynamic, int8, half, batch, nms",
-    [  # generate all combinations except for exclusion cases
-        (task, dynamic, int8, half, batch, nms)
-        for task, dynamic, int8, half, batch, nms in product(
-            TASKS, [True, False], [True, False], [True, False], [1, 2], [True, False]
-        )
-        if not ((int8 and half) or (task == "classify" and nms))
-    ],
-)
-def test_export_openvino_matrix(task, dynamic, int8, half, batch, nms):
-    """Test YOLO model exports to OpenVINO under various configuration matrix conditions."""
-    file = YOLO(TASK2MODEL[task]).export(
-        format="openvino",
-        imgsz=32,
-        dynamic=dynamic,
-        int8=int8,
-        half=half,
-        batch=batch,
-        data=TASK2DATA[task],
-        nms=nms,
-    )
-    if WINDOWS:
-        # Use unique filenames due to Windows file permissions bug possibly due to latent threaded use
-        # See https://github.com/ultralytics/ultralytics/actions/runs/8957949304/job/24601616830?pr=10423
-        file = Path(file)
-        file = file.rename(file.with_stem(f"{file.stem}-{uuid.uuid4()}"))
-    YOLO(file)([SOURCE] * batch, imgsz=64 if dynamic else 32)  # exported model inference
-    shutil.rmtree(file, ignore_errors=True)  # retry in case of potential lingering multi-threaded file usage errors
-
-
-@pytest.mark.slow
-@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))
-    ],
-)
-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
-    )
-    YOLO(file)([SOURCE] * batch, imgsz=64 if dynamic else 32)  # exported model inference
-    Path(file).unlink()  # cleanup
-
-
-@pytest.mark.slow
-@pytest.mark.parametrize(
-    "task, dynamic, int8, half, batch, nms",
-    [  # generate all combinations except for exclusion cases
-        (task, dynamic, int8, half, batch, nms)
-        for task, dynamic, int8, half, batch, nms in product(TASKS, [False], [False], [False], [1, 2], [True, False])
-        if not (task == "classify" and nms)
-    ],
-)
-def test_export_torchscript_matrix(task, dynamic, int8, half, batch, nms):
-    """Tests YOLO model exports to TorchScript format under varied configurations."""
-    file = YOLO(TASK2MODEL[task]).export(
-        format="torchscript", imgsz=32, dynamic=dynamic, int8=int8, half=half, batch=batch, nms=nms
-    )
-    YOLO(file)([SOURCE] * batch, imgsz=64 if dynamic else 32)  # exported model inference
-    Path(file).unlink()  # cleanup
-
-
-@pytest.mark.slow
-@pytest.mark.skipif(not MACOS, reason="CoreML inference only supported on macOS")
-@pytest.mark.skipif(not TORCH_1_9, reason="CoreML>=7.2 not supported with PyTorch<=1.8")
-@pytest.mark.skipif(checks.IS_PYTHON_3_13, reason="CoreML not supported in Python 3.13")
-@pytest.mark.parametrize(
-    "task, dynamic, int8, half, batch",
-    [  # generate all combinations except for exclusion cases
-        (task, dynamic, int8, half, batch)
-        for task, dynamic, int8, half, batch in product(TASKS, [False], [True, False], [True, False], [1])
-        if not (int8 and half)
-    ],
-)
-def test_export_coreml_matrix(task, dynamic, int8, half, batch):
-    """Test YOLO exports to CoreML format with various parameter configurations."""
-    file = YOLO(TASK2MODEL[task]).export(
-        format="coreml",
-        imgsz=32,
-        dynamic=dynamic,
-        int8=int8,
-        half=half,
-        batch=batch,
-    )
-    YOLO(file)([SOURCE] * batch, imgsz=32)  # exported model inference at batch=3
-    shutil.rmtree(file)  # cleanup
-
-
-@pytest.mark.slow
-@pytest.mark.skipif(not checks.IS_PYTHON_MINIMUM_3_10, reason="TFLite export requires Python>=3.10")
-@pytest.mark.skipif(
-    not LINUX or IS_RASPBERRYPI,
-    reason="Test disabled as TF suffers from install conflicts on Windows, macOS and Raspberry Pi",
-)
-@pytest.mark.parametrize(
-    "task, dynamic, int8, half, batch, nms",
-    [  # generate all combinations except for exclusion cases
-        (task, dynamic, int8, half, batch, nms)
-        for task, dynamic, int8, half, batch, nms in product(
-            TASKS, [False], [True, False], [True, False], [1], [True, False]
-        )
-        if not ((int8 and half) or (task == "classify" and nms) or (ARM64 and nms))
-    ],
-)
-def test_export_tflite_matrix(task, dynamic, int8, half, batch, nms):
-    """Test YOLO exports to TFLite format considering various export configurations."""
-    file = YOLO(TASK2MODEL[task]).export(
-        format="tflite", imgsz=32, dynamic=dynamic, int8=int8, half=half, batch=batch, nms=nms
-    )
-    YOLO(file)([SOURCE] * batch, imgsz=32)  # exported model inference at batch=3
-    Path(file).unlink()  # cleanup
-
-
-@pytest.mark.skipif(not TORCH_1_9, reason="CoreML>=7.2 not supported with PyTorch<=1.8")
-@pytest.mark.skipif(WINDOWS, reason="CoreML not supported on Windows")  # RuntimeError: BlobWriter not loaded
-@pytest.mark.skipif(LINUX and ARM64, reason="CoreML not supported on aarch64 Linux")
-@pytest.mark.skipif(checks.IS_PYTHON_3_13, reason="CoreML not supported in Python 3.13")
-def test_export_coreml():
-    """Test YOLO exports to CoreML format and check for errors."""
-    # Capture stdout and stderr
-    stdout, stderr = io.StringIO(), io.StringIO()
-    with redirect_stdout(stdout), redirect_stderr(stderr):
-        YOLO(MODEL).export(format="coreml", nms=True, imgsz=32)
-        if MACOS:
-            file = YOLO(MODEL).export(format="coreml", imgsz=32)
-            YOLO(file)(SOURCE, imgsz=32)  # model prediction only supported on macOS for nms=False models
-
-    # Check captured output for errors
-    output = stdout.getvalue() + stderr.getvalue()
-    assert "Error" not in output, f"CoreML export produced errors: {output}"
-    assert "You will not be able to run predict()" not in output, "CoreML export has predict() error"
-
-
-@pytest.mark.skipif(not checks.IS_PYTHON_MINIMUM_3_10, reason="TFLite export requires Python>=3.10")
-@pytest.mark.skipif(not LINUX, reason="Test disabled as TF suffers from install conflicts on Windows and macOS")
-def test_export_tflite():
-    """Test YOLO exports to TFLite format under specific OS and Python version conditions."""
-    model = YOLO(MODEL)
-    file = model.export(format="tflite", imgsz=32)
-    YOLO(file)(SOURCE, imgsz=32)
-
-
-@pytest.mark.skipif(True, reason="Test disabled")
-@pytest.mark.skipif(not LINUX, reason="TF suffers from install conflicts on Windows and macOS")
-def test_export_pb():
-    """Test YOLO exports to TensorFlow's Protobuf (*.pb) format."""
-    model = YOLO(MODEL)
-    file = model.export(format="pb", imgsz=32)
-    YOLO(file)(SOURCE, imgsz=32)
-
-
-@pytest.mark.skipif(True, reason="Test disabled as Paddle protobuf and ONNX protobuf requirements conflict.")
-def test_export_paddle():
-    """Test YOLO exports to Paddle format, noting protobuf conflicts with ONNX."""
-    YOLO(MODEL).export(format="paddle", imgsz=32)
-
-
-@pytest.mark.slow
-def test_export_mnn():
-    """Test YOLO exports to MNN format (WARNING: MNN test must precede NCNN test or CI error on Windows)."""
-    file = YOLO(MODEL).export(format="mnn", imgsz=32)
-    YOLO(file)(SOURCE, imgsz=32)  # exported model inference
-
-
-@pytest.mark.slow
-def test_export_ncnn():
-    """Test YOLO exports to NCNN format."""
-    file = YOLO(MODEL).export(format="ncnn", imgsz=32)
-    YOLO(file)(SOURCE, imgsz=32)  # exported model inference
-
-
-@pytest.mark.skipif(True, reason="Test disabled as keras and tensorflow version conflicts with TFlite export.")
-@pytest.mark.skipif(not LINUX or MACOS, reason="Skipping test on Windows and Macos")
-def test_export_imx():
-    """Test YOLO exports to IMX format."""
-    model = YOLO("yolov8n.pt")
-    file = model.export(format="imx", imgsz=32)
-    YOLO(file)(SOURCE, imgsz=32)

tests/test_integrations.py

@@ -1,146 +0,0 @@
-# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
-
-import contextlib
-import os
-import subprocess
-import time
-from pathlib import Path
-
-import pytest
-
-from tests import MODEL, SOURCE, TMP
-from ultralytics import YOLO, download
-from ultralytics.utils import DATASETS_DIR, SETTINGS
-from ultralytics.utils.checks import check_requirements
-
-
-@pytest.mark.skipif(not check_requirements("ray", install=False), reason="ray[tune] not installed")
-def test_model_ray_tune():
-    """Tune YOLO model using Ray for hyperparameter optimization."""
-    YOLO("yolo11n-cls.yaml").tune(
-        use_ray=True, data="imagenet10", grace_period=1, iterations=1, imgsz=32, epochs=1, plots=False, device="cpu"
-    )
-
-
-@pytest.mark.skipif(not check_requirements("mlflow", install=False), reason="mlflow not installed")
-def test_mlflow():
-    """Test training with MLflow tracking enabled (see https://mlflow.org/ for details)."""
-    SETTINGS["mlflow"] = True
-    YOLO("yolo11n-cls.yaml").train(data="imagenet10", imgsz=32, epochs=3, plots=False, device="cpu")
-    SETTINGS["mlflow"] = False
-
-
-@pytest.mark.skipif(True, reason="Test failing in scheduled CI https://github.com/ultralytics/ultralytics/pull/8868")
-@pytest.mark.skipif(not check_requirements("mlflow", install=False), reason="mlflow not installed")
-def test_mlflow_keep_run_active():
-    """Ensure MLflow run status matches MLFLOW_KEEP_RUN_ACTIVE environment variable settings."""
-    import mlflow
-
-    SETTINGS["mlflow"] = True
-    run_name = "Test Run"
-    os.environ["MLFLOW_RUN"] = run_name
-
-    # Test with MLFLOW_KEEP_RUN_ACTIVE=True
-    os.environ["MLFLOW_KEEP_RUN_ACTIVE"] = "True"
-    YOLO("yolo11n-cls.yaml").train(data="imagenet10", imgsz=32, epochs=1, plots=False, device="cpu")
-    status = mlflow.active_run().info.status
-    assert status == "RUNNING", "MLflow run should be active when MLFLOW_KEEP_RUN_ACTIVE=True"
-
-    run_id = mlflow.active_run().info.run_id
-
-    # Test with MLFLOW_KEEP_RUN_ACTIVE=False
-    os.environ["MLFLOW_KEEP_RUN_ACTIVE"] = "False"
-    YOLO("yolo11n-cls.yaml").train(data="imagenet10", imgsz=32, epochs=1, plots=False, device="cpu")
-    status = mlflow.get_run(run_id=run_id).info.status
-    assert status == "FINISHED", "MLflow run should be ended when MLFLOW_KEEP_RUN_ACTIVE=False"
-
-    # Test with MLFLOW_KEEP_RUN_ACTIVE not set
-    os.environ.pop("MLFLOW_KEEP_RUN_ACTIVE", None)
-    YOLO("yolo11n-cls.yaml").train(data="imagenet10", imgsz=32, epochs=1, plots=False, device="cpu")
-    status = mlflow.get_run(run_id=run_id).info.status
-    assert status == "FINISHED", "MLflow run should be ended by default when MLFLOW_KEEP_RUN_ACTIVE is not set"
-    SETTINGS["mlflow"] = False
-
-
-@pytest.mark.skipif(not check_requirements("tritonclient", install=False), reason="tritonclient[all] not installed")
-def test_triton():
-    """Test NVIDIA Triton Server functionalities with YOLO model."""
-    check_requirements("tritonclient[all]")
-    from tritonclient.http import InferenceServerClient  # noqa
-
-    # Create variables
-    model_name = "yolo"
-    triton_repo = TMP / "triton_repo"  # Triton repo path
-    triton_model = triton_repo / model_name  # Triton model path
-
-    # Export model to ONNX
-    f = YOLO(MODEL).export(format="onnx", dynamic=True)
-
-    # Prepare Triton repo
-    (triton_model / "1").mkdir(parents=True, exist_ok=True)
-    Path(f).rename(triton_model / "1" / "model.onnx")
-    (triton_model / "config.pbtxt").touch()
-
-    # Define image https://catalog.ngc.nvidia.com/orgs/nvidia/containers/tritonserver
-    tag = "nvcr.io/nvidia/tritonserver:23.09-py3"  # 6.4 GB
-
-    # Pull the image
-    subprocess.call(f"docker pull {tag}", shell=True)
-
-    # Run the Triton server and capture the container ID
-    container_id = (
-        subprocess.check_output(
-            f"docker run -d --rm -v {triton_repo}:/models -p 8000:8000 {tag} tritonserver --model-repository=/models",
-            shell=True,
-        )
-        .decode("utf-8")
-        .strip()
-    )
-
-    # Wait for the Triton server to start
-    triton_client = InferenceServerClient(url="localhost:8000", verbose=False, ssl=False)
-
-    # Wait until model is ready
-    for _ in range(10):
-        with contextlib.suppress(Exception):
-            assert triton_client.is_model_ready(model_name)
-            break
-        time.sleep(1)
-
-    # Check Triton inference
-    YOLO(f"http://localhost:8000/{model_name}", "detect")(SOURCE)  # exported model inference
-
-    # Kill and remove the container at the end of the test
-    subprocess.call(f"docker kill {container_id}", shell=True)
-
-
-@pytest.mark.skipif(not check_requirements("pycocotools", install=False), reason="pycocotools not installed")
-def test_pycocotools():
-    """Validate YOLO model predictions on COCO dataset using pycocotools."""
-    from ultralytics.models.yolo.detect import DetectionValidator
-    from ultralytics.models.yolo.pose import PoseValidator
-    from ultralytics.models.yolo.segment import SegmentationValidator
-
-    # Download annotations after each dataset downloads first
-    url = "https://github.com/ultralytics/assets/releases/download/v0.0.0/"
-
-    args = {"model": "yolo11n.pt", "data": "coco8.yaml", "save_json": True, "imgsz": 64}
-    validator = DetectionValidator(args=args)
-    validator()
-    validator.is_coco = True
-    download(f"{url}instances_val2017.json", dir=DATASETS_DIR / "coco8/annotations")
-    _ = validator.eval_json(validator.stats)
-
-    args = {"model": "yolo11n-seg.pt", "data": "coco8-seg.yaml", "save_json": True, "imgsz": 64}
-    validator = SegmentationValidator(args=args)
-    validator()
-    validator.is_coco = True
-    download(f"{url}instances_val2017.json", dir=DATASETS_DIR / "coco8-seg/annotations")
-    _ = validator.eval_json(validator.stats)
-
-    args = {"model": "yolo11n-pose.pt", "data": "coco8-pose.yaml", "save_json": True, "imgsz": 64}
-    validator = PoseValidator(args=args)
-    validator()
-    validator.is_coco = True
-    download(f"{url}person_keypoints_val2017.json", dir=DATASETS_DIR / "coco8-pose/annotations")
-    _ = validator.eval_json(validator.stats)