Ultralytics YOLO27:

Segmentazione delle istanze con Ultralytics YOLO#

Ultralytics YOLO instance segmentation examples

La segmentazione delle istanze fa un passo oltre il rilevamento degli oggetti e consiste nell'identificare i singoli oggetti in un'immagine e segmentarli dal resto dell'immagine.

L'output di un modello di segmentazione delle istanze è un insieme di maschere o contorni che delineano ogni oggetto nell'immagine, insieme alle etichette delle classi e ai punteggi di confidenza per ogni oggetto. La segmentazione delle istanze è utile quando devi sapere non solo dove si trovano gli oggetti in un'immagine, ma anche qual è la loro forma esatta.



Watch: Run Segmentation with Pretrained Ultralytics YOLO Model in Python.
Suggerimento

I modelli YOLO26 Segment utilizzano il suffisso -seg, ovvero yolo26n-seg.pt, e sono sottoposti a pretraining su COCO.

Modelli#

Qui sono mostrati i modelli Segment YOLO26 sottoposti a pretraining. I modelli Detect, Segment e Pose sono sottoposti a pretraining sul dataset COCO, i modelli Semantic sono sottoposti a pretraining su Cityscapes e i modelli Classify sono sottoposti a pretraining sul dataset ImageNet.

I modelli vengono scaricati automaticamente dall'ultima release di Ultralytics al primo utilizzo.

Modellodimensione
(pixel)
mAPbox
50-95(e2e)
mAPmask
50-95(e2e)
Velocità
CPU ONNX
(ms)
Velocità
T4 TensorRT10
(ms)
parametri
(M)
FLOPs
(B)
YOLO26n-seg64039.633.953.3 ± 0.52.1 ± 0.02.79.3
YOLO26s-seg64047.340.0118.4 ± 0.93.3 ± 0.010.434.5
YOLO26m-seg64052.544.1328.2 ± 2.46.7 ± 0.123.6121.7
YOLO26l-seg64054.445.5387.0 ± 3.78.0 ± 0.128.0140.1
YOLO26x-seg64056.547.0787.0 ± 6.816.4 ± 0.162.8314.0
  • I valori di mAPval si riferiscono a un singolo modello e a una singola scala sul dataset COCO val2017.
    Riproduci utilizzando yolo val segment data=coco.yaml device=0 nms=False
  • La velocità è calcolata come media sulle immagini COCO val utilizzando un'istanza Amazon EC2 P4d.
    Riproduci con yolo val segment data=coco.yaml batch=1 device=0|cpu nms=False
  • I valori di Params e FLOPs si riferiscono a modelli fusi dopo il folding di Conv/BatchNorm e la rimozione del ramo di rilevamento non utilizzato. I checkpoint preaddestrati mantengono l'intera architettura di addestramento e potrebbero mostrare conteggi superiori.

Questi checkpoint segmentano le 80 classi COCO. Per segmentare categorie al di fuori di questo elenco senza eseguire un nuovo training, consulta YOLOE, che accetta le classi come prompt testuale, esempio visivo o vocabolario integrato.

Consulta l'anteprima unreleased YOLO27 preview per i risultati preliminari su bounding box e maschere di COCO.

Addestramento#

Esegui il training di YOLO26n-seg sul dataset COCO8-seg per 100 epoche con una dimensione delle immagini pari a 640. Per un elenco completo degli argomenti disponibili, consulta la pagina Configurazione.

Esempio
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)

Consulta tutti i dettagli della modalità train nella pagina Train. I modelli di segmentazione possono essere sottoposti a training anche con il training cloud di Ultralytics Platform.

Formato del dataset#

Il formato del dataset di segmentazione YOLO può essere trovato in dettaglio nella Guida ai Dataset. Per convertire un dataset JSON COCO esistente nel formato YOLO, usa la funzione integrata convert_coco con use_segments=True, come descritto nella Guida da COCO a YOLO. Puoi anche creare maschere di segmentazione con l'annotazione della Piattaforma Ultralytics usando strumenti poligonali e l'annotazione intelligente basata su SAM.

Val#

Convalida l'accuratezza del modello YOLO26n-seg sottoposto a training sul dataset COCO8-seg. Non sono necessari argomenti, poiché model conserva i propri data e argomenti di training come attributi del modello.

Esempio
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

Predizione#

Usa un modello YOLO26n-seg sottoposto a training per eseguire predizioni sulle immagini.

Esempio
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

Consulta la pagina Predict per tutti i dettagli sulla modalità predict.

Output dei risultati#

La segmentazione delle istanze YOLO restituisce un oggetto Results per ogni immagine. Ogni risultato memorizza predizioni a livello di oggetto, in cui ogni istanza rilevata ha la propria maschera binaria, classe, confidenza e riquadro.

AttributoTipoFormaDescrizione
result.masksMasks(N)Maschere delle istanze.
result.masks.datatorch.uint8(N,H,W)Maschere binarie, con valori 0 o 1.
result.masks.xynp.float32list[(P,2)]Poligoni dei pixel.
result.masks.xynnp.float32list[(P,2)]Poligoni normalizzati.
result.boxesBoxes(N)Box/ classi/ confidenze delle istanze.
result.boxes.clstorch.float32(N,)ID delle classi; converti in int per ottenere i nomi.

Per i campi Results specifici dell'attività in tutte le attività, consulta la sezione Risultati delle predizioni per attività.

Differenze rispetto alla segmentazione semantica#

La segmentazione delle istanze è una segmentazione a livello di oggetto: due automobili producono due maschere, due riquadri e due punteggi di confidenza. La segmentazione semantica è una classificazione a livello di pixel: le stesse automobili diventano pixel con lo stesso ID di classe in un'unica mappa delle classi delle dimensioni dell'immagine, senza riquadri, confidenze o un elenco predefinito di poligoni per oggetto.

Esportazione#

Esporta un modello YOLO26n-seg in un formato diverso, come ONNX, CoreML e così via.

Esempio
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-trained model

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

I formati di esportazione YOLO26-seg disponibili sono riportati nella tabella seguente. Puoi esportare in qualsiasi formato usando l'argomento format, ovvero format='onnx' o format='engine'. Puoi eseguire predizioni o convalide direttamente sui modelli esportati, ovvero yolo predict model=yolo26n-seg.onnx. Al termine dell'esportazione vengono mostrati esempi di utilizzo per il tuo modello.

Nota

CoreML supporta la NMS integrata (nms=True) per il rilevamento, la segmentazione delle istanze e la stima della posa con forme statiche. Le esportazioni di segmentazione predefinite (nms=None) lasciano la NMS al consumatore.

FormatoArgomento formatModelloMetadatiArgomenti
PyTorch-yolo26n-seg.pt-
TorchScripttorchscriptyolo26n-seg.torchscriptimgsz, quantize, dynamic, nms, batch, device
ONNXonnxyolo26n-seg.onnximgsz, quantize, dynamic, simplify, opset, nms, batch, data, fraction, device
OpenVINOopenvinoyolo26n-seg_openvino_model/imgsz, quantize, dynamic, nms, batch, data, fraction, device
TensorRTengineyolo26n-seg.engineimgsz, quantize, dynamic, simplify, opset, workspace, nms, batch, data, fraction, device
CoreMLcoremlyolo26n-seg.mlpackageimgsz, dynamic, quantize, nms, batch, device
TF SavedModelsaved_modelyolo26n-seg_saved_model/imgsz, keras, quantize, opset, nms, batch, data, fraction, device
TF GraphDefpbyolo26n-seg.pbimgsz, opset, batch, device
TF Edge TPUedgetpuyolo26n-seg_edgetpu.tfliteimgsz, quantize, opset, data, fraction, device
PaddlePaddlepaddleyolo26n-seg_paddle_model/imgsz, batch, device
MNNmnnyolo26n-seg.mnnimgsz, batch, dynamic, quantize, simplify, opset, nms, device
NCNNncnnyolo26n-seg_ncnn_model/imgsz, quantize, batch, device
IMX500imxyolo26n-seg_imx_model/imgsz, quantize, data, fraction, nms, device
RKNNrknnyolo26n-seg_rknn_model/imgsz, batch, name, quantize, simplify, opset, data, fraction, device
ExecuTorchexecutorchyolo26n-seg_executorch_model/imgsz, batch, device
Axeleraaxelerayolo26n-seg_axelera_model/imgsz, batch, quantize, data, fraction, device
DEEPXdeepxyolo26n-seg_deepx_model/imgsz, quantize, simplify, opset, data, optimize, device
Qualcomm QNNqnnyolo26n-seg_qnn.onnximgsz, batch, name, quantize, simplify, opset, data, fraction, device
LiteRTlitertyolo26n-seg.tfliteimgsz, quantize, batch, data, fraction, device
Hailohailoyolo26n-seg_hailo_model/imgsz, name, quantize, data, fraction, simplify, conf, iou
Huawei Ascendascendyolo26n-seg_ascend_model/imgsz, batch, name, quantize, opset, simplify, nms
Apple Core AIcoreaiyolo26n-seg.aimodelimgsz, batch, quantize

nms=None utilizza i valori predefiniti per gli output grezzi per la NMS esterna. Imposta nms=False per selezionare una testa senza NMS disponibile; i formati non supportati ricorrono al loro percorso di output nativo. Le voci nms sopra indicano i formati che possono incorporare la NMS con nms=True.

Consulta la pagina Export per tutti i dettagli su export.

FAQ#

  • Per addestrare un modello di segmentazione YOLO26 su un dataset personalizzato, devi prima preparare il tuo dataset nel formato di segmentazione YOLO. Puoi usare l'utilità integrata convert_coco per convertire i dataset JSON COCO. Una volta che il tuo dataset è pronto, puoi addestrare il modello usando Python o i comandi della CLI:

    Esempio
    from ultralytics import YOLO
    
    # Load a pretrained YOLO26 segment model
    model = YOLO("yolo26n-seg.pt")
    
    # Train the model
    results = model.train(data="path/to/your_dataset.yaml", epochs=100, imgsz=640)

    Consulta la pagina Configurazione per altri argomenti disponibili.

  • Il rilevamento degli oggetti identifica e localizza gli oggetti all'interno di un'immagine disegnando riquadri di delimitazione attorno a essi, mentre la segmentazione delle istanze non solo identifica i riquadri di delimitazione, ma delinea anche la forma esatta di ogni oggetto. I modelli di segmentazione delle istanze YOLO26 forniscono maschere o contorni che delineano ogni oggetto rilevato, risultando particolarmente utili per attività in cui è importante conoscere la forma precisa degli oggetti, come l'imaging medico o la guida autonoma.

  • Ultralytics YOLO26 è un modello all'avanguardia riconosciuto per l'elevata accuratezza e le prestazioni in tempo reale, caratteristiche che lo rendono ideale per le attività di segmentazione delle istanze. I modelli YOLO26 Segment sono sottoposti a pretraining sul dataset COCO, garantendo prestazioni solide su un'ampia varietà di oggetti. Inoltre, YOLO supporta le funzionalità di training, convalida, predizione ed esportazione con un'integrazione fluida, risultando altamente versatile sia per la ricerca sia per le applicazioni industriali.

  • Caricare e convalidare un modello YOLO di segmentazione sottoposto a pretraining è semplice. Ecco come puoi farlo usando sia Python sia la CLI:

    Esempio
    from ultralytics import YOLO
    
    # Load a pretrained model
    model = YOLO("yolo26n-seg.pt")
    
    # Validate the model
    metrics = model.val()
    print("Mean Average Precision for boxes:", metrics.box.map)
    print("Mean Average Precision for masks:", metrics.seg.map)

    Questi passaggi ti forniranno metriche di convalida come la precisione media media (mAP), fondamentali per valutare le prestazioni del modello.

  • Esportare un modello YOLO di segmentazione nel formato ONNX è semplice e può essere fatto usando Python o i comandi CLI:

    Esempio
    from ultralytics import YOLO
    
    # Load a pretrained model
    model = YOLO("yolo26n-seg.pt")
    
    # Export the model to ONNX format
    model.export(format="onnx")

    Per maggiori dettagli sull'esportazione in vari formati, consulta la pagina Export.

Commenti