Jeu de données VisDrone#
Le VisDrone Dataset est un benchmark d'imagerie par drone à grande échelle dont le sous-ensemble de détection (VisDrone2019-DET) fournit 8 629 images aériennes — 6 471 pour l'entraînement, 548 pour la validation et 1 610 pour le test-dev — annotées avec 10 classes d'objets pour la détection d'objets. Il a été créé par l'équipe AISKYEYE du laboratoire de Machine Learning et de Data Mining de l'Université de Tianjin, en Chine.
Watch: How to Train Ultralytics YOLO on the VisDrone Dataset | Aerial Detection | Complete Tutorial 🚀
Le benchmark complet VisDrone comprend 288 clips vidéo (261 908 images) et 10 209 images statiques capturées par des caméras montées sur drone dans 14 villes différentes à travers la Chine, s'étendant sur des environnements urbains et ruraux, des scènes éparses et bondées, ainsi que des conditions météorologiques et d'éclairage variées. Ses images contiennent plus de 2,6 millions de bounding boxes annotées manuellement, avec des attributs supplémentaires tels que la visibilité de la scène, la classe d'objet et l'occlusion. La configuration Ultralytics VisDrone.yaml utilise le sous-ensemble d'images statiques VisDrone2019-DET de ce benchmark.
Fonctionnalités clés#
- Objets petits et denses : Les points de vue aériens rendent les cibles minuscules et regroupées — les 548 images de validation contiennent à elles seules 38 759 boîtes étiquetées, soit une moyenne d'environ 70 objets par image.
- Diversité des scènes : Imagerie provenant de 14 villes chinoises couvrant des zones urbaines et rurales, de jour comme de nuit, et dans diverses conditions météorologiques.
- Annotations riches : Plus de 2,6 millions de boîtes sur l'ensemble du benchmark, avec des attributs d'occlusion et de visibilité.
- Divisions prédéfinies : Divisions fixes train / val / test-dev (6 471 / 548 / 1 610 images) pour une évaluation cohérente.
Structure du jeu de données#
La configuration VisDrone d'Ultralytics couvre le sous-ensemble d'images VisDrone2019-DET, divisé en trois parties :
| Split | Images | Description |
|---|---|---|
| Entraîner (Train) | 6,471 | Images aériennes étiquetées utilisées pour entraîner le détecteur |
| Validation | 548 | Images utilisées pour l'évaluation pendant le développement |
| Test-dev | 1,610 | Images mises de côté pour l'évaluation finale du modèle entraîné |
Une quatrième division, test-challenge (1 580 images), est conservée pour la compétition VisDrone et n'est pas téléchargée, ce qui explique pourquoi l'ensemble complet DET totalise 10 209 images.
Le jeu de données annote 10 classes d'objets : piéton, personnes, bicyclette, voiture, camionnette, camion, tricycle, tricycle à auvent, bus et moto. VisDrone distingue piéton (une personne debout ou marchant) de personnes (une personne dans toute autre posture).
Lors de la première utilisation, le script de téléchargement convertit les annotations VisDrone originales au format YOLO, en sautant les régions marquées comme ignorées (ce qui exclut également la catégorie inutilisée "others").
Applications#
Les scènes denses et les cibles minuscules de VisDrone en font un benchmark standard pour la détection de petits objets depuis des points de vue aériens. Les applications courantes incluent :
- Surveillance du trafic et comptage de véhicules depuis des UAV
- Analyse de foule et surveillance de la sécurité publique
- Inspection d'infrastructures et de chantiers de construction
- La recherche en computer vision sur la détection de petits objets dans des scènes encombrées
Pour d'autres benchmarks d'imagerie aérienne, consulte le xView dataset axé sur les satellites ou le DOTA-v2 dataset à boîtes orientées.
YAML du jeu de données#
Le fichier VisDrone.yaml définit la configuration du dataset — les chemins du dataset, les noms des classes et le script de téléchargement et de conversion automatiques. Il est maintenu dans le dépôt Ultralytics sur https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/VisDrone.yaml.
# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
# VisDrone2019-DET dataset https://github.com/VisDrone/VisDrone-Dataset by Tianjin University
# Documentation: https://docs.ultralytics.com/datasets/detect/visdrone
# Example usage: yolo train data=VisDrone.yaml
# parent
# ├── ultralytics
# └── datasets
# └── VisDrone ← downloads here (~2 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: VisDrone # dataset root dir
train: images/train # train images (relative to 'path') 6471 images
val: images/val # val images (relative to 'path') 548 images
test: images/test # test-dev images (optional) 1610 images
# Classes
names:
0: pedestrian
1: people
2: bicycle
3: car
4: van
5: truck
6: tricycle
7: awning-tricycle
8: bus
9: motor
# Download script/URL (optional) ---------------------------------------------------------------------------------------
download: |
import os
from pathlib import Path
import shutil
from ultralytics.utils.downloads import download
from ultralytics.utils import ASSETS_URL, TQDM
def visdrone2yolo(dir, split, source_name=None):
"""Convert VisDrone annotations to YOLO format with images/{split} and labels/{split} structure."""
from PIL import Image
source_dir = dir / (source_name or f"VisDrone2019-DET-{split}")
images_dir = dir / "images" / split
labels_dir = dir / "labels" / split
labels_dir.mkdir(parents=True, exist_ok=True)
# Move images to new structure
if (source_images_dir := source_dir / "images").exists():
images_dir.mkdir(parents=True, exist_ok=True)
for img in source_images_dir.glob("*.jpg"):
img.rename(images_dir / img.name)
for f in TQDM((source_dir / "annotations").glob("*.txt"), desc=f"Converting {split}"):
img_size = Image.open(images_dir / f.with_suffix(".jpg").name).size
dw, dh = 1.0 / img_size[0], 1.0 / img_size[1]
lines = []
with open(f, encoding="utf-8") as file:
for row in [x.split(",") for x in file.read().strip().splitlines()]:
if row[4] != "0": # Skip ignored regions
x, y, w, h = map(int, row[:4])
cls = int(row[5]) - 1
# Convert to YOLO format
x_center, y_center = (x + w / 2) * dw, (y + h / 2) * dh
w_norm, h_norm = w * dw, h * dh
lines.append(f"{cls} {x_center:.6f} {y_center:.6f} {w_norm:.6f} {h_norm:.6f}\n")
(labels_dir / f.name).write_text("".join(lines), encoding="utf-8")
# Download (ignores test-challenge split)
dir = Path(yaml["path"]) # dataset root dir
urls = [
f"{ASSETS_URL}/VisDrone2019-DET-train.zip",
f"{ASSETS_URL}/VisDrone2019-DET-val.zip",
f"{ASSETS_URL}/VisDrone2019-DET-test-dev.zip",
# f"{ASSETS_URL}/VisDrone2019-DET-test-challenge.zip",
]
download(urls, dir=dir, threads=4)
# Convert
splits = {"VisDrone2019-DET-train": "train", "VisDrone2019-DET-val": "val", "VisDrone2019-DET-test-dev": "test"}
for folder, split in splits.items():
visdrone2yolo(dir, split, folder) # convert VisDrone annotations to YOLO labels
shutil.rmtree(dir / folder) # cleanup original directoryUtilisation#
VisDrone se télécharge automatiquement la première fois que tu lances un entraînement — trois archives totalisant environ 2 Go — et nécessite environ 4 Go d'espace disque libre pendant l'extraction et la conversion.
Pour entraîner un modèle YOLO26n sur le dataset VisDrone pendant 100 epochs avec une taille d'image de 640, tu peux utiliser les extraits de code suivants. Pour une liste complète 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 - dataset will auto-download on first run
results = model.train(data="VisDrone.yaml", epochs=100, imgsz=640)Pour étiqueter des images aériennes supplémentaires et gérer les exécutions d'entraînement VisDrone dans ton navigateur, utilise Ultralytics Platform.
Exemples de données et d'annotations#
L'exemple ci-dessous montre une scène typique de VisDrone : un point de vue aérien sur une route très fréquentée où les piétons et les véhicules apparaissent comme de petites cibles densément regroupées, dont beaucoup sont partiellement occultées par les autres.
Citations et remerciements#
Si tu utilises le jeu de données VisDrone dans tes travaux de recherche ou de développement, merci de citer l'article suivant :
@ARTICLE{9573394,
author={Zhu, Pengfei and Wen, Longyin and Du, Dawei and Bian, Xiao and Fan, Heng and Hu, Qinghua and Ling, Haibin},
journal={IEEE Transactions on Pattern Analysis and Machine Intelligence},
title={Detection and Tracking Meet Drones Challenge},
year={2022},
volume={44},
number={11},
pages={7380-7399},
doi={10.1109/TPAMI.2021.3119563}}Nous tenons à remercier l'équipe AISKYEYE du laboratoire de Machine Learning and Data Mining de l'Université de Tianjin, en Chine, pour la création et la maintenance du dataset VisDrone. Pour plus d'informations, visite le VisDrone Dataset GitHub repository.
FAQ#
VisDrone est utilisé pour entraîner et évaluer des détecteurs sur des images capturées par drone, où les objets sont petits, denses et vus d'en haut. Sa combinaison de points de vue aériens, de scènes bondées et de conditions variées en fait un banc d'essai standard pour la surveillance du trafic par UAV, l'analyse de foule et la recherche sur la détection de petits objets.
La configuration Ultralytics VisDrone contient 8 629 images : 6 471 pour l'entraînement, 548 pour la validation et 1 610 pour le test (test-dev). Toutes les divisions partagent les 10 mêmes classes : piéton, personnes, bicyclette, voiture, camionnette, camion, tricycle, tricycle bâché, bus et moto. Consulte Dataset Structure pour la répartition complète.
Entraîne un modèle YOLO26n sur VisDrone pendant 100 époques avec une taille d'image de 640 :
Exemple d'entraînementfrom ultralytics import YOLO # Load a model model = YOLO("yolo26n.pt") # load a pretrained model (recommended for training) # Train the model results = model.train(data="VisDrone.yaml", epochs=100, imgsz=640)Pour des configurations détaillées, consulte la page Entraînement et les conseils d'entraînement du modèle.
Les objets dans VisDrone sont minuscules par rapport à l'image — souvent seulement quelques dizaines de pixels — et apparaissent dans des groupes denses et fortement occlus, ce qui met à rude épreuve les détecteurs optimisés pour des photos prises au niveau du sol. L'entraînement et la prédiction à plus haute résolution (par exemple
imgsz=1280avec un batch plus petit) permettent de récupérer les petites cibles, et SAHI tiled inference découpe les grandes images pour que les petits objets occupent une plus grande partie de chaque fenêtre d'inférence.Le benchmark complet VisDrone couvre cinq tâches — la détection d'objets dans les images, la détection d'objets dans les vidéos, le suivi d'un seul objet, le multi-object tracking et le comptage de foule — à travers 288 clips vidéo et 10 209 images statiques. La configuration Ultralytics
VisDrone.yamlne couvre que la tâche de détection d'images (VisDrone2019-DET), en téléchargeant ses 6 471 images d'entraînement, 548 de validation et 1 610 de test-dev.Cite l'article "Detection and Tracking Meet Drones Challenge" (IEEE TPAMI, vol. 44, no. 11, 2022, DOI 10.1109/TPAMI.2021.3119563) ; l'entrée BibTeX complète se trouve dans la section Citations and Acknowledgments ci-dessus.
VisDrone se télécharge automatiquement lors de ta première session d'entraînement avec
data="VisDrone.yaml"— aucune étape manuelle n'est requise. Le script récupère trois archives (environ 2 Go) à partir des assets de release GitHub d'Ultralytics et convertit les annotations au format YOLO. La division de test cachée de la compétition n'est pas incluse.