Semantische Segmentierung#
Semantic segmentation weist jedem Pixel in einem Bild ein Klassenlabel zu und erzeugt so eine dichte Klassenkarte, die die gesamte Szene abdeckt. Im Gegensatz zur instance segmentation, die einzelne Objekte trennt, fasst die semantische Segmentierung alle Pixel derselben Klasse zusammen, unabhängig davon, wie viele verschiedene Objekte vorhanden sind.
Watch: Semantic Segmentation with Ultralytics YOLO26 | Quickstart Tutorial
Die Ausgabe eines semantischen Segmentierungsmodells ist eine einzelne Klassenkarte mit der Größe Höhe mal Breite, bei der jeder Pixelwert einer vorhergesagten Klassen-ID entspricht. Dies macht die semantische Segmentierung ideal für Szenenanalyse-Aufgaben wie autonomes Fahren, medizinische Bildgebung und Landbedeckungskartierung.
Verwende task=semantic oder die CLI-Aufgabe yolo semantic für die semantische Segmentierung. YOLO26-Modelldateien für die semantische Segmentierung verwenden das Suffix -sem, wie zum Beispiel yolo26n-sem.pt.
Models#
YOLO26-Modelle zur semantischen Segmentierung, die auf dem Cityscapes-Datensatz vortrainiert wurden, sind unten aufgeführt.
Modelle werden bei der ersten Verwendung automatisch aus dem neuesten Ultralytics-Release heruntergeladen.
| Modell | Größe (Pixel) | mIoUval | Geschwindigkeit RTX3090 PyTorch (ms) | Parameter (M) | FLOPs (B) |
|---|---|---|---|---|---|
| YOLO26n-sem | 1024 × 2048 | 78.3 | 4.4 ± 0.0 | 1.6 | 22.7 |
| YOLO26s-sem | 1024 × 2048 | 80.8 | 8.4 ± 0.0 | 6.5 | 88.8 |
| YOLO26m-sem | 1024 × 2048 | 82.0 | 19.9 ± 0.1 | 14.3 | 304.5 |
| YOLO26l-sem | 1024 × 2048 | 82.9 | 26.5 ± 0.1 | 17.9 | 384.7 |
| YOLO26x-sem | 1024 × 2048 | 83.6 | 48.9 ± 0.2 | 40.2 | 861.7 |
- mIoUval-Werte gelten für Einzelmodelle im Einzelmaßstab auf dem Validierungssatz von Cityscapes.
Reproduzieren mityolo semantic val data=cityscapes.yaml device=0 imgsz=2048 - Speed-Metriken werden über Cityscapes-Validierungsbilder hinweg unter Verwendung einer RTX3090-Instanz gemittelt.
Reproduzieren mityolo semantic val data=cityscapes.yaml batch=1 device=0|cpu imgsz=2048 - Params- und FLOPs-Werte gelten für das fusionierte Modell nach
model.fuse(), welches Conv- und BatchNorm-Schichten zusammenführt. Vortrainierte Checkpoints behalten die vollständige Trainingsarchitektur bei und können höhere Anzahlen aufweisen.
YOLO26-Modelle zur semantischen Segmentierung, die auf dem ADE20K-Datensatz vortrainiert wurden, sind unten aufgeführt.
Modelle werden bei der ersten Verwendung automatisch aus dem neuesten Ultralytics-Release heruntergeladen.
| Modell | Größe (Pixel) | mIoUval | Geschwindigkeit RTX3090 PyTorch (ms) | Parameter (M) | FLOPs (B) |
|---|---|---|---|---|---|
| YOLO26n-sem-ade20k | 640 | 38.8 | 3.9 ± 0.2 | 1.6 | 4.4 |
| YOLO26s-sem-ade20k | 640 | 45.6 | 4.2 ± 0.3 | 6.5 | 17.4 |
| YOLO26m-sem-ade20k | 640 | 47.4 | 4.7 ± 0.3 | 14.3 | 59.5 |
| YOLO26l-sem-ade20k | 640 | 49.7 | 8.3 ± 0.2 | 17.9 | 75.0 |
| YOLO26x-sem-ade20k | 640 | 51.5 | 9.9 ± 0.3 | 40.2 | 168.1 |
- mIoUval-Werte gelten für Einzelmodelle im Einzelmaßstab auf dem Validierungssatz von ADE20K.
Reproduzieren mityolo semantic val model=yolo26n-sem-ade20k.pt data=ade20k.yaml device=0 imgsz=640, indemyolo26n-sem-ade20k.ptdurch den gewünschtenyolo26*-sem-ade20k.pt-Checkpoint ersetzt wird. - Speed-Metriken werden über ADE20K-Validierungsbilder hinweg unter Verwendung einer RTX3090-Instanz gemittelt.
Reproduzieren mityolo semantic val model=yolo26n-sem-ade20k.pt data=ade20k.yaml batch=1 device=0|cpu imgsz=640, indemyolo26n-sem-ade20k.ptdurch den gewünschtenyolo26*-sem-ade20k.pt-Checkpoint ersetzt wird. - Params- und FLOPs-Werte gelten für das fusionierte Modell nach
model.fuse(), welches Conv- und BatchNorm-Schichten zusammenführt. Vortrainierte Checkpoints behalten die vollständige Trainingsarchitektur bei und können höhere Anzahlen aufweisen.
Trainieren#
Trainiere YOLO26n-sem auf dem Cityscapes8-Datensatz für 100 epochs bei einer Bildgröße von 1024. Eine vollständige Liste der verfügbaren Argumente findest du auf der Configuration-Seite.
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)Siehe vollständige Details zum train-Modus auf der Train-Seite. Modelle zur semantischen Segmentierung können auch mit dem Ultralytics Platform cloud training trainiert werden.
Datensatzformat#
Datensätze zur semantischen Segmentierung verwenden einkanalige Maskenbilder (typischerweise PNG), bei denen jeder Pixelwert eine Klassen-ID darstellt. Pixel mit dem Wert 255 werden als „ignorieren“ behandelt und von der Verlustberechnung ausgeschlossen. Das Datensatz-YAML sollte Pfade zu Bildern und deren entsprechenden Maskenverzeichnissen angeben. Siehe den Semantic Segmentation Dataset Guide für Formatdetails. Unterstützte Datensätze umfassen Cityscapes und ADE20K. Du kannst semantische Datensätze mit der Ultralytics Platform annotation verwalten und beschriften.
Validieren#
Validiere die accuracy des trainierten YOLO26n-sem-Modells anhand eines Datensatzes zur semantischen Segmentierung. Übergebe data explizit, damit die Validierung das beabsichtigte Datensatz-YAML verwendet.
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 accuracyVorhersagen#
Verwende ein trainiertes YOLO26n-sem-Modell, um Vorhersagen auf Bildern auszuführen.
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 countWeitere Details zum predict-Modus findest du auf der Predict-Seite.
Ergebnisausgabe#
Die YOLO-semantische Segmentierung gibt ein Results-Objekt pro Bild zurück. Jedes Ergebnis speichert eine dichte Klassenkarte für das gesamte Bild anstelle einer Liste von Objektmasken. Pixel mit derselben vorhergesagten Klasse teilen sich dieselbe Klassen-ID, selbst wenn sie zu verschiedenen Objekten gehören.
| Attribut | Typ | Form | Beschreibung |
|---|---|---|---|
result.semantic_mask | SemanticMask | (H,W) | Dichte Klassenkarte. |
result.semantic_mask.data | torch.uint8torch.int16torch.int32 | (H,W) | Klassen-IDs; der dtype wird nach Klassenanzahl ausgewählt. |
result.masks | - | - | Keine Instanzmasken. |
result.boxes | - | - | Keine Instanzboxen/Konfidenzen. |
result.masks.xy | - | - | Keine Standard-Polygone. |
Aufgabenspezifische Results-Felder für alle Aufgaben findest du im Abschnitt Predict Results by Task.
Die semantische Segmentierung sagt eine dichte Klassenkarte voraus und skaliert diese Karte dann für die Visualisierung und nachgeschaltete Verwendung auf die Bildform zurück. Sehr dünne Strukturen wie Fahrbahnmarkierungen, Spiellinien, Masten oder Drähte können daher treppenartig wirken, wenn die Inferenz bei einer viel niedrigeren imgsz als der ursprünglichen Bildauflösung ausgeführt wird. Wenn Ränder ausgefranst erscheinen, teste zuerst das native PyTorch .pt-Modell mit einem größeren imgsz wie 1024, 1280 oder dem nächstgelegenen praktischen Wert für die Quellbildgröße. Verwende exportierte Modelle erst, nachdem du bestätigt hast, dass die Ausgabe von .pt akzeptabel ist, da Niedrigauflösungseingaben feine Details, die in der vorhergesagten Klassenkarte nicht vorhanden waren, nicht wiederherstellen können.
Instanz- vs. semantische Segmentierung#
| Aspekt | Instanzsegmentierung (task="segment") | Semantische Segmentierung (task="semantic") |
|---|---|---|
| Vorhersageziel | Jedes erkannte Objekt separat segmentieren | Jedem Pixel eine Klassen-ID zuweisen |
| Ausgabefeld | result.masks | result.semantic_mask |
| Hauptdaten | result.masks.data | result.semantic_mask.data |
| Form | (N,H,W) | (H,W) |
| Pixelwerte | Binäre Maskenwerte: 0 oder 1 | Klassen-IDs: 0, 1, 2, ... |
| Dtype | torch.uint8 | torch.uint8torch.int16torch.int32 |
| Objekte derselben Klasse | Werden als separate Instanzen beibehalten | Werden in derselben Klassenregion zusammengeführt |
| Polygone | Ja, durch result.masks.xy und result.masks.xyn | Standardmäßig keine Polygon-Ausgabe |
| Boxen und Konfidenz | Ja, durch result.boxes | Keine instanzbasierten Boxen oder Konfidenz-Scores |
| Typische Verwendung | Zählen, Tracking, Zuschneiden, objektbasierte Messung | Dichte Szenenkennzeichnung, befahrbare Fläche, Landbedeckung, medizinische Regionen |
Exportieren#
Exportiere ein YOLO26n-sem-Modell in ein anderes Format wie ONNX, CoreML, etc.
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")Verfügbare Exportformate für die semantische Segmentierung von YOLO26 sind in der folgenden Tabelle aufgeführt. Du kannst in jedes Format exportieren, indem du das Argument format verwendest, d. h. format='onnx' oder format='engine'. Du kannst direkt mit exportierten Modellen vorhersagen oder validieren, d. h. yolo predict model=yolo26n-sem.onnx. Nutzungsbeispiele werden für dein Modell angezeigt, nachdem der Export abgeschlossen ist.
| Format | format-Argument | Modell | Metadaten | Argumente |
|---|---|---|---|---|
| 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 |
| TF SavedModel | saved_model | yolo26n-sem_saved_model/ | ✅ | imgsz, keras, 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 |
| 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 |
| LiteRT | litert | yolo26n-sem.tflite | ✅ | imgsz, quantize, batch, data, fraction, device |
| Hailo | hailo | yolo26n-sem_hailo_model/ | ✅ | imgsz, name, quantize, data, fraction, simplify, conf, iou |
| Huawei Ascend | ascend | yolo26n-sem_ascend_model/ | ✅ | imgsz, batch, name, quantize, opset, simplify, nms |
| Apple Core AI | coreai | yolo26n-sem.aimodel | ✅ | imgsz, batch, quantize |
Weitere Details zum export-Modus findest du auf der Export-Seite.
FAQ#
Um ein YOLO26-Modell für semantische Segmentierung auf einem benutzerdefinierten Dataset zu trainieren, musst du PNG-Maskenbilder vorbereiten, bei denen jeder Pixelwert eine Klassen-ID (0, 1, 2, ...) darstellt und Pixel mit dem Wert 255 während des Trainings ignoriert werden. Erstelle eine Dataset-YAML-Datei, die auf deine Bild- und Maskenverzeichnisse verweist, und trainiere dann das Modell:
Beispielfrom 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)Besuche die Konfigurationsseite, um weitere verfügbare Argumente zu finden.
Instanzsegmentierung und semantische Segmentierung sind beides pixelbasierte Aufgaben, unterscheiden sich aber in einem entscheidenden Punkt:
- Semantic segmentation weist jedem Pixel ein Klassenlabel zu, unterscheidet jedoch nicht zwischen einzelnen Objekten derselben Klasse. Beispielsweise teilen sich alle Autos in einer Szene dasselbe Klassenlabel.
- Instance segmentation identifiziert jedes einzelne Objekt separat und erzeugt für jedes Objekt unterschiedliche Masken, selbst wenn sie zur selben Klasse gehören.
Semantische Segmentierung eignet sich am besten für Aufgaben des Szenenverständnisses wie autonomes Fahren und Landbedeckungskartierung, während Instanzsegmentierung bevorzugt wird, wenn das Zählen oder Verfolgen einzelner Objekte wichtig ist.
Ja. Wenn dein Datensatz Ultralytics YOLO-Polygon-Labels verwendet (ein
.txtpro Bild), lassemasks_dirim Datensatz-YAML weg und stelle sicher, dass sich keinmasks/-Ordner neben deinen Bildern im Datensatz-Stammverzeichnis befindet (bereits seine Anwesenheit löst den PNG-Maskenmodus aus, selbst ohne gesetztesmasks_dir). Der Loader konvertiert Polygone dann im laufenden Betrieb in pro-Bild-semantische Masken. Für Datensätze mit mehreren Klassen (N > 1) wird automatisch eine zusätzlichebackground-Klasse annamesangehängt. Für einkanalige Datensätze (N == 1) bleibt das Training bei 1 Klasse – deine deklarierte Klasse wird zu1in der Maske und nicht abgedeckte Pixel werden zu0. Siehe den Semantic Segmentation Dataset Guide für Details.Ultralytics YOLO26 bietet integrierte Konfigurationen für mehrere Datasets für semantische Segmentierung:
- Cityscapes: Städtische Straßenszenen mit 19 Klassen, die häufig für die Forschung zum autonomen Fahren verwendet werden.
- ADE20K: Ein groß angelegter Szenenanalyse-Datensatz mit 150 Klassen.
Du kannst auch jedes benutzerdefinierte Dataset verwenden, das PNG-Maskenannotationen bereitstellt, bei denen Pixelwerte den Klassen-IDs entsprechen.
Validiere ein vortrainiertes YOLO26-Modell für semantische Segmentierung mit dem Dataset-YAML, das für die Evaluierung verwendet wurde:
Beispielfrom 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)Diese Schritte liefern dir Validierungsmetriken wie den Mean Intersection over Union (mIoU) und die Pixelgenauigkeit, welche Standardmaße zur Bewertung der Leistung der semantischen Segmentierung sind.
Exportiere ein YOLO26-Modell für semantische Segmentierung mit Python- oder CLI-Befehlen in das ONNX-Format:
Beispielfrom ultralytics import YOLO # Load a pretrained model model = YOLO("yolo26n-sem.pt") # Export the model to ONNX format model.export(format="onnx")Weitere Details zum Export in verschiedene Formate findest du auf der Export-Seite.