Présentation des jeux de données d’estimation de profondeur#

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

Ce guide explique le format de jeu de données utilisé par les modèles Ultralytics YOLO d’estimation de profondeur 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 des cartes 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 le depth_scale facultatif défini au niveau du jeu de données afin de 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 que la valeur est invalide ; les PNG n’ont pas besoin de métadonnées intégrées.

• Les fichiers de profondeur utilisent .png (recommandé) ou .npy. Les cartes PNG doivent être des images 2D en niveaux de gris uint16. Les tableaux NPY doivent être en 2D et à virgule flottante, avec des valeurs exprimées en mètres.
• Définis depth_scale uniquement lorsque les PNG n’utilisent pas la convention par défaut en millimètres. Par exemple, KITTI utilise 256 et Virtual KITTI 2 utilise 100.
• Chaque fichier de profondeur doit avoir le même nom de base que le fichier image correspondant (par exemple, scene_001.png est associé à scene_001.jpg).
• Les cartes de profondeur peuvent être plus petites que leurs images RGB, à condition que le rapport d’aspect soit identique ; l’entraînement les redimensionne en mémoire.
• Le chargeur de jeux de données recherche les fichiers de profondeur en remplaçant le composant de répertoire images par depth, en donnant la préférence à .png et en utilisant .npy comme solution de repli.
• Les pixels dont la profondeur est ≤ 0 sont considérés comme invalides et exclus du calcul de la perte et des métriques.

Comme 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 de valeurs :

Il s’agit de limites de stockage, et non de plafonds d’entraînement recommandés. Un jeu de données peut définir indépendamment une valeur max_depth plus petite pour l’étalonnage de la perte ou l’évaluation.

La structure 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 principaux champs sont les suivants :

# 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 YOLO26 d’estimation de profondeur avec Python ou la 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 multi-ensembles de données (~2,19M d'images) couvrant des plages d'intérieur (≤10 m) à d'extérieur (~80 m), puis évalués sur cinq benchmarks, en mode zéro-shot sur tous sauf KITTI Eigen. Chaque ensemble de données possède une page dédiée, et plusieurs sont hébergés sur Ultralytics Platform pour la navigation et l'entraînement dans le cloud.

Débogage

• Depth8 — 8 images SUN RGB-D dans une archive de 1,3 Mo téléchargée automatiquement, pour tester rapidement le 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 multisenseur
• DIODE — intérieur et extérieur réels, vérité terrain dense issue d’un scanner laser
• Hypersim — intérieur synthétique photoréaliste
• TartanAir — synthétique, environnements variés
• Virtual KITTI 2 — conduite extérieure synthétique
• KITTI — conduite extérieure réelle, LiDAR Velodyne (également un benchmark d’évaluation)
• ImageNet (pseudo-étiqueté) — jeu de distillation pseudo-étiqueté, la plus grande source unique

Benchmarks d’évaluation

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

La précision de chaque modèle sur ces benchmarks ainsi que les poids préentraînés téléchargeables sont répertorié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.

Ajouter ton propre jeu de données#

1. Enregistre les images RGB dans des dossiers de découpage tels que images/train et images/val.
2. Enregistre un PNG ou NPY de profondeur par image dans les dossiers correspondants depth/train et depth/val, en utilisant le même nom de base que l’image. Utilise save_depth_png() pour convertir les tableaux en mètres en PNG compacts en millimètres.
3. Vérifie que les valeurs de profondeur décodées sont exprimées 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#