Link to this sectionPrésentation des jeux de données pour l'estimation de profondeur#

L'estimation de profondeur monoculaire attribue une valeur de profondeur à virgule flottante en mètres à chaque pixel d'une image. La cible d'entraînement est une carte de profondeur dense par pixel stockée sous forme de tableau float32 .npy. Chaque valeur représente la distance entre la caméra et le point de la scène correspondant.

Ce guide explique le format de jeu de données utilisé par les modèles d'estimation de profondeur YOLO d'Ultralytics et répertorie les configurations de jeux de données intégrées disponibles pour l'entraînement et la validation.

Link to this sectionFormat de jeu de données pris en charge#

Link to this sectionFormat de carte de profondeur NPY#

Chaque échantillon d'entraînement se compose d'une image RGB et d'un fichier de profondeur .npy associé. Le fichier de profondeur stocke un tableau NumPy float32 2D de forme (H, W) où les valeurs sont des profondeurs en mètres.

• Les fichiers de profondeur doivent utiliser l'extension .npy et contenir un tableau float32.
• Chaque fichier de profondeur doit avoir le même radical que son fichier image correspondant (par exemple, scene_001.npy s'associe à scene_001.jpg).
• Le chargeur de jeu de données trouve les fichiers de profondeur en remplaçant la composante de répertoire images par depth dans le chemin d'accès et en remplaçant l'extension de l'image par .npy.
• Les pixels avec une profondeur ≤ 0 sont traités comme invalides et exclus du calcul de la perte et des métriques.

La disposition standard conserve les images et les cartes de profondeur dans des dossiers parallèles :

dataset/
├── images/
│   ├── train/
│   └── val/
└── depth/
    ├── train/
    └── val/

Par exemple, une image située dans images/train/scene_001.jpg est associée à une carte de profondeur dans depth/train/scene_001.npy.

Link to this sectionFormat YAML du jeu de données#

Les jeux de données d'estimation de profondeur sont configurés avec des fichiers YAML. Les champs principaux sont :

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

# NYU Depth V2 dataset for monocular depth estimation
# Documentation: https://cs.nyu.edu/~silberman/datasets/nyu_depth_v2.html
# 795 train + 654 val (Eigen test split) images, 480x640, indoor scenes, depth in meters
# Example usage: yolo depth train data=nyu-depth.yaml model=yolo26n-depth.pt
# parent
# ├── ultralytics
# └── datasets
#     └── nyu-depth  ← downloads here (≈1.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: nyu-depth # dataset root dir (relative to Ultralytics settings 'datasets_dir')
train: images/train # train images (relative to 'path') 795 images
val: images/val # val images (relative to 'path') 654 images

# Depth maps are paired .npy files (float32, meters) under depth/<split>/, resolved by
# swapping '/images/' -> '/depth/' on each image path.

# Classes
nc: 1
names:
  0: depth

channels: 3

# Download script/URL (optional)
download: https://github.com/ultralytics/assets/releases/download/v0.0.0/nyu-depth.zip

Link to this sectionUtilisation#

Entraîne un modèle d'estimation de profondeur YOLO26 avec Python ou CLI :

from ultralytics import YOLO

# Load a pretrained depth model
model = YOLO("yolo26n-depth.pt")

# Train on the NYU Depth V2 dataset
results = model.train(data="nyu-depth.yaml", epochs=100, imgsz=640)

Link to this sectionJeux de données pris en charge#

Les modèles de profondeur YOLO26 sont pré-entraînés sur un large mélange de jeux de données (~2,19 millions d'images) allant de l'intérieur (≤10 m) à l'extérieur (~80 m), puis évalués en zero-shot sur cinq benchmarks. Chaque jeu de données possède une page dédiée :

Débogage

• Depth8 — 8 images SUN RGB-D dans une archive à téléchargement automatique de 1,3 Mo, pour des tests rapides de pipeline

Sources de pré-entraînement

• ARKitScenes — intérieur réel, LiDAR Apple ARKit (la plus grande source réelle)
• SUN RGB-D — intérieur réel, RGB-D multi-capteurs
• DIODE — intérieur + extérieur réel, vérité terrain par scanner laser dense
• Hypersim — intérieur synthétique photoréaliste
• TartanAir — synthétique, environnements diversifiés
• Virtual KITTI 2 — conduite en extérieur synthétique
• KITTI — conduite en extérieur réel, Velodyne LiDAR (également un benchmark d'évaluation)
• ImageNet (pseudo-étiqueté) — ensemble de distillation pseudo-étiqueté, la plus grande source unique

Benchmarks d'évaluation

• NYU Depth V2 — benchmark intérieur principal
• KITTI Eigen — benchmark de conduite en extérieur
• ETH3D — intérieur + extérieur haute précision
• Make3D — extérieur, hors distribution
• iBims-1 — intérieur de haute qualité (bords et surfaces planes)

La précision par modèle sur ces benchmarks et les poids pré-entraînés téléchargeables sont listés sur la page de la tâche d'estimation de profondeur. Un YAML de jeu de données dont le champ train répertorie plusieurs répertoires d'images combine ces sources pour un entraînement mixte à grande échelle.

Link to this sectionAjouter ton propre jeu de données#

1. Enregistre les images RGB dans des dossiers de séparation tels que images/train et images/val.
2. Enregistre un tableau de profondeur float32 .npy par image dans les dossiers correspondants depth/train et depth/val en utilisant le même radical de fichier que l'image.
3. Assure-toi que les valeurs de profondeur sont en mètres et que les pixels invalides ou manquants utilisent 0 ou des valeurs négatives.
4. Crée un YAML de jeu de données avec path, train, val, nc: 1, et names: {0: depth}.

path: path/to/my-depth-dataset
train: images/train
val: images/val

nc: 1
names:
    0: depth

Link to this sectionFAQ#

Link to this sectionQuel format de fichier utiliser pour les cartes de profondeur ?#

Les cartes de profondeur doivent être enregistrées sous forme de fichiers NumPy .npy contenant des tableaux float32 de forme (H, W). Chaque élément stocke la profondeur en mètres pour le pixel d'image correspondant. N'utilise pas de formats PNG ou entier 16 bits — le chargeur attend des tableaux flottants bruts.

Link to this sectionComment les pixels de profondeur invalides sont-ils gérés ?#

Les pixels avec des valeurs de profondeur ≤ 0 sont traités comme invalides et masqués à la fois du calcul de la perte et de l'évaluation des métriques. Cela couvre le bruit des capteurs, les zones de ciel et les surfaces réfléchissantes où la profondeur ne peut pas être mesurée de manière fiable.

Link to this sectionQuelles métriques sont utilisées pour l'évaluation ?#

La validation de l'estimation de profondeur rapporte l'ensemble des métriques standard de Depth Anything :

• delta1 / delta2 / delta3 — pourcentage de pixels dans les seuils de 1,25×, 1,25²×, 1,25³×. Plus c'est élevé, mieux c'est.
• abs_rel — erreur relative absolue moyenne. Plus c'est bas, mieux c'est.
• rmse — erreur quadratique moyenne en mètres. Plus c'est bas, mieux c'est.
• silog — erreur logarithmique invariante à l'échelle. Plus c'est bas, mieux c'est.

Link to this sectionLes noms des fichiers de profondeur doivent-ils correspondre aux noms des fichiers images ?#

Oui. Chaque fichier de profondeur .npy doit partager le même radical que l'image correspondante. Le chargeur dérive le chemin de profondeur en remplaçant la composante de répertoire images par depth et en substituant l'extension de l'image par .npy. Les images dont le fichier de profondeur est manquant ou illisible sont ignorées lors du scan (mis en cache) du jeu de données avec un avertissement, exactement comme les images corrompues ; si aucune paire image-profondeur valide n'est trouvée, une erreur est générée.