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

ultralytics/__init__.py

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

ultralytics/engine/exporter.py

@@ -86,7 +86,6 @@ from ultralytics.utils import (
     LINUX,
     LOGGER,
     MACOS,
-    PYTHON_VERSION,
     RKNN_CHIPS,
     ROOT,
     WINDOWS,
@@ -795,7 +794,7 @@ class Exporter:
     def export_coreml(self, prefix=colorstr("CoreML:")):
         """YOLO CoreML export."""
         mlmodel = self.args.format.lower() == "mlmodel"  # legacy *.mlmodel export format requested
-        check_requirements("coremltools>=6.0,<=6.2" if mlmodel else "coremltools>=8.0")
+        check_requirements("coremltools>=8.0")
         import coremltools as ct  # noqa
 
         LOGGER.info(f"\n{prefix} starting export with coremltools {ct.__version__}...")
@@ -819,11 +818,15 @@ class Exporter:
                 # TODO CoreML Segment and Pose model pipelining
             model = self.model
         ts = torch.jit.trace(model.eval(), self.im, strict=False)  # TorchScript model
+
+        # Based on apple's documentation it is better to leave out the minimum_deployment target and let that get set
+        # Internally based on the model conversion and output type.
+        # Setting minimum_depoloyment_target >= iOS16 will require setting compute_precision=ct.precision.FLOAT32.
+        # iOS16 adds in better support for FP16, but none of the CoreML NMS specifications handle FP16 as input.
         ct_model = ct.convert(
             ts,
             inputs=[ct.ImageType("image", shape=self.im.shape, scale=scale, bias=bias)],  # expects ct.TensorType
             classifier_config=classifier_config,
-            minimum_deployment_target=ct.target.iOS15,  # warning: >=16 causes pipeline errors
             convert_to="neuralnetwork" if mlmodel else "mlprogram",
         )
         bits, mode = (8, "kmeans") if self.args.int8 else (16, "linear") if self.args.half else (32, None)
@@ -840,8 +843,6 @@ class Exporter:
                 ct_model = cto.palettize_weights(ct_model, config=config)
         if self.args.nms and self.model.task == "detect":
             if mlmodel:
-                # coremltools<=6.2 NMS export requires Python<3.11
-                check_version(PYTHON_VERSION, "<3.11", name="Python ", hard=True)
                 weights_dir = None
             else:
                 ct_model.save(str(f))  # save otherwise weights_dir does not exist
@@ -1469,7 +1470,7 @@ class Exporter:
 
         # 3. Create NMS protobuf
         nms_spec = ct.proto.Model_pb2.Model()
-        nms_spec.specificationVersion = 9
+        nms_spec.specificationVersion = spec.specificationVersion
         for i in range(2):
             decoder_output = model._spec.description.output[i].SerializeToString()
             nms_spec.description.input.add()
@@ -1522,7 +1523,7 @@ class Exporter:
         pipeline.spec.description.output[1].ParseFromString(nms_model._spec.description.output[1].SerializeToString())
 
         # Update metadata
-        pipeline.spec.specificationVersion = 9
+        pipeline.spec.specificationVersion = spec.specificationVersion
         pipeline.spec.description.metadata.userDefined.update(
             {"IoU threshold": str(nms.iouThreshold), "Confidence threshold": str(nms.confidenceThreshold)}
         )

{ultralytics-8.3.105.dist-info → ultralytics-8.3.106.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ultralytics
-Version: 8.3.105
+Version: 8.3.106
 Summary: Ultralytics YOLO 🚀 for SOTA object detection, multi-object tracking, instance segmentation, pose estimation and image classification.
 Author-email: Glenn Jocher <glenn.jocher@ultralytics.com>, Jing Qiu <jing.qiu@ultralytics.com>
 Maintainer-email: Ultralytics <hello@ultralytics.com>

{ultralytics-8.3.105.dist-info → ultralytics-8.3.106.dist-info}/RECORD

@@ -1,13 +1,4 @@
-tests/__init__.py,sha256=xnMhv3O_DF1YrW4zk__ZywQzAaoTDjPKPoiI1Ktss1w,670
-tests/conftest.py,sha256=rsIAipRKfrVNoTaJ1LdpYue8AbcJ_fr3d3WIlM_6uXY,2982
-tests/test_cli.py,sha256=DPxUjcGAex_cmGMNaRIK7mT7wrILWaPBtlfXuHQpveI,5284
-tests/test_cuda.py,sha256=0uvTF4bY_Grsd_Xgtp7TdIEgMpUqKv8_kWA82NYDl_g,6260
-tests/test_engine.py,sha256=aGqZ8P7QO5C_nOa1b4FOyk92Ysdk5WiP-ST310Vyxys,4962
-tests/test_exports.py,sha256=dhZn86LdbapW15RthQF870LGxDjC1MUZhlGdBgPmgIQ,9716
-tests/test_integrations.py,sha256=ZgpddWHEVqiP4bGhVw8fLc2wdz0rCxuxr0FQ2dTgnIE,6067
-tests/test_python.py,sha256=ij0MV87WtbY2WVs0uP41GdVxt_p_M5Rrkldna3M5nXY,24620
-tests/test_solutions.py,sha256=428CUFC-ns0GDRZWt_er1Ma8Kb1jtDgSj3cw3T2HjWE,5530
-ultralytics/__init__.py,sha256=70uClMXEl0zWqRYtxBGmqsXSqZT6XKCKR-m47cxzkGA,730
+ultralytics/__init__.py,sha256=ey81HB6cgSBcFyxUYLBPSmZvuTyw-WPic4IrVBhQboc,730
 ultralytics/assets/bus.jpg,sha256=wCAZxJecGR63Od3ZRERe9Aja1Weayrb9Ug751DS_vGM,137419
 ultralytics/assets/zidane.jpg,sha256=Ftc4aeMmen1O0A3o6GCDO9FlfBslLpTAw0gnetx7bts,50427
 ultralytics/cfg/__init__.py,sha256=UCUFiZg-bqJwpuLLaGgy7RvAMxD-nbcVsPLxSo8x3ZA,39821
@@ -111,7 +102,7 @@ ultralytics/data/loaders.py,sha256=_Gyp_BfGTZwsFdn4UnolXxdU_sAYZLIrv0L2TRI9R5g,2
 ultralytics/data/split_dota.py,sha256=p8eVGht9tABSVbf9vwvxA_AQYEva3IGHePKlMeNrn64,11872
 ultralytics/data/utils.py,sha256=aRPwIoLrCML_Kcd0dI9B6c5Ct4dvhdF36rDHtuf7Ww4,33217
 ultralytics/engine/__init__.py,sha256=lm6MckFYCPTbqIoX7w0s_daxdjNeBeKW6DXppv1-QUM,70
-ultralytics/engine/exporter.py,sha256=XJYeJYloVPkXyl7-kCzbYt6KqqZPpLz4-BgkUrQFlOc,78346
+ultralytics/engine/exporter.py,sha256=rIQpCkgC_f_3liWpkBUAhZTQmivN8ptDfkhpi39fyzY,78504
 ultralytics/engine/model.py,sha256=YgQKYZrPENSTvLENspg-bXI9FinzzWARfb0U-C9vH-M,52916
 ultralytics/engine/predictor.py,sha256=fRUh82EJlu_6ZlIy8NFovlCcgX53UbRYSXcLljOs7Sc,21669
 ultralytics/engine/results.py,sha256=H3pFJhUjYKvVyOUqqZjfIn8vnCpl81aYNOnregMrBoQ,79716
@@ -252,9 +243,9 @@ ultralytics/utils/callbacks/neptune.py,sha256=XXnnKQ-MoLIexl8y2Vb0i-cCLyePE0n5BU
 ultralytics/utils/callbacks/raytune.py,sha256=omVZNNuzYxsZZXrF9xpbFv7R1Wjdx1j-gv0xXuZrQas,1122
 ultralytics/utils/callbacks/tensorboard.py,sha256=7eUX21_Ym7i6iN4euZzrqglphyl5xak1yl_-wfFshbg,5502
 ultralytics/utils/callbacks/wb.py,sha256=iDRFXI4IIDm8R5OI89DMTmjs8aHLo1HRCLkOFKdaMG4,7507
-ultralytics-8.3.105.dist-info/licenses/LICENSE,sha256=DZak_2itbUtvHzD3E7GNUYSRK6jdOJ-GqncQ2weavLA,34523
-ultralytics-8.3.105.dist-info/METADATA,sha256=HYewTGSUpFpPREiAy_L5PYIA00RbBfj5jbm7miunRc0,37355
-ultralytics-8.3.105.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-ultralytics-8.3.105.dist-info/entry_points.txt,sha256=YM_wiKyTe9yRrsEfqvYolNO5ngwfoL4-NwgKzc8_7sI,93
-ultralytics-8.3.105.dist-info/top_level.txt,sha256=XP49TwiMw4QGsvTLSYiJhz1xF_k7ev5mQ8jJXaXi45Q,12
-ultralytics-8.3.105.dist-info/RECORD,,
+ultralytics-8.3.106.dist-info/licenses/LICENSE,sha256=DZak_2itbUtvHzD3E7GNUYSRK6jdOJ-GqncQ2weavLA,34523
+ultralytics-8.3.106.dist-info/METADATA,sha256=ljT7_fUugMTOUfhqXUXTuqgKPnVa-YBnNYzPJVZfizc,37355
+ultralytics-8.3.106.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+ultralytics-8.3.106.dist-info/entry_points.txt,sha256=YM_wiKyTe9yRrsEfqvYolNO5ngwfoL4-NwgKzc8_7sI,93
+ultralytics-8.3.106.dist-info/top_level.txt,sha256=XP49TwiMw4QGsvTLSYiJhz1xF_k7ev5mQ8jJXaXi45Q,12
+ultralytics-8.3.106.dist-info/RECORD,,

tests/__init__.py

@@ -1,22 +0,0 @@
-# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
-
-from ultralytics.utils import ASSETS, ROOT, 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"]
-TMP = (ROOT / "../tests/tmp").resolve()  # temp directory for test files
-CUDA_IS_AVAILABLE = checks.cuda_is_available()
-CUDA_DEVICE_COUNT = checks.cuda_device_count()
-
-__all__ = (
-    "MODEL",
-    "CFG",
-    "SOURCE",
-    "SOURCES_LIST",
-    "TMP",
-    "CUDA_IS_AVAILABLE",
-    "CUDA_DEVICE_COUNT",
-)

tests/conftest.py

@@ -1,83 +0,0 @@
-# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/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 for adding custom command-line options.
-
-    Returns:
-        (None)
-    """
-    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 (pytest.config.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.
-
-    Returns:
-        (None): The function modifies the 'items' list in place.
-    """
-    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.
-
-    Returns:
-        (None)
-    """
-    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 used for terminal output.
-        exitstatus (int): The exit status of the test run.
-        config (pytest.config.Config): The pytest config object.
-
-    Returns:
-        (None)
-    """
-    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", TMP.parents[1] / ".pytest_cache", TMP] + models:
-        shutil.rmtree(directory, ignore_errors=True)

tests/test_cli.py

@@ -1,124 +0,0 @@
-# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
-
-import subprocess
-
-import pytest
-from PIL import Image
-
-from tests import CUDA_DEVICE_COUNT, CUDA_IS_AVAILABLE
-from ultralytics.cfg import TASK2DATA, TASK2MODEL, TASKS
-from ultralytics.utils import ASSETS, WEIGHTS_DIR, checks
-from ultralytics.utils.torch_utils import TORCH_1_9
-
-# 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: 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")
-
-
-@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 predict model={model} source={ASSETS} imgsz=32 save save_crop save_txt")
-
-
-@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")
-
-
-def test_rtdetr(task: str = "detect", model: str = "yolov8n-rtdetr.yaml", data: str = "coco8.yaml") -> None:
-    """Test the RTDETR functionality within Ultralytics for detection tasks using specified model and data."""
-    # 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")  # spaces
-    run(f"yolo predict {task} model={model} source={ASSETS / 'bus.jpg'} imgsz=160 save save_crop save_txt")
-    if TORCH_1_9:
-        weights = WEIGHTS_DIR / "rtdetr-l.pt"
-        run(f"yolo predict {task} model={weights} 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: 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

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"