Instance Segmentation with Ultralytics YOLO#

Instance segmentation goes a step further than object detection and involves identifying individual objects in an image and segmenting them from the rest of the image.

The output of an instance segmentation model is a set of masks or contours that outline each object in the image, along with class labels and confidence scores for each object. Instance segmentation is useful when you need to know not only where objects are in an image, but also what their exact shape is.

Models#

YOLO26 Segment models pretrained on the COCO dataset are shown below.

Models download automatically from the latest Ultralytics release on first use.

• mAP^val values are for single-model single-scale on COCO val2017 dataset.
  Reproduce with yolo segment val data=coco.yaml device=0 nms=False
• Speed averaged over COCO val images with ONNX on CPU and TensorRT10 on an NVIDIA T4 GPU.
  Reproduce with yolo segment val data=coco.yaml batch=1 device=0|cpu nms=False
• Params and FLOPs values are for fused models after Conv/BatchNorm folding and removal of the unused detection branch. Pretrained checkpoints retain the full training architecture and may show higher counts.

These checkpoints segment the 80 COCO classes. To segment categories outside that list without retraining, see YOLOE, which takes the classes as a text prompt, a visual example, or a built-in vocabulary.

See the unreleased YOLO27 preview for preliminary COCO box and mask results.

Train#

Train YOLO26n-seg on the COCO8-seg dataset for 100 epochs at image size 640. For a full list of available arguments see the Configuration page.

from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n-seg.yaml")  # build a new model from YAML
model = YOLO("yolo26n-seg.pt")  # load a pretrained model (recommended for training)
model = YOLO("yolo26n-seg.yaml").load("yolo26n-seg.pt")  # build from YAML and transfer weights

# Train the model
results = model.train(data="coco8-seg.yaml", epochs=100, imgsz=640)

See full train mode details in the Train page. Segmentation models can also be trained with Ultralytics Platform cloud training.

Dataset format#

YOLO segmentation dataset format can be found in detail in the Dataset Guide. To convert an existing COCO JSON dataset to YOLO format, use the built-in convert_coco function with use_segments=True, as described in the COCO to YOLO guide. You can also create segmentation masks with Ultralytics Platform annotation using polygon tools and SAM-powered smart annotation.

Val#

Validate trained YOLO26n-seg model accuracy. No arguments are needed, as the model retains its training data and arguments as model attributes: path/to/best.pt from the Train example validates on COCO8-seg. Official weights record a training dataset path that doesn't exist on your machine, so they fall back to the task default coco8-seg.yaml with a warning. Pass data to validate on another dataset.

from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n-seg.pt")  # load an official model
model = YOLO("path/to/best.pt")  # load a custom model

# Validate the model
metrics = model.val()  # no arguments needed, dataset and settings remembered
metrics.box.map  # map50-95(B)
metrics.box.map50  # map50(B)
metrics.box.map75  # map75(B)
metrics.box.maps  # a list containing mAP50-95(B) for each category
metrics.box.image_metrics  # per-image metrics dictionary for det with precision, recall, F1, TP, FP, and FN
metrics.seg.map  # map50-95(M)
metrics.seg.map50  # map50(M)
metrics.seg.map75  # map75(M)
metrics.seg.maps  # a list containing mAP50-95(M) for each category
metrics.seg.image_metrics  # per-image metrics dictionary for seg with precision, recall, F1, TP, FP, and FN

Predict#

Use a trained YOLO26n-seg model to run predictions on images.

from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n-seg.pt")  # load an official model
model = YOLO("path/to/best.pt")  # load a custom model

# Predict with the model
results = model("https://ultralytics.com/images/bus.jpg")  # predict on an image

# Access the results
for result in results:
    xy = result.masks.xy  # mask polygons in pixel coordinates
    xyn = result.masks.xyn  # normalized mask polygons
    masks = result.masks.data  # binary masks, shape (N,H,W), dtype torch.uint8

See full predict mode details in the Predict page.

Results Output#

YOLO instance segmentation returns one Results object per image. Each result stores object-level predictions, where each detected instance has its own binary mask, class, confidence, and box.

For task-specific Results fields across every task, see the Predict Results by Task section.

Instance vs Semantic Segmentation#

Instance segmentation is object-level segmentation: two cars produce two masks, two boxes, and two confidence scores. Semantic segmentation is pixel-level classification: those same cars become pixels with the same class ID in one image-sized class map, with no per-object boxes, confidences, or default polygon list. See the field-by-field comparison on the semantic segmentation page.

Export#

Export a YOLO26n-seg model to a different format like ONNX, CoreML, etc.

from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n-seg.pt")  # load an official model
model = YOLO("path/to/best.pt")  # load a custom model

# Export the model
model.export(format="onnx")

Available YOLO26-seg export formats are in the table below. You can export to any format using the format argument, i.e., format='onnx' or format='engine'. You can predict or validate directly on exported models, i.e., yolo predict model=yolo26n-seg.onnx. Usage examples are shown for your model after export completes.

nms=None defaults to raw outputs for external NMS. Set nms=False to select an available NMS-free head; unsupported formats fall back to their native output path. The nms entries above identify formats that can embed NMS with nms=True.

See full export details in the Export page.

FAQ#