Link to this sectionPASCAL VOC Datensatz#

Der PASCAL VOC (Visual Object Classes) Datensatz ist ein klassischer Objekterkennungs-Benchmark mit 20 alltäglichen Objektklassen. Die Ultralytics VOC.yaml Konfiguration kombiniert die VOC2007- und VOC2012-Trainval-Splits zu einem Trainingsset mit 16.551 Bildern, validiert auf den 4.952 öffentlich annotierten VOC2007-Testbildern und lädt bei der ersten Verwendung automatisch alles herunter (2,8 GB).

Die PASCAL VOC Challenges liefen von 2005 bis 2012 und haben die Art und Weise geprägt, wie Objekterkennungs-Modelle bewertet werden: Der Benchmark umfasst Bildklassifizierungs-, Erkennungs- und Segmentierungsaufgaben und machte die mean Average Precision (mAP) als Standard-Erkennungsmetrik populär. Die Ultralytics VOC.yaml Konfiguration nutzt die Erkennungsannotationen und konvertiert die ursprünglichen XML-BBoxen während des Downloads in das YOLO-Format.

Link to this sectionHauptfunktionen#

• 20 alltägliche Objektklassen: Person; sechs Tiere (Vogel, Katze, Kuh, Hund, Pferd, Schaf); sieben Fahrzeuge (Flugzeug, Fahrrad, Boot, Bus, Auto, Motorrad, Zug); und sechs Innenraumobjekte (Flasche, Stuhl, Esstisch, Topfpflanze, Sofa, Fernseher).
• Zwei Challenge-Generationen kombiniert: Das Training führt VOC2007-Trainval (5.011 Bilder) mit VOC2012-Trainval (11.540 Bilder) zusammen.
• Standardisierte Bewertung: Jahrzehntelang veröffentlichte VOC-Baselines machen ihn zu einem praktischen Referenzpunkt für den Vergleich von Erkennungsmodellen.
• YOLO-bereit: Das Download-Skript ruft die Archive ab und konvertiert die Annotationen automatisch – keine manuelle Vorbereitung erforderlich.

Link to this sectionDatensatzstruktur#

Die Ultralytics VOC.yaml Konfiguration definiert folgende Splits:

Die Annotationen des VOC2007-Tests wurden nach der Challenge dieses Jahres öffentlich zugänglich gemacht, was es ermöglicht, diesen Split als validiertes Label-Set zu verwenden. VOC2012-Test-Annotationen bleiben zurückgehalten – Ergebnisse dazu können nur über den offiziellen PASCAL-Evaluierungsserver ausgewertet werden – daher sind sie nicht Teil dieser Konfiguration.

Erkunde VOC auf der Ultralytics Plattform, um die Bilder mit ihren Annotations-Overlays zu durchsuchen, die Klassenverteilung und BBox-Heatmaps im Tab Charts anzusehen und ihn zu klonen, um dein eigenes Modell in der Cloud zu trainieren.

Link to this sectionAnwendungen#

PASCAL VOC war der primäre Benchmark für die Objekterkennungsforschung in den Jahren vor dem größeren COCO Datensatz: Detektoren wie Faster R-CNN und SSD meldeten ihre ursprünglichen Ergebnisse damit, und Ultralytics YOLO Modelle trainieren damit sofort einsatzbereit. Heute bleibt er beliebt für:

• Benchmarking neuer Erkennungsarchitekturen gegen eine lange Historie veröffentlichter Baselines
• Schnelle Experimente und Kursarbeiten – mit 16.551 Trainingsbildern trainiert er weitaus schneller als COCO
• Transfer Learning Studien auf einem kompakten, gut verstandenen Set alltäglicher Klassen

Link to this sectionDatensatz-YAML#

Die VOC.yaml Datei definiert die Datensatz-Konfiguration – die Datensatzpfade, die 20 Klassennamen und das automatische Download- und Konvertierungsskript. Sie wird im Ultralytics Repository 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, 5011 images
      f"{ASSETS_URL}/VOCtest_06-Nov-2007.zip",  # 438MB, 4952 images
      f"{ASSETS_URL}/VOCtrainval_11-May-2012.zip",  # 1.95GB, 17125 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

Link to this sectionVerwendung#

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 Modell-Seite Training.

from ultralytics import YOLO

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

# Train the model - dataset will auto-download on first run
results = model.train(data="VOC.yaml", epochs=100, imgsz=640)

Link to this sectionBeispielbilder und Annotationen#

Das Bild unten zeigt einen mosaikierten Trainings-Batch aus dem VOC-Datensatz. Mosaiking kombiniert mehrere Bilder zu einem einzigen Trainingsbeispiel und erhöht die Vielfalt an Objekten, Skalierungen und Szenenkontexten, die das Modell in jedem Batch sieht – siehe den YOLO Datenaugmentierungs-Guide für Details.

Link to this sectionZitate und Danksagungen#

Wenn du den VOC-Datensatz in deiner Forschung oder Entwicklungsarbeit verwendest, zitiere bitte das folgende Dokument:

@article{everingham2010pascal,
  author={Everingham, Mark and Van Gool, Luc and Williams, Christopher K. I. and Winn, John and Zisserman, Andrew},
  journal={International Journal of Computer Vision},
  title={The Pascal Visual Object Classes (VOC) Challenge},
  year={2010},
  volume={88},
  number={2},
  pages={303-338},
  doi={10.1007/s11263-009-0275-4}}

Wir möchten dem PASCAL VOC Consortium für die Erstellung und Pflege dieser wertvollen Ressource für die Computer Vision-Community danken. Weitere Informationen über den VOC-Datensatz und seine Ersteller findest du auf der PASCAL VOC-Datensatz-Website.

Link to this sectionFAQ#

Link to this sectionWofür wird der PASCAL VOC Datensatz verwendet?#

PASCAL VOC wird verwendet, um Objekterkennungsmodelle mit 20 alltäglichen Objektklassen wie Person, Auto, Hund und Stuhl zu trainieren und zu benchen. Da er kompakt, vollständig annotiert und durch jahrelange publizierte Baselines abgesichert ist, ist er eine gängige Wahl für die Validierung neuer Architekturen, das Durchführen von Experimenten und schnelle Transfer Learning Studien.

Link to this sectionWie viele Bilder sind im PASCAL VOC Datensatz enthalten?#

Die Ultralytics VOC Konfiguration enthält 21.503 Bilder: 16.551 für das Training (VOC2007 trainval + VOC2012 trainval) und 4.952 für die Validierung (das VOC2007 Testset). Alle Splits teilen sich dieselben 20 Klassen. Siehe Datensatzstruktur für die vollständige Aufschlüsselung.

Link to this sectionWie lade ich den PASCAL VOC Datensatz herunter?#

VOC lädt beim ersten Training mit data="VOC.yaml" automatisch herunter – keine manuellen Schritte erforderlich. Das Skript ruft drei Archive (2,8 GB) aus den Ultralytics GitHub Release Assets ab und konvertiert die XML-Annotationen in das YOLO-Format.

Link to this sectionWie trainiere ich ein YOLO26 Modell auf dem VOC Datensatz?#

Trainiere ein YOLO26n Modell auf VOC für 100 Epochen bei einer Bildgröße von 640:

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)

Für detaillierte Konfigurationen siehe die Seite Training und Tipps zum Modelltraining.

Link to this sectionWas ist der Unterschied zwischen VOC2007 und VOC2012?#

Beide Challenges teilen sich dieselben 20 Klassen, tragen aber unterschiedliche Bilder bei. VOC2007 bietet 5.011 Trainval-Bilder plus ein 4.952-Bilder Testset, dessen Annotationen öffentlich sind; VOC2012 bietet 11.540 Trainval-Bilder, während deren Test-Annotationen zurückgehalten werden und nur durch den offiziellen Evaluierungsserver bewertet werden. Die Ultralytics VOC.yaml führt beide Trainval-Sets für das Training zusammen und validiert auf dem VOC2007 Testset.

Link to this sectionWie schneidet PASCAL VOC im Vergleich zum COCO Datensatz ab?#

VOC ist kleiner und einfacher: 20 Klassen und 21.503 Bilder gegenüber 80 Klassen und 330.000 Bildern bei COCO. VOC-Ergebnisse werden traditionell als mAP bei 0.5 IoU berichtet, während COCO den mAP über IoU-Schwellenwerte von 0.5 bis 0.95 mittelt. VOC trainiert viel schneller und eignet sich für schnelle Experimente; der COCO Datensatz ist der Standard für Benchmarking im Produktionsmaßstab.

Link to this sectionKann ich Segmentierungsmodelle mit VOC.yaml trainieren?#

Nein – VOC.yaml ist eine reine Erkennungskonfiguration: Der Konverter extrahiert Bounding Boxen aus den VOC XML-Annotationen, und die im ursprünglichen Benchmark enthaltenen Segmentierungsmasken werden nicht konvertiert. Um ein Instanzsegmentierungs-Modell zu trainieren, verwende einen Datensatz mit Polygon-Labels wie COCO-Seg mit einem yolo26n-seg.pt Modell.