VOC-Datensatz

Der PASCAL VOC (Visual Object Classes) Datensatz ist ein bekannter Datensatz für Objekterkennung, Segmentierung und Klassifizierung. Er wurde entwickelt, um die Forschung an einer Vielzahl von Objektkategorien zu fördern, und wird häufig für das Benchmarking von Computer-Vision-Modellen verwendet. Er ist ein wesentlicher Datensatz für Forscher und Entwickler, die an Aufgaben der Objekterkennung, Segmentierung und Klassifizierung arbeiten.

Hauptmerkmale

• Der VOC-Datensatz umfasst zwei Haupt-Challenges: VOC2007 und VOC2012.
• Der Datensatz umfasst 20 Objektkategorien, darunter häufige Objekte wie Autos, Fahrräder und Tiere sowie spezifischere Kategorien wie Boote, Sofas und Esstische.
• Die Annotationen umfassen Bounding Boxen für Objekte und Klassen-Labels für Objekterkennungs- und Klassifizierungsaufgaben sowie Segmentierungsmasken für Segmentierungsaufgaben.
• VOC bietet standardisierte Bewertungsmetriken wie mean Average Precision (mAP) für Objekterkennung und Klassifizierung, wodurch er sich für den Vergleich der Modellleistung eignet.

Datensatzstruktur

Der VOC-Datensatz ist in drei Teilmengen unterteilt:

1. Train: Diese Teilmenge enthält Bilder zum Training von Modellen für Objekterkennung, Segmentierung und Klassifizierung.
2. Validation: Diese Teilmenge enthält Bilder, die während des Modelltrainings zu Validierungszwecken verwendet werden.
3. Test: Diese Teilmenge besteht aus Bildern, die zum Testen und Benchmarking der trainierten Modelle verwendet werden. Ground-Truth-Annotationen für diese Teilmenge sind nicht öffentlich verfügbar, und die Ergebnisse wurden historisch zur Leistungsbewertung an den PASCAL VOC-Auswertungsserver übermittelt.

Anwendungen

Der VOC-Datensatz wird häufig zum Training und zur Bewertung von Deep Learning Modellen für Objekterkennung (wie Ultralytics YOLO, Faster R-CNN und SSD), Instanzsegmentierung (wie Mask R-CNN) und Bildklassifizierung verwendet. Die vielfältigen Objektkategorien des Datensatzes, die große Anzahl annotierter Bilder und die standardisierten Bewertungsmetriken machen ihn zu einer unverzichtbaren Ressource für Forscher und Praktiker im Bereich Computer Vision.

Datensatz-YAML

Eine YAML (Yet Another Markup Language) Datei wird verwendet, um die Dataset-Konfiguration zu definieren. Sie enthält Informationen über die Pfade, Klassen und andere relevante Details des Datensatzes. Im Fall des VOC-Datensatzes wird die VOC.yaml Datei unter https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/VOC.yaml gepflegt.

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

# PASCAL VOC dataset http://host.robots.ox.ac.uk/pascal/VOC by University of Oxford
# Documentation: https://docs.ultralytics.com/datasets/detect/voc/
# Example usage: yolo train data=VOC.yaml
# parent
# ├── ultralytics
# └── datasets
#     └── VOC ← downloads here (2.8 GB)

# 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: VOC
train: # train images (relative to 'path') 16551 images
  - images/train2012
  - images/train2007
  - images/val2012
  - images/val2007
val: # val images (relative to 'path') 4952 images
  - images/test2007
test: # test images (optional)
  - images/test2007

# Classes
names:
  0: aeroplane
  1: bicycle
  2: bird
  3: boat
  4: bottle
  5: bus
  6: car
  7: cat
  8: chair
  9: cow
  10: diningtable
  11: dog
  12: horse
  13: motorbike
  14: person
  15: pottedplant
  16: sheep
  17: sofa
  18: train
  19: tvmonitor

# Download script/URL (optional) ---------------------------------------------------------------------------------------
download: |
  import xml.etree.ElementTree as ET
  from pathlib import Path

  from ultralytics.utils.downloads import download
  from ultralytics.utils import ASSETS_URL, TQDM

  def convert_label(path, lb_path, year, image_id):
      """Converts XML annotations from VOC format to YOLO format by extracting bounding boxes and class IDs."""

      def convert_box(size, box):
          dw, dh = 1.0 / size[0], 1.0 / size[1]
          x, y, w, h = (box[0] + box[1]) / 2.0 - 1, (box[2] + box[3]) / 2.0 - 1, box[1] - box[0], box[3] - box[2]
          return x * dw, y * dh, w * dw, h * dh

      with open(path / f"VOC{year}/Annotations/{image_id}.xml") as in_file, open(lb_path, "w", encoding="utf-8") as out_file:
          tree = ET.parse(in_file)
          root = tree.getroot()
          size = root.find("size")
          w = int(size.find("width").text)
          h = int(size.find("height").text)

          names = list(yaml["names"].values())  # names list
          for obj in root.iter("object"):
              cls = obj.find("name").text
              if cls in names and int(obj.find("difficult").text) != 1:
                  xmlbox = obj.find("bndbox")
                  bb = convert_box((w, h), [float(xmlbox.find(x).text) for x in ("xmin", "xmax", "ymin", "ymax")])
                  cls_id = names.index(cls)  # class id
                  out_file.write(" ".join(str(a) for a in (cls_id, *bb)) + "\n")

  # Download
  dir = Path(yaml["path"])  # dataset root dir
  urls = [
      f"{ASSETS_URL}/VOCtrainval_06-Nov-2007.zip",  # 446MB, 5012 images
      f"{ASSETS_URL}/VOCtest_06-Nov-2007.zip",  # 438MB, 4953 images
      f"{ASSETS_URL}/VOCtrainval_11-May-2012.zip",  # 1.95GB, 17126 images
  ]
  download(urls, dir=dir / "images", threads=3, exist_ok=True)  # download and unzip over existing (required)

  # Convert
  path = dir / "images/VOCdevkit"
  for year, image_set in ("2012", "train"), ("2012", "val"), ("2007", "train"), ("2007", "val"), ("2007", "test"):
      imgs_path = dir / "images" / f"{image_set}{year}"
      lbs_path = dir / "labels" / f"{image_set}{year}"
      imgs_path.mkdir(exist_ok=True, parents=True)
      lbs_path.mkdir(exist_ok=True, parents=True)

      with open(path / f"VOC{year}/ImageSets/Main/{image_set}.txt") as f:
          image_ids = f.read().strip().split()
      for id in TQDM(image_ids, desc=f"{image_set}{year}"):
          f = path / f"VOC{year}/JPEGImages/{id}.jpg"  # old img path
          lb_path = (lbs_path / f.name).with_suffix(".txt")  # new label path
          f.rename(imgs_path / f.name)  # move image
          convert_label(path, lb_path, year, id)  # convert labels to YOLO format

Verwendung

Um ein YOLO26n Modell auf dem VOC-Datensatz für 100 Epochen mit einer Bildgröße von 640 zu trainieren, kannst du die folgenden Code-Snippets verwenden. Eine umfassende Liste der verfügbaren Argumente findest du auf der Seite Training des Modells.

from ultralytics import YOLO

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

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

Beispielbilder und Annotationen

Der VOC-Datensatz enthält eine vielfältige Sammlung von Bildern mit verschiedenen Objektkategorien und komplexen Szenen. Hier sind einige Beispiele von Bildern aus dem Datensatz, zusammen mit ihren entsprechenden Annotationen:

• Mosaik-Bild: Dieses Bild zeigt einen Trainings-Batch, der aus mosaikierten Datensatzbildern besteht. Mosaiking ist eine Technik, die während des Trainings verwendet wird, um mehrere Bilder zu einem einzigen Bild zu kombinieren, um die Vielfalt der Objekte und Szenen innerhalb jedes Trainings-Batches zu erhöhen. Dies trägt dazu bei, die Fähigkeit des Modells zu verbessern, auf verschiedene Objektgrößen, Seitenverhältnisse und Kontexte zu generalisieren.

Das Beispiel verdeutlicht die Vielfalt und Komplexität der Bilder im VOC-Datensatz sowie die Vorteile der Verwendung von Mosaicing während des Trainingsprozesses.

Zitate und Danksagungen

Wenn du den VOC-Datensatz für deine Forschungs- oder Entwicklungsarbeit verwendest, zitiere bitte das folgende Paper:

@misc{everingham2010pascal,
      title={The PASCAL Visual Object Classes (VOC) Challenge},
      author={Mark Everingham and Luc Van Gool and Christopher K. I. Williams and John Winn and Andrew Zisserman},
      year={2010},
      eprint={0909.5206},
      archivePrefix={arXiv},
      primaryClass={cs.CV}
}

Wir möchten dem PASCAL VOC Consortium dafür danken, dass es diese wertvolle Ressource für die Computer Vision Community erstellt und pflegt. Weitere Informationen über den VOC-Datensatz und seine Ersteller findest du auf der PASCAL VOC Datensatz-Website.

FAQ

Was ist der PASCAL VOC-Datensatz und warum ist er wichtig für Computer-Vision-Aufgaben?

Der PASCAL VOC (Visual Object Classes) Datensatz ist ein renommierter Benchmark für Objekterkennung, Segmentierung und Klassifizierung in der Computer Vision. Er enthält umfassende Annotationen wie Bounding Boxen, Klassen-Labels und Segmentierungsmasken für 20 verschiedene Objektkategorien. Forscher nutzen ihn weithin zur Bewertung der Leistung von Modellen wie Faster R-CNN, YOLO und Mask R-CNN aufgrund seiner standardisierten Bewertungsmetriken wie mean Average Precision (mAP).

Wie trainiere ich ein YOLO26 Modell mit dem VOC-Datensatz?

Um ein YOLO26 Modell mit dem VOC-Datensatz zu trainieren, benötigst du die Dataset-Konfiguration in einer YAML-Datei. Hier ist ein Beispiel, um mit dem Training eines YOLO26n Modells für 100 Epochen mit einer Bildgröße von 640 zu beginnen:

from ultralytics import YOLO

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

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

Was sind die primären Challenges, die im VOC-Datensatz enthalten sind?

Der VOC-Datensatz umfasst zwei Haupt-Challenges: VOC2007 und VOC2012. Diese Challenges testen Objekterkennung, Segmentierung und Klassifizierung über 20 verschiedene Objektkategorien hinweg. Jedes Bild ist akribisch mit Bounding Boxen, Klassen-Labels und Segmentierungsmasken annotiert. Die Challenges bieten standardisierte Metriken wie mAP, was den Vergleich und das Benchmarking verschiedener Computer-Vision-Modelle erleichtert.

Wie verbessert der PASCAL VOC-Datensatz das Benchmarking und die Bewertung von Modellen?

Der PASCAL VOC-Datensatz verbessert das Benchmarking und die Bewertung von Modellen durch seine detaillierten Annotationen und standardisierten Metriken wie mean Average Precision (mAP). Diese Metriken sind entscheidend für die Bewertung der Leistung von Objekterkennungs- und Klassifizierungsmodellen. Die vielfältigen und komplexen Bilder des Datensatzes gewährleisten eine umfassende Modellbewertung in verschiedenen realen Szenarien.

Wie verwende ich den VOC-Datensatz für semantische Segmentierung in YOLO Modellen?

Um den VOC-Datensatz für Aufgaben der semantischen Segmentierung mit YOLO Modellen zu verwenden, musst du den Datensatz korrekt in einer YAML-Datei konfigurieren. Die YAML-Datei definiert Pfade und Klassen, die für das Training von Segmentierungsmodellen erforderlich sind. Überprüfe die YAML-Konfigurationsdatei des VOC-Datensatzes unter VOC.yaml für detaillierte Einstellungen. Für Segmentierungsaufgaben würdest du ein segmentierungsspezifisches Modell wie yolo26n-seg.pt anstelle des Erkennungsmodells verwenden.