Link to this sectionJeu de données de profondeur KITTI#

Le jeu de données KITTI est un benchmark de conduite autonome en extérieur issu du monde réel, capturé depuis un véhicule en mouvement dans et autour de la ville de Karlsruhe. Pour l'estimation de profondeur monoculaire, la profondeur de vérité terrain est dérivée d'un scanner LiDAR Velodyne HDL-64 et densifiée en utilisant la méthode de Uhrig et al. 2017. Les cartes de profondeur résultantes restent éparses, avec environ 16 à 20 % des pixels possédant une valeur de profondeur valide. KITTI est la seule source réelle d'extérieur à longue portée dans le mix de pré-entraînement de YOLO26-Depth et sert également de benchmark d'évaluation KITTI Eigen.

Link to this sectionFonctionnalités clés#

• Scènes de conduite réelles en extérieur avec des profondeurs allant jusqu'à environ 80 m, bien au-delà de la portée intérieure typique.
• Vérité terrain de profondeur obtenue à partir d'un LiDAR Velodyne HDL-64 et densifiée avec l'approche Sparsity Invariant CNNs de Uhrig et al. 2017.
• Supervision éparse : seuls environ 16 à 20 % des pixels par image possèdent une valeur de profondeur valide ; les pixels invalides sont masqués lors du calcul de la perte et des métriques.
• Les paires d'images stéréo (gauche image_02 et droite image_03) fournissent des points de vue supplémentaires pour l'entraînement.
• Les valeurs de profondeur sont stockées sous forme de tableaux float32 .npy en mètres, suivant le format de jeu de données de profondeur Ultralytics.

Link to this sectionStructure du jeu de données#

Les données de profondeur KITTI utilisées par Ultralytics sont divisées en deux sous-ensembles :

1. Split d'entraînement : 60 040 images (gauche image_02 et droite image_03). Les 28 trajets de test KITTI Eigen sont exclus de l'entraînement pour garantir une évaluation équitable.
2. Split d'évaluation : le split de test KITTI Eigen, 32 378 images (les deux caméras). L'évaluation utilise le recadrage Garg, une limite de profondeur de 80 m et un alignement log-moindres carrés entre les prédictions et la vérité terrain.

La plage de profondeur atteint environ 80 m, et le fichier YAML du jeu de données (depth-kitti.yaml) définit max_depth: 80 en conséquence.

Link to this sectionRôle dans YOLO26-Depth#

KITTI fournit la seule supervision réelle en extérieur et à longue portée dans le mix de pré-entraînement YOLO26-Depth, complétant les sources principalement intérieures. C'est également le benchmark standard KITTI Eigen pour rapporter la précision de profondeur en scène de conduite.

KITTI est un exemple clé de la raison pour laquelle la tête de profondeur est non bornée (mode log) : un plafond de sortie fixe de 10 m ne peut pas représenter des scènes de conduite de 80 m. Consulte la page de tâche de profondeur pour plus de détails sur la plage de sortie de la tête et la gestion de max_depth.

Link to this sectionRésultats#

Précision delta1 de KITTI Eigen par taille de modèle (plus c'est élevé, mieux c'est) :

Link to this sectionYAML du jeu de données#

Un fichier YAML (Yet Another Markup Language) est utilisé pour définir la configuration du jeu de données. Il contient des informations sur les chemins du jeu de données, les classes et d'autres informations pertinentes telles que la profondeur maximale.

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

# KITTI dataset for monocular depth estimation — real outdoor driving, Velodyne HDL-64 LiDAR (densified), sparse, up to ~80 m
# Documentation: https://docs.ultralytics.com/datasets/depth/kitti
# Example usage: yolo depth train data=depth-kitti.yaml model=yolo26n-depth.pt
# parent
# ├── ultralytics
# └── datasets
#     └── depth-kitti  ← downloads here (~190 GB archives, ~230 GB converted)
#         ├── images/{train,val}  # RGB images
#         └── depth/{train,val}   # paired *.npy, float32 meters (images/ -> depth/)
# If an interrupted download leaves a partial dataset, delete the depth-kitti dir and re-run to rebuild it.

path: depth-kitti # dataset root dir (relative to Ultralytics settings 'datasets_dir')
train: images/train # train images (relative to 'path') 60040 images
val: images/val # val images (relative to 'path') 32378 images (KITTI Eigen test split)
max_depth: 80 # (m) maximum valid depth; GT beyond this is excluded from val metrics

nc: 1
names:
  0: depth

channels: 3

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

  import cv2
  import numpy as np

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

  # Drives of the 28 KITTI Eigen test scenes -> val; every other annotated drive -> train
  VAL_DRIVES = """2011_09_26_drive_0002 2011_09_26_drive_0009 2011_09_26_drive_0013 2011_09_26_drive_0020
  2011_09_26_drive_0023 2011_09_26_drive_0027 2011_09_26_drive_0029 2011_09_26_drive_0036 2011_09_26_drive_0046
  2011_09_26_drive_0048 2011_09_26_drive_0052 2011_09_26_drive_0056 2011_09_26_drive_0059 2011_09_26_drive_0064
  2011_09_26_drive_0084 2011_09_26_drive_0086 2011_09_26_drive_0093 2011_09_26_drive_0096 2011_09_26_drive_0101
  2011_09_26_drive_0106 2011_09_26_drive_0117 2011_09_28_drive_0002 2011_09_29_drive_0026 2011_09_29_drive_0071
  2011_09_30_drive_0016 2011_10_03_drive_0034 2011_10_03_drive_0042 2011_10_03_drive_0047""".split()
  # Annotated drives excluded from the release training set (raw data was unavailable at build time)
  SKIP_DRIVES = {"2011_09_28_drive_0104", "2011_09_28_drive_0135", "2011_09_28_drive_0177", "2011_09_28_drive_0214"}

  # Download the improved sparse GT (~14 GB) and the raw recordings it covers (~175 GB)
  dir = Path(yaml["path"])  # dataset root dir
  base = "https://s3.eu-central-1.amazonaws.com/avg-kitti"
  download([f"{base}/data_depth_annotated.zip"], dir=dir / "source", delete=True, exist_ok=True)
  gt_drives = sorted(p for p in (dir / "source" / "data_depth_annotated").glob("*/*_sync") if p.name[:-5] not in SKIP_DRIVES)
  urls = [f"{base}/raw_data/{p.name[:-5]}/{p.name}.zip" for p in gt_drives]
  download(urls, dir=dir / "source" / "raw", delete=True, exist_ok=True, threads=4)

  # Convert: GT PNGs are uint16 meters*256; RGB frames come from the matching raw drive
  for split in ("train", "val"):
      (dir / "images" / split).mkdir(parents=True, exist_ok=True)
      (dir / "depth" / split).mkdir(parents=True, exist_ok=True)
  for gt in TQDM(gt_drives, desc="Converting"):
      drive = gt.name[:-5]  # 2011_09_26_drive_0002
      split = "val" if drive in VAL_DRIVES else "train"
      for cam in ("image_02", "image_03"):
          for png in sorted((gt / "proj_depth" / "groundtruth" / cam).glob("*.png")):
              name = f"{drive}_{cam[-2:]}_{png.stem}"
              depth = cv2.imread(str(png), cv2.IMREAD_ANYDEPTH).astype(np.float32) / 256.0
              np.save(dir / "depth" / split / f"{name}.npy", depth)
              raw = dir / "source" / "raw" / drive[:10] / gt.name / cam / "data" / png.name
              raw.replace(dir / "images" / split / f"{name}.png")
  shutil.rmtree(dir / "source")

Link to this sectionUtilisation#

Pour entraîner un modèle YOLO26n-Depth sur le jeu de données KITTI pendant 100 époques, 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 pretrained depth model
model = YOLO("yolo26n-depth.pt")

# Train the model on KITTI
results = model.train(data="depth-kitti.yaml", epochs=100, imgsz=640)

Link to this sectionModèles pré-entraînés#

Les modèles pré-entraînés YOLO26-Depth se téléchargent automatiquement depuis la version des ressources v8.4.0 d'Ultralytics lorsqu'ils sont référencés par leur nom pour la première fois :

• YOLO26n-Depth
• YOLO26s-Depth
• YOLO26m-Depth
• YOLO26l-Depth
• YOLO26x-Depth

Link to this sectionCitations et remerciements#

Si tu utilises le jeu de données KITTI dans tes travaux de recherche ou de développement, merci de citer les articles suivants :

@article{geiger2013vision,
      title={Vision meets Robotics: The KITTI Dataset},
      author={Geiger, Andreas and Lenz, Philip and Stiller, Christoph and Urtasun, Raquel},
      journal={The International Journal of Robotics Research},
      year={2013},
      publisher={SAGE Publications}
}

@inproceedings{uhrig2017sparsity,
      title={Sparsity Invariant CNNs},
      author={Uhrig, Jonas and Schneider, Nick and Schneider, Lukas and Franke, Uwe and Brox, Thomas and Geiger, Andreas},
      booktitle={International Conference on 3D Vision (3DV)},
      year={2017}
}

Nous souhaitons remercier le Karlsruhe Institute of Technology et le Toyota Technological Institute at Chicago pour avoir créé et maintenu le jeu de données KITTI, ainsi que Uhrig et al. pour la méthode de densification de profondeur qui rend possible la supervision dense.