Dataset VOC
Il dataset PASCAL VOC (Visual Object Classes) è un noto dataset di rilevamento, segmentazione e classificazione degli oggetti. È progettato per incoraggiare la ricerca su un'ampia varietà di categorie di oggetti ed è comunemente utilizzato per il benchmarking dei modelli di computer vision. È un dataset essenziale per ricercatori e sviluppatori che lavorano su compiti di rilevamento, segmentazione e classificazione degli oggetti.
Caratteristiche principali
- Il dataset VOC include due sfide principali: VOC2007 e VOC2012.
- Il dataset comprende 20 categorie di oggetti, tra cui oggetti comuni come auto, biciclette e animali, nonché categorie più specifiche come barche, divani e tavoli da pranzo.
- Le annotazioni includono bounding box degli oggetti ed etichette di classe per il rilevamento e la classificazione degli oggetti, e maschere di segmentazione per i compiti di segmentazione.
- VOC fornisce metriche di valutazione standardizzate come la precisione media media (mAP) per il rilevamento e la classificazione degli oggetti, rendendolo adatto per confrontare le prestazioni dei modelli.
Struttura del set di dati
Il dataset VOC è suddiviso in tre sottoinsiemi:
- Train: Questo sottoinsieme contiene immagini per l'addestramento di modelli di rilevamento, segmentazione e classificazione degli oggetti.
- Validation: Questo sottoinsieme contiene immagini utilizzate per scopi di convalida durante l'addestramento del modello.
- Test: Questo sottoinsieme è costituito da immagini utilizzate per testare e valutare i modelli addestrati. Le annotazioni ground truth per questo sottoinsieme non sono disponibili pubblicamente e i risultati vengono inviati al server di valutazione PASCAL VOC per la valutazione delle prestazioni.
Applicazioni
Il dataset VOC è ampiamente utilizzato per l'addestramento e la valutazione di modelli di deep learning nell'object detection (come Ultralytics YOLO, Faster R-CNN e SSD), nella instance segmentation (come Mask R-CNN) e nella classificazione delle immagini. L'insieme diversificato di categorie di oggetti, l'elevato numero di immagini annotate e le metriche di valutazione standardizzate del dataset lo rendono una risorsa essenziale per i ricercatori e i professionisti della computer vision.
YAML del set di dati
Un file YAML (Yet Another Markup Language) viene utilizzato per definire la configurazione del dataset. Contiene informazioni sui percorsi, le classi e altre informazioni rilevanti del dataset. Nel caso del dataset VOC, il file VOC.yaml file è mantenuto in 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: # 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
Utilizzo
Per addestrare un modello YOLO11n sul dataset VOC per 100 epoche con una dimensione dell'immagine di 640, è possibile utilizzare i seguenti frammenti di codice. Per un elenco completo degli argomenti disponibili, fare riferimento alla pagina di Training del modello.
Esempio di addestramento
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
Immagini di esempio e annotazioni
Il dataset VOC contiene un insieme diversificato di immagini con varie categorie di oggetti e scene complesse. Ecco alcuni esempi di immagini dal dataset, insieme alle relative annotazioni:
- Immagine mosaicata: questa immagine mostra un batch di addestramento composto da immagini del dataset mosaicato. Il mosaicing è una tecnica utilizzata durante l'addestramento che combina più immagini in un'unica immagine per aumentare la varietà di oggetti e scene all'interno di ogni batch di addestramento. Ciò contribuisce a migliorare la capacità del modello di generalizzare a diverse dimensioni degli oggetti, proporzioni e contesti.
L'esempio mostra la varietà e la complessità delle immagini nel dataset VOC e i vantaggi dell'utilizzo del mosaicing durante il processo di addestramento.
Citazioni e ringraziamenti
Se utilizzi il dataset VOC nel tuo lavoro di ricerca o sviluppo, cita il seguente articolo:
@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}
}
Desideriamo ringraziare il PASCAL VOC Consortium per aver creato e mantenuto questa preziosa risorsa per la comunità di computer vision. Per ulteriori informazioni sul dataset VOC e sui suoi creatori, visitare il sito web del dataset PASCAL VOC.
FAQ
Cos'è il dataset PASCAL VOC e perché è importante per i compiti di computer vision?
Il dataset PASCAL VOC (Visual Object Classes) è un benchmark rinomato per il rilevamento di oggetti, la segmentazione e la classificazione nella visione artificiale. Include annotazioni complete come bounding box, etichette di classe e maschere di segmentazione in 20 diverse categorie di oggetti. I ricercatori lo utilizzano ampiamente per valutare le prestazioni di modelli come Faster R-CNN, YOLO e Mask R-CNN grazie alle sue metriche di valutazione standardizzate come la precisione media media (mAP).
Come posso addestrare un modello YOLO11 utilizzando il dataset VOC?
Per addestrare un modello YOLO11 con il dataset VOC, è necessaria la configurazione del dataset in un file YAML. Ecco un esempio per iniziare ad addestrare un modello YOLO11n per 100 epoche con una dimensione dell'immagine di 640:
Esempio di addestramento
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
Quali sono le principali sfide incluse nel dataset VOC?
Il dataset VOC include due sfide principali: VOC2007 e VOC2012. Queste sfide testano il rilevamento, la segmentazione e la classificazione degli oggetti in 20 diverse categorie di oggetti. Ogni immagine è meticolosamente annotata con bounding box, etichette di classe e maschere di segmentazione. Le sfide forniscono metriche standardizzate come mAP, facilitando il confronto e il benchmarking di diversi modelli di computer vision.
In che modo il dataset PASCAL VOC migliora il benchmarking e la valutazione dei modelli?
Il dataset PASCAL VOC migliora il benchmarking e la valutazione dei modelli attraverso le sue annotazioni dettagliate e metriche standardizzate come la precisione media media Precision (mAP). Queste metriche sono fondamentali per valutare le prestazioni dei modelli di rilevamento e classificazione degli oggetti. Le immagini diverse e complesse del dataset garantiscono una valutazione completa del modello in vari scenari del mondo reale.
Come posso utilizzare il dataset VOC per la segmentazione semantica nei modelli YOLO?
Per utilizzare il dataset VOC per attività di segmentazione semantica con i modelli YOLO, è necessario configurare correttamente il dataset in un file YAML. Il file YAML definisce i percorsi e le classi necessari per l'addestramento dei modelli di segmentazione. Controlla il file di configurazione YAML del dataset VOC in VOC.yaml per configurazioni dettagliate. Per le attività di segmentazione, è necessario utilizzare un modello specifico per la segmentazione come yolo11n-seg.pt invece del modello di rilevamento.
