ultralytics – ultralytics

Install the ultralytics package, including all requirements, in a Python>=3.8 environment with PyTorch>=1.8.

  

pip install ultralytics

For alternative installation methods, including Conda, Docker, and building from source via Git, please consult the Quickstart Guide.

  

CLI

You can use Ultralytics YOLO directly from the Command Line Interface (CLI) with the yolo command:

# Predict using a pretrained YOLO model (e.g., YOLO26n) on an image
yolo predict model=yolo26n.pt source='https://ultralytics.com/images/bus.jpg'

The yolo command supports various tasks and modes, accepting additional arguments like imgsz=640. Explore the YOLO CLI Docs for more examples.

Python

Ultralytics YOLO can also be integrated directly into your Python projects. It accepts the same configuration arguments as the CLI:

from ultralytics import YOLO

# Load a pretrained YOLO26n model
model = YOLO("yolo26n.pt")

# Train the model on the COCO8 dataset for 100 epochs
train_results = model.train(
    data="coco8.yaml",  # Path to dataset configuration file
    epochs=100,  # Number of training epochs
    imgsz=640,  # Image size for training
    device="cpu",  # Device to run on (e.g., 'cpu', 0, [0,1,2,3])
)

# Evaluate the model's performance on the validation set
metrics = model.val()

# Perform object detection on an image
results = model("path/to/image.jpg")  # Predict on an image
results[0].show()  # Display results

# Export the model to ONNX format for deployment
path = model.export(format="onnx")  # Returns the path to the exported model

Discover more examples in the YOLO Python Docs.

Explore the Detection Docs for usage examples. These models are trained on the COCO dataset, featuring 80 object classes.

| Model | size
^(pixels) | mAP^val
50-95 | mAP^{val
50-95(e2e)} | Speed
^{CPU ONNX
(ms)} | Speed
^{T4 TensorRT10
(ms)} | params
^(M) | FLOPs
^(B) |
| ---------------------------------------------------------------------- | --------------------------- | -------------------------- | ------------------------------- | ------------------------------------ | ----------------------------------------- | ------------------------ | ----------------------- |
| YOLO26n | 640 | 40.9 | 40.1 | 38.9 ± 0.7 | 1.7 ± 0.0 | 2.4 | 5.4 |
| YOLO26s | 640 | 48.6 | 47.8 | 87.2 ± 0.9 | 2.5 ± 0.0 | 9.5 | 20.7 |
| YOLO26m | 640 | 53.1 | 52.5 | 220.0 ± 1.4 | 4.7 ± 0.1 | 20.4 | 68.2 |
| YOLO26l | 640 | 55.0 | 54.4 | 286.2 ± 2.0 | 6.2 ± 0.2 | 24.8 | 86.4 |
| YOLO26x | 640 | 57.5 | 56.9 | 525.8 ± 4.0 | 11.8 ± 0.2 | 55.7 | 193.9 |

• mAP^val values refer to single-model single-scale performance on the COCO val2017 dataset. See YOLO Performance Metrics for details.
  Reproduce with yolo val detect data=coco.yaml device=0
• Speed metrics are averaged over COCO val images using an Amazon EC2 P4d instance. CPU speeds measured with ONNX export. GPU speeds measured with TensorRT export.
  Reproduce with yolo val detect data=coco.yaml batch=1 device=0|cpu

Refer to the Segmentation Docs for usage examples. These models are trained on COCO-Seg, including 80 classes.

| Model | size
^(pixels) | mAP^{box
50-95(e2e)} | mAP^{mask
50-95(e2e)} | Speed
^{CPU ONNX
(ms)} | Speed
^{T4 TensorRT10
(ms)} | params
^(M) | FLOPs
^(B) |
| ------------------------------------------------------------------------------ | --------------------------- | ------------------------------- | -------------------------------- | ------------------------------------ | ----------------------------------------- | ------------------------ | ----------------------- |
| YOLO26n-seg | 640 | 39.6 | 33.9 | 53.3 ± 0.5 | 2.1 ± 0.0 | 2.7 | 9.1 |
| YOLO26s-seg | 640 | 47.3 | 40.0 | 118.4 ± 0.9 | 3.3 ± 0.0 | 10.4 | 34.2 |
| YOLO26m-seg | 640 | 52.5 | 44.1 | 328.2 ± 2.4 | 6.7 ± 0.1 | 23.6 | 121.5 |
| YOLO26l-seg | 640 | 54.4 | 45.5 | 387.0 ± 3.7 | 8.0 ± 0.1 | 28.0 | 139.8 |
| YOLO26x-seg | 640 | 56.5 | 47.0 | 787.0 ± 6.8 | 16.4 ± 0.1 | 62.8 | 313.5 |

• mAP^val values are for single-model single-scale on the COCO val2017 dataset. See YOLO Performance Metrics for details.
  Reproduce with yolo val segment data=coco.yaml device=0
• Speed metrics are averaged over COCO val images using an Amazon EC2 P4d instance. CPU speeds measured with ONNX export. GPU speeds measured with TensorRT export.
  Reproduce with yolo val segment data=coco.yaml batch=1 device=0|cpu

See the Semantic Segmentation Docs for usage examples. These models are trained on Cityscapes, including 19 classes.

| Model | size
^(pixels) | mIoU^val | Speed
^{RTX3090 PyTorch
(ms)} | params
^(M) | FLOPs
^(B) |
| ------------------------------------------------------------------------------ | --------------------------- | ------------------ | ------------------------------------------- | ------------------------ | ----------------------- |
| YOLO26n-sem | 1024 × 2048 | 78.3 | 4.4 ± 0.0 | 1.6 | 22.7 |
| YOLO26s-sem | 1024 × 2048 | 80.8 | 8.4 ± 0.0 | 6.5 | 88.8 |
| YOLO26m-sem | 1024 × 2048 | 82.0 | 19.9 ± 0.1 | 14.3 | 304.5 |
| YOLO26l-sem | 1024 × 2048 | 82.9 | 26.5 ± 0.1 | 17.9 | 384.7 |
| YOLO26x-sem | 1024 × 2048 | 83.6 | 48.9 ± 0.2 | 40.2 | 861.7 |

• mIoU^val values are for single-model single-scale on the Cityscapes validation set.
  Reproduce with yolo semantic val data=cityscapes.yaml device=0 imgsz=2048
• Speed metrics are averaged over Cityscapes validation images using an RTX3090 instance.
  Reproduce with yolo semantic val data=cityscapes.yaml batch=1 device=0|cpu imgsz=2048

See the Depth Estimation Docs for usage examples. These models are pretrained on a broad multi-dataset mix and evaluated on the NYU Depth V2 Eigen test split, predicting per-pixel depth in meters.

| Model | size
^(pixels) | delta1^NYU | abs_rel^NYU | rmse^NYU | Speed
^{CPU ONNX
(ms)} | Speed
^{T4 TensorRT10
(ms)} | params
^(M) | FLOPs
^(B) |
| ---------------------------------------------------------------------------------- | --------------------------- | -------------------- | --------------------- | ------------------ | ------------------------------------ | ----------------------------------------- | ------------------------ | ----------------------- |
| YOLO26n-depth | 768 | 0.882 | 0.109 | 0.414 | 272.0 ± 27.2 | 2.7 ± 0.1 | 6.4 | 46.9 |
| YOLO26s-depth | 768 | 0.896 | 0.104 | 0.399 | 393.7 ± 13.1 | 3.8 ± 0.0 | 13.2 | 67.9 |
| YOLO26m-depth | 768 | 0.921 | 0.089 | 0.364 | 621.5 ± 49.7 | 6.0 ± 0.1 | 23.3 | 130.7 |
| YOLO26l-depth | 768 | 0.930 | 0.083 | 0.351 | 821.9 ± 50.7 | 7.7 ± 0.1 | 27.7 | 157.2 |
| YOLO26x-depth | 768 | 0.933 | 0.080 | 0.344 | 1240.9 ± 73.3 | 13.6 ± 0.2 | 57.0 | 302.0 |

• delta1^NYU is the percentage of pixels where the predicted depth is within a factor of 1.25 of the ground truth, on the NYU Depth V2 Eigen test split (654 images) with multi-scale + horizontal-flip TTA and log-least-squares alignment.
• Single-scale accuracy without TTA is reproducible with yolo depth val model=yolo26n-depth.pt data=nyu-depth.yaml imgsz=768 device=0 (substitute model= for each size), which uses median (scale-only) alignment and scores lower: delta1 0.785 (n), 0.786 (s), 0.827 (m), 0.839 (l), 0.843 (x).
• abs_rel is the mean absolute relative error between predicted and ground-truth depth values.
• rmse is the root mean squared error in meters.
• Speed is inference-only latency (pre/post-processing excluded) at imgsz=768, batch=1, reported as mean ± std over timed runs after warmup. CPU ONNX is ONNX Runtime fp32 on a 32-core Intel Xeon (Skylake); T4 TensorRT10 is TensorRT fp16 on a Tesla T4.
• params and FLOPs are measured at 768×768, the training resolution of the released weights.

Consult the Classification Docs for usage examples. These models are trained on ImageNet, covering 1000 classes.

| Model | size
^(pixels) | acc
^top1 | acc
^top5 | Speed
^{CPU ONNX
(ms)} | Speed
^{T4 TensorRT10
(ms)} | params
^(M) | FLOPs
^{(B) at 224} |
| ------------------------------------------------------------------------------ | --------------------------- | ---------------------- | ---------------------- | ------------------------------------ | ----------------------------------------- | ------------------------ | ------------------------------ |
| YOLO26n-cls | 224 | 71.4 | 90.1 | 5.0 ± 0.3 | 1.1 ± 0.0 | 2.8 | 0.5 |
| YOLO26s-cls | 224 | 76.0 | 92.9 | 7.9 ± 0.2 | 1.3 ± 0.0 | 6.7 | 1.6 |
| YOLO26m-cls | 224 | 78.1 | 94.2 | 17.2 ± 0.4 | 2.0 ± 0.0 | 11.6 | 4.9 |
| YOLO26l-cls | 224 | 79.0 | 94.6 | 23.2 ± 0.3 | 2.8 ± 0.0 | 14.1 | 6.2 |
| YOLO26x-cls | 224 | 79.9 | 95.0 | 41.4 ± 0.9 | 3.8 ± 0.0 | 29.6 | 13.6 |

• acc values represent model accuracy on the ImageNet dataset validation set.
  Reproduce with yolo val classify data=path/to/ImageNet device=0
• Speed metrics are averaged over ImageNet val images using an Amazon EC2 P4d instance. CPU speeds measured with ONNX export. GPU speeds measured with TensorRT export.
  Reproduce with yolo val classify data=path/to/ImageNet batch=1 device=0|cpu

See the Pose Estimation Docs for usage examples. These models are trained on COCO-Pose, focusing on the 'person' class.

| Model | size
^(pixels) | mAP^{pose
50-95(e2e)} | mAP^pose
50(e2e) | Speed
^{CPU ONNX
(ms)} | Speed
^{T4 TensorRT10
(ms)} | params
^(M) | FLOPs
^(B) |
| -------------------------------------------------------------------------------- | --------------------------- | -------------------------------- | ----------------------------- | ------------------------------------ | ----------------------------------------- | ------------------------ | ----------------------- |
| YOLO26n-pose | 640 | 57.2 | 83.3 | 40.3 ± 0.5 | 1.8 ± 0.0 | 2.9 | 7.5 |
| YOLO26s-pose | 640 | 63.0 | 86.6 | 85.3 ± 0.9 | 2.7 ± 0.0 | 10.4 | 23.9 |
| YOLO26m-pose | 640 | 68.8 | 89.6 | 218.0 ± 1.5 | 5.0 ± 0.1 | 21.5 | 73.1 |
| YOLO26l-pose | 640 | 70.4 | 90.5 | 275.4 ± 2.4 | 6.5 ± 0.1 | 25.9 | 91.3 |
| YOLO26x-pose | 640 | 71.6 | 91.6 | 565.4 ± 3.0 | 12.2 ± 0.2 | 57.6 | 201.7 |

• mAP^val values are for single-model single-scale on the COCO Keypoints val2017 dataset. See YOLO Performance Metrics for details.
  Reproduce with yolo val pose data=coco-pose.yaml device=0
• Speed metrics are averaged over COCO val images using an Amazon EC2 P4d instance. CPU speeds measured with ONNX export. GPU speeds measured with TensorRT export.
  Reproduce with yolo val pose data=coco-pose.yaml batch=1 device=0|cpu

Check the OBB Docs for usage examples. These models are trained on DOTAv1, including 15 classes.

| Model | size
^(pixels) | mAP^{test
50-95(e2e)} | mAP^test
50(e2e) | Speed
^{CPU ONNX
(ms)} | Speed
^{T4 TensorRT10
(ms)} | params
^(M) | FLOPs
^(B) |
| ------------------------------------------------------------------------------ | --------------------------- | -------------------------------- | ----------------------------- | ------------------------------------ | ----------------------------------------- | ------------------------ | ----------------------- |
| YOLO26n-obb | 1024 | 52.4 | 78.9 | 97.7 ± 0.9 | 2.8 ± 0.0 | 2.5 | 14.0 |
| YOLO26s-obb | 1024 | 54.8 | 80.9 | 218.0 ± 1.4 | 4.9 ± 0.1 | 9.8 | 55.1 |
| YOLO26m-obb | 1024 | 55.3 | 81.0 | 579.2 ± 3.8 | 10.2 ± 0.3 | 21.2 | 183.3 |
| YOLO26l-obb | 1024 | 56.2 | 81.6 | 735.6 ± 3.1 | 13.0 ± 0.2 | 25.6 | 230.0 |
| YOLO26x-obb | 1024 | 56.7 | 81.7 | 1485.7 ± 11.5 | 30.5 ± 0.9 | 57.6 | 516.5 |

• mAP^test values are for single-model multiscale performance on the DOTAv1 test set.
  Reproduce by yolo val obb data=DOTAv1.yaml device=0 split=test and submit merged results to the DOTA evaluation server.
• Speed metrics are averaged over DOTAv1 val images using an Amazon EC2 P4d instance. CPU speeds measured with ONNX export. GPU speeds measured with TensorRT export.
  Reproduce by yolo val obb data=DOTAv1.yaml batch=1 device=0|cpu