Zum Inhalt springen

Überblick über Objekterkennungs-Datasets

Das Trainieren eines robusten und genauen Objekterkennungsmodells erfordert einen umfassenden Datensatz. Dieser Leitfaden stellt verschiedene Formate von Datensätzen vor, die mit dem Ultralytics YOLO-Modell kompatibel sind, und gibt Einblicke in ihre Struktur, Verwendung und Konvertierung zwischen verschiedenen Formaten.

Unterstützte Datensatzformate

Ultralytics YOLO Format

Das Ultralytics YOLO-Format ist ein Datensatzkonfigurationsformat, mit dem Sie das Stammverzeichnis des Datensatzes, die relativen Pfade zu den Bildverzeichnissen für Training/Validierung/Test oder *.txt Dateien mit Bildpfaden und einem Dictionary mit Klassennamen. Hier ist ein Beispiel:

ultralytics/cfg/datasets/coco8.yaml

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

# COCO8 dataset (first 8 images from COCO train2017) by Ultralytics
# Documentation: https://docs.ultralytics.com/datasets/detect/coco8/
# Example usage: yolo train data=coco8.yaml
# parent
# ├── ultralytics
# └── datasets
#     └── coco8 ← 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 # 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.zip

Beschriftungen für dieses Format sollten mit einem in das YOLO-Format exportiert werden *.txt Datei pro Bild. Wenn ein Bild keine Objekte enthält, darf keine *.txt Datei ist erforderlich. Die *.txt Datei sollte mit einer Zeile pro Objekt in class x_center y_center width height Format. Box-Koordinaten müssen in normalisiertem xywh Format (von 0 bis 1). Wenn sich Ihre Boxen in Pixeln befinden, sollten Sie diese dividieren x_center und width durch die Bildbreite und y_center und height nach Bildhöhe. Klassennummern sollten nullindiziert sein (beginnend mit 0).

Beispiel für ein beschriftetes Bild

Die zum obigen Bild gehörende Beschriftungsdatei enthält 2 Personen (Klasse 0) und eine Krawatte (Klasse 27):

Beispiel für eine Beschriftungsdatei

Wenn Sie das Ultralytics YOLO-Format verwenden, organisieren Sie Ihre Trainings- und Validierungsbilder und -beschriftungen wie im folgenden COCO8-Datensatz-Beispiel gezeigt.

Beispiel für die Verzeichnisstruktur eines Datensatzes

Anwendungsbeispiel

Hier erfahren Sie, wie Sie Datensätze im YOLO-Format verwenden können, um Ihr Modell zu trainieren:

Beispiel

from ultralytics import YOLO

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

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

# Start training from a pretrained *.pt model
yolo detect train data=coco8.yaml model=yolo11n.pt epochs=100 imgsz=640

Ultralytics NDJSON-Format

Das NDJSON-Format (Newline Delimited JSON) bietet eine alternative Möglichkeit, Datensätze für Ultralytics YOLO11-Modelle zu definieren. Bei diesem Format werden Datensatz-Metadaten und -Annotationen in einer einzigen Datei gespeichert, wobei jede Zeile ein separates JSON-Objekt enthält.

Eine NDJSON-Datensatzdatei enthält:

  1. Datensatz-Eintrag (erste Zeile): Enthält Datensatz-Metadaten, einschließlich Aufgabentyp, Klassennamen und allgemeine Informationen
  2. Bild-Einträge (nachfolgende Zeilen): Enthält individuelle Bilddaten, einschließlich Abmessungen, Annotationen und Dateipfade

NDJSON-Beispiel

{
    "type": "dataset",
    "task": "detect",
    "name": "Example",
    "description": "COCO NDJSON example dataset",
    "url": "https://app.ultralytics.com/user/datasets/example",
    "class_names": { "0": "person", "1": "bicycle", "2": "car" },
    "bytes": 426342,
    "version": 0,
    "created_at": "2024-01-01T00:00:00Z",
    "updated_at": "2025-01-01T00:00:00Z"
}

{
    "type": "image",
    "file": "image1.jpg",
    "url": "https://www.url.com/path/to/image1.jpg",
    "width": 640,
    "height": 480,
    "split": "train",
    "annotations": {
        "boxes": [
            [0, 0.52481, 0.37629, 0.28394, 0.41832],
            [1, 0.73526, 0.29847, 0.19275, 0.33691]
        ]
    }
}

Anmerkungsformate nach Aufgabe:

  • Erkennung: "annotations": {"boxes": [[class_id, x_center, y_center, width, height], ...]}
  • Segmentierung: "annotations": {"segments": [[class_id, x1, y1, x2, y2, ...], ...]}
  • Pose: "annotations": {"pose": [[class_id, x1, y1, v1, x2, y2, v2, ...], ...]}
  • OBB: "annotations": {"obb": [[class_id, x_center, y_center, width, height, angle], ...]}
  • Klassifizierung: "annotations": {"classification": [class_id]}

Anwendungsbeispiel

Um einen NDJSON-Datensatz mit YOLO11 zu verwenden, gib einfach den Pfad zu dem .ndjson Datei:

Beispiel

from ultralytics import YOLO

# Load a model
model = YOLO("yolo11n.pt")

# Train using NDJSON dataset
results = model.train(data="path/to/dataset.ndjson", epochs=100, imgsz=640)

# Start training with NDJSON dataset
yolo detect train data=path/to/dataset.ndjson model=yolo11n.pt epochs=100 imgsz=640

Vorteile des NDJSON-Formats

  • Einzelne Datei: Alle Datensatzinformationen in einer Datei enthalten
  • Streaming: Kann große Datensätze Zeile für Zeile verarbeiten, ohne alles in den Speicher zu laden
  • Cloud-Integration: Unterstützt Remote-Bild-URLs für Cloud-basiertes Training
  • Erweiterbar: Einfaches Hinzufügen benutzerdefinierter Metadatenfelder
  • Versionskontrolle: Einzeldateiformat funktioniert gut mit Git- und Versionskontrollsystemen

Unterstützte Datensätze

Hier ist eine Liste der unterstützten Datensätze und eine kurze Beschreibung für jeden:

  • Argoverse: Ein Datensatz, der 3D-Tracking- und Bewegungsprognosedaten aus städtischen Umgebungen mit umfangreichen Anmerkungen enthält.
  • COCO: Common Objects in Context (COCO) ist ein umfangreicher Datensatz für Objekterkennung, Segmentierung und Bildbeschriftung mit 80 Objektkategorien.
  • LVIS: Ein umfangreicher Datensatz für Objekterkennung, Segmentierung und Bildbeschriftung mit 1203 Objektkategorien.
  • COCO8: Eine kleinere Teilmenge der ersten 4 Bilder aus COCO train und COCO val, geeignet für schnelle Tests.
  • COCO8-Grayscale: Eine Graustufenversion von COCO8, die durch Konvertierung von RGB in Graustufen erstellt wurde und für die Einkanal-Modellbewertung nützlich ist.
  • COCO8-Multispectral: Eine 10-Kanal-Multispektralversion von COCO8, die durch Interpolation von RGB-Wellenlängen erstellt wurde und für die spektrale Modellbewertung nützlich ist.
  • COCO128: Eine kleinere Teilmenge der ersten 128 Bilder aus COCO train und COCO val, geeignet für Tests.
  • Global Wheat 2020: Ein Datensatz, der Bilder von Weizenähren für die Global Wheat Challenge 2020 enthält.
  • Objects365: Ein hochwertiger, umfangreicher Datensatz für Objekterkennung mit 365 Objektkategorien und über 600.000 annotierten Bildern.
  • OpenImagesV7: Ein umfassender Datensatz von Google mit 1,7 Millionen Trainingsbildern und 42.000 Validierungsbildern.
  • SKU-110K: Ein Datensatz mit dichter Objekterkennung in Einzelhandelsumgebungen mit über 11.000 Bildern und 1,7 Millionen Bounding Boxes.
  • HomeObjects-3K: Ein Datensatz mit Haushaltsgegenständen für den Innenbereich, darunter Betten, Stühle, Fernseher und vieles mehr - ideal für Anwendungen in den Bereichen Smart Home-Automatisierung, Robotik, Augmented Reality und Raumaufteilungsanalyse.
  • Bau-PSA: Neu 🚀: Ein Datensatz mit Baustellenarbeitern mit gekennzeichneter Sicherheitsausrüstung wie Helmen, Westen, Handschuhen, Stiefeln und Schutzbrillen, einschließlich Anmerkungen zu fehlender Ausrüstung wie no_helmet, no_googles für die Überwachung der Einhaltung der Vorschriften in der Praxis.
  • VisDrone: Ein Datensatz, der Objekterkennungs- und Multi-Objekt-Tracking-Daten aus von Drohnen aufgenommenen Bildern mit über 10.000 Bildern und Videosequenzen enthält.
  • VOC: Der Pascal Visual Object Classes (VOC) Datensatz für Objekterkennung und Segmentierung mit 20 Objektklassen und über 11.000 Bildern.
  • xView: Ein Datensatz für Objekterkennung in Luftaufnahmen mit 60 Objektkategorien und über 1 Million annotierten Objekten.
  • Roboflow 100: Ein vielfältiger Benchmark für Objekterkennung mit 100 Datensätzen aus sieben Bildgebungsbereichen zur umfassenden Modellbewertung.
  • Brain-tumor: Ein Datensatz zur Erkennung von Hirntumoren, der MRT- oder CT-Scan-Bilder mit Details zu Vorhandensein, Lage und Eigenschaften des Tumors enthält.
  • African-wildlife: Ein Datensatz mit Bildern afrikanischer Wildtiere, darunter Büffel, Elefanten, Nashörner und Zebras.
  • Signature: Ein Datensatz mit Bildern verschiedener Dokumente mit annotierten Unterschriften, der die Dokumentenprüfung und die Forschung zur Betrugserkennung unterstützt.
  • Medical-pills: Ein Datensatz mit Bildern von medizinischen Pillen, die für Anwendungen wie pharmazeutische Qualitätssicherung, Pillensortierung und Einhaltung gesetzlicher Vorschriften annotiert sind.

Hinzufügen Ihres eigenen Datensatzes

Wenn Sie Ihr eigenes Dataset haben und es für das Training von Erkennungsmodellen im Ultralytics YOLO-Format verwenden möchten, stellen Sie sicher, dass es dem oben unter „Ultralytics YOLO-Format“ angegebenen Format entspricht. Konvertieren Sie Ihre Annotationen in das erforderliche Format und geben Sie die Pfade, die Anzahl der Klassen und die Klassennamen in der YAML-Konfigurationsdatei an.

Labelformate portieren oder konvertieren

COCO-Datensatzformat zu YOLO-Format

Sie können Labels einfach aus dem populären COCO-Datensatzformat in das YOLO-Format konvertieren, indem Sie den folgenden Code-Schnipsel verwenden:

Beispiel

from ultralytics.data.converter import convert_coco

convert_coco(labels_dir="path/to/coco/annotations/")

Dieses Konvertierungstool kann verwendet werden, um den COCO-Datensatz oder einen beliebigen Datensatz im COCO-Format in das Ultralytics YOLO-Format zu konvertieren. Der Prozess wandelt die JSON-basierten COCO-Annotationen in das einfachere textbasierte YOLO-Format um, wodurch es mit Ultralytics YOLO-Modellen kompatibel wird.

Denken Sie daran, nochmals zu überprüfen, ob das Dataset, das Sie verwenden möchten, mit Ihrem Modell kompatibel ist und die erforderlichen Formatkonventionen einhält. Korrekt formatierte Datasets sind entscheidend für das Trainieren erfolgreicher Objekterkennungsmodelle.

FAQ

Was ist das Ultralytics YOLO-Datensatzformat und wie ist es aufgebaut?

Das Ultralytics YOLO-Format ist eine strukturierte Konfiguration zur Definition von Datensätzen in Ihren Trainingsprojekten. Es beinhaltet das Festlegen von Pfaden zu Ihren Trainings-, Validierungs- und Testbildern sowie den dazugehörigen Beschriftungen. Zum Beispiel:

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

# COCO8 dataset (first 8 images from COCO train2017) by Ultralytics
# Documentation: https://docs.ultralytics.com/datasets/detect/coco8/
# Example usage: yolo train data=coco8.yaml
# parent
# ├── ultralytics
# └── datasets
#     └── coco8 ← 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 # 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.zip

Beschriftungen werden gespeichert in *.txt Dateien mit einer Datei pro Bild, formatiert als class x_center y_center width height mit normalisierten Koordinaten. Eine detaillierte Anleitung finden Sie im COCO8 Datensatz Beispiel.

Wie konvertiere ich einen COCO-Datensatz in das YOLO-Format?

Sie können einen COCO-Datensatz mit den Ultralytics-Konvertierungstools in das YOLO-Format konvertieren. Hier ist eine schnelle Methode:

from ultralytics.data.converter import convert_coco

convert_coco(labels_dir="path/to/coco/annotations/")

Dieser Code konvertiert Ihre COCO-Annotationen in das YOLO-Format und ermöglicht so eine nahtlose Integration mit Ultralytics YOLO-Modellen. Weitere Informationen finden Sie im Abschnitt Labelformate portieren oder konvertieren.

Welche Datasets werden von Ultralytics YOLO für die Objekterkennung unterstützt?

Ultralytics YOLO unterstützt eine Vielzahl von Datensätzen, darunter:

Jede Datensatzseite bietet detaillierte Informationen über die Struktur und Verwendung, die auf ein effizientes YOLO11-Training zugeschnitten sind. Entdecken Sie die vollständige Liste im Abschnitt Unterstützte Datensätze.

Wie beginne ich mit dem Training eines YOLO11-Modells mit meinem Datensatz?

Um mit dem Training eines YOLO11-Modells zu beginnen, stellen Sie sicher, dass Ihr Datensatz korrekt formatiert ist und die Pfade in einer YAML-Datei definiert sind. Verwenden Sie das folgende Skript, um mit dem Training zu beginnen:

Beispiel

from ultralytics import YOLO

model = YOLO("yolo11n.pt")  # Load a pretrained model
results = model.train(data="path/to/your_dataset.yaml", epochs=100, imgsz=640)

yolo detect train data=path/to/your_dataset.yaml model=yolo11n.pt epochs=100 imgsz=640

Weitere Informationen zur Verwendung verschiedener Modi, einschließlich CLI-Befehle, finden Sie im Abschnitt Verwendung.

Wo finde ich praktische Beispiele für die Verwendung von Ultralytics YOLO zur Objekterkennung?

Ultralytics bietet zahlreiche Beispiele und praktische Anleitungen für die Verwendung von YOLO11 in verschiedenen Anwendungen. Einen umfassenden Überblick finden Sie im Ultralytics-Blog, wo Sie Fallstudien, detaillierte Tutorials und Community-Berichte über Objekterkennung, Segmentierung und mehr mit YOLO11 finden. Spezifische Beispiele finden Sie im Abschnitt Verwendung in der Dokumentation.



📅 Vor 1 Jahr erstellt ✏️ Vor 11 Tagen aktualisiert
glenn-jocher RizwanMunawar Laughing-q Y-T-G UltralyticsAssistant MatthewNoyce jk4e IvorZhu331

Kommentare