Link to this sectionConjunto de datos PASCAL VOC#

El conjunto de datos PASCAL VOC (Visual Object Classes) es un referente clásico de detección de objetos con 20 clases de objetos cotidianos. La configuración VOC.yaml de Ultralytics combina las divisiones 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) al usarse por primera vez.

Los desafíos de PASCAL VOC se celebraron desde 2005 hasta 2012 y dieron forma a cómo se evalúan los modelos de detección de objetos: el referente abarca tareas de clasificación, detección y segmentación de imágenes, y popularizó la precisión media promedio (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.

Link to this sectionCaracterí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.

Link to this sectionEstructura 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 la Plataforma Ultralytics para navegar por 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.

Link to this sectionAplicaciones#

PASCAL VOC fue el referente principal para la investigación en detección de objetos en los años anteriores al conjunto de datos COCO más grande: detectores como Faster R-CNN y SSD reportaron sus resultados originales en él, y los modelos Ultralytics YOLO se entrenan con él de forma inmediata. 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 conocido de clases cotidianas

Link to this sectionYAML del dataset#

El archivo VOC.yaml define la configuración del conjunto de datos: las rutas del conjunto de 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 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 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)

Link to this sectionMuestras de imágenes y anotaciones#

La imagen a continuación 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 más detalles.

Link to this sectionCitas 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}}

Nos gustaría 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.

Link to this sectionFAQ#

Link to this section¿Para qué se utiliza el conjunto de datos PASCAL VOC?#

PASCAL VOC se utiliza para entrenar y comparar modelos de detección de objetos en 20 clases de objetos cotidianos como persona, coche, perro y silla. Debido a que es compacto, está totalmente etiquetado y cuenta con años de referencias publicadas, es una opción común para validar nuevas arquitecturas, realizar experimentos de cursos y realizar estudios rápidos de aprendizaje por transferencia.

Link to this section¿Cuántas imágenes hay en el conjunto de datos PASCAL VOC?#

La configuración VOC de Ultralytics contiene 21.503 imágenes: 16.551 para entrenamiento (VOC2007 trainval + VOC2012 trainval) y 4.952 para validación (el conjunto de prueba VOC2007). Todas las divisiones comparten las mismas 20 clases. Consulta Estructura del conjunto de datos para ver el desglose completo.

Link to this section¿Cómo descargo el conjunto de datos PASCAL VOC?#

VOC se descarga automáticamente la primera vez que entrenas con data="VOC.yaml": no se requieren pasos manuales. El script obtiene tres archivos (2,8 GB) de los activos de lanzamiento de GitHub de Ultralytics y convierte las anotaciones XML al formato YOLO.

Link to this section¿Cómo entreno un modelo YOLO26 en el conjunto de datos VOC?#

Entrena un modelo YOLO26n en VOC durante 100 épocas con un tamaño de imagen de 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 configuraciones detalladas, consulta la página de Entrenamiento y los consejos para el entrenamiento de modelos.

Link to this section¿Cuál es la diferencia entre VOC2007 y VOC2012?#

Ambos desafíos comparten las mismas 20 clases pero aportan imágenes diferentes. VOC2007 proporciona 5.011 imágenes de trainval más un conjunto de prueba de 4.952 imágenes cuyas anotaciones son públicas; VOC2012 proporciona 11.540 imágenes de trainval, mientras que sus anotaciones de prueba están ocultas y solo se puntúan a través del servidor de evaluación oficial. El VOC.yaml de Ultralytics fusiona ambos conjuntos de trainval para el entrenamiento y valida con la prueba VOC2007.

Link to this section¿Cómo se compara PASCAL VOC con el conjunto de datos COCO?#

VOC es más pequeño y sencillo: 20 clases y 21.503 imágenes frente a las 80 clases y 330.000 imágenes de COCO. Los resultados de VOC se reportan tradicionalmente como mAP a 0,5 IoU, mientras que COCO promedia el mAP sobre los umbrales de IoU de 0,5 a 0,95. VOC se entrena mucho más rápido y es adecuado para experimentos rápidos; el conjunto de datos COCO es el estándar para evaluaciones a escala de producción.

Link to this section¿Puedo entrenar modelos de segmentación con VOC.yaml?#

No: VOC.yaml es una configuración solo para detección: su convertidor extrae las cajas delimitadoras de las anotaciones XML de VOC, y las máscaras de segmentación incluidas en el referente original no se convierten. Para entrenar un modelo de segmentación de instancias, utiliza un conjunto de datos con etiquetas de polígono como COCO-Seg con un modelo yolo26n-seg.pt.