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.

1020 classes1.4 GBSep 2, 2026

aeroplanebicyclebirdboat+16

El conjunto de datos PASCAL VOC (clases de objetos visuales) es un benchmark clásico de detección de objetos con 20 clases de objetos cotidianos. La configuración VOC.yaml de Ultralytics 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 con anotaciones públicas y descarga todo automáticamente (2,8 GB) en el primer uso.

Los retos PASCAL VOC se celebraron entre 2005 y 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 promedio (mAP) como métrica estándar de detección. La configuración VOC.yaml de Ultralytics utiliza las anotaciones de detección y convierte las cajas delimitadoras 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 (avión, bicicleta, barco, autobús, coche, moto, tren); y seis objetos de interior (botella, silla, mesa de comedor, planta en maceta, sofá, televisor).
• Combinación de dos generaciones del reto: el entrenamiento combina trainval de VOC2007 (5.011 imágenes) con trainval de VOC2012 (11.540 imágenes).
• Evaluación estandarizada: las décadas de resultados publicados con VOC lo convierten en una referencia práctica para comparar modelos de detección.
• Listo para YOLO: el script de descarga obtiene los archivos comprimidos y convierte las anotaciones automáticamente; no hace falta prepararlo manualmente.

Estructura del conjunto de datos#

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

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

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

Aplicaciones#

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

• Comparar nuevas arquitecturas de detección con un amplio historial de resultados publicados
• Realizar experimentos rápidos y trabajos de curso: con 16.551 imágenes de entrenamiento, el entrenamiento es mucho más rápido que con COCO
• Estudios de aprendizaje por transferencia con un conjunto compacto y bien conocido de clases cotidianas

YAML del conjunto de datos#

El archivo VOC.yaml define la configuración del conjunto de datos: las rutas, los 20 nombres de clase y el script de descarga y conversión automáticas. 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 usar los siguientes fragmentos de código. Para consultar una lista completa de los argumentos disponibles, visita la página de entrenamiento del modelo.

from ultralytics import YOLO

# Cargar un modelo
model = YOLO("yolo26n.pt")  # Carga un modelo preentrenado (recomendado para el entrenamiento)

# Entrena el modelo: el conjunto de datos se descargará automáticamente en la primera ejecución
results = model.train(data="VOC.yaml", epochs=100, imgsz=640)

Imágenes de muestra y anotaciones#

La imagen siguiente muestra un lote de entrenamiento con mosaicos del conjunto de datos VOC. La creación de mosaicos combina varias imágenes en una única muestra de entrenamiento, lo que aumenta la variedad de objetos, escalas y contextos de escena que ve el modelo 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 artificial. 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#