Semantische Segmentierung mit Ultralytics YOLO#
Semantische Segmentierung weist jedem Pixel in einem Bild ein Klassenlabel zu und erzeugt eine dichte Klassenkarte, die die gesamte Szene abdeckt. Im Gegensatz zur Instanzsegmentierung, die einzelne Objekte voneinander trennt, fasst die semantische Segmentierung alle Pixel derselben Klasse zusammen, unabhängig davon, wie viele einzelne Objekte vorhanden sind.
Watch: Semantic Segmentation with Ultralytics YOLO26 | Quickstart Tutorial
Die Ausgabe eines Modells für semantische Segmentierung ist eine einzelne Klassenkarte mit der Höhe und Breite des Bildes, wobei jeder Pixelwert einer vorhergesagten Klassen-ID entspricht. Dadurch eignet sich die semantische Segmentierung ideal für Aufgaben zur Szenenanalyse wie autonomes Fahren, medizinische Bildgebung und Landbedeckungskartierung.
Verwende die Aufgabe task=semantic oder yolo semantic CLI für die semantische Segmentierung. Modelldateien für die semantische Segmentierung mit YOLO26 verwenden das Suffix -sem, zum Beispiel yolo26n-sem.pt.
Modelle#
Modelle für die semantische Segmentierung mit YOLO26, die auf dem Datensatz Cityscapes 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 | 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 |
- Die Werte für mIoUval gelten für ein einzelnes Modell mit einer einzigen Bildskala auf dem Validierungssatz von Cityscapes.
Reproduziere sie mityolo semantic val data=cityscapes.yaml device=0 imgsz=2048 - Die Geschwindigkeitsmetriken werden über die Validierungsbilder von Cityscapes mit einer RTX3090-Instanz gemittelt.
Reproduziere sie mityolo semantic val data=cityscapes.yaml batch=1 device=0|cpu imgsz=2048 - Die Werte für Params und FLOPs gelten für das fusionierte Modell nach
model.fuse(), das Conv- und BatchNorm-Schichten zusammenführt. Vortrainierte Checkpoints enthalten weiterhin die vollständige Trainingsarchitektur und können daher höhere Werte aufweisen.
Modelle für die semantische Segmentierung mit YOLO26, die auf dem Datensatz ADE20K 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.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 |
- Die Werte für mIoUval gelten für ein einzelnes Modell mit einer einzigen Bildskala auf dem Validierungssatz von ADE20K.
Reproduziere sie mityolo semantic val model=yolo26n-sem-ade20k.pt data=ade20k.yaml device=0 imgsz=640, indem duyolo26n-sem-ade20k.ptdurch den gewünschtenyolo26*-sem-ade20k.pt-Checkpoint ersetzt. - Die Geschwindigkeitsmetriken werden über die Validierungsbilder von ADE20K mit einer RTX3090-Instanz gemittelt.
Reproduziere sie mityolo semantic val model=yolo26n-sem-ade20k.pt data=ade20k.yaml batch=1 device=0|cpu imgsz=640, indem duyolo26n-sem-ade20k.ptdurch den gewünschtenyolo26*-sem-ade20k.pt-Checkpoint ersetzt. - Die Werte für Params und FLOPs gelten für das fusionierte Modell nach
model.fuse(), das Conv- und BatchNorm-Schichten zusammenführt. Vortrainierte Checkpoints enthalten weiterhin die vollständige Trainingsarchitektur und können daher höhere Werte aufweisen.
Siehe die unreleased YOLO27 preview für vorläufige Cityscapes-mIoU-Ergebnisse.
Trainieren#
Trainiere YOLO26n-sem 100 Epochen lang auf dem Datensatz Cityscapes8 mit einer Bildgröße von 1024. Eine vollständige Liste der verfügbaren Argumente findest du auf der Seite Konfiguration.
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)Ausführliche Informationen zum Modus train findest du auf der Seite Trainieren. Modelle für die semantische Segmentierung können auch mit dem Cloud-Training der Ultralytics Platform trainiert werden.
Datensatzformat#
Datensätze für die semantische Segmentierung verwenden einkanalige Maskenbilder, typischerweise im PNG-Format, wobei jeder Pixelwert eine Klassen-ID darstellt. Pixel mit dem Wert 255 werden als „ignore“ behandelt und von der Verlustberechnung ausgeschlossen. Die YAML-Datei des Datensatzes sollte Pfade zu den Bildern und den zugehörigen Maskenverzeichnissen enthalten. Einzelheiten zum Format findest du im Leitfaden zu Datensätzen für die semantische Segmentierung. Zu den unterstützten Datensätzen gehören Cityscapes und ADE20K. Mit der Annotation in der Ultralytics Platform kannst du semantische Datensätze verwalten und labeln.
Validierung#
Validiere die Genauigkeit eines trainierten YOLO26n-sem-Modells auf einem Datensatz für die semantische Segmentierung. Übergib data ausdrücklich, damit die Validierung die vorgesehene YAML-Datei des Datensatzes 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 accuracyVorhersage#
Verwende ein trainiertes YOLO26n-sem-Modell, um Vorhersagen für Bilder 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 countAusführliche Informationen zum Modus predict findest du auf der Seite Predict.
Ausgabe der Ergebnisse#
Die semantische Segmentierung mit YOLO liefert ein Results-Objekt pro Bild. Jedes Ergebnis enthält eine dichte Klassenkarte für das gesamte
Bild anstelle einer Liste von Objektmasken. Pixel mit derselben vorhergesagten Klasse haben dieselbe Klassen-ID, auch wenn sie zu getrennten 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 Datentyp wird anhand der Anzahl der Klassen ausgewählt. |
result.masks | - | - | Keine Instanzmasken. |
result.boxes | - | - | Keine Instanzboxen oder Konfidenzwerte. |
result.masks.xy | - | - | Keine Polygone standardmäßig. |
Task-spezifische Felder Results für alle Tasks findest du im Abschnitt Vorhersageergebnisse nach Task.
Die semantische Segmentierung sagt eine dichte Klassenkarte voraus und skaliert diese Karte anschließend für die Visualisierung und die weitere Verwendung auf die Bildgröße zurück. Sehr dünne Strukturen wie Fahrbahnmarkierungen, Spielfeldlinien, Masten oder Drähte können daher treppenförmig aussehen, wenn die Inferenz mit einer deutlich geringeren imgsz als der Auflösung des Originalbildes ausgeführt wird. Wenn Grenzen gezackt erscheinen, teste zunächst das native PyTorch-Modell .pt mit einer größeren imgsz, beispielsweise 1024, 1280 oder dem nächstgelegenen praktikablen Wert zur Bildgröße des Ausgangsbildes. Verwende exportierte Modelle erst, nachdem du bestätigt hast, dass die Ausgabe von .pt akzeptabel ist, da Eingaben mit niedrigerer Auflösung feine Details nicht wiederherstellen können, die in der vorhergesagten Klassenkarte nicht vorhanden waren.
Instanz- und semantische Segmentierung#
| Aspekt | Instanzsegmentierung (task="segment") | Semantische Segmentierung (task="semantic") |
|---|---|---|
| Ziel der Vorhersage | 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ärmaskenwerte: 0 oder 1 | Klassen-IDs: 0, 1, 2, ... |
| Datentyp | torch.uint8 | torch.uint8torch.int16torch.int32 |
| Objekte derselben Klasse | Als separate Instanzen beibehalten | Zur selben Klassenregion zusammengeführt |
| Polygone | Ja, über result.masks.xy und result.masks.xyn | Standardmäßig keine Polygon-Ausgabe |
| Bounding-Boxen und Konfidenz | Ja, über result.boxes | Keine Bounding-Boxen oder Konfidenzwerte pro Instanz |
| Typische Verwendung | Zählen, Verfolgen, Zuschneiden, Messungen auf Objektebene | Dichte Szenenbeschriftung, befahrbare Bereiche, Landbedeckung, medizinische Regionen |
Export#
Exportiere ein YOLO26n-sem-Modell in ein anderes Format wie ONNX, CoreML usw.
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")Die verfügbaren Exportformate für die semantische Segmentierung mit YOLO26 sind in der folgenden Tabelle aufgeführt. Du kannst mit dem Argument format in jedes Format exportieren, also beispielsweise mit format='onnx' oder format='engine'. Du kannst direkt Vorhersagen auf exportierten Modellen ausführen oder diese validieren, beispielsweise mit yolo predict model=yolo26n-sem.onnx. Nach Abschluss des Exports werden für dein Modell Verwendungsbeispiele angezeigt.
| Format | Argument format | 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 |
nms=None verwendet standardmäßig Rohausgaben für externes NMS. Setze nms=False, um einen verfügbaren NMS-freien Kopf auszuwählen; nicht unterstützte Formate greifen auf ihren nativen Ausgabepfad zurück. Die Einträge nms oben identifizieren Formate, die NMS mit nms=True einbetten können.
Ausführliche Informationen zu export findest du auf der Seite Export.
FAQ#
Um ein YOLO26-Modell für die semantische Segmentierung auf einem benutzerdefinierten Datensatz zu trainieren, musst du PNG-Maskenbilder vorbereiten, wobei jeder Pixelwert eine Klassen-ID (0, 1, 2, ...) darstellt und Pixel mit dem Wert 255 während des Trainings ignoriert werden. Erstelle eine YAML-Datei des Datensatzes, die auf die Verzeichnisse mit deinen Bildern und Masken verweist, und trainiere anschließend 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)Weitere verfügbare Argumente findest du auf der Seite Konfiguration.
Instanzsegmentierung und semantische Segmentierung sind beides Aufgaben auf Pixelebene, unterscheiden sich jedoch in einem wesentlichen Punkt:
- Semantische Segmentierung weist jedem Pixel ein Klassenlabel zu, unterscheidet jedoch nicht zwischen einzelnen Objekten derselben Klasse. Beispielsweise haben alle Autos in einer Szene dasselbe Klassenlabel.
- Instanzsegmentierung erkennt jedes einzelne Objekt separat und erzeugt für jedes Objekt eine eigene Maske, auch wenn die Objekte derselben Klasse angehören.
Die semantische Segmentierung eignet sich am besten für Aufgaben zum Szenenverständnis wie autonomes Fahren und Landbedeckungskartierung, während die Instanzsegmentierung bevorzugt wird, wenn das Zählen oder Verfolgen einzelner Objekte wichtig ist.
Ja. Wenn dein Datensatz Polygon-Labels im Ultralytics-YOLO-Format verwendet (ein
.txtpro Bild), lassemasks_dirin der YAML-Datei des Datensatzes weg und stelle sicher, dass im Stammverzeichnis des Datensatzes neben deinen Bildern kein Ordnermasks/vorhanden ist (sein bloßes Vorhandensein aktiviert den PNG-Maskenmodus, auch wennmasks_dirnicht gesetzt ist). Der Loader wandelt die Polygone dann während der Ausführung in semantische Masken pro Bild um. Bei Datensätzen mit mehreren Klassen (N > 1) wird automatisch eine zusätzliche Klassebackgroundannamesangehängt. Bei Datensätzen mit einer Klasse (N == 1) bleibt das Training bei 1 Klasse – deine deklarierte Klasse wird zu1in der Maske und nicht abgedeckte Pixel werden zu0. Einzelheiten findest du im Leitfaden zu Datensätzen für die semantische Segmentierung.Ultralytics YOLO26 bietet integrierte Konfigurationen für mehrere Datensätze zur semantischen 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 Datensatz zur Szenenanalyse mit 150 Klassen.
Du kannst auch jeden benutzerdefinierten Datensatz verwenden, der PNG-Maskenannotationen bereitstellt, bei denen die Pixelwerte den Klassen-IDs entsprechen.
Validiere ein vortrainiertes YOLO26-Modell für die semantische Segmentierung mit der für die Auswertung verwendeten YAML-Datei des Datensatzes:
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 die mittlere Schnittmenge über der Vereinigung (mIoU) und die Pixelgenauigkeit. Dabei handelt es sich um Standardmaße zur Bewertung der Leistung semantischer Segmentierungsmodelle.
Exportiere ein YOLO26-Modell für die 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 Informationen zum Export in verschiedene Formate findest du auf der Seite Export.