Estimation monoculaire de la profondeur avec Ultralytics YOLO#

L'estimation monoculaire de la profondeur 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 le point de surface correspondant.

La sortie d'un modèle de profondeur est une carte dense de nombres flottants de forme (H, W), alignée sur l'image d'entrée. Cette représentation par pixel rend l'estimation monoculaire de la profondeur 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 une disposition spatiale à partir d'une seule caméra.

Modèles#

Les modèles de profondeur YOLO26 préentraînés sur un vaste mélange de plusieurs jeux de données (intérieur + extérieur, ~2.19M images) sont présentés ci-dessous. Les colonnes de métriques correspondent au découpage 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 leur première utilisation.

• delta1^NYU est la proportion de pixels pour lesquels la profondeur prédite se situe dans un facteur de 1.25 de la vérité terrain, sur le découpage de test Eigen de NYU Depth V2 (654 images), avec TTA à plusieurs échelles et retournement horizontal, et alignement par moindres carrés logarithmiques.
• La précision à une seule échelle sans TTA peut être reproduite 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 (échelle uniquement) et obtient des scores plus faibles : 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.
• Vitesse correspond à la latence d'inférence uniquement (hors prétraitement et post-traitement) à imgsz=768, batch=1, rapportée comme moyenne ± écart-type sur les exécutions chronométrées après échauffement. 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 vision transformer et son décodeur DPT nécessitent beaucoup de calcul ; sur la même Tesla T4 avec TensorRT fp16, le plus petit modèle publié de Depth Anything V2 est donc 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 d'entraînement de ses poids publiés, et 770 px pour Depth Anything V2, dont le backbone DINOv2 nécessite un multiple de sa taille de patch de 14 :

À ~640 px — imgsz=640 et 644 px respectivement — le classement reste inchangé, et YOLO26n-depth est 5.9× plus rapide que Depth Anything V2 Small :

• La latence correspond à l'inférence uniquement, batch=1, TensorRT fp16 sur une Tesla T4 — le même banc de test que pour le tableau des modèles ci-dessus, affichée ici avec deux décimales ; les FPS sont l'inverse de la latence non arrondie. Les colonnes Accélération divisent les latences de Depth Anything V2 Small (20.99 ms) et Base (55.40 ms) par la latence de YOLO26.
• Depth Anything V2 Small et Base sont les points de contrôle 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) — sans limite (~0.02–150 m) — et découple 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 étalonnage léger ou par un ajustement fin. L'alternative courante, une tête sigmoid × max_depth bornée, intègre plutôt un plafond fixe dans l'architecture, de sorte que toute profondeur supérieure à max_depth est écrêtée — ce qui empêche l'entraînement sur des scènes à plus longue portée et leur prédiction.

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

La tête bornée ne peut pas représenter la majorité des pixels extérieurs à plus de 10 m et cesse donc presque immédiatement de s'améliorer ; la tête log apprend à partir de toute la plage.

Le problème corrigé — ajustement fin sur un seul jeu de données, stratifié par plage. L'ajustement fin d'une tête bornée (10 m) sur des jeux de données individuels fonctionne lorsque les données respectent la limite, mais échoue lorsqu'elles la dépassent :

L'effondrement se produit précisément à la limite supérieure. La tête log n'a pas cette limite.

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

Les deux colonnes sont telles que publiées. Les autres lignes sont évaluées selon le protocole TTA et moindres carrés logarithmiques décrit sur les pages de leurs jeux de données, que le validateur de ce dépôt n'implémente pas ; la ligne KITTI ne peut donc pas être réévaluée dans les mêmes conditions. La page KITTI présente plutôt les chiffres mesurés sur le découpage Eigen canonique de 652 images.

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

Entraînement#

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

from ultralytics import YOLO

# Charger un modèle
model = YOLO("yolo26n-depth.yaml")  # créer un nouveau modèle à partir du fichier YAML
model = YOLO("yolo26n-depth.pt")  # charger un modèle préentraîné (recommandé pour l’entraînement)
model = YOLO("yolo26n-depth.yaml").load("yolo26n-depth.pt")  # créer à partir du fichier YAML et transférer les poids

# Entraîner le modèle
results = model.train(data="depth8.yaml", epochs=100, imgsz=640)

Consulte la page Entraînement pour obtenir tous les détails du mode train. Les modèles de profondeur peuvent également être entraînés avec l'entraînement cloud d'Ultralytics Platform.

Format du jeu de données#

Les jeux de données d'estimation de profondeur associent chaque image RGB à une carte de profondeur PNG uint16 mise à l'échelle ou à une carte de profondeur NPY à virgule flottante en mètres. Par défaut, les valeurs PNG sont en millimètres ; pour les jeux de données utilisant une autre convention, définis depth_scale dans leur YAML. Le chargeur déduit le chemin de la carte de profondeur en remplaçant le composant images par depth, en privilégiant .png et en utilisant .npy à défaut.

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

Par exemple, une image à images/train/scene_001.jpg est associée à une carte de profondeur à depth/train/scene_001.png. Consulte le Guide des jeux de données d'estimation de profondeur pour connaître toutes les spécifications du format.

Ajustement fin 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 d'optimiseur par défaut sont réglés pour un entraînement depuis zéro ; 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 ajustement fin sur un seul domaine.

from ultralytics import YOLO

model = YOLO("yolo26s-depth.pt")  # partir de poids préentraînés

model.train(
    data="path/to/your_dataset.yaml",
    epochs=20,
    imgsz=640,
    optimizer="AdamW",
    lr0=1e-4,  # ~100x en dessous de la valeur par défaut pour un entraînement depuis zéro
    warmup_bias_lr=1e-4,  # garder aussi un warmup progressif
)

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 la même manière à 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 — voir Inspection des arguments d’entraînement d’un checkpoint YOLO26.
• mosaic, mixup, cutmix et copy_paste ne sont pas implémentés pour la profondeur. Le chargeur du jeu de données de profondeur définit automatiquement ces probabilités sur 0 ; les transmettre 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.
• Toutes les plages de profondeur fonctionnent directement. Les modèles log prédisent une profondeur non bornée ; ils s’adaptent donc aux données à courte portée (macro) ou à longue portée (extérieur/conduite) sans modification. Définir max_depth: dans le YAML de ton jeu de données (en mètres) délimite les pixels GT pris en compte dans les métriques de validation.
• Préserver les performances générales. Si tu veux que le modèle reste précis sur des scènes qui ne figurent pas dans ton jeu d’entraînement, ajoute une petite proportion (~5–10 %) d’images généralistes variées à tes données d’entraînement ; cela réduit considérablement l’oubli pendant le fine-tuning.
• Entraîner depuis zéro (model=yolo26s-depth.yaml) uniquement si ton domaine est très différent et que tu disposes d’un grand jeu de données — dans ce cas, la valeur par défaut optimizer=auto convient, puisqu’il n’y a pas de poids préentraînés à préserver.

Calibrer l’échelle de profondeur#

La tête de profondeur distingue 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 pour tes scènes, mais que les valeurs absolues ne correspondent pas à ta caméra, tu peux corriger l’échelle en quelques secondes avec model.calibrate() — un ajustement de forme fermée, limité à l’échelle, de la transformation log-affine de la tête sur un petit ensemble annoté, conservé uniquement s’il améliore δ1 sur les données de validation croisée mises de côté, sans entraînement par gradient ni modification des poids du réseau ; la structure relative ne peut donc pas se dégrader.

from ultralytics import YOLO

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

# Ajuster l’échelle sur une partition annotée (~100 images ou plus suffisent), puis la conserver
model.calibrate(data="path/to/your_dataset.yaml")
model.save("yolo26s-depth-calibrated.pt")

La calibration nécessite une profondeur de référence pour effectuer l’ajustement ; elle s’exécute donc sur une partition annotée — elle ne peut pas avoir lieu lors d’une inférence à l’aveugle. Elle ajuste et évalue les mêmes pixels que ceux utilisés pour les métriques de validation : les valeurs GT supérieures ou égales à max_depth du YAML du jeu de données (100 m par défaut) sont exclues. Utilise-la lorsque la profondeur relative est déjà bonne et que seule l’échelle/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 meilleurs checkpoints et les derniers checkpoints sont calibrés sur le jeu de validation afin de produire directement une profondeur à l’échelle métrique.

Les checkpoints yolo26*-depth.pt publiés intègrent déjà cette calibration, 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 avec une caméra ou un type de scène donné, exécute model.calibrate() sur une petite partition annotée de tes propres données — cela remplace l’ajustement intégré.

Obtenir une profondeur de vérité terrain sans caméra de profondeur#

Si ta caméra n’a pas de capteur de profondeur, tu peux tout de même la calibrer. La calibration ajuste une échelle globale et ignore les pixels dont la profondeur est égale à 0 : quelques points mesurés par image suffisent donc.

1. Collecte des images. Prends 50 à 150 images avec ta caméra à la résolution et avec les réglages d’objectif que tu utiliseras en production, puis place-les dans dataset/images/val/. La calibration lit la partition val.

2. Annote la profondeur. Utilise l’une des deux méthodes ci-dessous. Les deux enregistrent une carte de profondeur par image dans dataset/depth/val/, au format du jeu de données.

image,x,y,meters
img_0001.jpg,352,453,3.15
img_0001.jpg,28,300,2.672

import csv
from collections import defaultdict
from pathlib import Path

import cv2
import numpy as np

points = defaultdict(list)
with open("points.csv") as f:  # columns: image, x, y, meters
    for row in csv.DictReader(f):
        points[row["image"]].append((int(row["x"]), int(row["y"]), float(row["meters"])))

for name, pts in points.items():
    h, w = cv2.imread(f"dataset/images/val/{name}").shape[:2]
    depth = np.zeros((h, w), np.uint16)  # 0 means no label
    r = max(h, w) // 768 + 1  # dot radius that survives the resize to imgsz=768
    for x, y, meters in pts:
        cv2.circle(depth, (x, y), r, round(meters * 100), -1)  # centimeters, matching depth_scale: 100
    out = Path("dataset/depth/val") / f"{Path(name).stem}.png"
    out.parent.mkdir(parents=True, exist_ok=True)
    cv2.imwrite(str(out), depth)

3. Écris le YAML du jeu de données sous le nom calib.yaml. depth_scale: 100 lit les PNG en centimètres issus des points mesurés et est ignoré pour les cartes NPY :

   path: dataset
   train: images/val
   val: images/val
   depth_scale: 100 # PNG value 100 = 1 meter
   names:
       0: depth

4. Effectue la calibration et enregistre-la, puis charge yolo26s-depth-calibrated.pt pour la prédiction ou l’exportation :

   from ultralytics import YOLO
   
   model = YOLO("yolo26s-depth.pt")
   model.calibrate(data="calib.yaml", imgsz=768)
   model.save("yolo26s-depth-calibrated.pt")

Lors de tests avec yolo26s-depth.pt et 150 images par caméra, la calibration publiée présentait un écart de 4 % à 46 % par rapport à l’ajustement d’échelle réalisé sur les données de vérité terrain complètes pour NYU, KITTI et une caméra à objectif étroit. Une calibration basée sur 5 points mesurés par image s’approchait à moins de 1 % de cet ajustement, et une calibration basée sur les annotations DA3METRIC-LARGE, à moins de 7 %. Ajouter des images est plus utile qu’ajouter des points par image : 150 images avec 1 point chacune s’approchaient à environ 3 %, tandis que 20 images avec 5 points chacune présentaient un écart pouvant atteindre 9 %.

Validation#

Évalue la précision d’un modèle YOLO26n-depth entraîné sur un jeu de données d’estimation de profondeur. Passe explicitement data afin que l’évaluation utilise le YAML du jeu de données voulu. Les poids publiés sont entraînés à imgsz=768 sur des images étirées au format carré plutôt que redimensionnées avec des bandes de remplissage. Pour obtenir la meilleure précision, effectue donc l’évaluation et la prédiction à cette taille. La prédiction, l’évaluation et model.calibrate() étirent toutes l’image d’entrée de la même manière.

from ultralytics import YOLO

# Charger un modèle
model = YOLO("yolo26n-depth.pt")  # charger un modèle officiel
model = YOLO("path/to/best.pt")  # charger un modèle personnalisé

# Valider le modèle
metrics = model.val(data="nyu-depth.yaml")
metrics.delta1  # fraction de pixels sous le seuil δ=1.25
metrics.abs_rel  # erreur relative absolue moyenne
metrics.rmse  # racine de l’erreur quadratique moyenne (mètres)
metrics.silog  # erreur logarithmique invariante à l’échelle

Prédiction#

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

from ultralytics import YOLO

# Charger un modèle
model = YOLO("yolo26n-depth.pt")  # charger un modèle officiel
model = YOLO("path/to/best.pt")  # charger un modèle personnalisé

# Effectuer des prédictions avec le modèle
results = model("https://ultralytics.com/images/bus.jpg")  # effectuer une prédiction sur une image

# Accéder aux résultats
for result in results:
    depth_map = result.depth.data.cpu().numpy()  # torch.Tensor -> NumPy float32, forme (H, W), mètres

Consulte les détails complets du mode predict sur la page Predict.

Sortie des résultats#

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

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

Profondeur par objet avec segmentation d’instance#

Combine la segmentation d’instance à la profondeur pour estimer la distance de chaque objet détecté. Exécute les deux modèles sur la même image avec retina_masks=True afin que les masques partagent la résolution de la carte de profondeur de l’image d’origine, puis calcule la médiane des pixels de profondeur valides à l’intérieur de chaque masque.

from ultralytics import YOLO

image = "https://ultralytics.com/images/bus.jpg"
seg = YOLO("yolo26n-seg.pt")(image, retina_masks=True)[0]
depth = YOLO("yolo26n-depth.pt")(image)[0].depth.data  # (H, W) meters

if seg.masks is not None:
    for mask, cls in zip(seg.masks.data.bool(), seg.boxes.cls):
        values = depth[mask & (depth > 0)]  # valid depth pixels inside this mask
        if values.numel():
            print(f"{seg.names[int(cls)]}: {values.median():.2f} m")

La médiane résiste bien aux pixels d’arrière-plan situés aux bords des masques, mais elle décrit la surface visible de l’objet plutôt que son centre, et sa précision dépend de l’échelle de profondeur du modèle (voir Calibrer l’échelle de profondeur).

Coloriser la carte de profondeur#

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

result.plot() superpose déjà cette colorisation à l’image d’entrée en utilisant les valeurs par défaut (cmap="jet", mode="disparity") ; appelle directement colorize_depth si tu veux une image de profondeur colorisée autonome, une autre palette de couleurs ou une autre 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

# Coloriser avec le proche en teintes chaudes et enregistrer
cv2.imwrite("depth_colored.png", colorize_depth(depth, cmap="spectral"))  # (H, W, 3) BGR uint8

# Fixer la plage à 0–20 m pour que la même couleur corresponde à la même distance d’une image à l’autre
cv2.imwrite("depth_metric.png", colorize_depth(depth, vmin=0.0, vmax=20.0, cmap="inferno", mode="metric"))

# Superposition fusionnée directement depuis l’objet Results (utilise cmap="jet", mode="disparity")
result.save("depth_overlay.png")

Toutes les palettes de couleurs vont des tons froids/sombres aux tons chauds/lumineux. mode détermine quelle extrémité correspond au proche, et vmin/vmax fixe la plage d’une image à l’autre afin qu’une couleur corresponde toujours à la même distance.

Export#

Exporter un modèle YOLO26n-depth vers un autre format comme ONNX, CoreML, etc.

from ultralytics import YOLO

# Charger un modèle
model = YOLO("yolo26n-depth.pt")  # charger un modèle officiel
model = YOLO("path/to/best.pt")  # charger un modèle personnalisé

# Exporter le modèle
model.export(format="onnx")

Les formats d’export disponibles pour l’estimation de la profondeur avec YOLO26 figurent dans le tableau ci-dessous. Tu peux exporter vers n’importe quel format à l’aide de l’argument format, par exemple format='onnx' ou format='engine'. Tu peux effectuer des prédictions ou valider directement sur les modèles exportés, par exemple yolo predict model=yolo26n-depth.onnx. Des exemples d’utilisation de ton modèle s’affichent une fois l’export terminé.

nms=None produit par défaut des sorties brutes pour la NMS externe. Définis nms=False pour sélectionner une tête disponible sans NMS ; les formats non pris en charge utilisent leur voie de sortie native. Les entrées nms ci-dessus désignent les formats qui peuvent intégrer la NMS avec nms=True.

Consulte tous les détails de export sur la page Exportation.

FAQ#