Jeu de données VOC

Le jeu de données PASCAL VOC (Visual Object Classes) est un jeu de données reconnu pour la détection d'objets, la segmentation et la classification. Il est conçu pour encourager la recherche sur une grande variété de catégories d'objets et est couramment utilisé pour l'évaluation comparative de 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.

Fonctionnalités clés

• Le jeu de données VOC inclut 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 à manger.
• Les annotations incluent des boîtes englobantes d'objets 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 métriques d'évaluation standardisées comme la mean Average Precision (mAP) pour la détection et la classification d'objets, ce qui le rend adapté pour comparer les performances des modèles.

Structure 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 d'objets, de segmentation et de classification.
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 évaluer 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.

Applications

Le jeu de données VOC est largement utilisé pour l'entraînement et l'évaluation de modèles de deep learning en détection d'objets (comme Ultralytics YOLO, Faster R-CNN et SSD), en instance segmentation (comme Mask R-CNN) et en image classification. La diversité des catégories d'objets du jeu de données, le grand nombre d'images annotées et les métriques d'évaluation standardisées en font une ressource essentielle pour les chercheurs et praticiens en computer vision.

YAML 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 du jeu de données, les classes et d'autres informations pertinentes. Dans le cas du jeu de données VOC, le fichier VOC.yaml est maintenu à 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

Utilisation

Pour entraîner un modèle YOLO26n sur le jeu de données VOC pendant 100 epochs avec une taille d'image de 640, tu peux utiliser les extraits de code suivants. Pour une liste exhaustive des arguments disponibles, consulte la page Training 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)

Exemples d'images et d'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 provenant du jeu de données, accompagnées de leurs annotations correspondantes :

• Image en mosaïque : Cette image démontre un lot d'entraînement composé d'images du jeu de données en mosaïque. La mosaïque est une technique utilisée pendant l'entraînement qui combine plusieurs images en une seule image 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 met en valeur la variété et la complexité des images dans le jeu de données VOC ainsi que les avantages de l'utilisation de la mosaïque pendant le processus d'entraînement.

Citations et remerciements

Si tu utilises le jeu de données VOC dans tes travaux de recherche ou de développement, merci de citer le papier 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 souhaitons remercier le PASCAL VOC Consortium pour la création et la maintenance de cette ressource précieuse pour la communauté de la computer vision. 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

Qu'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 un benchmark renommé pour la object detection, 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 métriques d'évaluation standardisées telles que la mean Average Precision (mAP).

Comment puis-je 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 epochs 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)

Quels sont les défis principaux 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 d'objets, la segmentation et la classification à travers 20 catégories d'objets diverses. Chaque image est méticuleusement annotée avec des boîtes englobantes, des étiquettes de classe et des masques de segmentation. Les défis fournissent des métriques standardisées comme la mAP, facilitant la comparaison et l'évaluation comparative de différents modèles de vision par ordinateur.

Comment le jeu de données PASCAL VOC améliore-t-il l'évaluation comparative des modèles ?

Le jeu de données PASCAL VOC améliore l'évaluation comparative des modèles grâce à ses annotations détaillées et ses métriques standardisées comme la mean Average Precision (mAP). Ces métriques sont cruciales pour évaluer la performance des modèles de détection et de classification d'objets. Les images diverses et complexes du jeu de données assurent une évaluation complète des modèles à travers divers scénarios réels.

Comment utiliser le jeu de données VOC pour la semantic segmentation dans les modèles YOLO ?

Pour utiliser le jeu de données VOC pour des tâches de segmentation sémantique avec les 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 à l'entraînement des modèles de segmentation. Consulte 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.