VOC
Der PASCAL VOC (Visual Object Classes) ist ein bekannter Datensatz für die Erkennung, Segmentierung und Klassifizierung von Objekten. Er wurde entwickelt, um die Forschung zu einer Vielzahl von Objektkategorien zu fördern, und wird häufig zum Benchmarking von Computer-Vision-Modellen verwendet. Er ist ein wesentlicher Datensatz für Forscher und Entwickler, die sich mit Objekterkennung, -segmentierung und -klassifizierung befassen.
Hauptmerkmale
- Der VOC umfasst zwei große Herausforderungen: 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 Bewertungsmetriken wie die mittlere durchschnittliche PräzisionmAP) für die Objekterkennung und -klassifizierung und eignet sich daher für den Vergleich der Modellleistung.
Dataset-Struktur
Der VOC ist in drei Teilmengen aufgeteilt:
- Train: Diese Teilmenge enthält Bilder für das Training von Objekterkennung, Segmentierung und Klassifizierungsmodellen.
- Validierung: Diese Teilmenge enthält Bilder, die für Validierungszwecke während des Modelltrainings verwendet werden.
- Test: Diese Teilmenge besteht aus Bildern, die zum Testen und Benchmarking der trainierten Modelle verwendet werden. Die Ergebnisse werden zur Leistungsbewertung an den VOC übermittelt.
Anwendungen
Der VOC wird häufig zum Trainieren und Evaluieren von Deep-Learning-Modellen für die Objekterkennung verwendet (z. B. Ultralytics YOLO, Faster R-CNN und SSD), Instanzsegmentierung (z. B. Mask R-CNN) und Bildklassifizierung. Die vielfältigen Objektkategorien des Datensatzes, die große Anzahl kommentierter Bilder und die standardisierten Bewertungsmetriken machen ihn zu einer unverzichtbaren Ressource für Forscher und Praktiker im Bereich Computer Vision.
Datensatz-YAML
Eine YAML-Datei (Yet Another Markup Language) wird zur Definition der Datensatzkonfiguration verwendet. Sie enthält Informationen über die Pfade des Datensatzes, Klassen und andere relevante Informationen. Im Falle des VOC ist die VOC.yaml Datei wird verwaltet unter https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/VOC.yaml.
VOCyaml
# 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 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
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
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
Nutzung
Um ein YOLO11n-Modell auf dem VOC für 100 Epochen mit einer Bildgröße von 640 zu trainieren, können Sie die folgenden Codeschnipsel verwenden. Eine umfassende Liste der verfügbaren Argumente finden Sie auf der Seite Modelltraining.
Trainingsbeispiel
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 enthält eine Vielzahl von Bildern mit verschiedenen Objektkategorien und komplexen Szenen. Hier sind einige Beispiele von Bildern 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 verdeutlicht die Vielfalt und Komplexität der Bilder im VOC und die Vorteile der Mosaikbildung während des Trainingsprozesses.
Zitate und Danksagungen
Wenn Sie den VOC in Ihrer Forschungs- oder Entwicklungsarbeit verwenden, zitieren Sie bitte das folgende Papier:
@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 dem PASCAL VOC Consortium für die Erstellung und Pflege dieser wertvollen Ressource für die Computer Vision Community danken. Weitere Informationen über den VOC und seine Ersteller finden Sie auf der Website des PASCAL VOC .
FAQ
Was ist der VOC und warum ist er für Computer-Vision-Aufgaben wichtig?
Der PASCAL VOC (Visual Object Classes) ist ein renommierter Benchmark für die Objekterkennung, -segmentierung und -klassifizierung in der Computer Vision. Er enthält umfassende Annotationen wie Bounding Boxes, 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 zu bewerten, da er standardisierte Bewertungsmetriken wie die mittlere durchschnittliche PräzisionmAP) enthält.
Wie trainiere ich ein YOLO11 mit dem VOC ?
Um ein YOLO11 mit dem VOC zu trainieren, benötigen Sie die Konfiguration des Datensatzes in einer YAML-Datei. Hier ist ein Beispiel für das Training eines YOLO11n-Modells für 100 Epochen mit einer Bildgröße von 640:
Trainingsbeispiel
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
Was sind die wichtigsten Herausforderungen, die im VOC enthalten sind?
Der VOC umfasst zwei große Herausforderungen: VOC2007 und VOC2012. Bei diesen Aufgaben werden Objekterkennung, Segmentierung und Klassifizierung in 20 verschiedenen Objektkategorien getestet. Jedes Bild ist sorgfältig mit Bounding Boxes, Klassenbeschriftungen und Segmentierungsmasken versehen. Die Challenges liefern standardisierte Metriken wie mAP, die den Vergleich und das Benchmarking verschiedener Computer Vision Modelle erleichtern.
Wie kann der VOC das Benchmarking und die Bewertung von Modellen verbessern?
Der VOC verbessert das Benchmarking und die Bewertung von Modellen durch seine detaillierten Anmerkungen und standardisierten Metriken wie die mittlere durchschnittliche PräzisionmAP). 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 Modellevaluation in verschiedenen realen Szenarien.
Wie kann ich den VOC für die semantische Segmentierung in YOLO verwenden?
Um den VOC für semantische Segmentierungsaufgaben mit YOLO zu verwenden, müssen Sie den Datensatz in einer YAML-Datei richtig konfigurieren. Die YAML-Datei definiert Pfade und Klassen, die für das Training von Segmentierungsmodellen benötigt werden. Die YAML-Konfigurationsdatei VOC finden Sie unter VOCyaml für detaillierte Setups. Für Segmentierungsaufgaben würden Sie ein segmentierungsspezifisches Modell wie yolo11n-seg.pt anstelle des Erkennungsmodells.
