Dataset VisDrone#
Le dataset VisDrone 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 fouille de données de l’université de Tianjin, en Chine.
Watch: How to Train Ultralytics YOLO on the VisDrone Dataset | Aerial Detection | Complete Tutorial 🚀
Le benchmark VisDrone complet comprend 288 séquences vidéo (261 908 images) et 10 209 images statiques capturées par des caméras montées sur des drones dans 14 villes différentes de Chine, couvrant des environnements urbains et ruraux, des scènes peu denses et bondées, ainsi que diverses conditions météorologiques et d’éclairage. Ses images contiennent plus de 2,6 millions de boîtes englobantes annotées manuellement, avec des attributs supplémentaires tels que la visibilité de la scène, la classe de l’objet et l’occlusion. La configuration VisDrone.yaml d’Ultralytics utilise le sous-ensemble d’images statiques VisDrone2019-DET de ce benchmark.
Fonctionnalités clés#
- Objets petits et nombreux : les points de vue aériens rendent les cibles minuscules et rapprochées — les 548 images de validation contiennent à elles seules 38 759 boîtes annotées, soit environ 70 objets par image.
- Diversité des scènes : images provenant de 14 villes chinoises, couvrant des zones urbaines et rurales, de jour comme de nuit, ainsi que différentes 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é.
- Découpages prédéfinis : découpages fixes entraînement / validation / 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, réparti en trois parties :
| Sous-ensemble | Images | Description |
|---|---|---|
| Entraîner | 6,471 | Images aériennes annoté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é |
Un quatrième découpage, test-challenge (1 580 images), est réservé à la compétition VisDrone et n’est pas téléchargé, ce qui explique pourquoi l’ensemble DET complet totalise 10 209 images.
Le dataset annote 10 classes d’objets : piéton, personnes, vélo, voiture, fourgonnette, camion, tricycle, tricycle à auvent, bus et moto. VisDrone distingue piéton (une personne debout ou en train de marcher) de personnes (une personne dans toute autre posture).
Lors de la première utilisation, le script de téléchargement convertit les annotations VisDrone d’origine au format YOLO, en ignorant 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 comprennent :
- Surveillance du trafic et comptage des véhicules depuis des UAV
- Analyse des foules et surveillance de la sécurité publique
- Inspection des infrastructures et des chantiers de construction
- Recherche en vision par ordinateur sur la détection de petits objets dans des scènes encombrées
Pour découvrir d’autres benchmarks d’imagerie aérienne, consulte le dataset xView consacré aux images satellitaires ou le dataset DOTA-v2 à boîtes orientées.
YAML du jeu de données#
Le fichier VisDrone.yaml définit la configuration du dataset — les chemins des données, les noms des classes et le script de téléchargement et de conversion automatiques. Il est maintenu dans le dépôt Ultralytics à l’adresse 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 lors de ton premier 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 époques avec une taille d’image de 640, tu peux utiliser les extraits de code suivants. Pour obtenir la liste complète des arguments disponibles, consulte la page Entraînement 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 annoter d’autres images aériennes et gérer tes sessions d’entraînement VisDrone dans ton navigateur, utilise Ultralytics Platform.
Données et annotations d'exemple#
L’exemple ci-dessous montre une scène VisDrone typique : un point de vue aérien au-dessus d’une route très fréquentée, où les piétons et les véhicules apparaissent comme des cibles petites et très rapprochées, souvent partiellement masquées les unes par les autres.
Citations et remerciements#
Si tu utilises le dataset VisDrone dans tes travaux de recherche ou de développement, cite 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 souhaitons remercier l’équipe AISKYEYE du laboratoire de machine learning et de fouille de données de l’université de Tianjin, en Chine, pour avoir créé et maintenu le dataset VisDrone. Pour plus d’informations, consulte le dépôt GitHub du dataset VisDrone.
FAQ#
VisDrone sert à entraîner et à évaluer des détecteurs sur des images capturées par drone, dans lesquelles les objets sont petits, nombreux et vus d’en haut. La 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 des foules et la recherche sur la détection de petits objets.
La configuration VisDrone d’Ultralytics contient 8 629 images : 6 471 pour l’entraînement, 548 pour la validation et 1 610 pour le test (test-dev). Tous les découpages partagent les mêmes 10 classes : piéton, personnes, vélo, voiture, fourgonnette, camion, tricycle, tricycle à auvent, bus et moto. Consulte la page Structure du dataset 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 pour l’entraînement des modèles.
Les objets de VisDrone sont minuscules par rapport à l’image — souvent de seulement quelques dizaines de pixels — et apparaissent en groupes denses et fortement occlus, ce qui met à rude épreuve les détecteurs entraînés sur des photos prises au niveau du sol. Entraîner le modèle et effectuer les prédictions à une résolution plus élevée (par exemple
imgsz=1280avec un batch plus petit) permet de mieux détecter les petites cibles, tandis que l’inférence par tuiles SAHI découpe les grandes images afin que les petits objets occupent une plus grande partie de chaque fenêtre d’inférence.Le benchmark VisDrone complet couvre cinq tâches — détection d’objets dans des images, détection d’objets dans des vidéos, suivi d’un objet unique, suivi de plusieurs objets et comptage des foules — sur 288 séquences vidéo et 10 209 images statiques. La configuration
VisDrone.yamld’Ultralytics couvre uniquement la tâche de détection dans les images (VisDrone2019-DET) et télécharge ses 6 471 images d’entraînement, 548 images de validation et 1 610 images de test-dev.Cite l’article « Detection and Tracking Meet Drones Challenge » (IEEE TPAMI, vol. 44, n° 11, 2022, DOI 10.1109/TPAMI.2021.3119563) ; l’entrée BibTeX complète se trouve dans la section Citations et remerciements ci-dessus.
VisDrone se télécharge automatiquement lors de ton premier entraînement avec
data="VisDrone.yaml"— aucune étape manuelle n’est nécessaire. Le script récupère trois archives (environ 2 Go) depuis les ressources de publication GitHub d’Ultralytics et convertit les annotations au format YOLO. Le découpage test-challenge réservé à la compétition n’est pas inclus.