Dataset PASCAL VOC#

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

Il dataset PASCAL VOC (Classi di oggetti visivi) è un benchmark classico per la rilevazione degli oggetti, 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 addestramento di 16.551 immagini, esegue la validazione sulle 4.952 immagini di test VOC2007 annotate pubblicamente e scarica automaticamente tutto (2,8 GB) al primo utilizzo.

Le competizioni PASCAL VOC si sono svolte dal 2005 al 2012 e hanno influenzato il modo in cui vengono valutati i modelli di rilevazione degli oggetti: il benchmark comprende attività di classificazione delle immagini, rilevazione e segmentazione, e ha diffuso l'uso della media della precisione media (mAP) come metrica standard per la rilevazione. La configurazione Ultralytics VOC.yaml utilizza le annotazioni di rilevazione, convertendo i bounding box XML originali nel formato YOLO durante il download.

Funzionalità principali#

• 20 classi di oggetti di uso quotidiano: persona; sei animali (uccello, gatto, mucca, cane, cavallo, pecora); sette veicoli (aeroplano, bicicletta, barca, autobus, automobile, motocicletta, treno); e sei oggetti da interno (bottiglia, sedia, tavolo da pranzo, pianta in vaso, divano, televisore).
• Combinazione di due generazioni di competizioni: l'addestramento unisce VOC2007 trainval (5.011 immagini) e VOC2012 trainval (11.540 immagini).
• Valutazione standardizzata: decenni di baseline VOC pubblicate lo rendono un comodo punto di riferimento per confrontare i modelli di rilevazione.
• Pronto per YOLO: lo script di download scarica gli archivi e converte automaticamente le annotazioni, senza preparazione manuale.

Struttura del dataset#

La configurazione Ultralytics VOC.yaml definisce i seguenti split:

Le annotazioni di test VOC2007 sono state rese pubbliche dopo la competizione di quell'anno, consentendo a questo split di fungere da set di validazione annotato. Le annotazioni di test VOC2012 restano riservate: i risultati su di esse possono essere valutati solo tramite il server ufficiale di valutazione PASCAL; per questo non fanno parte di questa configurazione.

Esplora VOC su Ultralytics Platform per sfogliare le immagini con le relative sovrapposizioni delle annotazioni, visualizzare la distribuzione delle classi e le mappe di calore 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 sulla rilevazione degli oggetti negli anni precedenti al più grande dataset COCO: rilevatori come Faster R-CNN e SSD hanno riportato su di esso i loro risultati originali, e i modelli Ultralytics YOLO vengono addestrati su di esso senza configurazioni aggiuntive. Oggi resta popolare per:

• Confrontare nuove architetture di rilevazione con una lunga storia di baseline pubblicate
• Esperimenti rapidi e attività didattiche: con 16.551 immagini di addestramento, si addestra molto più velocemente di COCO
• Studi di transfer learning su un insieme compatto e ben noto di classi di oggetti di uso quotidiano

YAML del dataset#

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. È 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 delle immagini di 640, puoi usare i seguenti frammenti di codice. Per un elenco completo degli argomenti disponibili, consulta la pagina Addestramento 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)

Immagini ed esempi di annotazioni#

L'immagine seguente mostra un batch di addestramento mosaiced dal dataset VOC. Il mosaicing combina più immagini in un unico campione di addestramento, aumentando la varietà di oggetti, scale e contesti della scena visualizzati dal modello in ogni batch: consulta la guida all'aumento dei dati YOLO per i dettagli.

Citazioni e ringraziamenti#

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

Desideriamo ringraziare il Consorzio PASCAL VOC 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#