ultralytics 8.2.20__py3-none-any.whl → 8.2.21__py3-none-any.whl

tests/__init__.py

@@ -0,0 +1,22 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+
+from ultralytics.utils import ASSETS, ROOT, WEIGHTS_DIR, checks, is_dir_writeable
+
+# Constants used in tests
+MODEL = WEIGHTS_DIR / "path with spaces" / "yolov8n.pt"  # test spaces in path
+CFG = "yolov8n.yaml"
+SOURCE = ASSETS / "bus.jpg"
+TMP = (ROOT / "../tests/tmp").resolve()  # temp directory for test files
+IS_TMP_WRITEABLE = is_dir_writeable(TMP)
+CUDA_IS_AVAILABLE = checks.cuda_is_available()
+CUDA_DEVICE_COUNT = checks.cuda_device_count()
+
+__all__ = (
+    "MODEL",
+    "CFG",
+    "SOURCE",
+    "TMP",
+    "IS_TMP_WRITEABLE",
+    "CUDA_IS_AVAILABLE",
+    "CUDA_DEVICE_COUNT",
+)

tests/conftest.py

@@ -0,0 +1,71 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+
+import shutil
+from pathlib import Path
+
+from tests import TMP
+
+
+def pytest_addoption(parser):
+    """
+    Add custom command-line options to pytest.
+
+    Args:
+        parser (pytest.config.Parser): The pytest parser object.
+    """
+    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 remove tests marked as slow if the --slow option is not provided.
+
+    Args:
+        config (pytest.config.Config): The pytest config object.
+        items (list): List of test items to be executed.
+    """
+    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 and prepares the temporary directory for the test session.
+
+    Args:
+        session (pytest.Session): The pytest session object.
+    """
+    from ultralytics.utils.torch_utils import init_seeds
+
+    init_seeds()
+    shutil.rmtree(TMP, ignore_errors=True)  # delete any existing tests/tmp directory
+    TMP.mkdir(parents=True, exist_ok=True)  # create a new empty directory
+
+
+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 (pytest.terminal.TerminalReporter): The terminal reporter object.
+        exitstatus (int): The exit status of the test run.
+        config (pytest.config.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 ["bus.jpg", "yolov8n.onnx", "yolov8n.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 [TMP.parents[1] / ".pytest_cache", TMP] + models:
+        shutil.rmtree(directory, ignore_errors=True)

tests/test_cli.py

@@ -0,0 +1,128 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+
+import subprocess
+
+import pytest
+
+from ultralytics.cfg import TASK2DATA, TASK2MODEL, TASKS
+from ultralytics.utils import ASSETS, WEIGHTS_DIR, checks
+
+from tests import CUDA_DEVICE_COUNT, CUDA_IS_AVAILABLE
+
+# Constants
+TASK_MODEL_DATA = [(task, WEIGHTS_DIR / TASK2MODEL[task], TASK2DATA[task]) for task in TASKS]
+MODELS = [WEIGHTS_DIR / TASK2MODEL[task] for task in TASKS]
+
+
+def run(cmd):
+    """Execute a shell command using subprocess."""
+    subprocess.run(cmd.split(), check=True)
+
+
+def test_special_modes():
+    """Test various special command modes of YOLO."""
+    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, model, data):
+    """Test YOLO training for a given task, model, and data."""
+    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, model, data):
+    """Test YOLO validation for a given task, model, and data."""
+    run(f"yolo val {task} model={model} data={data} imgsz=32 save_txt save_json")
+
+
+@pytest.mark.parametrize("task,model,data", TASK_MODEL_DATA)
+def test_predict(task, model, data):
+    """Test YOLO prediction on sample assets for a given task and model."""
+    run(f"yolo predict model={model} source={ASSETS} imgsz=32 save save_crop save_txt")
+
+
+@pytest.mark.parametrize("model", MODELS)
+def test_export(model):
+    """Test exporting a YOLO model to different formats."""
+    run(f"yolo export model={model} format=torchscript imgsz=32")
+
+
+def test_rtdetr(task="detect", model="yolov8n-rtdetr.yaml", data="coco8.yaml"):
+    """Test the RTDETR functionality with the Ultralytics framework."""
+    # Warning: must use imgsz=640 (note also add coma, spaces, fraction=0.25 args to test single-image training)
+    run(f"yolo train {task} model={model} data={data} --imgsz= 160 epochs =1, cache = disk fraction=0.25")
+    run(f"yolo predict {task} model={model} source={ASSETS / 'bus.jpg'} imgsz=160 save save_crop save_txt")
+
+
+@pytest.mark.skipif(checks.IS_PYTHON_3_12, reason="MobileSAM with CLIP is not supported in Python 3.12")
+def test_fastsam(task="segment", model=WEIGHTS_DIR / "FastSAM-s.pt", data="coco8-seg.yaml"):
+    """Test FastSAM segmentation functionality 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.fastsam import FastSAMPrompt
+    from ultralytics.models.sam import Predictor
+
+    # Create a FastSAM model
+    sam_model = FastSAM(model)  # or FastSAM-x.pt
+
+    # Run inference on an image
+    everything_results = sam_model(source, device="cpu", retina_masks=True, imgsz=1024, conf=0.4, iou=0.9)
+
+    # Remove small regions
+    new_masks, _ = Predictor.remove_small_regions(everything_results[0].masks.data, min_area=20)
+
+    # Everything prompt
+    prompt_process = FastSAMPrompt(source, everything_results, device="cpu")
+    ann = prompt_process.everything_prompt()
+
+    # Bbox default shape [0,0,0,0] -> [x1,y1,x2,y2]
+    ann = prompt_process.box_prompt(bbox=[200, 200, 300, 300])
+
+    # Text prompt
+    ann = prompt_process.text_prompt(text="a photo of a dog")
+
+    # Point prompt
+    # Points default [[0,0]] [[x1,y1],[x2,y2]]
+    # Point_label default [0] [1,0] 0:background, 1:foreground
+    ann = prompt_process.point_prompt(points=[[200, 200]], pointlabel=[1])
+    prompt_process.plot(annotations=ann, output="./")
+
+
+def test_mobilesam():
+    """Test MobileSAM segmentation functionality 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 point prompt
+    model.predict(source, points=[900, 370], labels=[1])
+
+    # Predict a segment based on a box prompt
+    model.predict(source, bboxes=[439, 437, 524, 709])
+
+    # 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, model, data):
+    """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

tests/test_cuda.py

@@ -0,0 +1,134 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+
+from pathlib import Path
+from itertools import product
+
+import pytest
+import torch
+
+from ultralytics import YOLO
+from ultralytics.utils import ASSETS, WEIGHTS_DIR
+from ultralytics.cfg import TASK2DATA, TASK2MODEL, TASKS
+
+from tests import CUDA_DEVICE_COUNT, CUDA_IS_AVAILABLE, MODEL, SOURCE
+
+
+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.slow
+@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 exports to TensorRT format."""
+    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
+    )
+    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."""
+    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 on multiple devices."""
+    model = YOLO("yolov8n.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 batch size for YOLO model using autobatch."""
+    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 prediction with various prompts."""
+    from ultralytics import SAM
+    from ultralytics.models.sam import Predictor as SAMPredictor
+
+    # Load a model
+    model = SAM(WEIGHTS_DIR / "sam_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 points prompt
+    model(ASSETS / "zidane.jpg", points=[900, 370], labels=[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

@@ -0,0 +1,132 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+
+import sys
+from unittest import mock
+
+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
+
+from tests import MODEL
+
+
+def test_func(*args):  # noqa
+    """Test function callback."""
+    print("callback test passed")
+
+
+def test_export():
+    """Test model exporting functionality."""
+    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("yolov8n.yaml").model)
+    YOLO(f)(ASSETS)  # exported model inference
+
+
+def test_detect():
+    """Test object detection functionality."""
+    overrides = {"data": "coco8.yaml", "model": "yolov8n.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():
+    """Test image segmentation functionality."""
+    overrides = {"data": "coco8-seg.yaml", "model": "yolov8n-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 / "yolov8n-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 functionality."""
+    overrides = {"data": "imagenet10", "model": "yolov8n-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_explorer.py

@@ -0,0 +1,61 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+
+import PIL
+import pytest
+
+from ultralytics import Explorer
+from ultralytics.utils import ASSETS
+
+
+@pytest.mark.slow
+def test_similarity():
+    """Test similarity calculations and SQL queries for correctness and response length."""
+    exp = Explorer(data="coco8.yaml")
+    exp.create_embeddings_table()
+    similar = exp.get_similar(idx=1)
+    assert len(similar) == 4
+    similar = exp.get_similar(img=ASSETS / "bus.jpg")
+    assert len(similar) == 4
+    similar = exp.get_similar(idx=[1, 2], limit=2)
+    assert len(similar) == 2
+    sim_idx = exp.similarity_index()
+    assert len(sim_idx) == 4
+    sql = exp.sql_query("WHERE labels LIKE '%zebra%'")
+    assert len(sql) == 1
+
+
+@pytest.mark.slow
+def test_det():
+    """Test detection functionalities and ensure the embedding table has bounding boxes."""
+    exp = Explorer(data="coco8.yaml", model="yolov8n.pt")
+    exp.create_embeddings_table(force=True)
+    assert len(exp.table.head()["bboxes"]) > 0
+    similar = exp.get_similar(idx=[1, 2], limit=10)
+    assert len(similar) > 0
+    # This is a loose test, just checks errors not correctness
+    similar = exp.plot_similar(idx=[1, 2], limit=10)
+    assert isinstance(similar, PIL.Image.Image)
+
+
+@pytest.mark.slow
+def test_seg():
+    """Test segmentation functionalities and verify the embedding table includes masks."""
+    exp = Explorer(data="coco8-seg.yaml", model="yolov8n-seg.pt")
+    exp.create_embeddings_table(force=True)
+    assert len(exp.table.head()["masks"]) > 0
+    similar = exp.get_similar(idx=[1, 2], limit=10)
+    assert len(similar) > 0
+    similar = exp.plot_similar(idx=[1, 2], limit=10)
+    assert isinstance(similar, PIL.Image.Image)
+
+
+@pytest.mark.slow
+def test_pose():
+    """Test pose estimation functionalities and check the embedding table for keypoints."""
+    exp = Explorer(data="coco8-pose.yaml", model="yolov8n-pose.pt")
+    exp.create_embeddings_table(force=True)
+    assert len(exp.table.head()["keypoints"]) > 0
+    similar = exp.get_similar(idx=[1, 2], limit=10)
+    assert len(similar) > 0
+    similar = exp.plot_similar(idx=[1, 2], limit=10)
+    assert isinstance(similar, PIL.Image.Image)