Link to this sectionConjunto de dados PASCAL VOC#

O conjunto de dados PASCAL VOC (Visual Object Classes) é um benchmark clássico de detecção de objetos com 20 classes de objetos do cotidiano. A configuração VOC.yaml da Ultralytics combina os splits de treino/validação do VOC2007 e VOC2012 em um conjunto de treinamento de 16.551 imagens, valida nas 4.952 imagens de teste do VOC2007 anotadas publicamente e baixa tudo automaticamente (2,8 GB) no primeiro uso.

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

Link to this sectionPrincipais recursos#

• 20 classes de objetos do cotidiano: pessoa; seis animais (pássaro, gato, vaca, cachorro, cavalo, ovelha); sete veículos (avião, bicicleta, barco, ônibus, carro, moto, trem); e seis objetos internos (garrafa, cadeira, mesa de jantar, planta em vaso, sofá, monitor de TV).
• Duas gerações de desafios combinadas: o treinamento mescla o trainval do VOC2007 (5.011 imagens) com o trainval do VOC2012 (11.540 imagens).
• Avaliação padronizada: décadas de baselines do VOC publicados tornam-no um ponto de referência conveniente para comparar modelos de detecção.
• Pronto para YOLO: o script de download busca os arquivos e converte as anotações automaticamente — sem preparação manual.

Link to this sectionEstrutura do Dataset#

A configuração VOC.yaml da Ultralytics define os seguintes splits:

As anotações de teste do VOC2007 foram lançadas publicamente após o desafio daquele ano, o que permite que este split sirva como um conjunto de validação rotulado. As anotações de teste do VOC2012 permanecem retidas — os resultados nelas só podem ser pontuados através do servidor oficial de avaliação PASCAL — portanto, não fazem parte desta configuração.

Explore o VOC na Plataforma Ultralytics para navegar pelas imagens com suas sobreposições de anotação, visualize a distribuição de classes e mapas de calor de caixas delimitadoras na aba Charts e clone o conjunto para treinar seu próprio modelo na nuvem.

Link to this sectionAplicações#

O PASCAL VOC foi o principal benchmark para pesquisa em detecção de objetos nos anos anteriores ao maior conjunto de dados COCO: detectores como Faster R-CNN e SSD reportaram seus resultados originais nele, e os modelos Ultralytics YOLO treinam nele nativamente. Hoje, ele permanece popular para:

• Comparar novas arquiteturas de detecção com um longo histórico de baselines publicados
• Experimentos rápidos e trabalhos acadêmicos — com 16.551 imagens de treinamento, ele treina muito mais rápido que o COCO
• Estudos de Transfer learning em um conjunto compacto e bem compreendido de classes do cotidiano

Link to this sectionYAML do Dataset#

O arquivo VOC.yaml define a configuração do conjunto de dados — os caminhos do dataset, os nomes das 20 classes e o script automático de download e conversão. Ele é 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 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 sectionUso#

Para treinar um modelo YOLO26n no conjunto de dados VOC por 100 épocas com um tamanho de imagem de 640, podes usar os seguintes trechos de código. Para obter uma lista abrangente de argumentos disponíveis, consulta a página de Treinamento 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)

Link to this sectionExemplos de Imagens e Anotações#

A imagem abaixo mostra um lote de treinamento em mosaico do conjunto de dados VOC. O mosaico combina várias imagens em uma única amostra de treinamento, aumentando a variedade de objetos, escalas e contextos de cena que o modelo vê em cada lote — consulte o guia de aumento de dados YOLO para detalhes.

Link to this sectionCitações e Agradecimentos#

Se usares o conjunto de dados VOC no teu trabalho de pesquisa ou desenvolvimento, por favor 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 agradecer ao PASCAL VOC Consortium por criar e manter este recurso valioso para a comunidade de visão computacional. Para mais informações sobre o conjunto de dados VOC e seus criadores, visita o site do conjunto de dados PASCAL VOC.

Link to this sectionFAQ#

Link to this sectionPara que serve o conjunto de dados PASCAL VOC?#

O PASCAL VOC é usado para treinar e avaliar modelos de detecção de objetos em 20 classes do cotidiano, como pessoa, carro, cachorro e cadeira. Por ser compacto, totalmente rotulado e apoiado por anos de baselines publicados, é uma escolha comum para validar novas arquiteturas, executar experimentos acadêmicos e estudos rápidos de transfer learning.

Link to this sectionQuantas imagens existem no conjunto de dados PASCAL VOC?#

A configuração VOC da Ultralytics contém 21.503 imagens: 16.551 para treinamento (VOC2007 trainval + VOC2012 trainval) e 4.952 para validação (o conjunto de teste VOC2007). Todos os splits compartilham as mesmas 20 classes. Veja Estrutura do Conjunto de Dados para o detalhamento completo.

Link to this sectionComo faço o download do conjunto de dados PASCAL VOC?#

O VOC baixa automaticamente na primeira vez que você treina com data="VOC.yaml" — nenhuma etapa manual é necessária. O script busca três arquivos (2,8 GB) dos ativos de lançamento do GitHub da Ultralytics e converte as anotações XML para o formato YOLO.

Link to this sectionComo treino um modelo YOLO26 no conjunto de dados VOC?#

Treine um modelo YOLO26n no VOC por 100 épocas com tamanho de imagem 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)

Para configurações detalhadas, consulte a página de Treinamento e as dicas de treinamento de modelos.

Link to this sectionQual é a diferença entre VOC2007 e VOC2012?#

Ambos os desafios compartilham as mesmas 20 classes, mas contribuem com imagens diferentes. O VOC2007 fornece 5.011 imagens de trainval mais um conjunto de teste de 4.952 imagens cujas anotações são públicas; o VOC2012 fornece 11.540 imagens de trainval, enquanto suas anotações de teste são retidas e pontuadas apenas pelo servidor oficial de avaliação. O VOC.yaml da Ultralytics mescla ambos os conjuntos de trainval para treinamento e valida no teste do VOC2007.

Link to this sectionComo o PASCAL VOC se compara ao conjunto de dados COCO?#

O VOC é menor e mais simples: 20 classes e 21.503 imagens contra as 80 classes e 330 mil imagens do COCO. Os resultados do VOC são tradicionalmente reportados como mAP a 0,5 IoU, enquanto o COCO faz a média do mAP sobre limiares de IoU de 0,5 a 0,95. O VOC treina muito mais rápido e é adequado para experimentos rápidos; o conjunto de dados COCO é o padrão para benchmarking em escala de produção.

Link to this sectionPosso treinar modelos de segmentação com VOC.yaml?#

Não — VOC.yaml é uma configuração apenas para detecção: seu conversor extrai caixas delimitadoras das anotações XML do VOC, e as máscaras de segmentação incluídas no benchmark original não são convertidas. Para treinar um modelo de segmentação de instâncias, use um conjunto de dados com rótulos de polígono, como o COCO-Seg, com um modelo yolo26n-seg.pt.