VOC-Datensatz
Der PASCAL VOC-Datensatz (Visual Object Classes) ist ein bekannter Datensatz für object detection, Segmentierung und Klassifizierung. Er wurde entwickelt, um die Forschung an einer Vielzahl von Objektkategorien zu fördern, und wird häufig zum Benchmarking von Computer-Vision-Modellen verwendet. Er ist ein unverzichtbarer Datensatz für Forscher und Entwickler, die an object detection-, Segmentierungs- und Klassifizierungsaufgaben arbeiten.
Hauptmerkmale
- Der VOC-Datensatz umfasst zwei Haupt-Challenges: 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 mean Average Precision (mAP) für Objektdetektion und Klassifikation, wodurch es sich zum Vergleich der Modellleistung eignet.
Dataset-Struktur
Der VOC-Datensatz ist in drei Untergruppen 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: Dieser Teilsatz besteht aus Bildern, die zum Testen und Benchmarking der trainierten Modelle verwendet werden. Ground-Truth-Annotationen für diesen Teilsatz sind nicht öffentlich verfügbar, und die Ergebnisse werden zur Leistungsbewertung an den PASCAL VOC-Evaluierungsserver übermittelt.
Anwendungen
Der VOC-Datensatz wird häufig zum Trainieren und Evaluieren von Deep-Learning-Modellen in der Objekterkennung (wie Ultralytics YOLO, Faster R-CNN und SSD), der Instanzsegmentierung (wie Mask R-CNN) und der Bildklassifizierung verwendet. Der vielfältige Satz von Objektkategorien des Datensatzes, die große Anzahl annotierter Bilder und die standardisierten Bewertungsmetriken machen ihn zu einer unverzichtbaren Ressource für Computer-Vision-Forscher und -Praktiker.
Datensatz-YAML
Eine YAML (Yet Another Markup Language)-Datei wird verwendet, um die Dataset-Konfiguration zu definieren. Sie enthält Informationen über die Pfade, Klassen und andere relevante Informationen des Datasets. Im Falle des VOC-Datasets, VOC.yaml Datei wird verwaltet unter https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/VOC.yaml.
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
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 Trainingsseite des Modells.
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-Datensatz enthält einen vielfältigen Satz von Bildern mit verschiedenen Objektkategorien und komplexen Szenen. Hier sind einige Beispiele von Bildern aus dem Datensatz, samt ihren entsprechenden Annotationen:
- 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 veranschaulicht die Vielfalt und Komplexität der Bilder im VOC-Datensatz sowie 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 dem PASCAL VOC Consortium für die Erstellung und Pflege dieser wertvollen Ressource für die Computer-Vision-Community danken. Weitere Informationen zum VOC-Datensatz und seinen Erstellern finden Sie auf der PASCAL VOC Datensatz-Website.
FAQ
Was ist der PASCAL VOC-Datensatz und warum ist er für Computer-Vision-Aufgaben wichtig?
Der PASCAL VOC-Datensatz (Visual Object Classes) ist ein renommierter Benchmark für object detection, Segmentierung und Klassifizierung in der Computer Vision. Er umfasst umfassende Annotationen wie Bounding Boxes, Klassenlabels und Segmentierungsmasken für 20 verschiedene Objektkategorien. Forscher nutzen ihn häufig zur Bewertung der Leistung von Modellen wie Faster R-CNN, YOLO und Mask R-CNN, da er standardisierte Bewertungsmetriken wie die mittlere Average Precision (mAP) verwendet.
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 ein YOLO11n-Modell für 100 Epochen mit einer Bildgröße von 640 zu trainieren:
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
Welche primären Herausforderungen sind im VOC-Datensatz enthalten?
Der VOC-Datensatz umfasst zwei zentrale Herausforderungen: VOC2007 und VOC2012. Diese Challenges testen Objekterkennung, Segmentierung und Klassifizierung über 20 verschiedene Objektkategorien hinweg. Jedes Bild ist sorgfältig mit Bounding Boxes, Klassenlabels und Segmentierungsmasken annotiert. Die Challenges stellen standardisierte Metriken wie mAP bereit, was den Vergleich und das Benchmarking verschiedener Computer-Vision-Modelle erleichtert.
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 Annotationen 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 Modellevaluierung in verschiedenen realen Szenarien.
Wie verwende ich den VOC-Datensatz für die semantic segmentation in YOLO-Modellen?
Um den VOC-Datensatz für Aufgaben der semantischen Segmentierung mit YOLO-Modellen zu verwenden, müssen Sie den Datensatz korrekt 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.
