Link to this sectionJeu 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 d'entraînement, 548 de validation et 1 610 de 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.

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, couvrant des environnements urbains et ruraux, des scènes clairsemées 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 de l'objet et l'occlusion. La configuration VisDrone.yaml d'Ultralytics utilise le sous-ensemble d'images statiques VisDrone2019-DET de ce benchmark.

Link to this sectionFonctionnalité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.

Link to this sectionStructure du jeu de données#

La configuration VisDrone d'Ultralytics couvre le sous-ensemble d'images VisDrone2019-DET, divisé en trois parties :

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).

Link to this sectionApplications#

Les scènes denses et les cibles minuscules de VisDrone en font un benchmark standard pour la détection d'objets petits 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
• Recherche en vision par ordinateur sur la détection de petits objets dans des scènes encombrées

Pour d'autres benchmarks d'imagerie aérienne, voir le jeu de données xView axé sur le satellite ou le jeu de données DOTA-v2 avec boîtes orientées.

Link to this sectionYAML du jeu de données#

Le fichier VisDrone.yaml définit la configuration du jeu de données — les chemins du jeu de données, les noms des classes et le script de téléchargement et de conversion automatique. 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 directory

Link to this sectionUtilisation#

Pour entraîner un modèle YOLO26n sur le jeu de données 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 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 étiqueter des images aériennes supplémentaires et gérer tes entraînements VisDrone dans ton navigateur, utilise la plateforme Ultralytics.

Link to this sectionExemples 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.

Link to this sectionCitations 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 et de Data Mining, à l'Université de Tianjin, en Chine, pour avoir créé et maintenu le jeu de données VisDrone. Pour plus d'informations, visite le dépôt GitHub du jeu de données VisDrone.

Link to this sectionFAQ#

Link to this sectionÀ quoi sert le jeu de données VisDrone ?#

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.

Link to this sectionCombien d'images et de classes contient VisDrone ?#

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). Toutes les divisions partagent les 10 mêmes classes : piéton, personnes, bicyclette, voiture, camionnette, camion, tricycle, tricycle à auvent, bus et moto. Voir la Structure du jeu de données pour la ventilation complète.

Link to this sectionComment télécharger le jeu de données VisDrone ?#

VisDrone se télécharge automatiquement la première fois que tu lances un entraînement avec data="VisDrone.yaml" — aucune étape manuelle n'est requise. Le script récupère trois archives (environ 2 Go) depuis les assets de version GitHub d'Ultralytics et convertit les annotations au format YOLO. La division de test-challenge, conservée pour la compétition, n'est pas incluse.

Link to this sectionComment entraîner un modèle YOLO26 sur le jeu de données VisDrone ?#

Entraîne un modèle YOLO26n sur VisDrone pendant 100 époques avec une taille d'image de 640 :

from 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.

Link to this sectionPourquoi VisDrone est-il difficile pour les détecteurs d'objets, et comment puis-je améliorer la précision ?#

Les objets dans VisDrone sont minuscules par rapport à l'image — souvent seulement quelques dizaines de pixels — et apparaissent dans des groupes denses et fortement occultés, ce qui met à rude épreuve les détecteurs optimisés sur des photos prises depuis le sol. L'entraînement et la prédiction à une résolution plus élevée (par exemple imgsz=1280 avec un lot plus petit) permettent de récupérer les petites cibles, et l'inférence par tuiles SAHI découpe les grandes images pour que les petits objets occupent une plus grande partie de chaque fenêtre d'inférence.

Link to this sectionQuelle est la différence entre VisDrone-DET et le benchmark complet VisDrone ?#

Le benchmark complet VisDrone couvre cinq tâches — détection d'objets dans les images, détection d'objets dans les vidéos, suivi d'un seul objet, suivi multi-objets, et comptage de foule — à travers 288 clips vidéo et 10 209 images statiques. La configuration VisDrone.yaml d'Ultralytics couvre uniquement 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.

Link to this sectionComment citer VisDrone dans mes recherches ?#

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.