Conjunto de datos 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

El conjunto de datos PASCAL VOC (clases de objetos visuales (VOC)) es un benchmark clásico de detección de objetos con 20 clases de objetos cotidianos. La configuración de Ultralytics VOC.yaml combina las particiones trainval de VOC2007 y VOC2012 en un conjunto de entrenamiento de 16.551 imágenes, valida con las 4.952 imágenes de prueba de VOC2007 anotadas públicamente y descarga todo automáticamente (2,8 GB) la primera vez que se utiliza.

Los desafíos PASCAL VOC se celebraron de 2005 a 2012 y marcaron la forma de evaluar los modelos de detección de objetos: el benchmark abarca tareas de clasificación de imágenes, detección y segmentación, y popularizó la precisión media (mAP) como métrica estándar de detección. La configuración de Ultralytics VOC.yaml utiliza las anotaciones de detección y convierte los bounding boxes XML originales al formato YOLO durante la descarga.

Características principales#

• 20 clases de objetos cotidianos: persona; seis animales (pájaro, gato, vaca, perro, caballo, oveja); siete vehículos (aeroplano, bicicleta, barco, autobús, coche, motocicleta, tren); y seis objetos de interior (botella, silla, mesa de comedor, planta en maceta, sofá, monitor de TV).
• Dos generaciones de desafíos combinadas: el entrenamiento combina VOC2007 trainval (5.011 imágenes) con VOC2012 trainval (11.540 imágenes).
• Evaluación estandarizada: décadas de benchmarks de VOC publicados lo convierten en un punto de referencia práctico para comparar modelos de detección.
• Listo para YOLO: el script de descarga obtiene los archivos y convierte las anotaciones automáticamente; no hace falta ninguna preparación manual.

Estructura del dataset#

La configuración de Ultralytics VOC.yaml define las siguientes particiones:

Las anotaciones de prueba de VOC2007 se publicaron después del desafío de ese año, lo que permite que esta partición se utilice como conjunto de validación etiquetado. Las anotaciones de prueba de VOC2012 siguen sin publicarse; los resultados solo se pueden puntuar a través del servidor oficial de evaluación de PASCAL, por lo que no forman parte de esta configuración.

Explora VOC en Ultralytics Platform para examinar las imágenes con sus superposiciones de anotaciones, consultar la distribución de clases y los mapas de calor de bounding boxes en la pestaña Charts, y clonarlo para entrenar tu propio modelo en la nube.

Aplicaciones#

PASCAL VOC fue el benchmark principal de la investigación sobre detección de objetos en los años anteriores al conjunto de datos de mayor tamaño COCO: detectores como Faster R-CNN y SSD publicaron sus resultados originales en él, y los modelos de Ultralytics YOLO se entrenan con él directamente. Hoy sigue siendo popular para:

• Comparar nuevas arquitecturas de detección con una extensa trayectoria de benchmarks publicados
• Experimentos rápidos y trabajos académicos: con 16.551 imágenes de entrenamiento, se entrena mucho más rápido que COCO
• Estudios de aprendizaje por transferencia sobre un conjunto compacto y bien conocido de clases cotidianas

YAML del dataset#

El archivo VOC.yaml define la configuración del conjunto de datos: las rutas del conjunto de datos, los 20 nombres de clase y el script automático de descarga y conversión. Se mantiene en el repositorio de Ultralytics, en 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

Uso#

Para entrenar un modelo YOLO26n con el conjunto de datos VOC durante 100 épocas y con un tamaño de imagen de 640, puedes utilizar los siguientes fragmentos de código. Para consultar la lista completa de argumentos disponibles, visita la página de entrenamiento del 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)

Imágenes de ejemplo y anotaciones#

La imagen siguiente muestra un lote de entrenamiento con mosaico del conjunto de datos VOC. El mosaico combina varias imágenes en una única muestra de entrenamiento, lo que aumenta la variedad de objetos, escalas y contextos de escena que el modelo ve en cada lote; consulta la guía de aumento de datos de YOLO para obtener más información.

Citas y agradecimientos#

Si utilizas el conjunto de datos VOC en tu trabajo de investigación o desarrollo, cita el siguiente artículo:

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

Queremos agradecer al Consorcio PASCAL VOC la creación y el mantenimiento de este valioso recurso para la comunidad de visión por computador. Para obtener más información sobre el conjunto de datos VOC y sus creadores, visita el sitio web del conjunto de datos PASCAL VOC.

Preguntas frecuentes#