Link to this sectionJeu de données VOC#

Le jeu de données PASCAL VOC (Visual Object Classes) est un jeu de données bien connu pour la détection, la segmentation et la classification d'objets. Il est conçu pour encourager la recherche sur une grande variété de catégories d'objets et est couramment utilisé pour évaluer les modèles de vision par ordinateur. C'est un jeu de données essentiel pour les chercheurs et les développeurs travaillant sur des tâches de détection, de segmentation et de classification d'objets.

Link to this sectionFonctionnalités clés#

• Le jeu de données VOC comprend deux défis principaux : VOC2007 et VOC2012.
• Le jeu de données comprend 20 catégories d'objets, incluant des objets courants comme des voitures, des vélos et des animaux, ainsi que des catégories plus spécifiques comme des bateaux, des canapés et des tables de salle à manger.
• Les annotations incluent des boîtes englobantes (bounding boxes) et des étiquettes de classe pour les tâches de détection et de classification d'objets, ainsi que des masques de segmentation pour les tâches de segmentation.
• VOC fournit des mesures d'évaluation standardisées comme la précision moyenne (mAP) pour la détection et la classification d'objets, ce qui le rend adapté pour comparer les performances des modèles.

Link to this sectionStructure du jeu de données#

Le jeu de données VOC est divisé en trois sous-ensembles :

1. Train : Ce sous-ensemble contient des images pour l'entraînement des modèles de détection, de segmentation et de classification d'objets.
2. Validation : Ce sous-ensemble possède des images utilisées à des fins de validation pendant l'entraînement du modèle.
3. Test : Ce sous-ensemble consiste en des images utilisées pour tester et comparer les modèles entraînés. Les annotations de vérité terrain pour ce sous-ensemble ne sont pas accessibles au public, et les résultats étaient historiquement soumis au serveur d'évaluation PASCAL VOC pour l'évaluation des performances.

Link to this sectionApplications#

Le jeu de données VOC est largement utilisé pour l'entraînement et l'évaluation de modèles d'apprentissage profond en détection d'objets (comme Ultralytics YOLO, Faster R-CNN, et SSD), en segmentation d'instance (comme Mask R-CNN), et en classification d'image. L'ensemble diversifié de catégories d'objets, le grand nombre d'images annotées et les mesures d'évaluation standardisées font de ce jeu de données une ressource essentielle pour les chercheurs et les praticiens en vision par ordinateur.

Link to this sectionYAML du jeu de données#

Un fichier YAML (Yet Another Markup Language) est utilisé pour définir la configuration du jeu de données. Il contient des informations sur les chemins, les classes et d'autres informations pertinentes du jeu de données. Dans le cas du jeu de données VOC, le fichier VOC.yaml est maintenu 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, 5012 images
      f"{ASSETS_URL}/VOCtest_06-Nov-2007.zip",  # 438MB, 4953 images
      f"{ASSETS_URL}/VOCtrainval_11-May-2012.zip",  # 1.95GB, 17126 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
results = model.train(data="VOC.yaml", epochs=100, imgsz=640)

Link to this sectionExemples d'images et annotations#

Le jeu de données VOC contient un ensemble diversifié d'images avec diverses catégories d'objets et des scènes complexes. Voici quelques exemples d'images du jeu de données, accompagnées de leurs annotations correspondantes :

• Image mosaïquée : Cette image montre un lot d'entraînement composé d'images du jeu de données mosaïquées. La mosaïque est une technique utilisée pendant l'entraînement qui combine plusieurs images en une seule pour augmenter la variété des objets et des scènes au sein de chaque lot d'entraînement. Cela aide à améliorer la capacité du modèle à généraliser à différentes tailles d'objets, ratios d'aspect et contextes.

L'exemple présente la variété et la complexité des images dans le jeu de données VOC et les avantages de l'utilisation du mosaïquage pendant le processus d'entraînement.

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 :

@misc{everingham2010pascal,
      title={The PASCAL Visual Object Classes (VOC) Challenge},
      author={Mark Everingham and Luc Van Gool and Christopher K. I. Williams and John Winn and Andrew Zisserman},
      year={2010},
      eprint={0909.5206},
      archivePrefix={arXiv},
      primaryClass={cs.CV}
}

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 sectionQu'est-ce que le jeu de données PASCAL VOC et pourquoi est-il important pour les tâches de vision par ordinateur ?#

Le jeu de données PASCAL VOC (Visual Object Classes) est une référence renommée pour la détection d'objets, la segmentation et la classification en vision par ordinateur. Il inclut des annotations complètes comme des boîtes englobantes, des étiquettes de classe et des masques de segmentation pour 20 catégories d'objets différentes. Les chercheurs l'utilisent largement pour évaluer les performances de modèles comme Faster R-CNN, YOLO et Mask R-CNN en raison de ses mesures d'évaluation standardisées telles que la précision moyenne (mAP).

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

Pour entraîner un modèle YOLO26 avec le jeu de données VOC, tu as besoin de la configuration du jeu de données dans un fichier YAML. Voici un exemple pour commencer l'entraînement d'un modèle YOLO26n 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)

Link to this sectionQuels sont les principaux défis inclus dans le jeu de données VOC ?#

Le jeu de données VOC inclut deux défis principaux : VOC2007 et VOC2012. Ces défis testent la détection, la segmentation et la classification d'objets à travers 20 catégories d'objets diversifiées. Chaque image est minutieusement annotée avec des boîtes englobantes, des étiquettes de classe et des masques de segmentation. Les défis fournissent des mesures standardisées comme la mAP, facilitant la comparaison et l'évaluation comparative de différents modèles de vision par ordinateur.

Link to this sectionComment le jeu de données PASCAL VOC améliore-t-il l'évaluation et la comparaison des modèles ?#

Le jeu de données PASCAL VOC améliore l'évaluation et la comparaison des modèles grâce à ses annotations détaillées et ses mesures standardisées comme la précision moyenne (mAP). Ces mesures sont cruciales pour évaluer les performances des modèles de détection et de classification d'objets. Les images diverses et complexes du jeu de données garantissent une évaluation complète des modèles dans divers scénarios réels.

Link to this sectionComment utiliser le jeu de données VOC pour la segmentation sémantique dans les modèles YOLO ?#

Pour utiliser le jeu de données VOC pour des tâches de segmentation sémantique avec des modèles YOLO, tu dois configurer correctement le jeu de données dans un fichier YAML. Le fichier YAML définit les chemins et les classes nécessaires pour l'entraînement des modèles de segmentation. Vérifie le fichier de configuration YAML du jeu de données VOC sur VOC.yaml pour des configurations détaillées. Pour les tâches de segmentation, tu utiliserais un modèle spécifique à la segmentation comme yolo26n-seg.pt au lieu du modèle de détection.