YOLO Vision 2026:

Segmentazione semantica#

Semantic segmentation examples

Semantic segmentation assegna un'etichetta di classe a ogni pixel in un'immagine, producendo una mappa di classe densa che copre l'intera scena. A differenza della instance segmentation, che separa i singoli oggetti, la semantic segmentation raggruppa tutti i pixel della stessa classe indipendentemente da quanti oggetti distinti siano presenti.



Watch: Semantic Segmentation with Ultralytics YOLO26 | Quickstart Tutorial

L'output di un modello di segmentazione semantica è una singola mappa di classe altezza-per-larghezza in cui ogni valore di pixel corrisponde a un ID di classe previsto. Questo rende la segmentazione semantica ideale per attività di analisi della scena come la guida autonoma, l'imaging medico e la mappatura della copertura del suolo.

Suggerimento

Uusa task=semantic o l'attività CLI yolo semantic per la semantic segmentation. I file dei modelli YOLO26 semantic segmentation usano il suffisso -sem, come yolo26n-sem.pt.

Modelli#

I modelli YOLO26 semantic segmentation preaddestrati sul dataset Cityscapes sono mostrati di seguito.

I Modelli vengono scaricati automaticamente dall'ultimo rilascio di Ultralytics al primo utilizzo.

Modellodimensione
(pixel)
mIoUvalVelocità
RTX3090 PyTorch
(ms)
params
(M)
FLOPs
(B)
YOLO26n-sem1024 × 204878.34.4 ± 0.01.622.7
YOLO26s-sem1024 × 204880.88.4 ± 0.06.588.8
YOLO26m-sem1024 × 204882.019.9 ± 0.114.3304.5
YOLO26l-sem1024 × 204882.926.5 ± 0.117.9384.7
YOLO26x-sem1024 × 204883.648.9 ± 0.240.2861.7
  • I valori di mIoUval sono per modello singolo a scala singola sul set di validazione di Cityscapes.
    Riproduci con yolo semantic val data=cityscapes.yaml device=0 imgsz=2048
  • Le metriche di Speed sono mediate sulle immagini di validazione di Cityscapes usando un'istanza RTX3090.
    Riproduci con yolo semantic val data=cityscapes.yaml batch=1 device=0|cpu imgsz=2048
  • I valori di Params e FLOPs sono per il modello fuso dopo model.fuse(), che unisce i layer Conv e BatchNorm. I checkpoint preaddestrati mantengono l'intera architettura di training e potrebbero mostrare conteggi più alti.

I modelli YOLO26 semantic segmentation preaddestrati sul dataset ADE20K sono mostrati di seguito.

I Modelli vengono scaricati automaticamente dall'ultimo rilascio di Ultralytics al primo utilizzo.

Modellodimensione
(pixel)
mIoUvalVelocità
RTX3090 PyTorch
(ms)
params
(M)
FLOPs
(B)
YOLO26n-sem-ade20k64038.83.9 ± 0.21.64.4
YOLO26s-sem-ade20k64045.64.2 ± 0.36.517.4
YOLO26m-sem-ade20k64047.44.7 ± 0.314.359.5
YOLO26l-sem-ade20k64049.78.3 ± 0.217.975.0
YOLO26x-sem-ade20k64051.59.9 ± 0.340.2168.1
  • I valori di mIoUval sono per modello singolo a scala singola sul set di validazione di ADE20K.
    Riproduci con yolo semantic val model=yolo26n-sem-ade20k.pt data=ade20k.yaml device=0 imgsz=640, sostituendo yolo26n-sem-ade20k.pt con il checkpoint yolo26*-sem-ade20k.pt desiderato.
  • Le metriche di Speed sono mediate sulle immagini di validazione di ADE20K usando un'istanza RTX3090.
    Riproduci con yolo semantic val model=yolo26n-sem-ade20k.pt data=ade20k.yaml batch=1 device=0|cpu imgsz=640, sostituendo yolo26n-sem-ade20k.pt con il checkpoint yolo26*-sem-ade20k.pt desiderato.
  • I valori di Params e FLOPs sono per il modello fuso dopo model.fuse(), che unisce i layer Conv e BatchNorm. I checkpoint preaddestrati mantengono l'intera architettura di training e potrebbero mostrare conteggi più alti.

Addestramento#

Addestra YOLO26n-sem sul dataset Cityscapes8 per 100 epochs a una dimensione immagine di 1024. Per un elenco completo degli argomenti disponibili vedi la pagina Configuration.

Esempio
from ultralytics import YOLO

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

# Train the model
results = model.train(data="cityscapes8.yaml", epochs=100, imgsz=1024)

Vedi i dettagli completi della modalità train nella pagina Train. I modelli di semantic segmentation possono anche essere addestrati con il cloud training di Ultralytics Platform.

Formato del dataset#

I dataset di semantic segmentation usano immagini di maschere a canale singolo, tipicamente PNG, in cui ogni valore di pixel rappresenta un ID di classe. I pixel con valore 255 sono trattati come "ignore" ed esclusi dal calcolo della loss. Lo YAML del dataset dovrebbe specificare i percorsi alle immagini e alle relative directory di maschere. Vedi la Guida al dataset di Semantic Segmentation per i dettagli sul formato. I dataset supportati includono Cityscapes e ADE20K. Puoi gestire ed etichettare i dataset semantici con l'annotazione di Ultralytics Platform.

Valutazione#

Valida l'accuracy del modello YOLO26n-sem addestrato su un dataset di semantic segmentation. Passa esplicitamente data in modo che la validazione usi lo YAML del dataset inteso.

Esempio
from ultralytics import YOLO

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

# Validate the model
metrics = model.val(data="cityscapes.yaml")
metrics.miou  # mean Intersection over Union
metrics.pixel_accuracy  # overall pixel accuracy

Previsione#

Usa un modello YOLO26n-sem addestrato per eseguire predizioni sulle immagini.

Esempio
from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n-sem.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:
    semantic_mask = result.semantic_mask.data  # class map, shape (H,W), integer dtype selected by class count

Visualizza i dettagli completi della modalità predict nella pagina Predict.

Output dei risultati#

YOLO semantic segmentation restituisce un oggetto Results per immagine. Ogni risultato memorizza una mappa di classe densa per l'intera immagine anziché un elenco di maschere di oggetti. I pixel con la stessa classe prevista condividono lo stesso ID di classe, anche quando appartengono a oggetti separati.

AttributoTipoFormaDescrizione
result.semantic_maskSemanticMask(H,W)Mappa delle classi densa.
result.semantic_mask.datatorch.uint8
torch.int16
torch.int32
(H,W)ID di classe; dtype selezionato in base al conteggio delle classi.
result.masks--Nessuna maschera di istanza.
result.boxes--Nessun box/confidenza di istanza.
result.masks.xy--Nessun poligono predefinito.

Per i campi specifici dell'attività Results relativi a ogni attività, consulta la sezione Risultati di predizione per attività.

Qualità dei contorni della maschera

La semantic segmentation predice una mappa di classe densa, quindi ridimensiona quella mappa alla forma dell'immagine per la visualizzazione e l'uso successivo. Strutture molto sottili, come la segnaletica stradale, le linee dei campi, i pali o i cavi, possono quindi apparire a gradini quando l'inferenza viene eseguita a un imgsz molto inferiore rispetto alla risoluzione originale dell'immagine. Se i bordi appaiono sdentati, testa prima il modello PyTorch nativo .pt con un imgsz più grande, come 1024, 1280 o il valore pratico più vicino alla dimensione dell'immagine sorgente. Usa i modelli esportati solo dopo aver confermato che l'output di .pt è accettabile, poiché gli input a risoluzione inferiore non possono recuperare dettagli fini che non erano presenti nella mappa di classe prevista.

Segmentazione di istanze vs semantica#

AspettoInstance Segmentation (task="segment")Semantic Segmentation (task="semantic")
Obiettivo della predizioneSegmenta ogni oggetto rilevato separatamenteAssegna un ID di classe a ogni pixel
Campo di outputresult.masksresult.semantic_mask
Dati principaliresult.masks.dataresult.semantic_mask.data
Forma(N,H,W)(H,W)
Valori dei pixelValori della maschera binaria: 0 o 1ID di classe: 0, 1, 2, ...
Dtypetorch.uint8torch.uint8
torch.int16
torch.int32
Oggetti della stessa classeMantenuti come istanze separateUniti nella stessa regione di classe
PoligoniSì, tramite result.masks.xy e result.masks.xynNessun output di poligoni per impostazione predefinita
Box e confidenzaSì, tramite result.boxesNessun box o punteggio di confidenza per istanza
Uso tipicoConteggio, tracciamento, ritaglio, misurazione a livello di oggettoEtichettatura densa della scena, area transitabile, copertura del suolo, regioni mediche

Esportazione#

Esporta un modello YOLO26n-sem in un formato diverso come ONNX, CoreML, ecc.

Esempio
from ultralytics import YOLO

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

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

I formati di esportazione disponibili per YOLO26 semantic segmentation sono nella tabella sottostante. Puoi esportare in qualsiasi formato usando l'argomento format, ad es. format='onnx' o format='engine'. Puoi effettuare previsioni o validare direttamente su modelli esportati, ad es. yolo predict model=yolo26n-sem.onnx. Gli esempi d'uso vengono mostrati per il tuo modello al termine dell'esportazione.

FormatoArgomento formatModelloMetadatiArgomenti
PyTorch-yolo26n-sem.pt-
TorchScripttorchscriptyolo26n-sem.torchscriptimgsz, quantize, dynamic, nms, batch, device
ONNXonnxyolo26n-sem.onnximgsz, quantize, dynamic, simplify, opset, nms, batch, data, fraction, device
OpenVINOopenvinoyolo26n-sem_openvino_model/imgsz, quantize, dynamic, nms, batch, data, fraction, device
TensorRTengineyolo26n-sem.engineimgsz, quantize, dynamic, simplify, opset, workspace, nms, batch, data, fraction, device
CoreMLcoremlyolo26n-sem.mlpackageimgsz, dynamic, quantize, nms, batch, device
TF SavedModelsaved_modelyolo26n-sem_saved_model/imgsz, keras, quantize, opset, nms, batch, data, fraction, device
TF GraphDefpbyolo26n-sem.pbimgsz, opset, batch, device
TF Edge TPUedgetpuyolo26n-sem_edgetpu.tfliteimgsz, quantize, opset, data, fraction, device
PaddlePaddlepaddleyolo26n-sem_paddle_model/imgsz, batch, device
MNNmnnyolo26n-sem.mnnimgsz, batch, dynamic, quantize, simplify, opset, nms, device
NCNNncnnyolo26n-sem_ncnn_model/imgsz, quantize, batch, device
IMX500imxyolo26n-sem_imx_model/imgsz, quantize, data, fraction, nms, device
RKNNrknnyolo26n-sem_rknn_model/imgsz, batch, name, quantize, simplify, opset, data, fraction, device
ExecuTorchexecutorchyolo26n-sem_executorch_model/imgsz, batch, device
Axeleraaxelerayolo26n-sem_axelera_model/imgsz, batch, quantize, data, fraction, device
DEEPXdeepxyolo26n-sem_deepx_model/imgsz, quantize, simplify, opset, data, optimize, device
Qualcomm QNNqnnyolo26n-sem_qnn.onnximgsz, batch, name, quantize, simplify, opset, data, fraction, device
LiteRTlitertyolo26n-sem.tfliteimgsz, quantize, batch, data, fraction, device
Hailohailoyolo26n-sem_hailo_model/imgsz, name, quantize, data, fraction, simplify, conf, iou
Huawei Ascendascendyolo26n-sem_ascend_model/imgsz, batch, name, quantize, opset, simplify, nms
Apple Core AIcoreaiyolo26n-sem.aimodelimgsz, batch, quantize

Visualizza i dettagli completi di export nella pagina Export.

FAQ#

  • Per addestrare un modello di segmentazione semantica YOLO26 su un dataset personalizzato, devi preparare immagini con maschera PNG in cui ogni valore di pixel rappresenta un ID di classe (0, 1, 2, ...) e i pixel con valore 255 vengono ignorati durante l'addestramento. Crea un file YAML del dataset che punta alle directory delle immagini e delle maschere, quindi addestra il modello:

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

    Controlla la pagina Configurazione per ulteriori argomenti disponibili.

  • La segmentazione di istanze e la segmentazione semantica sono entrambe attività a livello di pixel ma differiscono in un aspetto chiave:

    • Semantic segmentation assegna un'etichetta di classe a ogni pixel ma non distingue tra singoli oggetti della stessa classe. Ad esempio, tutte le auto in una scena condividono la stessa etichetta di classe.
    • Instance segmentation identifica ogni singolo oggetto separatamente, producendo maschere distinte per ciascun oggetto anche se appartengono alla stessa classe.

    La segmentazione semantica è più adatta per attività di comprensione della scena come la guida autonoma e la mappatura della copertura del suolo, mentre la segmentazione di istanze è preferibile quando conta il conteggio o il tracciamento dei singoli oggetti.

  • Sì. Se il tuo dataset usa etichette poligonali Ultralytics YOLO (un .txt per immagine), ometti masks_dir dallo YAML del dataset e assicurati che non esista alcuna cartella masks/ accanto alle tue immagini nella root del dataset (la sua sola presenza attiva la modalità maschera PNG anche senza che masks_dir sia impostato). Il loader converte quindi i poligoni in maschere semantiche per immagine al volo. Per i dataset multi-classe (N > 1) viene aggiunta automaticamente un'ulteriore classe background a names. Per i dataset a classe singola (N == 1) il training rimane a 1 classe: la tua classe dichiarata diventa 1 nella maschera e i pixel non coperti diventano 0. Vedi la Guida al dataset di Semantic Segmentation per i dettagli.

  • Ultralytics YOLO26 fornisce configurazioni integrate per diversi dataset di segmentazione semantica:

    • Cityscapes: Scene stradali urbane con 19 classi, ampiamente utilizzate per la ricerca sulla guida autonoma.
    • ADE20K: Un dataset di parsing di scene su larga scala con 150 classi.

    Puoi anche utilizzare qualsiasi dataset personalizzato che fornisca annotazioni di maschera PNG dove i valori dei pixel corrispondono agli ID di classe.

  • Valida un modello di segmentazione semantica YOLO26 preaddestrato con il YAML del dataset utilizzato per la valutazione:

    Esempio
    from ultralytics import YOLO
    
    # Load a pretrained model
    model = YOLO("yolo26n-sem.pt")
    
    # Validate the model
    metrics = model.val(data="cityscapes.yaml")
    print("Mean IoU:", metrics.miou)
    print("Pixel Accuracy:", metrics.pixel_accuracy)

    Questi passaggi ti forniranno metriche di validazione come la media dell'intersezione sull'unione (mIoU) e l'accuratezza dei pixel, che sono misure standard per valutare le prestazioni della segmentazione semantica.

  • Esporta un modello di segmentazione semantica YOLO26 in formato ONNX con comandi Python o CLI:

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

    Per ulteriori dettagli sull'esportazione in vari formati, fai riferimento alla pagina Export.

Commenti