Jeu de données 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

Le jeu de données PASCAL VOC (classes d’objets visuels) est un benchmark classique de détection d’objets comprenant 20 classes d’objets du quotidien. La configuration VOC.yaml d’Ultralytics regroupe les partitions trainval de VOC2007 et VOC2012 pour former un ensemble d’entraînement de 16,551 images, effectue la validation sur les 4,952 images de test VOC2007 annotées publiquement et télécharge automatiquement l’ensemble des données (2,8 Go) lors de la première utilisation.

Les défis PASCAL VOC se sont déroulés de 2005 à 2012 et ont façonné les méthodes d’évaluation des modèles de détection d’objets : le benchmark couvre des tâches de classification d’images, de détection et de segmentation, et a popularisé la précision moyenne (mAP) comme métrique standard de détection. La configuration VOC.yaml d’Ultralytics utilise les annotations de détection et convertit les boîtes englobantes XML d’origine au format YOLO pendant le téléchargement.

Fonctionnalités clés#

• 20 classes d’objets du quotidien : personne ; six animaux (bird, cat, cow, dog, horse, sheep) ; sept véhicules (aeroplane, bicycle, boat, bus, car, motorbike, train) ; et six objets d’intérieur (bottle, chair, diningtable, pottedplant, sofa, tvmonitor).
• Deux générations de défis réunies : l’entraînement regroupe la partition trainval de VOC2007 (5,011 images) et celle de VOC2012 (11,540 images).
• Évaluation standardisée : des décennies de résultats de référence publiés sur VOC en font un point de comparaison pratique pour évaluer les modèles de détection.
• Prêt pour YOLO : le script de téléchargement récupère les archives et convertit automatiquement les annotations — aucune préparation manuelle n’est nécessaire.

Structure du jeu de données#

La configuration VOC.yaml d’Ultralytics définit les partitions suivantes :

Les annotations du test VOC2007 ont été rendues publiques après le défi de cette année-là, ce qui permet d’utiliser cette partition comme ensemble de validation annoté. Les annotations du test VOC2012 restent confidentielles — les résultats ne peuvent être évalués que via le serveur d’évaluation officiel PASCAL — et ne font donc pas partie de cette configuration.

Explore VOC sur Ultralytics Platform pour parcourir les images avec leurs superpositions d’annotations, consulter la répartition des classes et les cartes thermiques des boîtes englobantes dans l’onglet Charts, puis en créer un clone pour entraîner ton propre modèle dans le cloud.

Applications#

PASCAL VOC a été le benchmark principal de la recherche sur la détection d’objets avant l’apparition du jeu de données COCO, plus vaste : des détecteurs comme Faster R-CNN et SSD y ont publié leurs premiers résultats, et les modèles Ultralytics YOLO peuvent être entraînés dessus directement. Aujourd’hui, il reste populaire pour :

• Comparer de nouvelles architectures de détection à un vaste historique de résultats de référence publiés
• Réaliser rapidement des expériences et des travaux pratiques — avec 16,551 images d’entraînement, l’entraînement est bien plus rapide que sur COCO
• Étudier l’apprentissage par transfert sur un ensemble compact et bien connu de classes d’objets du quotidien

Fichier YAML du jeu de données#

Le fichier VOC.yaml définit la configuration du jeu de données — les chemins d’accès, les noms des 20 classes et le script de téléchargement et de conversion automatiques. Il est maintenu dans le dépôt Ultralytics à 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

Utilisation#

Pour entraîner un modèle YOLO26n sur le jeu de données VOC pendant 100 époques avec une taille d’image de 640, tu peux utiliser les extraits de code suivants. Pour consulter la liste complète des arguments disponibles, reporte-toi à la page Entraînement du modèle.

from ultralytics import YOLO

# Charger un modèle
model = YOLO("yolo26n.pt")  # charger un modèle préentraîné (recommandé pour l’entraînement)

# Entraîner le modèle - le jeu de données se télécharge automatiquement à la première exécution
results = model.train(data="VOC.yaml", epochs=100, imgsz=640)

Exemples d’images et annotations#

L’image ci-dessous montre un lot d’entraînement mosaïqué provenant du jeu de données VOC. La mosaïque combine plusieurs images en un seul échantillon d’entraînement, ce qui augmente la variété des objets, des échelles et des contextes de scène que le modèle voit dans chaque lot — consulte le guide d’augmentation des données YOLO pour en savoir plus.

Citations et remerciements#

Si tu utilises le jeu de données VOC dans tes travaux de recherche ou de développement, cite l’article suivant :

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

Nous tenons à remercier le Consortium PASCAL VOC d’avoir créé et maintenu cette précieuse ressource pour la communauté de la vision par ordinateur. Pour en savoir plus sur le jeu de données VOC et ses créateurs, consulte le site Web du jeu de données PASCAL VOC.

FAQ#