Estimation de la profondeur monoculaire avec Ultralytics YOLO#

L’estimation de la profondeur monoculaire prédit une carte de profondeur par pixel à partir d’une seule image RGB. Chaque pixel de sortie contient une valeur de profondeur en mètres représentant la distance estimée entre la caméra et ce point de la surface.

La sortie d’un modèle de profondeur est une carte flottante dense de forme (H, W), alignée sur l’image d’entrée. Cette représentation par pixel rend l’estimation de la profondeur monoculaire particulièrement adaptée à la reconstruction de scènes 3D, à la navigation des robots, à la création de contenu AR/VR et à toute application nécessitant la disposition spatiale d’une scène à partir d’une seule caméra.

Modèles#

Les modèles de profondeur YOLO26 préentraînés sur un vaste mélange de jeux de données (intérieur + extérieur, ~2,19 M d’images) sont présentés ci-dessous. Les colonnes de métriques sont calculées sur le split de test Eigen de NYU Depth V2.

Les modèles sont automatiquement téléchargés depuis la dernière version d’Ultralytics lors de la première utilisation.

• delta1^NYU est le pourcentage de pixels pour lesquels la profondeur prédite se situe dans un facteur de 1,25 par rapport à la vérité terrain, sur le split de test Eigen de NYU Depth V2 (654 images), avec TTA multi-échelle et retournement horizontal, ainsi qu’un alignement par moindres carrés logarithmiques.
• La précision à une seule échelle sans TTA est reproductible avec yolo depth val model=yolo26n-depth.pt data=nyu-depth.yaml imgsz=768 device=0 (remplace model= par chaque taille), qui utilise un alignement médian (à l’échelle uniquement) et obtient des scores inférieurs : delta1 0,783 (n), 0,793 (s), 0,840 (m), 0,853 (l), 0,860 (x).
• abs_rel est l’erreur relative absolue moyenne entre les valeurs de profondeur prédites et celles de la vérité terrain.
• rmse est la racine de l’erreur quadratique moyenne, en mètres.
• La vitesse correspond à la latence d’inférence uniquement (prétraitement et post-traitement exclus) à imgsz=768, batch=1, rapportée comme moyenne ± écart type sur plusieurs exécutions chronométrées après préchauffage. CPU ONNX correspond à ONNX Runtime fp32 sur un Intel Xeon à 32 cœurs (Skylake) ; T4 TensorRT10 correspond à TensorRT fp16 sur une Tesla T4.
• params et FLOPs sont mesurés à 768×768, la résolution d’entraînement des poids publiés.

Consulte l'aperçu non publié de YOLO27 pour les résultats préliminaires sur NYU Depth V2.

Vitesse comparée à Depth Anything V2#

Depth Anything V2 est une référence ouverte largement utilisée pour la profondeur monoculaire. Son backbone DINOv2 et son décodeur DPT basés sur un transformer de vision nécessitent beaucoup de calcul ; ainsi, sur la même Tesla T4 avec TensorRT fp16, le plus petit modèle Depth Anything V2 publié est plus lent que tous les modèles de profondeur YOLO26 — y compris YOLO26x-depth, qui compte plus de deux fois plus de paramètres.

À ~768 px — imgsz=768 pour YOLO26, la résolution à laquelle ses poids publiés sont entraînés, et 770 px pour Depth Anything V2, dont le backbone DINOv2 exige un multiple de la taille de ses patches, soit 14 :

À ~640 px — imgsz=640 et 644 px respectivement — l’ordre reste inchangé, et YOLO26n-depth est 5,9× plus rapide que Depth Anything V2 Small :

• La latence correspond à l’inférence uniquement, batch=1, avec TensorRT fp16 sur une Tesla T4 — le même banc de test que pour le tableau des modèles ci-dessus, affiché ici avec deux décimales ; les FPS correspondent à l’inverse de la latence non arrondie. Les colonnes Accélération divisent la latence de Depth Anything V2 Small (20,99 ms) et Base (55,40 ms) par la latence de YOLO26.
• Depth Anything V2 Small et Base correspondent aux checkpoints ViT-S et ViT-B publiés.
• La comparaison porte uniquement sur la latence — les deux familles de modèles ne sont pas évaluées ici selon un protocole de précision commun.

Plage de profondeur et tête de profondeur logarithmique#

La tête de profondeur prédit exp(logit) — non bornée (~0,02–150 m) — et dissocie la forme de la scène de l’échelle absolue : le réseau prédit un champ de profondeur logarithmique relative, et les mètres absolus sont définis par une transformation distincte à deux paramètres (exp(a·log d + b)), obtenue lors de l’évaluation, par un calibrage léger ou par un fine-tuning. L’alternative courante, une tête sigmoid × max_depth bornée, intègre au contraire un plafond fixe dans l’architecture ; toute profondeur supérieure à max_depth est donc tronquée, ce qui empêche l’entraînement sur des scènes à plus longue portée et leur prédiction.

Pourquoi la tête est non bornée : observations sur différentes plages de profondeur#

A/B contrôlé — mêmes données, même calendrier, seule la tête diffère. En entraînant les deux têtes à partir de zéro sur un mélange identique de données intérieures (≤10 m) et extérieures (≤80 m) :

La tête bornée ne peut pas représenter la majorité des pixels extérieurs situés à plus de 10 m ; elle cesse donc presque immédiatement de progresser. La tête log apprend sur toute la plage.

Le problème qu’elle corrige — fine-tuning sur un seul jeu de données, stratifié par plage. Le fine-tuning d’une tête bornée (10 m) sur des jeux de données individuels fonctionne lorsque les données respectent le plafond, mais s’effondre lorsqu’elles le dépassent :

L’effondrement se produit exactement à la limite du plafond. La tête log ne présente pas une telle limite.

Modèles publiés — performances sur différentes plages. La famille publiée à tête log, évaluée sur des benchmarks couvrant une plage de 10 m (NYU, iBims-1) à 80 m (KITTI), avec un δ1 aligné sur l’échelle :

Les deux colonnes sont présentées telles quelles dans la publication. Les autres lignes sont évaluées avec le protocole TTA et des moindres carrés logarithmiques décrit sur les pages de leurs jeux de données ; le validateur de ce dépôt ne l’implémente pas, et la ligne KITTI ne peut donc pas être remesurée dans les mêmes conditions. La page KITTI fournit à la place les valeurs mesurées sur le split Eigen canonique de 652 images.

Les gains les plus importants sont observés sur les benchmarks extérieurs à plus longue portée (KITTI, ETH3D) — précisément là où un plafond fixe de 10 m est le plus pénalisant — tandis que les performances en intérieur sont conservées.

Entraîner#

Entraîne YOLO26n-depth sur le jeu de données Depth8 pendant 100 époques, avec une taille d’image de 640. Pour obtenir la liste complète des arguments disponibles, consulte la page Configuration.

from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n-depth.yaml")  # build a new model from YAML
model = YOLO("yolo26n-depth.pt")  # load a pretrained model (recommended for training)
model = YOLO("yolo26n-depth.yaml").load("yolo26n-depth.pt")  # build from YAML and transfer weights

# Train the model
results = model.train(data="depth8.yaml", epochs=100, imgsz=640)

Consulte les détails complets du mode train sur la page Entraînement.

Fine-tuning sur tes propres données#

Lorsque tu adaptes un modèle de profondeur préentraîné à un jeu de données personnalisé, réduis le taux d’apprentissage et utilise l’optimiseur AdamW. Les paramètres par défaut de l’optimiseur sont réglés pour un entraînement à partir de zéro (SGD avec lr0=0.01) ; appliqués à un modèle de profondeur déjà convergé, ils peuvent écraser les connaissances préentraînées et dégrader les résultats, en particulier lors d’un fine-tuning sur un domaine unique.

from ultralytics import YOLO

model = YOLO("yolo26s-depth.pt")  # start from pretrained weights

model.train(
    data="path/to/your_dataset.yaml",
    epochs=20,
    imgsz=640,
    optimizer="AdamW",
    lr0=1e-4,  # ~100x below the from-scratch default
    warmup_bias_lr=1e-4,  # keep warmup gentle too
)

Conseils supplémentaires :

• L’augmentation est contrôlée par les arguments standard (degrees, translate, scale, shear, perspective, flipud, fliplr, hsv_h, hsv_s, hsv_v) ; la déformation géométrique et les retournements sont appliqués de manière identique à la carte de profondeur associée. Pour voir la recette exacte utilisée pour les poids YOLO26-Depth publiés, examine le train_args enregistré dans le checkpoint — consulte Inspection des arguments d’entraînement du checkpoint YOLO26.
• mosaic, mixup, cutmix et copy_paste ne sont pas implémentés pour la profondeur. Le chargeur de jeux de données de profondeur définit automatiquement ces probabilités sur 0 ; leur transmission n’a donc aucun effet. Ces augmentations ne sont pas prises en charge, car elles combinent plusieurs images, ce qui produirait des cartes de profondeur associées invalides.
• Toute plage de profondeur fonctionne immédiatement. Les modèles à tête log prédisent une profondeur non bornée ; ils s’adaptent donc aux données à courte portée (macro) comme à celles à longue portée (extérieur/conduite), sans modification. Définir max_depth: dans ton fichier YAML de jeu de données (en mètres) détermine les pixels de vérité terrain pris en compte dans les métriques de validation.
• Conserve les performances générales. Si tu veux que le modèle reste précis sur des scènes situées au-delà de celles de ton jeu d’entraînement, mélange une petite proportion (~5–10 %) d’images générales diversifiées à tes données d’entraînement ; cela réduit considérablement l’oubli pendant le fine-tuning.
• Entraîne à partir de zéro (model=yolo26s-depth.yaml) uniquement si ton domaine est très différent et que tu disposes d’un jeu de données volumineux — dans ce cas, le SGD lr0=0.01 par défaut est approprié, puisqu’il n’y a pas de poids préentraînés à préserver.

Calibrage de l’échelle de profondeur#

La tête de profondeur sépare la forme (structure relative de la scène) de l’échelle (mètres absolus). Si un modèle produit déjà une bonne profondeur relative sur tes scènes, mais que les valeurs absolues sont incorrectes pour ta caméra, tu peux corriger l’échelle en quelques secondes avec model.calibrate() — un ajustement sous forme fermée d’une transformation log-affine à deux paramètres sur un petit ensemble de données annotées, sans entraînement par gradient ni modification des poids du réseau, de sorte que la structure relative ne peut pas être dégradée.

from ultralytics import YOLO

model = YOLO("yolo26s-depth.pt")

# Fit scale on a labeled split (~100+ images is enough), then persist it
model.calibrate(data="path/to/your_dataset.yaml")
model.save("yolo26s-depth-calibrated.pt")

La calibration a besoin d’une profondeur de référence sur laquelle s’ajuster, elle s’exécute donc sur une partition annotée — elle ne peut pas avoir lieu lors d’une inférence à l’aveugle. Elle s’ajuste et évalue les mêmes pixels que ceux utilisés par les métriques de validation : les valeurs GT supérieures ou égales à max_depth du fichier YAML du dataset (100 m par défaut) sont exclues. Utilise-la lorsque la profondeur relative est déjà bonne et que seule l’échelle ou la plage est incorrecte ; si la structure relative elle-même doit changer pour ton domaine, effectue plutôt un fine-tuning.

L’entraînement s’en charge automatiquement : une fois model.train(...) terminé, les checkpoints optimal et final sont calibrés sur l’ensemble de validation afin de produire directement une profondeur mise à l’échelle métrique.

Les checkpoints yolo26*-depth.pt distribués sont déjà fournis avec cette calibration intégrée, ajustée sur le mélange de validation du préentraînement. Il s’agit d’une échelle globale unique pour tous les domaines ; pour obtenir la profondeur absolue la plus précise sur une caméra ou un type de scène spécifique, exécute model.calibrate() sur une petite partition annotée de tes propres données — cela remplace l’ajustement intégré.

Format du dataset#

Les datasets d’estimation de profondeur associent chaque image RGB à une image PNG de profondeur uint16 mise à l’échelle ou à une carte de profondeur NPY à virgule flottante, en mètres. Par défaut, les valeurs PNG utilisent les millimètres ; les datasets appliquant une autre convention définissent depth_scale dans leur YAML. Le chargeur déduit le chemin de profondeur en remplaçant le composant images par depth, en donnant la préférence à .png et en utilisant .npy comme solution de repli.

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. Consulte le Guide des datasets d’estimation de profondeur pour connaître la spécification complète du format.

Validation#

Valide l’exactitude d’un modèle YOLO26n-depth entraîné sur un dataset d’estimation de profondeur. Indique explicitement data afin que la validation utilise le YAML du dataset prévu. Les poids distribués sont entraînés à imgsz=768 ; valide et effectue les prédictions à cette taille pour obtenir une précision optimale.

from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n-depth.pt")  # load an official model
model = YOLO("path/to/best.pt")  # load a custom model

# Validate the model
metrics = model.val(data="nyu-depth.yaml")
metrics.delta1  # percentage of pixels within threshold δ=1.25
metrics.abs_rel  # mean absolute relative error
metrics.rmse  # root mean squared error (meters)
metrics.silog  # scale-invariant logarithmic error

Prédiction#

Utilise un modèle YOLO26n-depth entraîné pour effectuer des prédictions sur des images.

from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n-depth.pt")  # load an official model
model = YOLO("path/to/best.pt")  # load a custom model

# Predict with the model
results = model("https://ultralytics.com/images/bus.jpg")  # predict on an image

# Access the results
for result in results:
    depth_map = result.depth.data.cpu().numpy()  # torch.Tensor -> NumPy float32, shape (H, W), meters

Consulte les détails complets du mode predict dans la page Prédiction.

Sortie des résultats#

L’estimation de profondeur YOLO renvoie un objet Results par image. Chaque résultat contient une carte de profondeur dense à virgule flottante couvrant l’image entière.

Pour connaître les champs Results spécifiques à chaque tâche, consulte la section Résultats des prédictions par tâche.

Colorisation de la carte de profondeur#

La carte de profondeur brute est un tableau flottant à un seul canal, en mètres — utile pour les calculs, mais difficile à lire directement. Pour la convertir en image couleur, utilise l’utilitaire colorize_depth dans ultralytics.utils.plotting, qui convertit le tableau de profondeur (H, W) en une image BGR (H, W, 3) uint8 (les pixels invalides <= 0 sont rendus en noir).

result.plot() superpose déjà cette colorisation sur l’image d’entrée avec les valeurs par défaut (cmap="jet", mode="disparity") ; appelle directement colorize_depth lorsque tu veux une image de profondeur colorée autonome, ou une autre palette de couleurs ou normalisation.

import cv2

from ultralytics import YOLO
from ultralytics.utils.plotting import colorize_depth

model = YOLO("yolo26n-depth.pt")
result = model("https://ultralytics.com/images/bus.jpg")[0]

depth = result.depth.data.cpu().numpy()  # (H, W) float32, meters

# Colorize with near = warm and save
cv2.imwrite("depth_colored.png", colorize_depth(depth, cmap="spectral"))  # (H, W, 3) BGR uint8

# Fix the range to 0-20 m so the same color means the same distance across frames
cv2.imwrite("depth_metric.png", colorize_depth(depth, vmin=0.0, vmax=20.0, cmap="inferno", mode="metric"))

# Blended overlay straight from the Results object (uses cmap="jet", mode="disparity")
result.save("depth_overlay.png")

Chaque palette va du froid/sombre → chaud/clair. mode détermine quelle extrémité correspond aux éléments proches, tandis que vmin/vmax fixent la plage entre les images afin qu’une couleur représente toujours la même distance.

Exportation#

Exporte un modèle YOLO26n-depth vers un autre format tel que ONNX, CoreML, etc.

from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n-depth.pt")  # load an official model
model = YOLO("path/to/best.pt")  # load a custom model

# Export the model
model.export(format="onnx")

Les formats d’exportation disponibles pour l’estimation de profondeur YOLO26 sont indiqués dans le tableau ci-dessous. Tu peux exporter vers n’importe quel format avec l’argument format, c’est-à-dire format='onnx' ou format='engine'. Tu peux effectuer directement des prédictions ou une validation sur les modèles exportés, c’est-à-dire yolo predict model=yolo26n-depth.onnx. Des exemples d’utilisation sont affichés pour ton modèle une fois l’exportation terminée.

nms=None utilise par défaut des sorties brutes pour NMS externe. Définis nms=False pour sélectionner une tête sans NMS disponible ; les formats non pris en charge reviennent à leur chemin de sortie natif. Les entrées nms ci-dessus identifient les formats capables d'intégrer NMS avec nms=True.

Consulte les détails complets du mode export dans la page Exportation.

FAQ#