Link to this sectionDataset PASCAL VOC#

Il dataset 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 i trainval split di VOC2007 e VOC2012 in un set di addestramento da 16.551 immagini, esegue la validazione sulle 4.952 immagini di test di 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 compiti di classificazione delle 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 riquadri di delimitazione XML originali nel formato YOLO durante il download.

Link to this sectionCaratteristiche 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.

Link to this sectionStruttura 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 sulla Piattaforma Ultralytics per sfogliare le immagini con le relative sovrapposizioni di annotazione, visualizzare la distribuzione delle classi e le mappe di calore dei riquadri di delimitazione nella scheda Grafici e clonarlo per addestrare il tuo modello nel cloud.

Link to this sectionApplicazioni#

PASCAL VOC è stato il benchmark principale per la ricerca sull'object detection negli anni precedenti al più ampio dataset COCO: rilevatori 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 immediatamente. 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 noto di classi di uso quotidiano

Link to this sectionDataset YAML#

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

# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license

# PASCAL VOC dataset http://host.robots.ox.ac.uk/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

Link to this sectionUtilizzo#

Per addestrare un modello YOLO26n sul dataset VOC per 100 epochs con una dimensione dell'immagine di 640, puoi utilizzare i seguenti frammenti di codice. Per un elenco completo degli argomenti disponibili, consulta la pagina 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)

Link to this sectionEsempi di immagini e annotazioni#

L'immagine qui sotto mostra un batch di addestramento a mosaico dal dataset VOC. Il mosaico combina più immagini in un singolo campione di addestramento, aumentando la varietà di oggetti, scale e contesti di scena che il modello vede in ogni batch — vedi la guida all'aumento dei dati YOLO per i dettagli.

Link to this sectionCitazioni 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}}

Vorremmo ringraziare il PASCAL VOC Consortium per aver creato e mantenuto questa preziosa risorsa per la comunità di computer vision. Per maggiori informazioni sul dataset VOC e sui suoi creatori, visita il sito web del dataset PASCAL VOC.

Link to this sectionFAQ#

Link to this sectionA cosa serve il dataset PASCAL VOC?#

PASCAL VOC viene utilizzato per addestrare e sottoporre a benchmark modelli di object detection su 20 classi di oggetti di uso quotidiano come persona, auto, cane e sedia. Poiché è compatto, completamente etichettato e supportato da anni di baselines pubblicate, è una scelta comune per validare nuove architetture, eseguire esperimenti di studio e condurre rapidi studi di transfer learning.

Link to this sectionQuante immagini ci sono nel dataset PASCAL VOC?#

La configurazione Ultralytics VOC contiene 21.503 immagini: 16.551 per l'addestramento (VOC2007 trainval + VOC2012 trainval) e 4.952 per la validazione (il set di test VOC2007). Tutti gli split condividono le stesse 20 classi. Vedi Struttura del Dataset per la scomposizione completa.

Link to this sectionCome scarico il dataset PASCAL VOC?#

VOC si scarica automaticamente la prima volta che effettui l'addestramento con data="VOC.yaml" — non sono necessari passaggi manuali. Lo script recupera tre archivi (2,8 GB) dagli asset di rilascio di Ultralytics GitHub e converte le annotazioni XML in formato YOLO.

Link to this sectionCome addestro un modello YOLO26 sul dataset VOC?#

Addestra un modello YOLO26n su VOC per 100 epoche con una dimensione dell'immagine di 640:

from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n.pt")  # load a pretrained model (recommended for training)

# Train the model
results = model.train(data="VOC.yaml", epochs=100, imgsz=640)

Per configurazioni dettagliate, consulta la pagina Training e i consigli per l'addestramento del modello.

Link to this sectionQual è la differenza tra VOC2007 e VOC2012?#

Entrambe le sfide condividono le stesse 20 classi ma contribuiscono con immagini diverse. VOC2007 fornisce 5.011 immagini trainval più un set di test da 4.952 immagini le cui annotazioni sono pubbliche; VOC2012 fornisce 11.540 immagini trainval, mentre le sue annotazioni di test sono riservate e valutate solo dal server di valutazione ufficiale. Il VOC.yaml di Ultralytics unisce entrambi i set trainval per l'addestramento ed esegue la validazione sul test VOC2007.

Link to this sectionCome si confronta PASCAL VOC con il dataset COCO?#

VOC è più piccolo e semplice: 20 classi e 21.503 immagini contro le 80 classi e 330.000 immagini di COCO. I risultati VOC sono tradizionalmente riportati come mAP a 0,5 IoU, mentre COCO calcola la media della mAP su soglie IoU da 0,5 a 0,95. VOC si addestra molto più velocemente e si adatta a esperimenti rapidi; il dataset COCO è lo standard per il benchmarking su scala di produzione.

Link to this sectionPosso addestrare modelli di segmentazione con VOC.yaml?#

No — VOC.yaml è una configurazione solo per il rilevamento: il suo convertitore estrae i riquadri di delimitazione dalle annotazioni XML VOC e le maschere di segmentazione incluse nel benchmark originale non vengono convertite. Per addestrare un modello di instance segmentation, utilizza un dataset con etichette poligonali come COCO-Seg con un modello yolo26n-seg.pt.