Segmentazione delle istanze con Ultralytics YOLO#
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.
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.
| Modello | dimensione (pixel) | mAPbox 50-95(e2e) | mAPmask 50-95(e2e) | Velocità CPU ONNX (ms) | Velocità T4 TensorRT10 (ms) | parametri (M) | FLOPs (B) |
|---|---|---|---|---|---|---|---|
| YOLO26n-seg | 640 | 39.6 | 33.9 | 53.3 ± 0.5 | 2.1 ± 0.0 | 2.7 | 9.3 |
| YOLO26s-seg | 640 | 47.3 | 40.0 | 118.4 ± 0.9 | 3.3 ± 0.0 | 10.4 | 34.5 |
| YOLO26m-seg | 640 | 52.5 | 44.1 | 328.2 ± 2.4 | 6.7 ± 0.1 | 23.6 | 121.7 |
| YOLO26l-seg | 640 | 54.4 | 45.5 | 387.0 ± 3.7 | 8.0 ± 0.1 | 28.0 | 140.1 |
| YOLO26x-seg | 640 | 56.5 | 47.0 | 787.0 ± 6.8 | 16.4 ± 0.1 | 62.8 | 314.0 |
- I valori di mAPval si riferiscono a un singolo modello e a una singola scala sul dataset COCO val2017.
Riproduci utilizzandoyolo 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 conyolo 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.
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.
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 FNPredizione#
Usa un modello YOLO26n-seg sottoposto a training per eseguire predizioni sulle immagini.
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.uint8Consulta 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.
| Attributo | Tipo | Forma | Descrizione |
|---|---|---|---|
result.masks | Masks | (N) | Maschere delle istanze. |
result.masks.data | torch.uint8 | (N,H,W) | Maschere binarie, con valori 0 o 1. |
result.masks.xy | np.float32 | list[(P,2)] | Poligoni dei pixel. |
result.masks.xyn | np.float32 | list[(P,2)] | Poligoni normalizzati. |
result.boxes | Boxes | (N) | Box/ classi/ confidenze delle istanze. |
result.boxes.cls | torch.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.
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.
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.
| Formato | Argomento format | Modello | Metadati | Argomenti |
|---|---|---|---|---|
| PyTorch | - | yolo26n-seg.pt | ✅ | - |
| TorchScript | torchscript | yolo26n-seg.torchscript | ✅ | imgsz, quantize, dynamic, nms, batch, device |
| ONNX | onnx | yolo26n-seg.onnx | ✅ | imgsz, quantize, dynamic, simplify, opset, nms, batch, data, fraction, device |
| OpenVINO | openvino | yolo26n-seg_openvino_model/ | ✅ | imgsz, quantize, dynamic, nms, batch, data, fraction, device |
| TensorRT | engine | yolo26n-seg.engine | ✅ | imgsz, quantize, dynamic, simplify, opset, workspace, nms, batch, data, fraction, device |
| CoreML | coreml | yolo26n-seg.mlpackage | ✅ | imgsz, dynamic, quantize, nms, batch, device |
| TF SavedModel | saved_model | yolo26n-seg_saved_model/ | ✅ | imgsz, keras, quantize, opset, nms, batch, data, fraction, device |
| TF GraphDef | pb | yolo26n-seg.pb | ❌ | imgsz, opset, batch, device |
| TF Edge TPU | edgetpu | yolo26n-seg_edgetpu.tflite | ✅ | imgsz, quantize, opset, data, fraction, device |
| PaddlePaddle | paddle | yolo26n-seg_paddle_model/ | ✅ | imgsz, batch, device |
| MNN | mnn | yolo26n-seg.mnn | ✅ | imgsz, batch, dynamic, quantize, simplify, opset, nms, device |
| NCNN | ncnn | yolo26n-seg_ncnn_model/ | ✅ | imgsz, quantize, batch, device |
| IMX500 | imx | yolo26n-seg_imx_model/ | ✅ | imgsz, quantize, data, fraction, nms, device |
| RKNN | rknn | yolo26n-seg_rknn_model/ | ✅ | imgsz, batch, name, quantize, simplify, opset, data, fraction, device |
| ExecuTorch | executorch | yolo26n-seg_executorch_model/ | ✅ | imgsz, batch, device |
| Axelera | axelera | yolo26n-seg_axelera_model/ | ✅ | imgsz, batch, quantize, data, fraction, device |
| DEEPX | deepx | yolo26n-seg_deepx_model/ | ✅ | imgsz, quantize, simplify, opset, data, optimize, device |
| Qualcomm QNN | qnn | yolo26n-seg_qnn.onnx | ✅ | imgsz, batch, name, quantize, simplify, opset, data, fraction, device |
| LiteRT | litert | yolo26n-seg.tflite | ✅ | imgsz, quantize, batch, data, fraction, device |
| Hailo | hailo | yolo26n-seg_hailo_model/ | ✅ | imgsz, name, quantize, data, fraction, simplify, conf, iou |
| Huawei Ascend | ascend | yolo26n-seg_ascend_model/ | ✅ | imgsz, batch, name, quantize, opset, simplify, nms |
| Apple Core AI | coreai | yolo26n-seg.aimodel | ✅ | imgsz, 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_cocoper convertire i dataset JSON COCO. Una volta che il tuo dataset è pronto, puoi addestrare il modello usando Python o i comandi della CLI:Esempiofrom 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:
Esempiofrom 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:
Esempiofrom 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.