Übersicht über Instanzsegmentierungs-Datensätze

Instanzsegmentierung ist eine Aufgabe der Computer Vision, bei der einzelne Objekte in einem Bild identifiziert und umrissen werden. Dieser Leitfaden bietet einen Überblick über die von Ultralytics YOLO unterstützten Datensatzformate für Instanzsegmentierungsaufgaben sowie Anleitungen zur Vorbereitung, Konvertierung und Verwendung dieser Datensätze für das Training deiner Modelle.

Unterstützte Datensatzformate

Ultralytics YOLO-Format

Das für das Training von YOLO-Segmentierungsmodellen verwendete Datensatz-Label-Format sieht wie folgt aus:

1. Eine Textdatei pro Bild: Jedes Bild im Datensatz hat eine entsprechende Textdatei mit dem gleichen Namen wie die Bilddatei und der Erweiterung ".txt".
2. Eine Zeile pro Objekt: Jede Zeile in der Textdatei entspricht einer Objektinstanz im Bild.
3. Objektinformationen pro Zeile: Jede Zeile enthält die folgenden Informationen über die Objektinstanz:
   • Objektklassen-Index: Eine Ganzzahl, die die Klasse des Objekts darstellt (z. B. 0 für Person, 1 für Auto, etc.).
   • Objekt-Begrenzungskoordinaten: Die Begrenzungskoordinaten um den Maskenbereich, normalisiert auf einen Wert zwischen 0 und 1.

Das Format für eine einzelne Zeile in der Segmentierungs-Datensatzdatei sieht wie folgt aus:

In diesem Format ist <class-index> der Index der Klasse für das Objekt, und <x1> <y1> <x2> <y2> ... <xn> <yn> sind die normalisierten Polygon-Koordinaten der Segmentierungsmaske des Objekts (Werte liegen im Bereich [0, 1] relativ zur Bildbreite und -höhe). Die Koordinaten werden durch Leerzeichen getrennt.

Hier ist ein Beispiel für das YOLO-Datensatzformat für ein einzelnes Bild mit zwei Objekten, die aus einem 3-Punkt-Segment und einem 5-Punkt-Segment bestehen.

0 0.681 0.485 0.670 0.487 0.676 0.487
1 0.504 0.000 0.501 0.004 0.498 0.004 0.493 0.010 0.492 0.0104

Datensatz YAML-Format

Das Ultralytics-Framework verwendet ein YAML-Dateiformat, um den Datensatz und die Modellkonfiguration für das Training von Segmentierungsmodellen zu definieren. Hier ist ein Beispiel für das YAML-Format, das zur Definition eines Segmentierungsdatensatzes verwendet wird:

# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license

# COCO8-seg dataset (first 8 images from COCO train2017) by Ultralytics
# Documentation: https://docs.ultralytics.com/datasets/segment/coco8-seg/
# Example usage: yolo train data=coco8-seg.yaml
# parent
# ├── ultralytics
# └── datasets
#     └── coco8-seg ← downloads here (1 MB)

# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
path: coco8-seg # dataset root dir
train: images/train # train images (relative to 'path') 4 images
val: images/val # val images (relative to 'path') 4 images
test: # test images (optional)

# Classes
names:
  0: person
  1: bicycle
  2: car
  3: motorcycle
  4: airplane
  5: bus
  6: train
  7: truck
  8: boat
  9: traffic light
  10: fire hydrant
  11: stop sign
  12: parking meter
  13: bench
  14: bird
  15: cat
  16: dog
  17: horse
  18: sheep
  19: cow
  20: elephant
  21: bear
  22: zebra
  23: giraffe
  24: backpack
  25: umbrella
  26: handbag
  27: tie
  28: suitcase
  29: frisbee
  30: skis
  31: snowboard
  32: sports ball
  33: kite
  34: baseball bat
  35: baseball glove
  36: skateboard
  37: surfboard
  38: tennis racket
  39: bottle
  40: wine glass
  41: cup
  42: fork
  43: knife
  44: spoon
  45: bowl
  46: banana
  47: apple
  48: sandwich
  49: orange
  50: broccoli
  51: carrot
  52: hot dog
  53: pizza
  54: donut
  55: cake
  56: chair
  57: couch
  58: potted plant
  59: bed
  60: dining table
  61: toilet
  62: tv
  63: laptop
  64: mouse
  65: remote
  66: keyboard
  67: cell phone
  68: microwave
  69: oven
  70: toaster
  71: sink
  72: refrigerator
  73: book
  74: clock
  75: vase
  76: scissors
  77: teddy bear
  78: hair drier
  79: toothbrush

# Download script/URL (optional)
download: https://github.com/ultralytics/assets/releases/download/v0.0.0/coco8-seg.zip

Die Felder train und val geben die Pfade zu den Verzeichnissen an, die die Trainings- bzw. Validierungsbilder enthalten.

names ist ein Wörterbuch der Klassennamen. Die Reihenfolge der Namen sollte mit der Reihenfolge der Objektklassen-Indizes in den YOLO-Datensatzdateien übereinstimmen.

Verwendung

from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n-seg.pt")  # load a pretrained model (recommended for training)

# Train the model
results = model.train(data="coco8-seg.yaml", epochs=100, imgsz=640)

Unterstützte Datensätze

Ultralytics YOLO unterstützt verschiedene Datensätze für Instanzsegmentierungsaufgaben. Hier ist eine Liste der am häufigsten verwendeten:

• Carparts-seg: Ein spezialisierter Datensatz, der sich auf die Segmentierung von Autoteilen konzentriert und ideal für Automobilanwendungen ist. Er umfasst eine Vielzahl von Fahrzeugen mit detaillierten Annotationen einzelner Fahrzeugkomponenten.
• COCO: Ein umfassender Datensatz für Objekterkennung, Segmentierung und Bildbeschriftung, der über 200.000 beschriftete Bilder in einer Vielzahl von Kategorien enthält.
• COCO8-seg: Ein kompakter Unterdatensatz von COCO mit 8 Bildern, der für schnelle Tests des Segmentierungsmodell-Trainings konzipiert ist und sich ideal für CI-Prüfungen und Workflow-Validierungen im ultralytics-Repository eignet.
• COCO128-seg: Ein kleinerer Datensatz für Instanzsegmentierungsaufgaben, der einen Teilbestand von 128 COCO-Bildern mit Segmentierungsannotationen enthält.
• Crack-seg: Ein Datensatz, der auf die Segmentierung von Rissen in verschiedenen Oberflächen zugeschnitten ist. Er ist für die Instandhaltung von Infrastrukturen und die Qualitätskontrolle unerlässlich und liefert detailliertes Bildmaterial für das Training von Modellen zur Erkennung struktureller Schwachstellen.
• Package-seg: Ein Datensatz zur Segmentierung verschiedener Arten von Verpackungsmaterialien und -formen. Er ist besonders nützlich für die Logistik und Lagerautomatisierung und unterstützt die Entwicklung von Systemen zur Handhabung und Sortierung von Paketen.

Hinzufügen deines eigenen Datensatzes

Wenn du deinen eigenen Datensatz hast und diesen für das Training von Segmentierungsmodellen mit dem Ultralytics YOLO-Format verwenden möchtest, stelle sicher, dass er dem oben unter "Ultralytics YOLO format" angegebenen Format folgt. Konvertiere deine Annotationen in das erforderliche Format und gib die Pfade, die Anzahl der Klassen und die Klassennamen in der YAML-Konfigurationsdatei an. Behalte images/ und labels/ als separate Ordner auf derselben Ebene bei, mit passender Unterordnerstruktur; das Platzieren von .txt-Label-Dateien im Bilderordner kann dazu führen, dass das Modell die Labels nicht erkennt.

Labelformate portieren oder konvertieren

COCO-Datensatzformat in das YOLO-Format

Du kannst Labels aus dem bekannten COCO-Datensatzformat mit dem folgenden Code-Schnipsel einfach in das YOLO-Format konvertieren:

from ultralytics.data.converter import convert_coco

convert_coco(labels_dir="path/to/coco/annotations/", use_segments=True)

Dieses Konvertierungstool kann verwendet werden, um den COCO-Datensatz oder jeden Datensatz im COCO-Format in das Ultralytics YOLO-Format zu konvertieren.

Denk daran, zu überprüfen, ob der Datensatz, den du verwenden möchtest, mit deinem Modell kompatibel ist und den erforderlichen Formatkonventionen folgt. Korrekt formatierte Datensätze sind entscheidend für das Training erfolgreicher Segmentierungsmodelle.

Auto-Annotation

Auto-Annotation ist eine wesentliche Funktion, die es dir ermöglicht, einen Segmentierungsdatensatz mithilfe eines vortrainierten Erkennungsmodells zu erstellen. Damit kannst du schnell und präzise eine große Anzahl von Bildern annotieren, ohne dass eine manuelle Beschriftung erforderlich ist, was Zeit und Mühe spart.

Segmentierungsdatensatz mit einem Erkennungsmodell generieren

Um deinen Datensatz mit dem Ultralytics-Framework automatisch zu annotieren, kannst du die Funktion auto_annotate wie unten gezeigt verwenden:

from ultralytics.data.annotator import auto_annotate

auto_annotate(data="path/to/images", det_model="yolo26x.pt", sam_model="sam_b.pt")

Die Funktion auto_annotate nimmt den Pfad zu deinen Bildern entgegen, zusammen mit optionalen Argumenten zur Angabe der vortrainierten Erkennungsmodelle, d. h. YOLO26, YOLO11 oder anderen Modellen, sowie Segmentierungsmodelle wie SAM, SAM2 oder MobileSAM, dem Gerät, auf dem die Modelle ausgeführt werden sollen, und dem Ausgabeverzeichnis zum Speichern der annotierten Ergebnisse.

Durch die Nutzung der Leistungsfähigkeit vortrainierter Modelle kann die Auto-Annotation den Zeit- und Arbeitsaufwand für die Erstellung hochwertiger Segmentierungsdatensätze erheblich reduzieren. Diese Funktion ist besonders nützlich für Forscher und Entwickler, die mit großen Bildsammlungen arbeiten, da sie sich auf die Modellentwicklung und -evaluierung konzentrieren können, anstatt auf manuelle Annotation.

Datensatz-Annotationen visualisieren

Bevor du dein Modell trainierst, ist es oft hilfreich, deine Datensatz-Annotationen zu visualisieren, um sicherzustellen, dass sie korrekt sind. Ultralytics bietet eine Hilfsfunktion für diesen Zweck:

from ultralytics.data.utils import visualize_image_annotations

label_map = {  # Define the label map with all annotated class labels.
    0: "person",
    1: "car",
}

# Visualize
visualize_image_annotations(
    "path/to/image.jpg",  # Input image path.
    "path/to/annotations.txt",  # Annotation file path for the image.
    label_map,
)

Diese Funktion zeichnet Begrenzungsrahmen, beschriftet Objekte mit Klassennamen und passt die Textfarbe für eine bessere Lesbarkeit an, wodurch du Fehler bei der Annotation vor dem Training erkennen und korrigieren kannst.

Segmentierungsmasken in das YOLO-Format konvertieren

Wenn du Segmentierungsmasken im Binärformat hast, kannst du diese mit folgendem Befehl in das YOLO-Segmentierungsformat konvertieren:

from ultralytics.data.converter import convert_segment_masks_to_yolo_seg

# For datasets like COCO with 80 classes
convert_segment_masks_to_yolo_seg(masks_dir="path/to/masks_dir", output_dir="path/to/output_dir", classes=80)

Dieses Hilfsprogramm konvertiert binäre Maskenbilder in das YOLO-Segmentierungsformat und speichert sie im angegebenen Ausgabeverzeichnis.

FAQ

Welche Datensatzformate unterstützt Ultralytics YOLO für die Instanzsegmentierung?

Ultralytics YOLO unterstützt verschiedene Datensatzformate für die Instanzsegmentierung, wobei das primäre Format das eigene Ultralytics YOLO-Format ist. Jedes Bild in deinem Datensatz benötigt eine entsprechende Textdatei mit Objektinformationen, die in mehrere Zeilen segmentiert sind (eine Zeile pro Objekt) und den Klassenindex sowie normalisierte Begrenzungskoordinaten auflisten. Weitere detaillierte Anleitungen zum YOLO-Datensatzformat findest du in der Übersicht über Instanzsegmentierungs-Datensätze.

Wie kann ich COCO-Datensatz-Annotationen in das YOLO-Format konvertieren?

Die Konvertierung von Annotationen im COCO-Format in das YOLO-Format ist mit Ultralytics-Tools unkompliziert. Du kannst die Funktion convert_coco aus dem Modul ultralytics.data.converter verwenden:

from ultralytics.data.converter import convert_coco

convert_coco(labels_dir="path/to/coco/annotations/", use_segments=True)

Dieses Skript konvertiert deine COCO-Datensatz-Annotationen in das erforderliche YOLO-Format und macht sie so für das Training deiner YOLO-Modelle geeignet. Weitere Details findest du unter Port or Convert Label Formats.

Wie bereite ich eine YAML-Datei für das Training von Ultralytics YOLO-Modellen vor?

Um eine YAML-Datei für das Training von YOLO-Modellen mit Ultralytics vorzubereiten, musst du die Datensatzpfade und Klassennamen definieren. Hier ist eine Beispiel-YAML-Konfiguration:

# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license

# COCO8-seg dataset (first 8 images from COCO train2017) by Ultralytics
# Documentation: https://docs.ultralytics.com/datasets/segment/coco8-seg/
# Example usage: yolo train data=coco8-seg.yaml
# parent
# ├── ultralytics
# └── datasets
#     └── coco8-seg ← downloads here (1 MB)

# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
path: coco8-seg # dataset root dir
train: images/train # train images (relative to 'path') 4 images
val: images/val # val images (relative to 'path') 4 images
test: # test images (optional)

# Classes
names:
  0: person
  1: bicycle
  2: car
  3: motorcycle
  4: airplane
  5: bus
  6: train
  7: truck
  8: boat
  9: traffic light
  10: fire hydrant
  11: stop sign
  12: parking meter
  13: bench
  14: bird
  15: cat
  16: dog
  17: horse
  18: sheep
  19: cow
  20: elephant
  21: bear
  22: zebra
  23: giraffe
  24: backpack
  25: umbrella
  26: handbag
  27: tie
  28: suitcase
  29: frisbee
  30: skis
  31: snowboard
  32: sports ball
  33: kite
  34: baseball bat
  35: baseball glove
  36: skateboard
  37: surfboard
  38: tennis racket
  39: bottle
  40: wine glass
  41: cup
  42: fork
  43: knife
  44: spoon
  45: bowl
  46: banana
  47: apple
  48: sandwich
  49: orange
  50: broccoli
  51: carrot
  52: hot dog
  53: pizza
  54: donut
  55: cake
  56: chair
  57: couch
  58: potted plant
  59: bed
  60: dining table
  61: toilet
  62: tv
  63: laptop
  64: mouse
  65: remote
  66: keyboard
  67: cell phone
  68: microwave
  69: oven
  70: toaster
  71: sink
  72: refrigerator
  73: book
  74: clock
  75: vase
  76: scissors
  77: teddy bear
  78: hair drier
  79: toothbrush

# Download script/URL (optional)
download: https://github.com/ultralytics/assets/releases/download/v0.0.0/coco8-seg.zip

Stelle sicher, dass du die Pfade und Klassennamen entsprechend deinem Datensatz aktualisierst. Weitere Informationen findest du im Abschnitt Dataset YAML Format.

Was ist die Auto-Annotation-Funktion in Ultralytics YOLO?

Die Auto-Annotation in Ultralytics YOLO ermöglicht es dir, Segmentierungsannotationen für deinen Datensatz mithilfe eines vortrainierten Erkennungsmodells zu generieren. Dies reduziert den Bedarf an manueller Beschriftung erheblich. Du kannst die Funktion auto_annotate wie folgt verwenden:

from ultralytics.data.annotator import auto_annotate

auto_annotate(data="path/to/images", det_model="yolo26x.pt", sam_model="sam_b.pt")  # or sam_model="mobile_sam.pt"

Diese Funktion automatisiert den Annotationsprozess und macht ihn schneller und effizienter. Weitere Details findest du in der Auto-Annotate-Referenz.