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

Le jeu de données PASCAL VOC (Visual Object Classes) est un banc d'essai classique de détection d'objets comprenant 20 classes d'objets du quotidien. La configuration Ultralytics VOC.yaml combine les ensembles trainval de VOC2007 et VOC2012 pour former un ensemble d'entraînement de 16 551 images, valide sur les 4 952 images de test VOC2007 annotées publiquement, et télécharge tout automatiquement (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 banc d'essai englobe des tâches de classification d'images, de détection et de segmentation, et a popularisé la précision moyenne moyenne (mAP) comme mesure de détection standard. La configuration Ultralytics VOC.yaml utilise les annotations de détection, en convertissant les boîtes englobantes 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 de salle à manger, plante en pot, canapé, moniteur TV).
• Combinaison de deux générations de défis : l'entraînement fusionne les jeux d'entraînement et de validation VOC2007 (5 011 images) avec ceux de VOC2012 (11 540 images).
• Évaluation standardisée : des décennies de références VOC publiées en font un point de comparaison pratique pour comparer les modèles de détection.
• Prêt pour YOLO : le script de téléchargement récupère les archives et convertit les annotations automatiquement — aucune préparation manuelle requise.

Structure du jeu de données#

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

Les annotations de test VOC2007 ont été publiées après le défi de cette année-là, ce qui permet à ce découpage de servir de jeu de validation étiqueté. Les annotations de test VOC2012 restent confidentielles — les résultats sur ces dernières ne peuvent être évalués que via le serveur d'évaluation officiel PASCAL — elles 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 distribution des classes et les cartes thermiques des boîtes englobantes dans l'onglet Graphiques, et le cloner pour entraîner ton propre modèle dans le cloud.

Applications#

PASCAL VOC a été le principal banc d'essai pour la recherche en détection d'objets dans les années précédant le jeu de données COCO (plus grand) : des détecteurs tels que Faster R-CNN et SSD y ont publié leurs résultats initiaux, et les modèles Ultralytics YOLO s'entraînent dessus clés en main. Aujourd'hui, il reste populaire pour :

• Comparer de nouvelles architectures de détection par rapport à un long historique de références publiées
• Les expériences rapides et les cours — avec 16 551 images d'entraînement, il s'entraîne beaucoup plus rapidement que COCO
• Les études d'apprentissage par transfert sur un ensemble compact et bien maîtrisé 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 jeux de données, les 20 noms de classes et le script de téléchargement et de conversion automatique. 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 une liste exhaustive des arguments disponibles, réfère-toi à 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 annotations#

L'image ci-dessous montre un lot d'entraînement en mosaïque issu 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 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, merci de citer 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 PASCAL VOC Consortium pour la création et la maintenance de cette ressource précieuse pour la communauté de vision par ordinateur. Pour plus d'informations sur le jeu de données VOC et ses créateurs, visite le site Web du jeu de données PASCAL VOC.

FAQ#