Dataset PASCAL VOC#

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

Il set di dati PASCAL VOC (Visual Object Classes) è un classico benchmark di object detection con 20 classi di oggetti di uso quotidiano. La configurazione Ultralytics VOC.yaml combina gli split trainval di VOC2007 e VOC2012 in un set di training di 16.551 immagini, esegue la validazione sulle 4.952 immagini di test VOC2007 annotate pubblicamente e scarica tutto automaticamente (2,8 GB) al primo utilizzo.

Le sfide PASCAL VOC si sono svolte dal 2005 al 2012 e hanno plasmato il modo in cui vengono valutati i modelli di object detection: il benchmark spazia tra attività di classificazione di immagini, rilevamento e segmentazione, e ha reso popolare la mean Average Precision (mAP) come metrica di rilevamento standard. La configurazione Ultralytics VOC.yaml utilizza le annotazioni di rilevamento, convertendo i bounding box XML originali in formato YOLO durante il download.

Caratteristiche principali#

• 20 classi di oggetti di uso quotidiano: persona; sei animali (uccello, gatto, mucca, cane, cavallo, pecora); sette veicoli (aereo, bicicletta, barca, autobus, auto, motocicletta, treno); e sei oggetti da interno (bottiglia, sedia, tavolo da pranzo, pianta in vaso, divano, monitor TV).
• Due generazioni di sfide combinate: l'addestramento unisce VOC2007 trainval (5.011 immagini) con VOC2012 trainval (11.540 immagini).
• Valutazione standardizzata: decenni di baselines VOC pubblicate lo rendono un comodo punto di riferimento per confrontare i modelli di rilevamento.
• Pronto per YOLO: lo script di download recupera gli archivi e converte automaticamente le annotazioni — nessuna preparazione manuale.

Struttura del dataset#

La configurazione Ultralytics VOC.yaml definisce i seguenti split:

Le annotazioni di test di VOC2007 sono state rilasciate pubblicamente dopo la sfida di quell'anno, il che consente a questo split di servire come set di validazione etichettato. Le annotazioni di test di VOC2012 rimangono riservate — i risultati su di esse possono essere valutati solo tramite il server di valutazione ufficiale PASCAL — quindi non fanno parte di questa configurazione.

Esplora VOC su Ultralytics Platform per sfogliare le immagini con i relativi overlay di annotazione, visualizzare la distribuzione delle classi e le heatmap dei bounding box nella scheda Charts, e clonarlo per addestrare il tuo modello nel cloud.

Applicazioni#

PASCAL VOC è stato il benchmark principale per la ricerca sull'object detection negli anni precedenti al più ampio dataset COCO: detector come Faster R-CNN e SSD hanno riportato i loro risultati originali su di esso, e i modelli Ultralytics YOLO si addestrano su di esso nativamente. Oggi rimane popolare per:

• Benchmark di nuove architetture di rilevamento rispetto a una lunga storia di baselines pubblicate
• Esperimenti rapidi e corsi di studio — con 16.551 immagini di addestramento si addestra molto più rapidamente di COCO
• Studi di transfer learning su un set compatto e ben compreso di classi di uso quotidiano

Dataset YAML#

Il file VOC.yaml definisce la configurazione del dataset: i percorsi del dataset, i 20 nomi delle classi e lo script automatico di download e conversione. Viene mantenuto nel repository Ultralytics all'indirizzo https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/VOC.yaml.

# 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

Utilizzo#

Per addestrare un modello YOLO26n sul dataset VOC per 100 epoche con una dimensione dell'immagine di 640, puoi utilizzare i seguenti frammenti di codice. Per un elenco completo degli argomenti disponibili, fai riferimento alla pagina di Training del modello.

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)

Esempi di immagini e annotazioni#

L'immagine sottostante mostra un batch di training a mosaico tratto dal dataset VOC. La tecnica del mosaico combina più immagini in un unico campione di training, aumentando la varietà di oggetti, scale e contesti di scena che il modello vede in ogni batch — consulta la guida all'augmenting dei dati di YOLO per i dettagli.

Citazioni e riconoscimenti#

Se utilizzi il dataset VOC nel tuo lavoro di ricerca o sviluppo, cita il seguente articolo:

@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}}

Ringraziamo il PASCAL VOC Consortium per aver creato e mantenuto questa preziosa risorsa per la comunità della computer vision. Per ulteriori informazioni sul dataset VOC e sui suoi creatori, visita il sito Web del dataset PASCAL VOC.

FAQ#