Ultralytics YOLO27:
Get Started

Semantische Segmentierung mit Ultralytics YOLO#

Semantic segmentation examples

Die semantische Segmentierung weist jedem Pixel in einem Bild eine Klassenbezeichnung zu und erzeugt so eine dichte Klassenkarte, die die gesamte Szene abdeckt. Anders als bei der Instanzsegmentierung, bei der einzelne Objekte voneinander getrennt werden, fasst die semantische Segmentierung alle Pixel derselben Klasse zusammen, unabhängig davon, wie viele einzelne Objekte vorhanden sind.



Ansehen: Semantische Segmentierung mit Ultralytics YOLO26 | Schnellstart-Tutorial

Die Ausgabe eines Modells für semantische Segmentierung ist eine einzelne Klassenkarte mit Höhe und Breite des Bildes, bei der jeder Pixelwert einer vorhergesagten Klassen-ID entspricht. Dadurch eignet sich die semantische Segmentierung ideal für die Szenenanalyse, etwa beim autonomen Fahren, in der medizinischen Bildgebung und bei der Kartierung der Landbedeckung.

Tipp

Verwende task=semantic oder die CLI-Aufgabe yolo semantic für die semantische Segmentierung. Die Dateien von YOLO26-Modellen für semantische Segmentierung verwenden das Suffix -sem, zum Beispiel yolo26n-sem.pt.

Modelle#

Unten sind semantische YOLO26-Modelle aufgeführt, die auf dem Cityscapes-Datensatz vortrainiert wurden.

Modelle werden bei der ersten Verwendung automatisch aus der neuesten Ultralytics-Version heruntergeladen.

ModellGröße
(Pixel)
mIoUvalGeschwindigkeit
RTX3090 PyTorch
(ms)
Parameter
(M)
FLOPs
(B)
YOLO26n-sem1024 × 204878.34.4 ± 0.01.623.8
YOLO26s-sem1024 × 204880.88.4 ± 0.06.591.0
YOLO26m-sem1024 × 204882.019.9 ± 0.114.3305.5
YOLO26l-sem1024 × 204882.926.5 ± 0.117.8388.2
YOLO26x-sem1024 × 204883.648.9 ± 0.240.1866.9
  • Die mIoUval-Werte gelten für ein einzelnes Modell mit einer einzelnen Skalierung auf dem Validierungssatz von Cityscapes.
    Reproduziere die Ergebnisse mit yolo semantic val data=cityscapes.yaml device=0 imgsz=2048
  • Die Geschwindigkeitsmetriken sind Mittelwerte über die Validierungsbilder von Cityscapes und wurden mit einer RTX3090-Instanz ermittelt.
    Reproduziere die Ergebnisse mit yolo semantic val data=cityscapes.yaml batch=1 device=0|cpu imgsz=2048
  • Die Werte für Parameter und FLOPs gelten für das fusionierte Modell nach model.fuse(), wodurch Conv- und BatchNorm-Schichten zusammengeführt werden. Vortrainierte Checkpoints behalten die vollständige Trainingsarchitektur bei und können daher höhere Werte aufweisen.

Unten sind semantische YOLO26-Modelle aufgeführt, die auf dem ADE20K-Datensatz vortrainiert wurden.

ModellGröße
(Pixel)
mIoUvalGeschwindigkeit
RTX3090 PyTorch
(ms)
Parameter
(M)
FLOPs
(B)
YOLO26n-sem-ade20k64038.83.9 ± 0.21.64.5
YOLO26s-sem-ade20k64045.64.2 ± 0.36.517.5
YOLO26m-sem-ade20k64047.44.7 ± 0.314.459.6
YOLO26l-sem-ade20k64049.78.3 ± 0.217.975.2
YOLO26x-sem-ade20k64051.59.9 ± 0.340.2168.4
  • Die mIoUval-Werte gelten für ein einzelnes Modell mit einer einzelnen Skalierung auf dem Validierungssatz von ADE20K.
    Reproduziere die Ergebnisse mit yolo semantic val model=yolo26n-sem-ade20k.pt data=ade20k.yaml device=0 imgsz=640 und ersetze dabei yolo26n-sem-ade20k.pt durch den gewünschten yolo26*-sem-ade20k.pt-Checkpoint.
  • Die Geschwindigkeitsmetriken sind Mittelwerte über die Validierungsbilder von ADE20K und wurden mit einer RTX3090-Instanz ermittelt.
    Reproduziere die Ergebnisse mit yolo semantic val model=yolo26n-sem-ade20k.pt data=ade20k.yaml batch=1 device=0|cpu imgsz=640 und ersetze dabei yolo26n-sem-ade20k.pt durch den gewünschten yolo26*-sem-ade20k.pt-Checkpoint.
  • Die Werte für Parameter und FLOPs gelten für das fusionierte Modell nach model.fuse(), wodurch Conv- und BatchNorm-Schichten zusammengeführt werden. Vortrainierte Checkpoints behalten die vollständige Trainingsarchitektur bei und können daher höhere Werte aufweisen.

Vorläufige mIoU-Ergebnisse für Cityscapes findest du in der unveröffentlichten YOLO27-Vorschau.

Trainieren#

Trainiere YOLO26n-sem 100 Epochen lang mit einer Bildgröße von 1024 auf dem Datensatz Cityscapes8. Eine vollständige Liste der verfügbaren Argumente findest du auf der Seite Konfiguration.

Beispiel
from ultralytics import YOLO

# Ein Modell laden
model = YOLO("yolo26n-sem.yaml")  # ein neues Modell aus YAML erstellen
model = YOLO("yolo26n-sem.pt")  # ein vortrainiertes Modell laden (für das Training empfohlen)
model = YOLO("yolo26n-sem.yaml").load("yolo26n-sem.pt")  # aus YAML erstellen und Gewichte übertragen

# Das Modell trainieren
results = model.train(data="cityscapes8.yaml", epochs=100, imgsz=1024)

Die vollständigen Details zum Modus train findest du auf der Seite Trainieren. Modelle für semantische Segmentierung lassen sich auch mit dem Cloud-Training der Ultralytics Platform trainieren.

Datensatzformat#

Datensätze für semantische Segmentierung verwenden Einkanal-Maskenbilder, typischerweise im PNG-Format, in denen jeder Pixelwert eine Klassen-ID darstellt. Pixel mit dem Wert 255 werden als „ignorieren“ behandelt und bei der Berechnung des Verlusts ausgeschlossen. In der YAML-Datei des Datensatzes sollten die Pfade zu den Bildern und den zugehörigen Maskenverzeichnissen angegeben sein. Datensätze mit YOLO-Polygonbeschriftungen können direkt zum Training verwendet werden; die Umwandlung in Masken erfolgt während der Ausführung (siehe unten Kann ich Daten zur Instanzsegmentierung verwenden). Details zum Format findest du im Leitfaden zu Datensätzen für 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 beschriften.

Validieren#

Validiere die Genauigkeit des trainierten Modells YOLO26n-sem auf einem Datensatz zur semantischen Segmentierung. Gib data ausdrücklich an, damit bei der Validierung die vorgesehene YAML-Datei des Datensatzes verwendet wird.

Beispiel
from ultralytics import YOLO

# Ein Modell laden
model = YOLO("yolo26n-sem.pt")  # Ein offizielles Modell laden
model = YOLO("path/to/best.pt")  # Ein benutzerdefiniertes Modell laden

# Das Modell validieren
metrics = model.val(data="cityscapes.yaml")
metrics.miou  # mittlere Schnittmenge über Vereinigungsmenge
metrics.pixel_accuracy  # Gesamtgenauigkeit auf Pixelebene

Vorhersagen#

Verwende ein trainiertes YOLO26n-sem-Modell, um Vorhersagen für Bilder zu erstellen.

Beispiel
from ultralytics import YOLO

# Ein Modell laden
model = YOLO("yolo26n-sem.pt")  # Ein offizielles Modell laden
model = YOLO("path/to/best.pt")  # Ein benutzerdefiniertes Modell laden

# Mit dem Modell Vorhersagen erstellen
results = model("https://ultralytics.com/images/bus.jpg")  # Eine Vorhersage für ein Bild erstellen

# Auf die Ergebnisse zugreifen
for result in results:
    semantic_mask = result.semantic_mask.data  # Klassenkarte, Form (H,W), ganzzahliger Datentyp entsprechend der Anzahl der Klassen

Ausführliche Informationen zum Modus predict findest du auf der Seite Vorhersagen.

Ausgabe der Ergebnisse#

Die semantische YOLO-Segmentierung gibt für jedes Bild ein Results-Objekt zurück. Jedes Ergebnis enthält eine einzelne dichte Klassenkarte für das gesamte Bild statt einer Liste von Objektmasken. Pixel mit derselben vorhergesagten Klasse haben dieselbe Klassen-ID, selbst wenn sie zu unterschiedlichen Objekten gehören.

AttributTypFormBeschreibung
result.semantic_maskSemanticMask(H,W)Dichte Klassenkarte.
result.semantic_mask.datatorch.uint8
torch.int16
torch.int32
(H,W)Klassen-IDs; der Datentyp wird anhand der Anzahl der Klassen ausgewählt.
result.masks--Keine Instanzmasken.
result.boxes--Keine Instanzboxen/Konfidenzwerte.

Task-spezifische Results-Felder für alle Aufgaben findest du im Abschnitt Vorhersageergebnisse nach Aufgabe.

Qualität der Maskenränder

Bei der semantischen Segmentierung wird eine dichte Klassenkarte vorhergesagt und anschließend für die Darstellung und Weiterverarbeitung wieder auf die Bildgröße gebracht. Sehr dünne Strukturen wie Fahrbahnmarkierungen, Spielfeldlinien, Masten oder Drähte können dadurch stufig wirken, wenn die Inferenz mit einer deutlich geringeren imgsz als der ursprünglichen Bildauflösung ausgeführt wird. Wenn die Ränder gezackt wirken, teste zunächst erneut das native PyTorch-Modell .pt mit einer größeren imgsz, etwa 1024, 1280 oder dem nächstliegenden praktikablen Wert zur Größe des Quellbilds. Verwende exportierte Modelle erst, nachdem du bestätigt hast, dass die Ausgabe .pt akzeptabel ist, da Eingaben mit geringerer Auflösung feine Details, die in der vorhergesagten Klassenkarte nicht enthalten waren, nicht wiederherstellen können.

Instanz- und semantische Segmentierung#

AspektInstanzsegmentierung (task="segment")Semantische Segmentierung (task="semantic")
Ziel der VorhersageJedes erkannte Objekt einzeln segmentierenJedem Pixel eine Klassen-ID zuweisen
Ausgabefeldresult.masksresult.semantic_mask
Hauptdatenresult.masks.dataresult.semantic_mask.data
Form(N,H,W)(H,W)
PixelwerteBinärmaskenwerte: 0 oder 1Klassen-IDs: 0, 1, 2, ...
Datentyptorch.uint8torch.uint8
torch.int16
torch.int32
Objekte derselben KlasseAls getrennte Instanzen beibehaltenZu einem Bereich derselben Klasse zusammengeführt
PolygoneJa, über result.masks.xy und result.masks.xynStandardmäßig keine Polygon-Ausgabe
Boxen und KonfidenzJa, über result.boxesKeine Boxen oder Konfidenzwerte pro Instanz
Typische VerwendungZählen, Verfolgen, Zuschneiden, Messen auf ObjektebeneDichte Szenenbeschriftung, befahrbare Bereiche, Landbedeckung, medizinische Bereiche

Exportieren#

Exportiere ein YOLO26n-sem-Modell in ein anderes Format wie ONNX, CoreML usw.

Beispiel
from ultralytics import YOLO

# Ein Modell laden
model = YOLO("yolo26n-sem.pt")  # Ein offizielles Modell laden
model = YOLO("path/to/best.pt")  # Ein benutzerdefiniertes Modell laden

# Modell exportieren
model.export(format="onnx")

Die verfügbaren Exportformate für die semantische YOLO26-Segmentierung findest du in der Tabelle unten. Mit dem Argument format kannst du in jedes Format exportieren, also etwa format='onnx' oder format='engine'. Du kannst direkt mit exportierten Modellen Vorhersagen erstellen oder sie validieren, also yolo predict model=yolo26n-sem.onnx. Nach Abschluss des Exports werden Anwendungsbeispiele für dein Modell angezeigt.

FormatArgument formatModellMetadatenArgumente
PyTorch-yolo26n-sem.pt✅-
TorchScripttorchscriptyolo26n-sem.torchscript✅imgsz, quantize, dynamic, nms, batch, device
ONNXonnxyolo26n-sem.onnx✅imgsz, quantize, dynamic, simplify, opset, nms, batch, data, fraction, device
OpenVINOopenvinoyolo26n-sem_openvino_model/✅imgsz, quantize, dynamic, nms, batch, data, fraction, device
TensorRTengineyolo26n-sem.engine✅imgsz, quantize, dynamic, simplify, opset, workspace, nms, batch, data, fraction, device
CoreMLcoremlyolo26n-sem.mlpackage✅imgsz, dynamic, quantize, nms, batch, device
Apple Core AIcoreaiyolo26n-sem.aimodel✅imgsz, batch, quantize
TF SavedModelsaved_modelyolo26n-sem_saved_model/✅imgsz, quantize, opset, nms, batch, data, fraction, device
TF GraphDefpbyolo26n-sem.pb❌imgsz, opset, batch, device
TF Edge TPUedgetpuyolo26n-sem_edgetpu.tflite✅imgsz, quantize, opset, data, fraction, device
LiteRTlitertyolo26n-sem.tflite✅imgsz, quantize, batch, data, fraction, device
PaddlePaddlepaddleyolo26n-sem_paddle_model/✅imgsz, batch, device
MNNmnnyolo26n-sem.mnn✅imgsz, 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.onnx✅imgsz, batch, name, quantize, simplify, opset, data, fraction, device
Hailohailoyolo26n-sem_hailo_model/✅imgsz, name, quantize, data, fraction, simplify, conf, iou, device
Huawei Ascendascendyolo26n-sem_ascend_model/✅imgsz, batch, name, quantize, opset, simplify, nms, device
AMD Xilinxxilinxyolo26n-sem_xilinx_model/✅imgsz, name, quantize, data, fraction, opset, simplify, device

nms=None gibt standardmäßig Rohdaten für die externe NMS aus. Lege nms=False fest, um einen verfügbaren Kopf ohne NMS auszuwählen; nicht unterstützte Formate greifen auf ihren nativen Ausgabepfad zurück. Die obigen Einträge nms kennzeichnen Formate, die NMS mit nms=True integrieren können.

Ausführliche Informationen zu export findest du auf der Seite Export.

Häufig gestellte Fragen#

  • Um ein YOLO26-Modell zur semantischen Segmentierung mit einem benutzerdefinierten Datensatz zu trainieren, musst du PNG-Maskenbilder vorbereiten, bei denen jeder Pixelwert eine Klassen-ID (0, 1, 2, ...) darstellt und Pixel mit dem Wert 255 beim Training ignoriert werden. Erstelle eine YAML-Datei für den Datensatz, die auf die Verzeichnisse mit den Bildern und Masken verweist, und trainiere dann das Modell:

    Beispiel
    from ultralytics import YOLO
    
    # Ein vortrainiertes YOLO26-Modell zur semantischen Segmentierung laden
    model = YOLO("yolo26n-sem.pt")
    
    # Das Modell trainieren
    results = model.train(data="path/to/your_dataset.yaml", epochs=100, imgsz=1024)

    Auf der Seite Konfiguration findest du weitere verfügbare Argumente.

  • Instanzsegmentierung und semantische Segmentierung sind beides Aufgaben auf Pixelebene, unterscheiden sich jedoch in einem wichtigen 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, selbst wenn die Objekte derselben Klasse angehören.

    Semantische Segmentierung eignet sich am besten für Aufgaben zum Szenenverständnis, etwa autonomes Fahren und die Kartierung der Landbedeckung. Instanzsegmentierung ist vorzuziehen, wenn einzelne Objekte gezählt oder verfolgt werden müssen.

  • Ja. Wenn dein Datensatz Ultralytics-YOLO-Polygonlabels verwendet (ein .txt pro Bild), lasse masks_dir in der YAML-Datei des Datensatzes weg und stelle sicher, dass sich im Stammverzeichnis des Datensatzes neben deinen Bildern kein Ordner masks/ befindet (allein dessen Vorhandensein aktiviert den PNG-Maskenmodus, auch wenn masks_dir nicht gesetzt ist). Der Loader wandelt Polygone dann während der Ausführung in semantische Masken für jedes Bild um. Bei Datensätzen mit mehreren Klassen (N > 1) wird automatisch eine zusätzliche Klasse background an names angehängt. Bei Datensätzen mit einer Klasse (N == 1) bleibt das Training bei einer Klasse – deine deklarierte Klasse wird in der Maske zu 1, und nicht abgedeckte Pixel werden zu 0. Weitere Informationen findest du im Leitfaden zu Datensätzen für 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 in der Forschung zum autonomen Fahren verwendet werden.
    • ADE20K: Ein umfangreicher Datensatz zur Szeneninterpretation mit 150 Klassen.

    Du kannst auch jeden benutzerdefinierten Datensatz verwenden, der annotierte PNG-Masken bereitstellt, deren Pixelwerte den Klassen-IDs entsprechen.

  • Validiere ein vortrainiertes YOLO26-Modell zur semantischen Segmentierung mit der für die Auswertung verwendeten YAML-Datei des Datensatzes:

    Beispiel
    from ultralytics import YOLO
    
    # Vortrainiertes Modell laden
    model = YOLO("yolo26n-sem.pt")
    
    # Das Modell validieren
    metrics = model.val(data="cityscapes.yaml")
    print("Mean IoU:", metrics.miou)
    print("Pixel Accuracy:", metrics.pixel_accuracy)

    Mit diesen Schritten erhältst du Validierungsmetriken wie die mittlere Schnittmenge über Vereinigung (mIoU) und die Pixelgenauigkeit. Dies sind gängige Maße zur Bewertung der Leistung semantischer Segmentierung.

  • Exportiere ein YOLO26-Modell zur semantischen Segmentierung mit Python- oder CLI-Befehlen ins ONNX-Format:

    Beispiel
    from ultralytics import YOLO
    
    # Vortrainiertes Modell laden
    model = YOLO("yolo26n-sem.pt")
    
    # Exportiere das Modell in das ONNX-Format
    model.export(format="onnx")

    Weitere Informationen zum Export in verschiedene Formate findest du auf der Seite Export.

Kommentare