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.

1020 classes1.4 GBSep 2, 2026

aeroplanebicyclebirdboat+16

Il dataset PASCAL VOC (classi di oggetti visivi) è un benchmark classico per il rilevamento degli oggetti, con 20 classi di oggetti di uso quotidiano. La configurazione Ultralytics VOC.yaml unisce gli split trainval di VOC2007 e VOC2012 in un set di addestramento da 16.551 immagini, esegue la convalida sulle 4.952 immagini di test VOC2007 annotate e rese pubbliche, e scarica automaticamente tutti i dati (2,8 GB) al primo utilizzo.

Le sfide PASCAL VOC si sono svolte dal 2005 al 2012 e hanno influenzato il modo in cui vengono valutati i modelli di rilevamento degli oggetti: il benchmark comprende attività di classificazione, rilevamento e segmentazione delle immagini, e ha reso popolare la precisione media media (mAP) come metrica standard per il rilevamento. La configurazione Ultralytics VOC.yaml usa le annotazioni di rilevamento e converte i riquadri di delimitazione 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 interni (bottiglia, sedia, tavolo da pranzo, pianta in vaso, divano, monitor TV).
• Due generazioni di sfide combinate: l'addestramento unisce VOC2007 trainval (5.011 immagini) e VOC2012 trainval (11.540 immagini).
• Valutazione standardizzata: decenni di baseline VOC pubblicate ne fanno un comodo riferimento per confrontare i modelli di rilevamento.
• Pronto per YOLO: lo script di download recupera gli archivi e converte automaticamente le annotazioni; non è necessaria alcuna preparazione manuale.

Struttura del dataset#

La configurazione Ultralytics VOC.yaml definisce i seguenti split:

Le annotazioni del test VOC2007 sono state rese pubbliche dopo la sfida di quell'anno, consentendo di usare questo split come set di convalida etichettato. Le annotazioni del test VOC2012 restano riservate: i risultati possono essere valutati solo tramite il server ufficiale di valutazione PASCAL, quindi 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 riquadri di delimitazione nella scheda Grafici, e creare un clone per addestrare il tuo modello nel cloud.

Applicazioni#

PASCAL VOC è stato il benchmark principale per la ricerca sul rilevamento degli oggetti negli anni precedenti al più grande dataset COCO: rilevatori come Faster R-CNN e SSD vi hanno pubblicato i risultati originali, e i modelli Ultralytics YOLO possono essere addestrati direttamente su questo dataset. Oggi resta molto usato per:

• Valutare nuove architetture di rilevamento confrontandole con una lunga serie di baseline pubblicate
• Esperimenti rapidi e attività didattiche: con 16.551 immagini di addestramento, l'addestramento è molto più veloce che su COCO
• Studi di apprendimento per trasferimento su un insieme compatto e ben conosciuto di classi di uso quotidiano

YAML del dataset#

Il file VOC.yaml definisce la configurazione del dataset: i percorsi del dataset, i nomi delle 20 classi e lo script automatico per il download e la 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 dell'immagine di 640, puoi usare i seguenti frammenti di codice. Per un elenco completo degli argomenti disponibili, consulta la pagina Training del modello.

from ultralytics import YOLO

# Carica un modello
model = YOLO("yolo26n.pt")  # carica un modello preaddestrato (consigliato per l'addestramento)

# Addestra il modello: il dataset verrà scaricato automaticamente alla prima esecuzione
results = model.train(data="VOC.yaml", epochs=100, imgsz=640)

Immagini di esempio e annotazioni#

L'immagine qui sotto mostra un batch di addestramento mosaicato del dataset VOC. La mosaificazione combina più immagini in un singolo campione di addestramento, aumentando la varietà di oggetti, scale e contesti delle scene che il modello vede in ogni batch — per i dettagli, consulta la guida all'aumento dei dati di YOLO.

Citazioni e ringraziamenti#

Se usi 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 PASCAL VOC Consortium per aver creato e mantenuto questa preziosa risorsa per la comunità della visione artificiale. Per ulteriori informazioni sul dataset VOC e sui suoi creatori, visita il sito web del dataset PASCAL VOC.

Domande frequenti#