Estimation de profondeur monoculaire#

L'estimation de 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 surface.

La sortie d'un modèle de profondeur est une carte de nombres flottants dense de forme (H, W) alignée sur l'image d'entrée. Cette représentation par pixel rend l'estimation de profondeur monoculaire idéale pour la reconstruction de scènes 3D, la navigation de 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 large mélange multi-jeux de données (intérieur + extérieur, ~2,19M d'images) sont présentés ci-dessous. Les colonnes de métriques sont rapportées sur la division de test Eigen de NYU Depth V2.

Les modèles se téléchargent automatiquement à partir de la dernière version d'Ultralytics lors de la première utilisation.

• delta1^NYU est le pourcentage de pixels où la profondeur prédite est à moins d'un facteur de 1,25 de la vérité terrain, sur la séparation de test NYU Depth V2 Eigen (654 images) avec TTA multi-échelle + retournement horizontal et alignement log-moindres-carrés.
• 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= pour chaque taille), qui utilise un alignement médian (é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 l'erreur quadratique moyenne en mètres.
• La vitesse correspond à la latence d'inférence uniquement (pré/post-traitement exclus) à imgsz=768, batch=1, rapportée en moyenne ± écart-type sur des exécutions chronométrées après échauffement. CPU ONNX est ONNX Runtime fp32 sur un Intel Xeon à 32 cœurs (Skylake) ; T4 TensorRT10 est TensorRT fp16 sur une Tesla T4.
• params et FLOPs sont mesurés à 768×768, la résolution d'entraînement des poids publiés.

Vitesse par rapport à Depth Anything V2#

Depth Anything V2 est une base ouverte largement utilisée pour la profondeur monoculaire. Son backbone Transformer de vision DINOv2 et son décodeur DPT sont gourmandes en calculs, de sorte que sur la même Tesla T4 sous 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 comporte 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 nécessite un multiple de sa taille de patch de 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 est l'inférence seule, batch=1, TensorRT fp16 sur un Tesla T4 — la même configuration que le tableau de modèles ci-dessus, affichée 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 sont les points de contrôle ViT-S et ViT-B publiés.
• La comparaison ne porte que sur la latence — les deux familles de modèles ne sont pas évaluées ici selon un protocole de précision partagé.

Plage de profondeur et tête de log-profondeur#

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 log-profondeur relatif, et les mètres absolus sont définis par une transformation distincte à deux paramètres (exp(a·log d + b)) récupérée lors de l'évaluation, par un étalonnage léger, ou par réglage 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 au-delà de max_depth est coupée — ce qui empêche l'entraînement et la prédiction sur des scènes à plus longue portée.

Pourquoi la tête est non bornée : preuves à travers les plages de profondeur#

A/B contrôlé — mêmes données, même planning, seule la tête diffère. Entraîner les deux têtes à partir de 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é (>10 m) des pixels extérieurs, elle cesse donc de s'améliorer presque immédiatement ; la tête log apprend à partir de toute la plage.

Le mode d'échec qu'elle corrige — ajustement fin sur jeu de données unique, stratifié par portée. Ajuster finement une tête bornée (10 m) sur des jeux de données individuels fonctionne lorsque les données correspondent à la limite et s'effondre lorsqu'elles la 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 — performance multi-portée. La famille dotée de la tête log livrée, évaluée sur des benchmarks allant de 10 m (NYU, iBims-1) à 80 m (KITTI), avec un δ1 aligné sur l'échelle :

Les deux colonnes sont telles que publiées. Les autres lignes sont évaluées avec le protocole TTA et log-moindres-carrés décrit sur leurs pages de jeux de données respectives, que le validateur de ce dépôt ne met pas en œuvre, de sorte que la ligne KITTI ne peut pas être mesurée sur le même pied d'égalité ; la page KITTI présente des chiffres mesurés sur la division canonique Eigen de 652 images.

Les gains les plus importants se situent sur les benchmarks extérieurs à plus longue portée (KITTI, ETH3D) — exactement là où un plafond fixe de 10 m nuit le plus — tandis que les performances en intérieur sont conservées.

Entraîner (Train)#

Entraîne YOLO26n-depth sur le jeu de données Depth8 pendant 100 époques à une taille d'image de 640. Pour une 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 tous les détails du mode train dans la page Entraîner.

Ajustement fin sur tes propres données#

Lors de l'adaptation d'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 à 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 du réglage fin sur un seul domaine.

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 distorsion géométrique et les retours 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, inspecte le train_args stocké dans le point de contrôle — consulte Inspection des arguments d'entraînement du point de contrôle 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 à 0, donc les transmettre n'a aucun effet. Ces augmentations ne sont pas prises en charge car elles combinent plusieurs images, ce qui produirait des cartes de profondeur appariées non valides.
• N'importe quelle plage de profondeur fonctionne dès la sortie de la boîte. Les modèles dotés de la tête 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 qui comptent pour les métriques de validation.
• Conserve la performance générale. Si tu as besoin que le modèle reste précis sur des scènes au-delà de ton jeu d'entraînement, mélange une petite fraction (~5–10 %) d'images diverses à usage général dans tes données d'entraînement ; cela réduit considérablement l'oubli pendant l'ajustement fin.
• 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 grand jeu de données — le SGD lr0=0.01 par défaut y est approprié, puisqu'il n'y a pas de poids pré-entraînés à préserver.

Calibration 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 erronées pour ta caméra, tu peux corriger l'échelle en quelques secondes avec model.calibrate() — un ajustement sous forme fermée d'une log-affine à deux paramètres par rapport à un petit ensemble étiqueté, sans entraînement de gradient et sans modification des poids du réseau, de sorte qu'il ne peut pas dégrader la structure relative.

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")

L'étalonnage nécessite une profondeur de vérité terrain à laquelle s'ajuster, il s'exécute donc sur une division étiquetée — ce n'est pas quelque chose qui peut se produire lors d'une inférence aveugle. Il s'ajuste et marque sur les mêmes pixels que ceux évalués par les métriques de validation : la GT située au niveau ou au-delà de max_depth du YAML du jeu de données (par défaut 100 m) est exclue. Utilise-le lorsque la profondeur relative est déjà bonne et que seule l'échelle/la plage est erronée ; si la structure relative elle-même doit changer pour ton domaine, affine à la place.

L'entraînement fait cela pour toi automatiquement : après que model.train(...) soit terminé, les points de contrôle les meilleurs et les derniers sont étalonnés sur l'ensemble de validation afin qu'ils affichent une profondeur mise à l'échelle en mètres dès la sortie de la boîte.

Les points de contrôle yolo26*-depth.pt publiés sont livrés avec cet étalonnage déjà intégré, ajusté sur le mélange de validation du pré-entraînement. Il s'agit d'une échelle globale unique à travers tous les domaines, donc 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 division étiquetée de tes propres données — cela remplace l'ajustement intégré.

Format de jeu de données#

Les jeux de données d'estimation de profondeur associent chaque image RVB à un fichier de profondeur correspondant. Les cibles de profondeur sont stockées sous forme de tableaux .npy contenant des valeurs float32 en mètres. Le YAML du jeu de données pointe vers un répertoire images/ ; le chargeur déduit le chemin du fichier de profondeur en remplaçant le composant images par depth et en remplaçant l'extension de l'image par .npy.

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.npy. Consulte le Guide du jeu de données d'estimation de profondeur pour la spécification complète du format.

Valider (Val)#

Valide la précision d'un modèle YOLO26n-depth entraîné sur un jeu de données d'estimation de profondeur. Transmets explicitement data afin que la validation utilise le YAML du jeu de données prévu. Les poids publiés sont entraînés à imgsz=768, valide et prédis donc à cette taille pour 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édire (Predict)#

Utilise un modèle YOLO26n-depth entraîné pour exécuter 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 tous les détails du mode predict dans la page Prédire.

Sortie des résultats#

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

Pour les champs Results spécifiques à chaque tâche, consulte la section Résultats de prédiction par tâche.

Colorisation de la carte de profondeur#

La carte de profondeur brute est un tableau de nombres à virgule flottante à canal unique en mètres — utile pour le calcul, mais difficile à lire directement. Pour la transformer en image couleur, utilise l'aide colorize_depth dans ultralytics.utils.plotting, qui fait correspondre le tableau de profondeur (H, W) à une image BGR uint8 (H, W, 3) (les pixels invalides <= 0 sont affichés en noir).

result.plot() superpose déjà cette colorisation sur l'image d'entrée en utilisant les valeurs par défaut (cmap="jet", mode="disparity") ; appelle directement colorize_depth lorsque tu souhaites une image de profondeur en couleur autonome ou une palette de couleurs ou une normalisation différente.

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 de couleurs va du froid/sombre au chaud/lumineux. Le mode détermine quelle extrémité est proche, et vmin/vmax verrouillent la plage à travers les images pour qu'une couleur signifie toujours la même distance.

Exporter (Export)#

Exporte un modèle YOLO26n-depth vers un format différent comme 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 d'estimation de profondeur YOLO26 disponibles se trouvent dans le tableau ci-dessous. Tu peux exporter vers n'importe quel format en utilisant l'argument format, c'est-à-dire format='onnx' ou format='engine'. Tu peux prédire ou valider directement 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.

Consulte tous les détails de export dans la page Exporter.

FAQ#