Conjunto de datos PASCAL VOC#

21,500

VOC

ultralytics

publicDetect

The PASCAL VOC (Visual Object Classes) dataset is a well-known object detection dataset designed to encourage research on a wide variety of object categories and is commonly used for benchmarking computer vision models.

720 classes1.4 GBApr 28, 2026

aeroplanebicyclebirdboat+16

El conjunto de datos PASCAL VOC (Visual Object Classes) es una referencia clásica de detección de objetos con 20 clases de objetos cotidianos. La configuración VOC.yaml de Ultralytics combina los conjuntos de entrenamiento y validación (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) en el primer uso.

Los desafíos PASCAL VOC se celebraron entre 2005 y 2012 y moldearon la forma en que se evalúan los modelos de detección de objetos: la referencia abarca tareas de clasificación de imágenes, detección y segmentación, y popularizó la precisión media media (mAP) como la métrica de detección estándar. La configuración VOC.yaml de Ultralytics utiliza las anotaciones de detección, convirtiendo las cajas delimitadoras XML originales al formato YOLO durante la descarga.

Características clave#

• 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, 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 fusiona VOC2007 trainval (5.011 imágenes) con VOC2012 trainval (11.540 imágenes).
• Evaluación estandarizada: décadas de referencias VOC publicadas lo convierten en un punto de referencia conveniente para comparar modelos de detección.
• Preparado para YOLO: el script de descarga obtiene los archivos y convierte las anotaciones automáticamente; sin preparación manual.

Estructura del dataset#

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

Las anotaciones de la prueba VOC2007 se publicaron después del desafío de ese año, lo que permite que esta división sirva como un conjunto de validación etiquetado. Las anotaciones de la prueba VOC2012 permanecen ocultas (los resultados solo se pueden puntuar a través del servidor de evaluación oficial 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, ver la distribución de clases y los mapas de calor de las cajas delimitadoras en la pestaña Charts, y clónalo para entrenar tu propio modelo en la nube.

Aplicaciones#

PASCAL VOC fue la referencia principal para la investigación en detección de objetos en los años anteriores al conjunto de datos COCO, que es más grande: detectores como Faster R-CNN y SSD publicaron sus resultados originales en él, y los modelos de Ultralytics YOLO se entrenan en él de forma nativa. Hoy en día sigue siendo popular para:

• Comparar nuevas arquitecturas de detección con un largo historial de referencias publicadas
• Experimentos rápidos y cursos: con 16.551 imágenes de entrenamiento se entrena mucho más rápido que con COCO
• Estudios de aprendizaje por transferencia en un conjunto compacto y bien comprendido de clases cotidianas

YAML del dataset#

El archivo VOC.yaml define la configuración del conjunto de datos: las rutas de los datos, los nombres de las 20 clases 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 en el conjunto de datos VOC durante 100 épocas con un tamaño de imagen de 640, puedes usar los siguientes fragmentos de código. Para obtener una lista completa de los argumentos disponibles, consulta 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)

Muestras de imágenes y anotaciones#

La imagen siguiente muestra un lote de entrenamiento en mosaico del conjunto de datos VOC. El mosaico combina varias imágenes en una sola 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 detalles.

Citas y agradecimientos#

Si utilizas el conjunto de datos VOC en tu trabajo de investigación o desarrollo, por favor 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 por crear y mantener 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.

FAQ#