Link to this sectionVisDrone Dataset#

The VisDrone Dataset is a large-scale drone-imagery benchmark whose detection subset (VisDrone2019-DET) provides 8,629 aerial images — 6,471 train, 548 validation, and 1,610 test-dev — annotated with 10 object classes for object detection. It was created by the AISKYEYE team at the Lab of Machine Learning and Data Mining, Tianjin University, China.

The full VisDrone benchmark comprises 288 video clips (261,908 frames) and 10,209 static images captured by drone-mounted cameras in 14 different cities across China, spanning urban and rural environments, sparse and crowded scenes, and varied weather and lighting conditions. Its frames carry over 2.6 million manually annotated bounding boxes, with extra attributes such as scene visibility, object class, and occlusion. The Ultralytics VisDrone.yaml configuration uses the VisDrone2019-DET static-image subset of this benchmark.

Link to this sectionKey Features#

• Small, dense objects: Aerial viewpoints make targets tiny and crowded — the 548 validation images alone contain 38,759 labeled boxes, an average of about 70 objects per image.
• Scene diversity: Imagery from 14 Chinese cities covering urban and rural locations, day and night, and different weather conditions.
• Rich annotations: Over 2.6 million boxes across the full benchmark, with occlusion and visibility attributes.
• Pre-defined splits: Fixed train / val / test-dev splits (6,471 / 548 / 1,610 images) for consistent evaluation.

Link to this sectionDataset Structure#

The Ultralytics VisDrone configuration covers the VisDrone2019-DET image subset, split into three parts:

A fourth split, test-challenge (1,580 images), is withheld for the VisDrone competition and is not downloaded, which is why the full DET set totals 10,209 images.

The dataset annotates 10 object classes: pedestrian, people, bicycle, car, van, truck, tricycle, awning-tricycle, bus, and motor. VisDrone distinguishes pedestrian (a person standing or walking) from people (a person in any other posture).

Link to this sectionApplications#

VisDrone's dense scenes and tiny targets make it a standard benchmark for small-object detection from aerial viewpoints. Common applications include:

• Traffic monitoring and vehicle counting from UAVs
• Crowd analysis and public-safety surveillance
• Infrastructure and construction-site inspection
• Computer vision research on detecting small objects in cluttered scenes

For other aerial-imagery benchmarks, see the satellite-focused xView dataset or the oriented-box DOTA-v2 dataset.

Link to this sectionDataset YAML#

The VisDrone.yaml file defines the dataset configuration — the dataset paths, class names, and the automatic download-and-convert script. It is maintained in the Ultralytics repository at 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 sectionUsage#

To train a YOLO26n model on the VisDrone dataset for 100 epochs with an image size of 640, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model Training page.

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)

To label additional aerial images and manage VisDrone training runs in your browser, use Ultralytics Platform.

Link to this sectionSample Data and Annotations#

The sample below shows a typical VisDrone scene: an aerial viewpoint over a busy road where pedestrians and vehicles appear as small, densely packed targets, many partially occluded by one another.

Link to this sectionCitations and Acknowledgments#

If you use the VisDrone dataset in your research or development work, please cite the following paper:

@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}}

We would like to acknowledge the AISKYEYE team at the Lab of Machine Learning and Data Mining, Tianjin University, China, for creating and maintaining the VisDrone dataset. For more information, visit the VisDrone Dataset GitHub repository.

Link to this sectionFAQ#

Link to this sectionWhat is the VisDrone dataset used for?#

VisDrone is used to train and benchmark detectors on drone-captured imagery, where objects are small, dense, and seen from above. Its combination of aerial viewpoints, crowded scenes, and varied conditions makes it a standard testbed for UAV-based traffic monitoring, crowd analysis, and small-object detection research.

Link to this sectionHow many images and classes does VisDrone have?#

The Ultralytics VisDrone configuration contains 8,629 images: 6,471 for training, 548 for validation, and 1,610 for testing (test-dev). All splits share the same 10 classes: pedestrian, people, bicycle, car, van, truck, tricycle, awning-tricycle, bus, and motor. See Dataset Structure for the full breakdown.

Link to this sectionHow do I download the VisDrone dataset?#

VisDrone downloads automatically the first time you train with data="VisDrone.yaml" — no manual steps are required. The script fetches three archives (about 2 GB) from Ultralytics GitHub release assets and converts the annotations to YOLO format. The competition's withheld test-challenge split is not included.

Link to this sectionHow do I train a YOLO26 model on the VisDrone dataset?#

Train a YOLO26n model on VisDrone for 100 epochs at an image size of 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)

For detailed configurations, see the Training page and model training tips.

Link to this sectionWhy is VisDrone difficult for object detectors, and how can I improve accuracy?#

Objects in VisDrone are tiny relative to the frame — often only a few dozen pixels — and appear in dense, heavily occluded groups, which strains detectors tuned on ground-level photos. Training and predicting at a higher resolution (for example imgsz=1280 with a smaller batch) recovers small targets, and SAHI tiled inference slices large images so small objects occupy more of each inference window.

Link to this sectionWhat is the difference between VisDrone-DET and the full VisDrone benchmark?#

The full VisDrone benchmark spans five tasks — object detection in images, object detection in videos, single-object tracking, multi-object tracking, and crowd counting — across 288 video clips and 10,209 static images. The Ultralytics VisDrone.yaml configuration covers only the image detection task (VisDrone2019-DET), downloading its 6,471 train, 548 validation, and 1,610 test-dev images.

Link to this sectionHow do I cite VisDrone in my research?#

Cite the paper "Detection and Tracking Meet Drones Challenge" (IEEE TPAMI, vol. 44, no. 11, 2022, DOI 10.1109/TPAMI.2021.3119563); the full BibTeX entry is in the Citations and Acknowledgments section above.