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.

820 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 Ultralytics VOC.yaml combine les partitions trainval de VOC2007 et VOC2012 en 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é l’évaluation des modèles de détection d’objets : le benchmark couvre les 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 Ultralytics VOC.yaml utilise les annotations de détection et convertit les BBox XML d’origine au format YOLO lors du téléchargement.

Fonctionnalités clés#

• 20 classes d’objets du quotidien : personne ; six animaux (oiseau, chat, vache, chien, cheval, mouton) ; sept véhicules (avion, vélo, bateau, bus, voiture, moto, train) ; et six objets d’intérieur (bouteille, chaise, table à manger, plante en pot, canapé, téléviseur).
• Deux générations de défis combinées : l’entraînement fusionne VOC2007 trainval (5 011 images) et VOC2012 trainval (11 540 images).
• Évaluation standardisée : des décennies de résultats VOC publiés en font un point de référence pratique pour comparer les modèles de détection.
• Compatible avec YOLO : le script de téléchargement récupère les archives et convertit automatiquement les annotations — aucune préparation manuelle.

Structure du jeu de données#

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

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

Explore VOC sur la plateforme Ultralytics pour parcourir les images avec leurs superpositions d’annotations, consulter la répartition des classes et les cartes de chaleur des BBox dans l’onglet Charts, puis le cloner afin d’entraîner ton propre modèle dans le cloud.

Applications#

PASCAL VOC a été le benchmark principal de la recherche en détection d’objets avant l’arrivée du plus grand jeu de données COCO : des détecteurs tels que 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 long historique de résultats de référence publiés
• Les expérimentations rapides et les travaux pratiques — avec 16 551 images d’entraînement, il s’entraîne bien plus vite que COCO
• Les études d’apprentissage par transfert sur un ensemble compact et bien compris de classes du quotidien

YAML du jeu de données#

Le fichier VOC.yaml définit la configuration du jeu de données — les chemins des données, les 20 noms de classes et le script de téléchargement et de conversion automatiques. Il est maintenu dans le dépôt Ultralytics à l’adresse 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 obtenir la liste complète des arguments disponibles, consulte la page Entraînement du modèle.

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)

Exemples d’images et d’annotations#

L’image ci-dessous montre un lot d’entraînement mosaïqué 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 vus par le modèle dans chaque lot — consulte le guide d’augmentation des données YOLO pour plus de détails.

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 souhaitons remercier le consortium PASCAL VOC pour avoir créé et maintenu cette ressource précieuse destinée à la communauté de la vision par ordinateur. Pour plus d’informations sur le jeu de données VOC et ses créateurs, consulte le site web du jeu de données PASCAL VOC.

FAQ#