PASCAL-VOC-Datensatz#

21,500

VOC

ultralytics

publicDetect

PASCAL VOC is a foundational object-detection benchmark spanning 20 everyday classes, including people, animals, vehicles, and household objects. Its diverse real-world scenes and standardized evaluation established a widely used reference point for model comparison.

820 classes1.4 GBSep 2, 2026

aeroplanebicyclebirdboat+16

Der PASCAL VOC-Datensatz (Visuelle Objektklassen) ist ein klassischer Benchmark für die Objekterkennung mit 20 Klassen alltäglicher Objekte. Die Ultralytics-Konfiguration VOC.yaml kombiniert die Trainval-Splits von VOC2007 und VOC2012 zu einem Trainingsdatensatz mit 16.551 Bildern, validiert mit den 4.952 öffentlich annotierten VOC2007-Testbildern und lädt bei der ersten Verwendung alles automatisch herunter (2,8 GB).

Die PASCAL-VOC-Wettbewerbe fanden von 2005 bis 2012 statt und prägten die Bewertung von Objekterkennungsmodellen: Der Benchmark umfasst Aufgaben zur Bildklassifikation, Objekterkennung und Segmentierung und machte die mittlere durchschnittliche Präzision (mAP) als Standardmetrik für die Objekterkennung populär. Die Ultralytics-Konfiguration VOC.yaml verwendet die Annotationen für die Objekterkennung und wandelt die ursprünglichen XML-Bounding-Boxen beim Download in das YOLO-Format um.

Wichtige Funktionen#

• 20 Klassen alltäglicher Objekte: Person; sechs Tiere (Vogel, Katze, Kuh, Hund, Pferd, Schaf); sieben Fahrzeuge (Flugzeug, Fahrrad, Boot, Bus, Auto, Motorrad, Zug) und sechs Objekte in Innenräumen (Flasche, Stuhl, Esstisch, Topfpflanze, Sofa, Fernseher).
• Zwei Wettbewerbsgenerationen kombiniert: Das Training führt VOC2007 trainval (5.011 Bilder) und VOC2012 trainval (11.540 Bilder) zusammen.
• Standardisierte Evaluierung: Jahrzehnte veröffentlichter VOC-Baselines machen den Datensatz zu einem praktischen Referenzpunkt für den Vergleich von Objekterkennungsmodellen.
• Für YOLO vorbereitet: Das Download-Skript lädt die Archive herunter und wandelt die Annotationen automatisch um – keine manuelle Vorbereitung erforderlich.

Datensatzstruktur#

Die Ultralytics-Konfiguration VOC.yaml definiert die folgenden Splits:

Die Annotationen des VOC2007-Tests wurden nach dem Wettbewerb des jeweiligen Jahres öffentlich bereitgestellt. Dadurch kann dieser Split als annotierter Validierungsdatensatz dienen. Die Annotationen des VOC2012-Tests werden weiterhin zurückgehalten – Ergebnisse dazu können nur über den offiziellen PASCAL-Evaluierungsserver bewertet werden –, daher sind sie nicht Teil dieser Konfiguration.

Öffne VOC auf der Ultralytics Platform, um die Bilder mit ihren Annotationen zu durchsuchen, die Klassenverteilung und Heatmaps der Bounding-Boxen im Tab Charts anzuzeigen und den Datensatz zu klonen, um dein eigenes Modell in der Cloud zu trainieren.

Anwendungen#

PASCAL VOC war in den Jahren vor dem größeren COCO-Datensatz der wichtigste Benchmark für die Forschung zur Objekterkennung: Detektoren wie Faster R-CNN und SSD veröffentlichten ihre ursprünglichen Ergebnisse darauf, und Ultralytics YOLO-Modelle lassen sich direkt damit trainieren. Heute wird der Datensatz weiterhin häufig verwendet für:

• Das Bewerten neuer Architekturen für die Objekterkennung anhand einer langen Geschichte veröffentlichter Baselines
• Schnelle Experimente und Lehrveranstaltungen – mit 16.551 Trainingsbildern ist das Training deutlich schneller als bei COCO
• Studien zum Transferlernen mit einer kompakten, gut verstandenen Auswahl alltäglicher Klassen

Dataset-YAML#

Die Datei VOC.yaml definiert die Konfiguration des Datensatzes – die Pfade, die 20 Klassennamen und das automatische Skript zum Herunterladen und Umwandeln. 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 https://www.robots.ox.ac.uk/~vgg/projects/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

Verwendung#

Um ein YOLO26n-Modell 100 Epochen lang auf dem VOC-Datensatz mit einer Bildgröße von 640 zu trainieren, kannst du die folgenden Codeausschnitte verwenden. Eine vollständige Liste der verfügbaren Argumente findest du auf der Seite zum Training des Modells.

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)

Beispielbilder und Annotationen#

Das folgende Bild zeigt einen mosaikierten Trainings-Batch aus dem VOC-Datensatz. Beim Mosaikieren werden mehrere Bilder zu einem einzigen Trainingsbeispiel kombiniert. Dadurch erhöht sich die Vielfalt der Objekte, Maßstäbe und Szenenkontexte, die das Modell in jedem Batch sieht – weitere Informationen findest du im YOLO-Leitfaden zur Datenerweiterung.

Zitate und Danksagungen#

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

@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 zum VOC-Datensatz und seinen Erstellern findest du auf der Website des PASCAL-VOC-Datensatzes.

FAQ#