VOC-Datensatz

Der PASCAL VOC-Datensatz (Visual Object Classes) ist ein bekannter Datensatz für Objekterkennung, Segmentierung und Klassifizierung. Er soll die Forschung an einer Vielzahl von Objektkategorien fördern und wird häufig für das Benchmarking von Computer-Vision-Modellen verwendet. Er ist ein unverzichtbarer Datensatz für Forscher und Entwickler, die an Aufgaben der Objekterkennung, Segmentierung und Klassifizierung arbeiten.

Hauptmerkmale

• Der VOC-Datensatz umfasst zwei Hauptaufgaben: VOC2007 und VOC2012.
• Der Datensatz umfasst 20 Objektkategorien, darunter gängige Objekte wie Autos, Fahrräder und Tiere, sowie spezifischere Kategorien wie Boote, Sofas und Esstische.
• Annotationen umfassen Objektbegrenzungsrahmen und Klassenbezeichnungen für Objekterkennungs- und Klassifizierungsaufgaben sowie Segmentierungsmasken für die Segmentierungsaufgaben.
• VOC bietet standardisierte Evaluierungsmetriken wie Mean Average Precision (mAP) für Objekterkennung und -klassifizierung, wodurch es sich für den Vergleich der Modellleistung eignet.

Dataset-Struktur

Der VOC-Datensatz ist in drei Untergruppen unterteilt:

1. Train: Diese Teilmenge enthält Bilder für das Training von Objekterkennung, Segmentierung und Klassifizierungsmodellen.
2. Validierung: Diese Teilmenge enthält Bilder, die für Validierungszwecke während des Modelltrainings verwendet werden.
3. Test: Diese Teilmenge besteht aus Bildern, die zum Testen und Benchmarking der trainierten Modelle verwendet werden. Ground-Truth-Annotationen für diese Teilmenge sind nicht öffentlich verfügbar, und die Ergebnisse werden zur Leistungsbewertung an den PASCAL VOC-Evaluierungsserver übermittelt.

Anwendungen

Der VOC-Datensatz wird häufig für das Training und die Evaluierung von Deep-Learning-Modellen in der Objektdetektion (wie Ultralytics YOLO, Faster R-CNN und SSD), Instanzsegmentierung (wie Mask R-CNN) und Bildklassifizierung verwendet. Die vielfältigen Objektkategorien des Datensatzes, die große Anzahl annotierter Bilder und die standardisierten Evaluierungsmetriken machen ihn zu einer unverzichtbaren Ressource für Computer Vision-Forscher und -Praktiker.

Datensatz-YAML

Eine YAML-Datei (Yet Another Markup Language) wird verwendet, um die Konfiguration des Datensatzes zu definieren. Sie enthält Informationen über die Pfade, Klassen und andere relevante Informationen des Datensatzes. Im Fall des VOC-Datensatzes ist die VOC.yaml Datei wird verwaltet unter 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: # 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 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

      in_file = open(path / f"VOC{year}/Annotations/{image_id}.xml")
      out_file = open(lb_path, "w")
      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
  url = "https://github.com/ultralytics/assets/releases/download/v0.0.0/"
  urls = [
      f"{url}VOCtrainval_06-Nov-2007.zip",  # 446MB, 5012 images
      f"{url}VOCtest_06-Nov-2007.zip",  # 438MB, 4953 images
      f"{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

Nutzung

Um ein YOLO11n-Modell auf dem VOC-Datensatz für 100 Epochen mit einer Bildgröße von 640 zu trainieren, können Sie die folgenden Code-Snippets verwenden. Eine umfassende Liste der verfügbaren Argumente finden Sie auf der Trainings-Seite des Modells.

from ultralytics import YOLO

# Load a model
model = YOLO("yolo11n.pt")  # load a pretrained model (recommended for training)

# Train the model
results = model.train(data="VOC.yaml", epochs=100, imgsz=640)

# Start training from a pretrained *.pt model
yolo detect train data=VOC.yaml model=yolo11n.pt epochs=100 imgsz=640

sample_images und Anmerkungen

Der VOC-Datensatz enthält eine vielfältige Sammlung von Bildern mit verschiedenen Objektkategorien und komplexen Szenen. Hier sind einige Beispiele für Bilder aus dem Datensatz zusammen mit den entsprechenden Anmerkungen:

• Mosaikbild: Dieses Bild zeigt einen Trainings-Batch, der aus Mosaik-Datensatzbildern besteht. Mosaicing ist eine Technik, die während des Trainings verwendet wird und mehrere Bilder zu einem einzigen Bild kombiniert, um die Vielfalt der Objekte und Szenen innerhalb jedes Trainings-Batch zu erhöhen. Dies trägt dazu bei, die Fähigkeit des Modells zu verbessern, auf verschiedene Objektgrößen, Seitenverhältnisse und Kontexte zu generalisieren.

Das Beispiel zeigt die Vielfalt und Komplexität der Bilder im VOC-Datensatz und die Vorteile der Verwendung von Mosaicing während des Trainingsprozesses.

Zitate und Danksagungen

Wenn Sie den VOC-Datensatz in Ihrer Forschungs- oder Entwicklungsarbeit verwenden, zitieren Sie bitte das folgende Paper:

@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}
}

Wir möchten das PASCAL VOC-Konsortium für die Erstellung und Pflege dieser wertvollen Ressource für die Computer-Vision-Community anerkennen. Weitere Informationen über den VOC-Datensatz und seine Urheber finden Sie auf der PASCAL VOC-Datensatz-Website.

FAQ

Was ist der PASCAL VOC-Datensatz und warum ist er für Aufgaben der Computer Vision wichtig?

Der PASCAL VOC-Datensatz (Visual Object Classes) ist ein bekannter Benchmark für Objekterkennung, Segmentierung und Klassifizierung im Bereich Computer Vision. Er enthält umfassende Annotationen wie Begrenzungsrahmen, Klassenbezeichnungen und Segmentierungsmasken für 20 verschiedene Objektkategorien. Forscher verwenden ihn häufig, um die Leistung von Modellen wie Faster R-CNN, YOLO und Mask R-CNN aufgrund seiner standardisierten Bewertungsmetriken wie z. B. mean Average Precision (mAP) zu bewerten.

Wie trainiere ich ein YOLO11-Modell mit dem VOC Datensatz?

Um ein YOLO11-Modell mit dem VOC-Datensatz zu trainieren, benötigen Sie die Datensatzkonfiguration in einer YAML-Datei. Hier ist ein Beispiel, um mit dem Training eines YOLO11n-Modells für 100 Epochen mit einer Bildgröße von 640 zu beginnen:

from ultralytics import YOLO

# Load a model
model = YOLO("yolo11n.pt")  # load a pretrained model (recommended for training)

# Train the model
results = model.train(data="VOC.yaml", epochs=100, imgsz=640)

# Start training from a pretrained *.pt model
yolo detect train data=VOC.yaml model=yolo11n.pt epochs=100 imgsz=640

Welche primären Herausforderungen sind im VOC-Datensatz enthalten?

Der VOC-Datensatz umfasst zwei Hauptwettbewerbe: VOC2007 und VOC2012. Diese Wettbewerbe testen Objekterkennung, Segmentierung und Klassifizierung über 20 verschiedene Objektkategorien hinweg. Jedes Bild ist sorgfältig mit Begrenzungsrahmen, Klassenbezeichnungen und Segmentierungsmasken versehen. Die Wettbewerbe bieten standardisierte Metriken wie mAP, die den Vergleich und das Benchmarking verschiedener Computer-Vision-Modelle erleichtern.

Wie verbessert der PASCAL VOC-Datensatz das Modell-Benchmarking und die -Evaluierung?

Der PASCAL VOC Datensatz verbessert das Modell-Benchmarking und die -Evaluierung durch seine detaillierten Anmerkungen und standardisierten Metriken wie Mean Average Precision (mAP). Diese Metriken sind entscheidend für die Bewertung der Leistung von Objekterkennungs- und Klassifizierungsmodellen. Die vielfältigen und komplexen Bilder des Datensatzes gewährleisten eine umfassende Modellbewertung in verschiedenen realen Szenarien.

Wie verwende ich den VOC-Datensatz für die semantische Segmentierung in YOLO-Modellen?

Um den VOC-Datensatz für semantische Segmentierungsaufgaben mit YOLO-Modellen zu verwenden, müssen Sie den Datensatz ordnungsgemäß in einer YAML-Datei konfigurieren. Die YAML-Datei definiert Pfade und Klassen, die für das Training von Segmentierungsmodellen benötigt werden. Überprüfen Sie die YAML-Konfigurationsdatei des VOC-Datensatzes unter VOC.yaml für detaillierte Setups. Für Segmentierungsaufgaben würden Sie ein segmentierungsspezifisches Modell wie yolo11n-seg.pt anstelle des Erkennungsmodells.

📅 Vor 1 Jahr erstellt ✏️ Vor 6 Monaten aktualisiert

Kommentare