Présentation des jeux de données pour l'estimation de profondeur#

L'estimation de la profondeur monoculaire attribue une valeur de profondeur en mètres à chaque pixel d'une image. Les cibles de profondeur utilisent soit des fichiers PNG en nuances de gris 16 bits mis à l'échelle, soit des tableaux NPY à virgule flottante en mètres.

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.

Format de jeu de données pris en charge#

Format de carte de profondeur#

Chaque échantillon d'entraînement se compose d'une image RGB et d'un fichier de profondeur associé. Les valeurs PNG sont divisées par depth_scale au niveau du jeu de données optionnel pour produire des mètres. La valeur par défaut est 1000, donc une valeur de 1500 représente 1.5 mètres. Le code 0 signifie invalide ; les PNG ne nécessitent aucune métadonnée intégrée.

• Les fichiers de profondeur utilisent .png (recommandé) ou .npy. Les cartes PNG doivent être des images en nuances de gris uint16 2D. Les tableaux NPY doivent être 2D et à virgule flottante, avec des valeurs en mètres.
• Définis depth_scale uniquement lorsque les PNG n'utilisent pas la convention millimétrique par défaut. Par exemple, KITTI utilise 256 et Virtual KITTI 2 utilise 100.
• Chaque fichier de profondeur doit avoir le même nom de base que son fichier d'image correspondant (par exemple, scene_001.png est associé à scene_001.jpg).
• Les cartes de profondeur peuvent être plus petites que leurs images RGB tant que le rapport hauteur/largeur correspond ; l'entraînement les redimensionne en mémoire.
• Le chargeur de jeu de données trouve les fichiers de profondeur en remplaçant le composant de répertoire images par depth, en privilégiant .png et en se repliant sur .npy.
• Les pixels avec une profondeur ≤ 0 sont traités comme invalides et exclus du calcul de la perte et des métriques.

Étant donné que le code 0 est réservé aux pixels invalides, un PNG uint16 fournit 65 535 valeurs de profondeur positives. L'échelle contrôle à la fois la précision et la plage :

Ce sont des limites de stockage, et non des plafonds d'entraînement recommandés. Un jeu de données peut définir un max_depth plus petit indépendamment pour l'étalonnage de la perte ou l'évaluation.

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 à images/train/scene_001.jpg est associée à une carte de profondeur située à depth/train/scene_001.png.

Format 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/~fergus/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-png  ← 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-png # 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 uint16 millimeter PNGs under depth/<split>/, resolved by
# swapping '/images/' -> '/depth/' on each image path.

# Classes
nc: 1
names:
  0: depth

channels: 3
depth_scale: 1000

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

Utilisation#

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)

Jeux 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 de téléchargement automatique de 1,3 Mo, pour un test rapide du pipeline

Sources de pré-entraînement

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

Benchmarks d'évaluation

• NYU Depth V2 — principal banc d'essai pour l'intérieur
• KITTI Eigen — banc d'essai pour la conduite extérieure
• ETH3D — intérieur et extérieur de haute précision
• Make3D — extérieur, hors distribution
• iBims-1 — intérieur de haute qualité (bords et surfaces planaires)

La précision par modèle sur ces bancs d'essai et les poids pré-entraînés téléchargeables sont répertoriés sur la page de la tâche Estimation de profondeur. Un fichier 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.

Ajouter ton propre jeu de données#

1. Enregistre les images RGB sous des dossiers de division tels que images/train et images/val.
2. Enregistre un PNG ou NPY de profondeur par image sous les dossiers correspondants depth/train et depth/val en utilisant le même nom de fichier de base que l'image. Utilise save_depth_png() pour convertir des tableaux en mètres en PNG millimétriques compacts.
3. Assure-toi que les valeurs de profondeur décodées sont en mètres et que les pixels invalides ou manquants utilisent 0 ou des valeurs négatives.
4. Crée un fichier 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

# Optional: PNG integer units per meter (default 1000)
depth_scale: 1000

FAQ#