Segmentazione semantica con Ultralytics YOLO#
La segmentazione semantica assegna un'etichetta di classe a ogni pixel di un'immagine, producendo una mappa di classi densa che copre l'intera scena. A differenza della segmentazione delle istanze, che separa i singoli oggetti, la segmentazione semantica raggruppa tutti i pixel della stessa classe, indipendentemente dal numero di oggetti distinti presenti.
Guarda: Segmentazione semantica con Ultralytics YOLO26 | Tutorial rapido
L'output di un modello di segmentazione semantica è un'unica mappa di classi con altezza e larghezza pari a quelle dell'immagine, in cui ogni valore di pixel corrisponde a un ID di classe previsto. Per questo la segmentazione semantica è ideale per attività di analisi delle scene come la guida autonoma, l'imaging medico e la mappatura della copertura del suolo.
Usa task=semantic o l'attività CLI yolo semantic per la segmentazione semantica. I file dei modelli di segmentazione semantica YOLO26 usano il suffisso -sem, ad esempio yolo26n-sem.pt.
Modelli#
Di seguito sono mostrati i modelli YOLO26 Semantic preaddestrati sul dataset Cityscapes.
I modelli vengono scaricati automaticamente dalla più recente release di Ultralytics al primo utilizzo.
| Modello | dimensione (pixel) | mIoUval | Velocità RTX3090 PyTorch (ms) | parametri (M) | FLOPs (B) |
|---|---|---|---|---|---|
| YOLO26n-sem | 1024 × 2048 | 78.3 | 4.4 ± 0.0 | 1.6 | 23.8 |
| YOLO26s-sem | 1024 × 2048 | 80.8 | 8.4 ± 0.0 | 6.5 | 91.0 |
| YOLO26m-sem | 1024 × 2048 | 82.0 | 19.9 ± 0.1 | 14.3 | 305.5 |
| YOLO26l-sem | 1024 × 2048 | 82.9 | 26.5 ± 0.1 | 17.8 | 388.2 |
| YOLO26x-sem | 1024 × 2048 | 83.6 | 48.9 ± 0.2 | 40.1 | 866.9 |
- I valori mIoUval si riferiscono a un singolo modello e a una singola scala sul set di convalida Cityscapes.
Riproduci i risultati conyolo semantic val data=cityscapes.yaml device=0 imgsz=2048 - Le metriche di velocità sono medie calcolate sulle immagini di convalida Cityscapes usando un'istanza RTX3090.
Riproduci i risultati conyolo semantic val data=cityscapes.yaml batch=1 device=0|cpu imgsz=2048 - I valori di Params e FLOPs si riferiscono al modello fuso dopo
model.fuse(), che unisce i layer Conv e BatchNorm. I checkpoint preaddestrati mantengono l'architettura di addestramento completa e possono riportare valori più alti.
Di seguito sono mostrati i modelli YOLO26 Semantic preaddestrati sul dataset ADE20K.
| Modello | dimensione (pixel) | mIoUval | Velocità RTX3090 PyTorch (ms) | parametri (M) | FLOPs (B) |
|---|---|---|---|---|---|
| YOLO26n-sem-ade20k | 640 | 38.8 | 3.9 ± 0.2 | 1.6 | 4.5 |
| YOLO26s-sem-ade20k | 640 | 45.6 | 4.2 ± 0.3 | 6.5 | 17.5 |
| YOLO26m-sem-ade20k | 640 | 47.4 | 4.7 ± 0.3 | 14.4 | 59.6 |
| YOLO26l-sem-ade20k | 640 | 49.7 | 8.3 ± 0.2 | 17.9 | 75.2 |
| YOLO26x-sem-ade20k | 640 | 51.5 | 9.9 ± 0.3 | 40.2 | 168.4 |
- I valori mIoUval si riferiscono a un singolo modello e a una singola scala sul set di convalida ADE20K.
Riproduci i risultati conyolo semantic val model=yolo26n-sem-ade20k.pt data=ade20k.yaml device=0 imgsz=640, sostituendoyolo26n-sem-ade20k.ptcon il checkpointyolo26*-sem-ade20k.ptdesiderato. - Le metriche di velocità sono medie calcolate sulle immagini di convalida ADE20K usando un'istanza RTX3090.
Riproduci i risultati conyolo semantic val model=yolo26n-sem-ade20k.pt data=ade20k.yaml batch=1 device=0|cpu imgsz=640, sostituendoyolo26n-sem-ade20k.ptcon il checkpointyolo26*-sem-ade20k.ptdesiderato. - I valori di Params e FLOPs si riferiscono al modello fuso dopo
model.fuse(), che unisce i layer Conv e BatchNorm. I checkpoint preaddestrati mantengono l'architettura di addestramento completa e possono riportare valori più alti.
Consulta l'anteprima non ancora rilasciata di YOLO27 per i risultati preliminari di mIoU su Cityscapes.
Addestra#
Addestra YOLO26n-sem sul dataset Cityscapes8 per 100 epoche con una dimensione delle immagini di 1024. Per l'elenco completo degli argomenti disponibili, consulta la pagina Configurazione.
from ultralytics import YOLO
# Carica un modello
model = YOLO("yolo26n-sem.yaml") # crea un nuovo modello dal file YAML
model = YOLO("yolo26n-sem.pt") # carica un modello preaddestrato (consigliato per l'addestramento)
model = YOLO("yolo26n-sem.yaml").load("yolo26n-sem.pt") # crea dal file YAML e trasferisci i pesi
# Addestra il modello
results = model.train(data="cityscapes8.yaml", epochs=100, imgsz=1024)Consulta la pagina Addestramento per tutti i dettagli sulla modalità train. Puoi addestrare i modelli di segmentazione semantica anche con l'addestramento cloud di Ultralytics Platform.
Formato del dataset#
I dataset di segmentazione semantica usano immagini di maschere a canale singolo, generalmente in formato PNG, in cui ogni valore di pixel rappresenta un ID di classe. I pixel con valore 255 vengono considerati "da ignorare" ed esclusi dal calcolo della loss. Il file YAML del dataset deve specificare i percorsi delle immagini e delle rispettive directory delle maschere. I dataset con etichette poligonali YOLO possono essere usati direttamente per l'addestramento; vengono convertiti in maschere al volo (vedi sotto Posso usare dati di segmentazione delle istanze). Per i dettagli sul formato, consulta la Guida ai dataset di segmentazione semantica. Tra i dataset supportati figurano Cityscapes e ADE20K. Puoi gestire ed etichettare i dataset semantici con l'annotazione di Ultralytics Platform.
Convalida#
Convalida l'accuratezza del modello YOLO26n-sem addestrato su un dataset di segmentazione semantica. Passa esplicitamente data affinché la convalida usi il file YAML del dataset desiderato.
from ultralytics import YOLO
# Carica un modello
model = YOLO("yolo26n-sem.pt") # carica un modello ufficiale
model = YOLO("path/to/best.pt") # carica un modello personalizzato
# Convalida il modello
metrics = model.val(data="cityscapes.yaml")
metrics.miou # media dell'intersezione sull'unione
metrics.pixel_accuracy # accuratezza complessiva dei pixelPredici#
Usa un modello YOLO26n-sem addestrato per eseguire predizioni sulle immagini.
from ultralytics import YOLO
# Carica un modello
model = YOLO("yolo26n-sem.pt") # carica un modello ufficiale
model = YOLO("path/to/best.pt") # carica un modello personalizzato
# Esegui previsioni con il modello
results = model("https://ultralytics.com/images/bus.jpg") # esegui una previsione su un’immagine
# Accedi ai risultati
for result in results:
semantic_mask = result.semantic_mask.data # mappa delle classi, forma (H,W), tipo intero selezionato in base al numero di classiConsulta la pagina Previsione per i dettagli completi sulla modalità predict.
Output dei risultati#
La segmentazione semantica YOLO restituisce un oggetto Results per immagine. Ogni risultato memorizza un'unica mappa di classi densa per l'intera immagine, anziché un elenco di maschere degli oggetti. I pixel con la stessa classe prevista condividono lo stesso ID di classe, anche se appartengono a oggetti distinti.
| Attributo | Tipo | Forma | Descrizione |
|---|---|---|---|
result.semantic_mask | SemanticMask | (H,W) | Mappa densa delle classi. |
result.semantic_mask.data | torch.uint8torch.int16torch.int32 | (H,W) | ID delle classi; il tipo di dato viene scelto in base al numero di classi. |
result.masks | - | - | Nessuna maschera di istanza. |
result.boxes | - | - | Nessun riquadro/valore di confidenza di istanza. |
Per consultare i campi Results specifici di ogni attività, visita la sezione Risultati delle previsioni per attività.
La segmentazione semantica prevede una mappa di classi densa, poi ridimensiona la mappa alla forma dell'immagine per la visualizzazione e l'uso a valle. Di conseguenza, le strutture molto sottili, come le linee di delimitazione delle corsie, le linee dei campi, i pali o i cavi, possono apparire a gradini se l'inferenza viene eseguita con un imgsz molto inferiore alla risoluzione originale dell'immagine. Se i contorni appaiono frastagliati, prova prima il modello PyTorch nativo .pt con un imgsz maggiore, come 1024, 1280 o il valore pratico più vicino alle dimensioni dell'immagine sorgente. Usa i modelli esportati solo dopo aver verificato che l'output .pt sia accettabile, perché gli input a risoluzione inferiore non possono recuperare i dettagli fini assenti dalla mappa di classi prevista.
Segmentazione delle istanze e segmentazione semantica#
| Aspetto | Segmentazione delle istanze (task="segment") | Segmentazione semantica (task="semantic") |
|---|---|---|
| Obiettivo della predizione | Segmentare separatamente ogni oggetto rilevato | Assegnare un ID di classe a ogni pixel |
| Campo dell'output | result.masks | result.semantic_mask |
| Dati principali | result.masks.data | result.semantic_mask.data |
| Forma | (N,H,W) | (H,W) |
| Valori dei pixel | Valori delle maschere binarie: 0 o 1 | ID di classe: 0, 1, 2, ... |
| Tipo di dato | torch.uint8 | torch.uint8torch.int16torch.int32 |
| Oggetti della stessa classe | Mantenuti come istanze separate | Uniti nella stessa regione di classe |
| Poligoni | Sì, tramite result.masks.xy e result.masks.xyn | Nessun output poligonale per impostazione predefinita |
| BBox e confidenza | Sì, tramite result.boxes | Nessuna BBox o punteggio di confidenza per singola istanza |
| Uso tipico | Conteggio, tracciamento, ritaglio e misurazione a livello di oggetto | Etichettatura densa delle scene, aree percorribili, copertura del suolo e regioni mediche |
Esporta#
Esporta un modello YOLO26n-sem in un altro formato, ad esempio ONNX, CoreML e così via.
from ultralytics import YOLO
# Carica un modello
model = YOLO("yolo26n-sem.pt") # carica un modello ufficiale
model = YOLO("path/to/best.pt") # carica un modello personalizzato
# Esporta il modello
model.export(format="onnx")I formati di esportazione disponibili per la segmentazione semantica YOLO26 sono elencati nella tabella seguente. Puoi esportare in qualsiasi formato usando l'argomento format, ad esempio format='onnx' o format='engine'. Puoi eseguire predizioni o convalidare direttamente i modelli esportati, ad esempio yolo predict model=yolo26n-sem.onnx. Al termine dell'esportazione, vengono mostrati esempi d'uso per il tuo modello.
| Formato | Argomento format | Modello | Metadati | Argomenti |
|---|---|---|---|---|
| PyTorch | - | yolo26n-sem.pt | ✅ | - |
| TorchScript | torchscript | yolo26n-sem.torchscript | ✅ | imgsz, quantize, dynamic, nms, batch, device |
| ONNX | onnx | yolo26n-sem.onnx | ✅ | imgsz, quantize, dynamic, simplify, opset, nms, batch, data, fraction, device |
| OpenVINO | openvino | yolo26n-sem_openvino_model/ | ✅ | imgsz, quantize, dynamic, nms, batch, data, fraction, device |
| TensorRT | engine | yolo26n-sem.engine | ✅ | imgsz, quantize, dynamic, simplify, opset, workspace, nms, batch, data, fraction, device |
| CoreML | coreml | yolo26n-sem.mlpackage | ✅ | imgsz, dynamic, quantize, nms, batch, device |
| Apple Core AI | coreai | yolo26n-sem.aimodel | ✅ | imgsz, batch, quantize |
| TF SavedModel | saved_model | yolo26n-sem_saved_model/ | ✅ | imgsz, quantize, opset, nms, batch, data, fraction, device |
| TF GraphDef | pb | yolo26n-sem.pb | ❌ | imgsz, opset, batch, device |
| TF Edge TPU | edgetpu | yolo26n-sem_edgetpu.tflite | ✅ | imgsz, quantize, opset, data, fraction, device |
| LiteRT | litert | yolo26n-sem.tflite | ✅ | imgsz, quantize, batch, data, fraction, device |
| PaddlePaddle | paddle | yolo26n-sem_paddle_model/ | ✅ | imgsz, batch, device |
| MNN | mnn | yolo26n-sem.mnn | ✅ | imgsz, batch, dynamic, quantize, simplify, opset, nms, device |
| NCNN | ncnn | yolo26n-sem_ncnn_model/ | ✅ | imgsz, quantize, batch, device |
| IMX500 | imx | yolo26n-sem_imx_model/ | ✅ | imgsz, quantize, data, fraction, nms, device |
| RKNN | rknn | yolo26n-sem_rknn_model/ | ✅ | imgsz, batch, name, quantize, simplify, opset, data, fraction, device |
| ExecuTorch | executorch | yolo26n-sem_executorch_model/ | ✅ | imgsz, batch, device |
| Axelera | axelera | yolo26n-sem_axelera_model/ | ✅ | imgsz, batch, quantize, data, fraction, device |
| DEEPX | deepx | yolo26n-sem_deepx_model/ | ✅ | imgsz, quantize, simplify, opset, data, optimize, device |
| Qualcomm QNN | qnn | yolo26n-sem_qnn.onnx | ✅ | imgsz, batch, name, quantize, simplify, opset, data, fraction, device |
| Hailo | hailo | yolo26n-sem_hailo_model/ | ✅ | imgsz, name, quantize, data, fraction, simplify, conf, iou, device |
| Huawei Ascend | ascend | yolo26n-sem_ascend_model/ | ✅ | imgsz, batch, name, quantize, opset, simplify, nms, device |
| AMD Xilinx | xilinx | yolo26n-sem_xilinx_model/ | ✅ | imgsz, name, quantize, data, fraction, opset, simplify, device |
nms=None restituisce per impostazione predefinita output grezzi per NMS esterno. Imposta nms=False per selezionare una head disponibile senza NMS; i formati non supportati utilizzano il proprio percorso di output nativo. Le voci nms qui sopra identificano i formati che possono integrare NMS con nms=True.
Consulta i dettagli completi di export nella pagina Esportazione.
Domande frequenti#
Per addestrare un modello di segmentazione semantica YOLO26 su un dataset personalizzato, devi preparare immagini di maschere PNG in cui il valore di ogni 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 punti alle directory delle immagini e delle maschere, quindi addestra il modello:
Esempiofrom ultralytics import YOLO # Carica un modello YOLO26 di segmentazione semantica preaddestrato model = YOLO("yolo26n-sem.pt") # Addestra il modello results = model.train(data="path/to/your_dataset.yaml", epochs=100, imgsz=1024)Consulta la pagina Configurazione per altri argomenti disponibili.
La segmentazione di istanze e la segmentazione semantica sono entrambe attività a livello di pixel, ma differiscono per un aspetto fondamentale:
- La segmentazione semantica assegna un'etichetta di classe a ogni pixel, ma non distingue i singoli oggetti appartenenti alla stessa classe. Ad esempio, in una scena tutte le auto condividono la stessa etichetta di classe.
- La segmentazione di istanze identifica separatamente ogni singolo oggetto, producendo maschere distinte per ciascun oggetto anche quando appartengono alla stessa classe.
La segmentazione semantica è particolarmente adatta ad attività di comprensione della scena, come la guida autonoma e la mappatura della copertura del suolo, mentre la segmentazione di istanze è preferibile quando è importante contare o tracciare i singoli oggetti.
Sì. Se il tuo dataset usa etichette poligonali Ultralytics YOLO (una
.txtper immagine), omettimasks_dirdal file YAML del dataset e assicurati che nella directory principale del dataset, accanto alle immagini, non esista alcuna cartellamasks/(la sua sola presenza attiva la modalità con maschere PNG anche senzamasks_dirimpostato). Il caricatore converte quindi al volo i poligoni in maschere semantiche per ogni immagine. Per i dataset multiclasse (N > 1), viene aggiunta automaticamente una classebackgroundaggiuntiva anames. Per i dataset a classe singola (N == 1), l'addestramento rimane a 1 classe: la classe dichiarata diventa1nella maschera e i pixel non coperti diventano0. Consulta la guida ai dataset per la segmentazione semantica per maggiori dettagli.Ultralytics YOLO26 include configurazioni integrate per diversi dataset di segmentazione semantica:
- Cityscapes: scene stradali urbane con 19 classi, ampiamente utilizzate nella ricerca sulla guida autonoma.
- ADE20K: un dataset di parsing delle scene su larga scala con 150 classi.
Puoi usare anche qualsiasi dataset personalizzato che fornisca annotazioni con maschere PNG, in cui i valori dei pixel corrispondono agli ID delle classi.
Convalida un modello YOLO26 di segmentazione semantica preaddestrato usando il file YAML del dataset per la valutazione:
Esempiofrom ultralytics import YOLO # Carica un modello preaddestrato model = YOLO("yolo26n-sem.pt") # Convalida il modello metrics = model.val(data="cityscapes.yaml") print("Mean IoU:", metrics.miou) print("Pixel Accuracy:", metrics.pixel_accuracy)Questi passaggi ti forniranno metriche di convalida come l'intersezione media sull'unione (mIoU) e l'accuratezza dei pixel, misure standard per valutare le prestazioni della segmentazione semantica.
Esporta un modello YOLO26 di segmentazione semantica in formato ONNX usando Python o i comandi CLI:
Esempiofrom ultralytics import YOLO # Carica un modello preaddestrato model = YOLO("yolo26n-sem.pt") # Esporta il modello in formato ONNX model.export(format="onnx")Per maggiori dettagli sull'esportazione in vari formati, consulta la pagina Esportazione.