Link to this sectionJeu de données PASCAL VOC#

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

Les défis PASCAL VOC ont eu lieu de 2005 à 2012 et ont façonné la manière dont les modèles de détection d'objets sont évalués : 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 de détection standard. La configuration VOC.yaml d'Ultralytics utilise les annotations de détection, en convertissant les boîtes englobantes XML originales au format YOLO lors du téléchargement.

Link to this sectionFonctionnalité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.

Link to this sectionStructure du jeu de données#

La configuration VOC.yaml d'Ultralytics 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, visualiser la répartition des classes et les cartes thermiques des boîtes englobantes dans l'onglet Graphiques, et clone-le pour entraîner ton propre modèle dans le cloud.

Link to this sectionApplications#

PASCAL VOC était le benchmark principal pour la recherche en détection d'objets dans les années précédant le jeu de données COCO, plus vaste : des détecteurs tels que Faster R-CNN et SSD ont rapporté leurs résultats originaux sur celui-ci, et les modèles Ultralytics YOLO s'y entraînent nativement. 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 de transfer learning sur un ensemble compact et bien compris de classes du quotidien

Link to this sectionYAML du jeu de données#

Le fichier VOC.yaml définit la configuration du jeu de données — les chemins vers les données, les 20 noms de classes et le script automatique de téléchargement et de conversion. Il est maintenu dans le dépôt Ultralytics sur 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 sectionUtilisation#

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 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)

Link to this sectionExemples 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, augmentant ainsi 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 de données YOLO pour plus de détails.

Link to this sectionCitations 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 Consortium PASCAL VOC pour la création et la maintenance de cette ressource précieuse pour la communauté de la 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.

Link to this sectionFAQ#

Link to this sectionÀ quoi sert le jeu de données PASCAL VOC ?#

PASCAL VOC est utilisé pour entraîner et évaluer des modèles de détection d'objets sur 20 classes d'objets du quotidien tels que des personnes, des voitures, des chiens et des chaises. Parce qu'il est compact, entièrement étiqueté et soutenu par des années de références publiées, c'est un choix courant pour valider de nouvelles architectures, réaliser des expériences de cours et effectuer des études rapides de transfer learning.

Link to this sectionCombien d'images contient le jeu de données PASCAL VOC ?#

La configuration VOC d'Ultralytics contient 21 503 images : 16 551 pour l'entraînement (VOC2007 trainval + VOC2012 trainval) et 4 952 pour la validation (le jeu de test VOC2007). Toutes les divisions partagent les mêmes 20 classes. Voir Structure du jeu de données pour la ventilation complète.

Link to this sectionComment télécharger le jeu de données PASCAL VOC ?#

VOC se télécharge automatiquement la première fois que tu lances un entraînement avec data="VOC.yaml" — aucune étape manuelle n'est nécessaire. Le script récupère trois archives (2,8 Go) depuis les assets des releases GitHub d'Ultralytics et convertit les annotations XML au format YOLO.

Link to this sectionComment entraîner un modèle YOLO26 sur le jeu de données VOC ?#

Entraîne un modèle YOLO26n sur VOC pendant 100 époques avec une taille d'image 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)

Pour des configurations détaillées, consulte la page Entraînement et les conseils pour l'entraînement des modèles.

Link to this sectionQuelle est la différence entre VOC2007 et VOC2012 ?#

Les deux défis partagent les mêmes 20 classes mais apportent des images différentes. VOC2007 fournit 5 011 images d'entraînement et de validation ainsi qu'un jeu de test de 4 952 images dont les annotations sont publiques ; VOC2012 fournit 11 540 images d'entraînement et de validation, tandis que ses annotations de test restent confidentielles et ne sont notées que par le serveur d'évaluation officiel. Le VOC.yaml d'Ultralytics fusionne les deux ensembles d'entraînement et de validation pour l'entraînement et valide sur le test VOC2007.

Link to this sectionComment PASCAL VOC se compare-t-il au jeu de données COCO ?#

VOC est plus petit et plus simple : 20 classes et 21 503 images contre 80 classes et 330 000 images pour COCO. Les résultats VOC sont traditionnellement rapportés en mAP à 0,5 IoU, tandis que COCO calcule la moyenne de la mAP sur des seuils d'IoU allant de 0,5 à 0,95. VOC s'entraîne beaucoup plus rapidement et convient aux expériences rapides ; le jeu de données COCO est la norme pour l'évaluation à l'échelle de la production.

Link to this sectionPuis-je entraîner des modèles de segmentation avec VOC.yaml ?#

Non — VOC.yaml est une configuration dédiée uniquement à la détection : son convertisseur extrait les boîtes englobantes des annotations XML de VOC, et les masques de segmentation inclus dans le benchmark original ne sont pas convertis. Pour entraîner un modèle de segmentation d'instances, utilise un jeu de données avec des étiquettes polygonales comme COCO-Seg avec un modèle yolo26n-seg.pt.