Jeu de données Argoverse#

66,953

Argoverse-HD

ultralytics

publicDetect

Argoverse-HD is an autonomous-driving object detection dataset derived from Argoverse 1.1 ring-front-center tracking images with Argoverse-HD annotations from Carnegie Mellon University's Streaming Perception benchmark. This normalized release contains 66,953 globally unique 1920 x 1200 images: 39,384 train, 15,062 validation, and 12,507 unlabeled test images. The 54,446 train/validation images contain 1,025,715 boxes across 8 classes; 19 are background images without boxes. Data and documentation © 2018-2019 Argo AI, LLC, licensed CC BY-NC-SA 4.0. Argoverse-HD annotations are attributed to the CMU Streaming Perception project.

8 classes23.5 GBAug 21, 2026

personbicyclecarmotorcycle+4

autonomous-drivingobject-detectionargoverse+1

Le jeu de données Ultralytics Argoverse (Argoverse-HD) est un jeu de données de détection d'objets 2D de 54 446 images de conduite autonome — 39 384 pour l'entraînement et 15 062 pour la validation — réparties en 8 classes : personne, vélo, voiture, moto, bus, camion, feu de circulation et panneau stop. Les images sont capturées par la caméra avant centrale d'un véhicule, et les annotations proviennent du projet de perception en continu de l'Université Carnegie Mellon, basé sur les données de conduite Argoverse 1.1 d'Argo AI. C'est un grand benchmark du monde réel pour l'entraînement de modèles de vision par ordinateur afin de détecter des objets routiers dans des scénarios de conduite autonome.

Explore Argoverse-HD on Ultralytics Platform pour prévisualiser des exemples annotés, inspecter les statistiques du dataset et le cloner pour l'entraînement.

Fonctionnalités clés#

• 8 classes de détection d'objets : personne, vélo, voiture, moto, bus, camion, feu de signalisation et panneau stop.
• 54 446 images étiquetées — 39 384 pour l'entraînement et 15 062 pour la validation — plus un jeu de test non étiqueté réservé au défi eval.ai.
• ~31,5 Go d'images haute résolution capturées par la caméra avant centrale dans des scènes de conduite urbaine autonome.
• Les annotations sont automatiquement converties au format YOLO lors de la première utilisation, permettant ainsi d'entraîner le jeu de données directement avec les modèles de détection Ultralytics YOLO.

Structure du jeu de données#

Le jeu de données Argoverse-HD est divisé en trois sous-ensembles prédéfinis, définis par la configuration Argoverse.yaml :

Toutes les images partagent les 8 mêmes classes d'objets (indices 0–7) : personne, vélo, voiture, moto, bus, camion, feu de signalisation et panneau stop.

Applications#

Le jeu de données Argoverse-HD prend en charge une gamme d'applications de détection d'objets en conduite autonome :

• Perception en conduite autonome — détecte les véhicules, les piétons et les cyclistes à partir d'une caméra orientée vers l'avant pour prendre en charge la navigation de véhicules autonomes.
• Systèmes avancés d'aide à la conduite (ADAS) — reconnaître les feux de signalisation et les panneaux stop pour des alertes conducteur en temps réel.
• Surveillance du trafic — compter et suivre les usagers de la route dans des scènes urbaines pour l'analyse des villes intelligentes.
• Recherche et prototypage — un grand benchmark du monde réel pour l'apprentissage de l'entraînement de modèles et de la prédiction sur des données de conduite.

YAML du jeu de données#

Un fichier YAML définit la configuration du jeu de données, y compris les chemins, les classes et d'autres détails pertinents. Pour le jeu de données Argoverse, le fichier Argoverse.yaml est maintenu sur 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

Utilisation#

Pour entraîner un modèle YOLO26n sur le jeu de données Argoverse pendant 100 époques avec une taille d'image de 640, utilise les exemples 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
results = model.train(data="Argoverse.yaml", epochs=100, imgsz=640)

Une fois entraîné, exécute l'inférence avec le modèle affiné sur de nouvelles images ou vidéos de conduite :

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

Exemples de données et d'annotations#

Le jeu de données Argoverse-HD contient des images de conduite haute résolution capturées par une caméra avant centrale, annotées avec des boîtes englobantes 2D pour les 8 classes d'objets. Voici ci-dessous un exemple d'image issue du jeu de données avec ses annotations correspondantes :

• Scène de conduite annotée : Cette image montre des objets routiers — tels que des véhicules et des piétons — labellisés avec des boîtes englobantes 2D, le format que les modèles YOLO apprennent à prédire durant l'entraînement.

Citations et remerciements#

Les annotations de détection 2D Argoverse-HD utilisées dans ce jeu de données proviennent des travaux de perception en flux continu de l'Université Carnegie Mellon. Si tu utilises ce jeu de données dans tes recherches ou ton développement, merci de citer :

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

Nous tenons à remercier l'Université Carnegie Mellon pour les annotations de détection d'Argoverse-HD et Argo AI pour avoir créé le jeu de données Argoverse d'origine en tant que ressource précieuse pour la communauté de recherche sur la conduite autonome.

FAQ#