Présentation des jeux de données pour l’estimation de la 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 images PNG en niveaux de gris 16 bits mises à 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 la 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 comprend une image RGB et 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 pour obtenir des mètres. La valeur par défaut est 1000 : une valeur de 1500 représente donc 1.5 mètres. Le code 0 indique une valeur invalide ; les fichiers 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 en niveaux de gris uint16 à 2 dimensions. Les tableaux NPY doivent être à 2 dimensions et à virgule flottante, avec des valeurs exprimées en mètres.
• Définis depth_scale uniquement si les fichiers 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 (p. ex., scene_001.png correspond à scene_001.jpg).
• Les cartes de profondeur peuvent être plus petites que leurs images RGB, à condition que leur rapport hauteur/largeur soit identique ; 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 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 fonction de perte et des métriques.

Comme le code 0 est réservé aux pixels invalides, un fichier PNG uint16 fournit 65 535 valeurs de profondeur positives. L’échelle détermine à la fois la précision et la plage :

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

La structure standard organise 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 située dans depth/train/scene_001.png.

Format YAML du jeu de données#

Les jeux de données d’estimation de la profondeur sont configurés au moyen de fichiers YAML. Les principaux champs 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 YOLO26 d’estimation de la profondeur avec Python ou la CLI :

from ultralytics import YOLO

# Charger un modèle de profondeur préentraîné
model = YOLO("yolo26n-depth.pt")

# Entraîner sur le jeu de données NYU Depth V2
results = model.train(data="nyu-depth.yaml", epochs=100, imgsz=640)

Jeux de données pris en charge#

Les modèles YOLO26 d’estimation de la profondeur sont préentraînés sur un vaste mélange de plusieurs jeux de données (environ 2,19 millions d’images), couvrant une plage allant de l’intérieur (≤ 10 m) à l’extérieur (environ 80 m), puis évalués sur cinq références, en mode zéro-shot sur toutes sauf KITTI Eigen. Chaque jeu de données dispose d’une page dédiée, et plusieurs sont hébergés sur Ultralytics Platform pour consultation et entraînement dans le cloud.

Débogage

• Depth8 — 8 images SUN RGB-D dans une archive de 1,3 Mo à téléchargement automatique, 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 — environnements synthétiques variés
• Virtual KITTI 2 — conduite extérieure synthétique
• KITTI — conduite réelle en extérieur, LiDAR Velodyne (également une référence d’évaluation)
• ImageNet (pseudo-étiqueté) — jeu de données de distillation pseudo-étiqueté, la plus grande source unique

Références d’évaluation

• NYU Depth V2 — principale référence pour l’intérieur
• KITTI Eigen — référence pour la conduite en extérieur
• ETH3D — intérieur et extérieur haute précision
• Make3D — extérieur, hors distribution
• iBims-1 — intérieur de haute qualité (contours et surfaces planes)

La précision de chaque modèle sur ces références et les poids préentraînés téléchargeables sont répertoriés sur la page de la tâche d’estimation de la 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 dans des dossiers de partition, tels que images/train et images/val.
2. Enregistre un fichier de profondeur PNG ou NPY 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 fichiers PNG compacts en millimètres.
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#