Link to this sectionArgoverse Dataset#

The Ultralytics Argoverse dataset (Argoverse-HD) is a 2D object detection dataset of 54,446 labeled autonomous-driving images — 39,384 for training and 15,062 for validation — across 8 classes: person, bicycle, car, motorcycle, bus, truck, traffic light, and stop sign. The images are captured from a vehicle's ring-front-center camera, and the annotations come from Carnegie Mellon University's streaming-perception project, built on Argo AI's Argoverse 1.1 driving data. It is a large, real-world benchmark for training computer vision models to detect road objects in self-driving scenarios.

Link to this sectionKey Features#

• 8 object-detection classes: person, bicycle, car, motorcycle, bus, truck, traffic light, and stop sign.
• 54,446 labeled images — 39,384 for training and 15,062 for validation — plus an unlabeled test split reserved for the eval.ai challenge.
• ~31.5 GB of high-resolution ring-front-center camera frames captured in urban autonomous-driving scenes.
• Annotations are converted to YOLO format automatically on first use, so the dataset trains directly with Ultralytics YOLO detection models.

Link to this sectionDataset Structure#

The Argoverse-HD dataset is split into three predefined subsets, defined by the Argoverse.yaml configuration:

All images share the same 8 object classes (indices 0–7): person, bicycle, car, motorcycle, bus, truck, traffic light, and stop sign.

Link to this sectionApplications#

The Argoverse-HD dataset supports a range of object detection applications in autonomous driving:

• Self-driving perception — detect vehicles, pedestrians, and cyclists from a forward-facing camera to support autonomous-vehicle navigation.
• Advanced driver-assistance systems (ADAS) — recognize traffic lights and stop signs for real-time driver alerts.
• Traffic monitoring — count and track road users in urban scenes for smart-city analytics.
• Research and prototyping — a large, real-world benchmark for learning model training and prediction on driving data.

Link to this sectionDataset YAML#

A YAML file defines the dataset configuration, including paths, classes, and other relevant details. For the Argoverse dataset, the Argoverse.yaml file is maintained at https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/Argoverse.yaml.

# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license

# Argoverse-HD dataset (ring-front-center camera) by Argo AI: https://www.cs.cmu.edu/~mengtial/proj/streaming/
# Documentation: https://docs.ultralytics.com/datasets/detect/argoverse
# Example usage: yolo train data=Argoverse.yaml
# parent
# ├── ultralytics
# └── datasets
#     └── Argoverse ← downloads here (31.5 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: Argoverse # dataset root dir
train: Argoverse-1.1/images/train/ # train images (relative to 'path') 39384 images
val: Argoverse-1.1/images/val/ # val images (relative to 'path') 15062 images
test: Argoverse-1.1/images/test/ # test images (optional) https://eval.ai/web/challenges/challenge-page/800/overview

# Classes
names:
  0: person
  1: bicycle
  2: car
  3: motorcycle
  4: bus
  5: truck
  6: traffic_light
  7: stop_sign

# Download script/URL (optional) ---------------------------------------------------------------------------------------
download: |
  import json
  from pathlib import Path

  from ultralytics.utils import TQDM
  from ultralytics.utils.downloads import download

  def argoverse2yolo(annotation_file):
      """Convert Argoverse dataset annotations to YOLO format for object detection tasks."""
      labels = {}
      with open(annotation_file, encoding="utf-8") as f:
          a = json.load(f)
      for annot in TQDM(a["annotations"], desc=f"Converting {annotation_file} to YOLO format..."):
          img_id = annot["image_id"]
          img_name = a["images"][img_id]["name"]
          img_label_name = f"{Path(img_name).stem}.txt"

          cls = annot["category_id"]  # instance class id
          x_center, y_center, width, height = annot["bbox"]
          x_center = (x_center + width / 2) / 1920.0  # offset and scale
          y_center = (y_center + height / 2) / 1200.0  # offset and scale
          width /= 1920.0  # scale
          height /= 1200.0  # scale

          img_dir = annotation_file.parents[2] / "Argoverse-1.1" / "labels" / a["seq_dirs"][a["images"][annot["image_id"]]["sid"]]
          if not img_dir.exists():
              img_dir.mkdir(parents=True, exist_ok=True)

          k = str(img_dir / img_label_name)
          if k not in labels:
              labels[k] = []
          labels[k].append(f"{cls} {x_center} {y_center} {width} {height}\n")

      for k in labels:
          with open(k, "w", encoding="utf-8") as f:
              f.writelines(labels[k])

  # Download 'https://argoverse-hd.s3.amazonaws.com/Argoverse-HD-Full.zip' (deprecated S3 link)
  dir = Path(yaml["path"])  # dataset root dir
  urls = ["https://drive.google.com/file/d/1st9qW3BeIwQsnR0t8mRpvbsSWIo16ACi/view?usp=drive_link"]
  print("\n\nWARNING: Argoverse dataset MUST be downloaded manually, autodownload will NOT work.")
  print(f"WARNING: Manually download Argoverse dataset '{urls[0]}' to '{dir}' and re-run your command.\n\n")
  # download(urls, dir=dir)

  # Convert
  annotations_dir = "Argoverse-HD/annotations/"
  (dir / "Argoverse-1.1" / "tracking").rename(dir / "Argoverse-1.1" / "images")  # rename 'tracking' to 'images'
  for d in "train.json", "val.json":
      argoverse2yolo(dir / annotations_dir / d)  # convert Argoverse annotations to YOLO labels

Link to this sectionUsage#

To train a YOLO26n model on the Argoverse dataset for 100 epochs with an image size of 640, use the following code samples. 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
results = model.train(data="Argoverse.yaml", epochs=100, imgsz=640)

Once trained, run inference with the fine-tuned model on new driving images or video:

from ultralytics import YOLO

# Load a model
model = YOLO("path/to/best.pt")  # load an Argoverse fine-tuned model

# Inference using the model
results = model.predict("path/to/driving-scene.jpg")

Link to this sectionSample Data and Annotations#

The Argoverse-HD dataset contains high-resolution driving images captured from a ring-front-center camera, annotated with 2D bounding boxes for the 8 object classes. Below is an example image from the dataset with its corresponding annotations:

• Annotated driving scene: This image shows road objects — such as vehicles and pedestrians — labeled with 2D bounding boxes, the format YOLO models learn to predict during training.

Link to this sectionCitations and Acknowledgments#

The Argoverse-HD 2D detection annotations used in this dataset come from Carnegie Mellon University's streaming-perception work. If you use the dataset in your research or development, please cite:

@inproceedings{li2020towards,
  title={Towards Streaming Perception},
  author={Li, Mengtian and Wang, Yu-Xiong and Ramanan, Deva},
  booktitle={Proceedings of the European Conference on Computer Vision (ECCV)},
  pages={473--488},
  year={2020}
}

@inproceedings{chang2019argoverse,
  title={Argoverse: 3D Tracking and Forecasting with Rich Maps},
  author={Chang, Ming-Fang and Lambert, John and Sangkloy, Patsorn and Singh, Jagjeet and Bak, Slawomir and Hartnett, Andrew and Wang, Dequan and Carr, Peter and Lucey, Simon and Ramanan, Deva and others},
  booktitle={Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition},
  pages={8748--8757},
  year={2019}
}

We would like to acknowledge Carnegie Mellon University for the Argoverse-HD detection annotations and Argo AI for creating the original Argoverse dataset as a valuable resource for the autonomous-driving research community.

Link to this sectionFAQ#

Link to this sectionWhat is the Argoverse dataset, and what is it used for?#

The Ultralytics Argoverse dataset (Argoverse-HD) is a 2D object detection dataset of 54,446 autonomous-driving images across 8 classes — person, bicycle, car, motorcycle, bus, truck, traffic light, and stop sign. It is used to train and evaluate models that detect road objects from a forward-facing vehicle camera, supporting self-driving perception, ADAS, and traffic-monitoring research.

Link to this sectionHow many classes and images are in the Argoverse dataset?#

The Argoverse-HD dataset has 8 classes (person, bicycle, car, motorcycle, bus, truck, traffic light, and stop sign) and 54,446 labeled images — 39,384 for training and 15,062 for validation — plus an unlabeled test split reserved for the eval.ai challenge.

Link to this sectionIs the Argoverse dataset 2D or 3D detection in Ultralytics?#

In Ultralytics it is a 2D object detection dataset (Argoverse-HD camera frames with 2D bounding boxes), not the 3D-tracking, motion-forecasting, or LiDAR research suite from the broader Argoverse program. You train it with a standard detection model such as yolo26n.pt.

Link to this sectionHow do I train a YOLO26 model using the Argoverse dataset?#

Download the dataset manually first (see below), then train with the Argoverse.yaml configuration file:

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="Argoverse.yaml", epochs=100, imgsz=640)

For a detailed explanation of the arguments, refer to the model Training page.

Link to this sectionWhere can I download the Argoverse dataset now that it has been removed from Amazon S3?#

The Argoverse-HD *.zip file (~31.5 GB), previously hosted on Amazon S3, can now be downloaded manually from Google Drive. Automatic download will not work, so fetch the archive before running your training command.

Link to this sectionCan I use the Argoverse dataset with Ultralytics Platform?#

Yes. Ultralytics Platform lets you upload and version large datasets like Argoverse-HD, then train and deploy object detection models in the cloud without heavy local setup. You can also browse related datasets in the detection datasets overview.