ultralytics 8.1.5__tar.gz → 8.1.7__tar.gz

{ultralytics-8.1.5/ultralytics.egg-info → ultralytics-8.1.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ultralytics
-Version: 8.1.5
+Version: 8.1.7
 Summary: Ultralytics YOLOv8 for SOTA object detection, multi-object tracking, instance segmentation, pose estimation and image classification.
 Author: Glenn Jocher, Ayush Chaurasia, Jing Qiu
 Maintainer: Glenn Jocher, Ayush Chaurasia, Jing Qiu
@@ -55,7 +55,7 @@ Requires-Dist: mkdocs-material; extra == "dev"
 Requires-Dist: mkdocstrings[python]; extra == "dev"
 Requires-Dist: mkdocs-jupyter; extra == "dev"
 Requires-Dist: mkdocs-redirects; extra == "dev"
-Requires-Dist: mkdocs-ultralytics-plugin>=0.0.38; extra == "dev"
+Requires-Dist: mkdocs-ultralytics-plugin>=0.0.42; extra == "dev"
 Provides-Extra: export
 Requires-Dist: onnx>=1.12.0; extra == "export"
 Requires-Dist: coremltools>=7.0; platform_system != "Windows" and extra == "export"

{ultralytics-8.1.5 → ultralytics-8.1.7}/pyproject.toml

@@ -93,7 +93,7 @@ dev = [
     "mkdocstrings[python]",
     "mkdocs-jupyter", # for notebooks
     "mkdocs-redirects", # for 301 redirects
-    "mkdocs-ultralytics-plugin>=0.0.38", # for meta descriptions and images, dates and authors
+    "mkdocs-ultralytics-plugin>=0.0.42", # for meta descriptions and images, dates and authors
 ]
 export = [
     "onnx>=1.12.0", # ONNX export

{ultralytics-8.1.5 → ultralytics-8.1.7}/tests/test_cli.py

@@ -10,17 +10,19 @@ from ultralytics.utils.checks import cuda_device_count, cuda_is_available
 CUDA_IS_AVAILABLE = cuda_is_available()
 CUDA_DEVICE_COUNT = cuda_device_count()
 TASK_ARGS = [
-    ('detect', 'yolov8n', 'coco8.yaml'),
-    ('segment', 'yolov8n-seg', 'coco8-seg.yaml'),
-    ('classify', 'yolov8n-cls', 'imagenet10'),
-    ('pose', 'yolov8n-pose', 'coco8-pose.yaml'),
-    ('obb', 'yolov8n-obb', 'dota8.yaml'), ]  # (task, model, data)
+    ("detect", "yolov8n", "coco8.yaml"),
+    ("segment", "yolov8n-seg", "coco8-seg.yaml"),
+    ("classify", "yolov8n-cls", "imagenet10"),
+    ("pose", "yolov8n-pose", "coco8-pose.yaml"),
+    ("obb", "yolov8n-obb", "dota8.yaml"),
+]  # (task, model, data)
 EXPORT_ARGS = [
-    ('yolov8n', 'torchscript'),
-    ('yolov8n-seg', 'torchscript'),
-    ('yolov8n-cls', 'torchscript'),
-    ('yolov8n-pose', 'torchscript'),
-    ('yolov8n-obb', 'torchscript'), ]  # (model, format)
+    ("yolov8n", "torchscript"),
+    ("yolov8n-seg", "torchscript"),
+    ("yolov8n-cls", "torchscript"),
+    ("yolov8n-pose", "torchscript"),
+    ("yolov8n-obb", "torchscript"),
+]  # (model, format)
 
 
 def run(cmd):
@@ -30,50 +32,50 @@ def run(cmd):
 
 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')
+    run("yolo help")
+    run("yolo checks")
+    run("yolo version")
+    run("yolo settings reset")
+    run("yolo cfg")
 
 
-@pytest.mark.parametrize('task,model,data', TASK_ARGS)
+@pytest.mark.parametrize("task,model,data", TASK_ARGS)
 def test_train(task, model, data):
     """Test YOLO training for a given task, model, and data."""
-    run(f'yolo train {task} model={model}.yaml data={data} imgsz=32 epochs=1 cache=disk')
+    run(f"yolo train {task} model={model}.yaml data={data} imgsz=32 epochs=1 cache=disk")
 
 
-@pytest.mark.parametrize('task,model,data', TASK_ARGS)
+@pytest.mark.parametrize("task,model,data", TASK_ARGS)
 def test_val(task, model, data):
     """Test YOLO validation for a given task, model, and data."""
-    run(f'yolo val {task} model={WEIGHTS_DIR / model}.pt data={data} imgsz=32 save_txt save_json')
+    run(f"yolo val {task} model={WEIGHTS_DIR / model}.pt data={data} imgsz=32 save_txt save_json")
 
 
-@pytest.mark.parametrize('task,model,data', TASK_ARGS)
+@pytest.mark.parametrize("task,model,data", TASK_ARGS)
 def test_predict(task, model, data):
     """Test YOLO prediction on sample assets for a given task and model."""
-    run(f'yolo predict model={WEIGHTS_DIR / model}.pt source={ASSETS} imgsz=32 save save_crop save_txt')
+    run(f"yolo predict model={WEIGHTS_DIR / model}.pt source={ASSETS} imgsz=32 save save_crop save_txt")
 
 
-@pytest.mark.parametrize('model,format', EXPORT_ARGS)
+@pytest.mark.parametrize("model,format", EXPORT_ARGS)
 def test_export(model, format):
     """Test exporting a YOLO model to different formats."""
-    run(f'yolo export model={WEIGHTS_DIR / model}.pt format={format} imgsz=32')
+    run(f"yolo export model={WEIGHTS_DIR / model}.pt format={format} imgsz=32")
 
 
-def test_rtdetr(task='detect', model='yolov8n-rtdetr.yaml', data='coco8.yaml'):
+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
-    run(f'yolo train {task} model={model} data={data} --imgsz= 640 epochs =1, cache = disk')  # add coma, spaces to args
+    run(f"yolo train {task} model={model} data={data} --imgsz= 640 epochs =1, cache = disk")  # add coma, spaces to args
     run(f"yolo predict {task} model={model} source={ASSETS / 'bus.jpg'} imgsz=640 save save_crop save_txt")
 
 
-def test_fastsam(task='segment', model=WEIGHTS_DIR / 'FastSAM-s.pt', data='coco8-seg.yaml'):
+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'
+    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')
+    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
@@ -83,26 +85,26 @@ def test_fastsam(task='segment', model=WEIGHTS_DIR / 'FastSAM-s.pt', data='coco8
     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)
+    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')
+    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')
+    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='./')
+    prompt_process.plot(annotations=ann, output="./")
 
 
 def test_mobilesam():
@@ -110,10 +112,10 @@ def test_mobilesam():
     from ultralytics import SAM
 
     # Load the model
-    model = SAM(WEIGHTS_DIR / 'mobile_sam.pt')
+    model = SAM(WEIGHTS_DIR / "mobile_sam.pt")
 
     # Source
-    source = ASSETS / 'zidane.jpg'
+    source = ASSETS / "zidane.jpg"
 
     # Predict a segment based on a point prompt
     model.predict(source, points=[900, 370], labels=[1])
@@ -127,10 +129,10 @@ def test_mobilesam():
 
 # Slow Tests -----------------------------------------------------------------------------------------------------------
 @pytest.mark.slow
-@pytest.mark.parametrize('task,model,data', TASK_ARGS)
-@pytest.mark.skipif(not CUDA_IS_AVAILABLE, reason='CUDA is not available')
-@pytest.mark.skipif(CUDA_DEVICE_COUNT < 2, reason='DDP is not available')
+@pytest.mark.parametrize("task,model,data", TASK_ARGS)
+@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}.yaml data={data} imgsz=32 epochs=1 device=0')  # single GPU
-    run(f'yolo train {task} model={model}.pt data={data} imgsz=32 epochs=1 device=0,1')  # multi GPU
+    run(f"yolo train {task} model={model}.yaml data={data} imgsz=32 epochs=1 device=0")  # single GPU
+    run(f"yolo train {task} model={model}.pt data={data} imgsz=32 epochs=1 device=0,1")  # multi GPU

{ultralytics-8.1.5 → ultralytics-8.1.7}/tests/test_cuda.py

@@ -9,9 +9,9 @@ from ultralytics.utils import ASSETS, WEIGHTS_DIR, checks
 CUDA_IS_AVAILABLE = checks.cuda_is_available()
 CUDA_DEVICE_COUNT = checks.cuda_device_count()
 
-MODEL = WEIGHTS_DIR / 'path with spaces' / 'yolov8n.pt'  # test spaces in path
-DATA = 'coco8.yaml'
-BUS = ASSETS / 'bus.jpg'
+MODEL = WEIGHTS_DIR / "path with spaces" / "yolov8n.pt"  # test spaces in path
+DATA = "coco8.yaml"
+BUS = ASSETS / "bus.jpg"
 
 
 def test_checks():
@@ -20,7 +20,7 @@ def test_checks():
     assert torch.cuda.device_count() == CUDA_DEVICE_COUNT
 
 
-@pytest.mark.skipif(not CUDA_IS_AVAILABLE, reason='CUDA is not available')
+@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]
@@ -28,32 +28,32 @@ def test_train():
 
 
 @pytest.mark.slow
-@pytest.mark.skipif(not CUDA_IS_AVAILABLE, reason='CUDA is not available')
+@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 = YOLO("yolov8n.pt")
     model = model.cpu()
-    assert str(model.device) == 'cpu'
+    assert str(model.device) == "cpu"
     _ = model(BUS)  # CPU inference
-    assert str(model.device) == 'cpu'
+    assert str(model.device) == "cpu"
 
-    model = model.to('cuda:0')
-    assert str(model.device) == 'cuda:0'
+    model = model.to("cuda:0")
+    assert str(model.device) == "cuda:0"
     _ = model(BUS)  # CUDA inference
-    assert str(model.device) == 'cuda:0'
+    assert str(model.device) == "cuda:0"
 
     model = model.cpu()
-    assert str(model.device) == 'cpu'
+    assert str(model.device) == "cpu"
     _ = model(BUS)  # CPU inference
-    assert str(model.device) == 'cpu'
+    assert str(model.device) == "cpu"
 
     model = model.cuda()
-    assert str(model.device) == 'cuda:0'
+    assert str(model.device) == "cuda:0"
     _ = model(BUS)  # CUDA inference
-    assert str(model.device) == 'cuda:0'
+    assert str(model.device) == "cuda:0"
 
 
-@pytest.mark.skipif(not CUDA_IS_AVAILABLE, reason='CUDA is not available')
+@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
@@ -62,24 +62,24 @@ def test_autobatch():
 
 
 @pytest.mark.slow
-@pytest.mark.skipif(not CUDA_IS_AVAILABLE, reason='CUDA is not available')
+@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)
+    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')
+@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')
+    model = SAM(WEIGHTS_DIR / "sam_b.pt")
 
     # Display model information (optional)
     model.info()
@@ -91,14 +91,14 @@ def test_predict_sam():
     model(BUS, bboxes=[439, 437, 524, 709], device=0)
 
     # Run inference with points prompt
-    model(ASSETS / 'zidane.jpg', points=[900, 370], labels=[1], device=0)
+    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')
+    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.set_image(ASSETS / "zidane.jpg")  # set with image file
     # predictor(bboxes=[439, 437, 524, 709])
     # predictor(points=[900, 370], labels=[1])
 

ultralytics-8.1.7/tests/test_engine.py

@@ -0,0 +1,128 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+
+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
+
+CFG_DET = "yolov8n.yaml"
+CFG_SEG = "yolov8n-seg.yaml"
+CFG_CLS = "yolov8n-cls.yaml"  # or 'squeezenet1_0'
+CFG = get_cfg(DEFAULT_CFG)
+MODEL = WEIGHTS_DIR / "yolov8n"
+
+
+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(CFG_DET).model)
+    YOLO(f)(ASSETS)  # exported model inference
+
+
+def test_detect():
+    """Test object detection functionality."""
+    overrides = {"data": "coco8.yaml", "model": CFG_DET, "imgsz": 32, "epochs": 1, "save": False}
+    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"
+    result = pred(source=ASSETS, model=f"{MODEL}.pt")
+    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": CFG_SEG, "imgsz": 32, "epochs": 1, "save": False}
+    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=f"{MODEL}-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": CFG_CLS, "imgsz": 32, "epochs": 1, "save": False}
+    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"

{ultralytics-8.1.5 → ultralytics-8.1.7}/tests/test_explorer.py

@@ -12,7 +12,7 @@ def test_similarity():
     exp.create_embeddings_table()
     similar = exp.get_similar(idx=1)
     assert len(similar) == 25
-    similar = exp.get_similar(img=ASSETS / 'zidane.jpg')
+    similar = exp.get_similar(img=ASSETS / "zidane.jpg")
     assert len(similar) == 25
     similar = exp.get_similar(idx=[1, 2], limit=10)
     assert len(similar) == 10
@@ -24,9 +24,9 @@ def test_similarity():
 
 def test_det():
     """Test detection functionalities and ensure the embedding table has bounding boxes."""
-    exp = Explorer(data='coco8.yaml', model='yolov8n.pt')
+    exp = Explorer(data="coco8.yaml", model="yolov8n.pt")
     exp.create_embeddings_table(force=True)
-    assert len(exp.table.head()['bboxes']) > 0
+    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
@@ -36,9 +36,9 @@ def test_det():
 
 def test_seg():
     """Test segmentation functionalities and verify the embedding table includes masks."""
-    exp = Explorer(data='coco8-seg.yaml', model='yolov8n-seg.pt')
+    exp = Explorer(data="coco8-seg.yaml", model="yolov8n-seg.pt")
     exp.create_embeddings_table(force=True)
-    assert len(exp.table.head()['masks']) > 0
+    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)
@@ -47,9 +47,9 @@ def test_seg():
 
 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 = Explorer(data="coco8-pose.yaml", model="yolov8n-pose.pt")
     exp.create_embeddings_table(force=True)
-    assert len(exp.table.head()['keypoints']) > 0
+    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)

ultralytics-8.1.7/tests/test_integrations.py

@@ -0,0 +1,117 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+
+import contextlib
+from pathlib import Path
+
+import pytest
+
+from ultralytics import YOLO, download
+from ultralytics.utils import ASSETS, DATASETS_DIR, ROOT, SETTINGS, WEIGHTS_DIR
+from ultralytics.utils.checks import check_requirements
+
+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
+
+
+@pytest.mark.skipif(not check_requirements("ray", install=False), reason="ray[tune] not installed")
+def test_model_ray_tune():
+    """Tune YOLO model with Ray optimization library."""
+    YOLO("yolov8n-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."""
+    SETTINGS["mlflow"] = True
+    YOLO("yolov8n-cls.yaml").train(data="imagenet10", imgsz=32, epochs=3, plots=False, device="cpu")
+
+
+@pytest.mark.skipif(not check_requirements("tritonclient", install=False), reason="tritonclient[all] not installed")
+def test_triton():
+    """Test NVIDIA Triton Server functionalities."""
+    check_requirements("tritonclient[all]")
+    import subprocess
+    import time
+
+    from tritonclient.http import InferenceServerClient  # noqa
+
+    # Create variables
+    model_name = "yolo"
+    triton_repo_path = TMP / "triton_repo"
+    triton_model_path = triton_repo_path / model_name
+
+    # Export model to ONNX
+    f = YOLO(MODEL).export(format="onnx", dynamic=True)
+
+    # Prepare Triton repo
+    (triton_model_path / "1").mkdir(parents=True, exist_ok=True)
+    Path(f).rename(triton_model_path / "1" / "model.onnx")
+    (triton_model_path / "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_path}:/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 model predictions 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/v8.1.0/"
+
+    args = {"model": "yolov8n.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": "yolov8n-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": "yolov8n-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)