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

O dataset PASCAL VOC (classes visuais de objetos) é um benchmark clássico de deteção de objetos com 20 classes de objetos do quotidiano. A configuração VOC.yaml da Ultralytics combina as divisões trainval de VOC2007 e VOC2012 num conjunto de treino com 16.551 imagens, valida com as 4.952 imagens de teste VOC2007 anotadas publicamente e descarrega tudo automaticamente (2,8 GB) na primeira utilização.

Os desafios PASCAL VOC decorreram de 2005 a 2012 e moldaram a forma como os modelos de deteção de objetos são avaliados: o benchmark abrange tarefas de classificação de imagens, deteção e segmentação, e popularizou a precisão média (mAP) como métrica padrão de deteção. A configuração VOC.yaml da Ultralytics utiliza as anotações de deteção, convertendo as caixas delimitadoras XML originais para o formato YOLO durante o download.

Principais funcionalidades#

• 20 classes de objetos do quotidiano: pessoa; seis animais (pássaro, gato, vaca, cão, cavalo, ovelha); sete veículos (avião, bicicleta, barco, autocarro, carro, motociclo, comboio); e seis objetos de interior (garrafa, cadeira, mesa de jantar, planta em vaso, sofá, monitor de televisão).
• Duas gerações de desafios combinadas: o treino combina VOC2007 trainval (5.011 imagens) com VOC2012 trainval (11.540 imagens).
• Avaliação padronizada: décadas de baselines VOC publicados fazem dele um ponto de referência conveniente para comparar modelos de deteção.
• Pronto para YOLO: o script de download obtém os arquivos e converte automaticamente as anotações — sem preparação manual.

Estrutura do Conjunto de Dados#

A configuração VOC.yaml da Ultralytics define as seguintes divisões:

As anotações de teste VOC2007 foram disponibilizadas publicamente após o desafio desse ano, o que permite que esta divisão funcione como um conjunto de validação anotado. As anotações de teste VOC2012 continuam indisponíveis — os resultados só podem ser avaliados através do servidor oficial de avaliação PASCAL —, pelo que não fazem parte desta configuração.

Explora o VOC na Ultralytics Platform para navegar pelas imagens com as respetivas sobreposições de anotações, ver a distribuição das classes e os mapas de calor das caixas delimitadoras no separador Charts, e cloná-lo para treinares o teu próprio modelo na cloud.

Aplicações#

O PASCAL VOC foi o principal benchmark para investigação em deteção de objetos nos anos anteriores ao maior dataset COCO: detetores como o Faster R-CNN e o SSD publicaram nele os seus resultados originais, e os modelos Ultralytics YOLO treinam nele diretamente. Atualmente, continua popular para:

• Avaliar novas arquiteturas de deteção face a uma longa história de baselines publicados
• Experiências rápidas e trabalhos académicos — com 16.551 imagens de treino, o treino é muito mais rápido do que no COCO
• Estudos de transferência de aprendizagem num conjunto compacto e bem conhecido de classes do quotidiano

YAML do Conjunto de Dados#

O ficheiro VOC.yaml define a configuração do dataset — os caminhos do dataset, os 20 nomes de classes e o script automático de download e conversão. É mantido no repositório da Ultralytics em 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

Utilização#

Para treinares um modelo YOLO26n no dataset VOC durante 100 épocas com um tamanho de imagem de 640, podes utilizar os seguintes excertos de código. Para obteres uma lista completa dos argumentos disponíveis, consulta a página de Treino do modelo.

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)

Imagens de exemplo e anotações#

A imagem abaixo mostra um batch de treino mosaico do dataset VOC. O mosaico combina várias imagens numa única amostra de treino, aumentando a variedade de objetos, escalas e contextos de cena que o modelo vê em cada batch — consulta o guia de aumento de dados do YOLO para obteres mais detalhes.

Citações e agradecimentos#

Se utilizares o dataset VOC no teu trabalho de investigação ou desenvolvimento, cita o seguinte artigo:

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

Gostaríamos de reconhecer o PASCAL VOC Consortium por criar e manter este valioso recurso para a comunidade de visão computacional. Para obteres mais informações sobre o dataset VOC e os seus criadores, visita o site do dataset PASCAL VOC.

Perguntas frequentes#