PASCAL VOC Datensatz#

21,500

VOC

ultralytics

publicDetect

The PASCAL VOC (Visual Object Classes) dataset is a well-known object detection dataset designed to encourage research on a wide variety of object categories and is commonly used for benchmarking computer vision models.

720 classes1.4 GBApr 28, 2026

aeroplanebicyclebirdboat+16

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

Die PASCAL VOC Challenges fanden von 2005 bis 2012 statt und prägten die Evaluierung von Objekterkennungs-Modellen: Der Benchmark umfasst Bildklassifizierungs-, Erkennungs- und Segmentierungsaufgaben und machte die mittlere durchschnittliche Präzision (mAP) als Standard-Erkennungsmetrik populär. Die Ultralytics Konfiguration VOC.yaml verwendet die Erkennungsannotationen und konvertiert die ursprünglichen XML-Bounding-Boxen während desDownloads in das YOLO-Format.

Hauptfunktionen#

• 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.

Datensatzstruktur#

Die Ultralytics Konfiguration VOC.yaml definiert die folgenden 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.

Entdecke VOC auf der Ultralytics Plattform, um die Bilder mit ihren Annotations-Overlays zu durchstöbern, die Klassenverteilung und Bounding-Box-Heatmaps im Tab Diagramme anzuzeigen und das Dataset zu klonen, um ein eigenes Modell in der Cloud zu trainieren.

Anwendungen#

PASCAL VOC war in den Jahren vor dem größeren COCO Dataset der primäre Benchmark für die Forschung zur Objekterkennung: Detektoren wie Faster R-CNN und SSD haben ihre ursprünglichen Ergebnisse daran gemessen, und Ultralytics YOLO Modelle trainieren direkt damit. Heute ist es weiterhin 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
• Transferlernen-Studien an einem kompakten, gut verstandenen Set alltäglicher Klassen

Datensatz-YAML#

Die Datei VOC.yaml definiert die Dataset-Konfiguration – die Dataset-Pfade, 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 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 für 100 Epochen mit einer Bildgröße von 640 auf dem VOC Dataset zu trainieren, kannst du die folgenden Code-Snippets verwenden. Eine umfassende Liste der verfügbaren Argumente findest du auf der Trainings-Seite 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 Bild unten zeigt einen gemosaikten Trainings-Batch aus dem VOC Dataset. Mosaicing kombiniert mehrere Bilder zu einem einzigen Trainingsbeispiel, wodurch die Vielfalt an Objekten, Skalierungen und Szenenkontexten erhöht wird, die das Modell in jedem Batch sieht – siehe den YOLO-Leitfaden zur Datenaugmentierung für Details.

Zitate 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 das VOC Dataset und dessen Ersteller findest du auf der Website des PASCAL VOC Datasets.

FAQ#