Link to this sectionEstimation 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 flottante dense de forme (H, W) alignée sur l'image d'entrée. Cette représentation par pixel rend l'estimation de profondeur monoculaire parfaitement adaptée à la reconstruction de scènes 3D, à la navigation robotique, à la création de contenu AR/VR et à toute application nécessitant une disposition spatiale à partir d'une seule caméra.

Link to this sectionModèles#

Les modèles YOLO26 depth pré-entraînés sur un large mélange de 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 séparation de test Eigen du NYU Depth V2.

Les modèles se téléchargent automatiquement depuis 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 à échelle unique sans TTA est reproductible avec yolo depth val model=yolo26n-depth.pt data=nyu-depth.yaml imgsz=768 device=0 (substitue model= pour chaque taille), qui utilise un alignement médian (échelle uniquement) et obtient des scores inférieurs : delta1 0,785 (n), 0,786 (s), 0,827 (m), 0,839 (l), 0,843 (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.
• params et FLOPs sont mesurés à 768×768, la résolution d'entraînement des poids publiés.

Link to this sectionPlage 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 découple 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 séparée à deux paramètres (exp(a·log d + b)) récupérée à l'évaluation, par calibration légère ou par ajustement fin (fine-tuning). 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 sur, et la prédiction de, scènes à plus longue portée.

Link to this sectionPourquoi 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é des pixels extérieurs >10 m, donc elle arrête de s'améliorer presque immédiatement ; la tête log apprend sur 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 n'a pas une telle limite.

Modèles publiés — performance inter-portée. La famille log-head livrée, évaluée sur des benchmarks allant de 10 m (NYU, iBims-1) à 80 m (KITTI), avec δ1 aligné sur l'échelle :

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.

Link to this sectionEntraî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 les détails complets du mode train sur la page Entraînement.

Link to this sectionAjustement fin sur tes propres données#

Lorsque tu adaptes un modèle de profondeur pré-entraîné à un jeu de données personnalisé, diminue le taux d'apprentissage et utilise l'optimiseur AdamW. Les réglages par défaut de l'optimiseur sont ajusté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 — surtout lors d'un ajustement fin 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 standards (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 appariée. Pour voir la recette exacte utilisée pour les poids YOLO26-Depth publiés, inspecte les train_args stockés dans le point de contrôle — voir Inspection des Args 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 jeu 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 invalides.
• Toute plage de profondeur fonctionne immédiatement. Les modèles log-head 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 changement. Définir max_depth: dans ton YAML de jeu de données (en mètres) borne les pixels de vérité terrain 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) seulement si ton domaine est très différent et que tu disposes d'un grand jeu de données — là, le SGD par défaut lr0=0.01 est approprié, puisqu'il n'y a pas de poids pré-entraînés à préserver.

Link to this sectionCalibration 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 de forme fermée d'un log-affine à deux paramètres contre un petit ensemble étiqueté, sans entraînement par gradient et sans changement des poids du réseau, il ne peut donc 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")

La calibration nécessite une profondeur de vérité terrain pour s'ajuster, elle s'exécute donc sur une séparation étiquetée — ce n'est pas quelque chose qui peut arriver lors d'une inférence à l'aveugle. Utilise-la lorsque la profondeur relative est déjà bonne et que seule l'échelle/plage est fausse ; si la structure relative elle-même doit changer pour ton domaine, ajuste finement à la place.

L'entraînement le fait automatiquement pour toi : une fois que model.train(...) est terminé, les meilleurs points de contrôle et les derniers sont calibrés sur le jeu de validation afin qu'ils sortent une profondeur mise à l'échelle métrique immédiatement.

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

Link to this sectionFormat de jeu de données#

Les jeux de données d'estimation de profondeur associent chaque image RGB à 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érive le chemin du fichier de profondeur en remplaçant la composante 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 sur images/train/scene_001.jpg est associée à une carte de profondeur sur depth/train/scene_001.npy. Voir le Guide du Jeu de Données d'Estimation de Profondeur pour la spécification complète du format.

Link to this sectionValider (Val)#

Valide la précision d'un modèle YOLO26n-depth entraîné sur un jeu de données d'estimation de profondeur. Passe data explicitement pour que la validation utilise le YAML du jeu de données prévu. Les poids publiés sont entraînés à imgsz=768, donc valide et prédit à cette taille pour une meilleure précision.

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

Link to this sectionPré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

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

Link to this sectionSortie 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 Predict Results by Task.

Link to this sectionExporter (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 sont dans le tableau ci-dessous. Tu peux exporter vers n'importe quel format en utilisant l'argument format, c.-à-d. format='onnx' ou format='engine'. Tu peux prédire ou valider directement sur des modèles exportés, c.-à-d. yolo predict model=yolo26n-depth.onnx. Des exemples d'utilisation sont montrés pour ton modèle après la fin de l'exportation.

Consulte les détails complets de export sur la page Export.

Link to this sectionFAQ#

Link to this sectionComment entraîner un modèle d'estimation de profondeur YOLO26 sur un jeu de données personnalisé ?#

Prépare des images RVB appariées et des fichiers de profondeur .npy, puis crée un YAML de jeu de données pointant vers ton répertoire images/. Le chargeur trouve automatiquement les fichiers de profondeur en remplaçant images par depth dans le chemin et en remplaçant l'extension de l'image par .npy.

Pars de poids pré-entraînés et utilise un faible taux d'apprentissage avec AdamW pour que le réglage fin conserve ce que le modèle connaît déjà (vois Réglage fin sur tes propres données pour savoir pourquoi) :

from ultralytics import YOLO

# Load a pretrained YOLO26 depth model
model = YOLO("yolo26s-depth.pt")

# Fine-tune on a custom depth dataset
results = model.train(
    data="path/to/your_dataset.yaml",
    epochs=20,
    imgsz=640,
    optimizer="AdamW",
    lr0=1e-4,
    warmup_bias_lr=1e-4,
)

Consulte la page Configuration pour plus d'arguments disponibles.

Link to this sectionQuelles métriques le modèle d'estimation de profondeur YOLO26 rapporte-t-il ?#

La validation de l'estimation de profondeur rapporte l'ensemble de métriques utilisé par Depth Anything et les travaux connexes sur la profondeur monoculaire :

• delta1 / delta2 / delta3 — pourcentage de pixels où le rapport entre la profondeur prédite et la profondeur réelle (ou son inverse) est inférieur à 1,25, 1,25² et 1,25³ respectivement. Plus c'est élevé, mieux c'est.
• abs_rel — erreur relative absolue moyenne. Plus c'est bas, mieux c'est.
• rmse — racine de l'erreur quadratique moyenne en mètres. Plus c'est bas, mieux c'est.
• silog — erreur logarithmique invariante à l'échelle. Plus c'est bas, mieux c'est.

Chaque prédiction est alignée sur la médiane de sa vérité terrain par image, et les statistiques sont ensuite regroupées sur chaque pixel valide de l'ensemble de validation (les images avec plus de pixels de profondeur valides pèsent proportionnellement plus). Les articles qui font la moyenne des métriques par image peuvent rapporter des valeurs légèrement différentes sur les mêmes prédictions.

Link to this sectionQuel est le format de sortie de la carte de profondeur ?#

La carte de profondeur est stockée sous forme de torch.Tensor de forme (H, W) où chaque valeur est la profondeur prédite en mètres (utilise result.depth.data.cpu().numpy() pour un tableau NumPy float32). Accède-y via result.depth.data après avoir exécuté la prédiction. La carte est alignée sur la résolution de l'image d'entrée.

Link to this sectionQuels jeux de données sont pris en charge pour l'estimation de profondeur ?#

Ultralytics YOLO26 fournit des configurations YAML intégrées pour plusieurs jeux de données d'estimation de profondeur, notamment NYU Depth V2, KITTI, Hypersim, SUN RGB-D et ARKitScenes. Consulte le Guide des jeux de données d'estimation de profondeur pour obtenir la liste complète et les détails du format.

Link to this sectionComment valider un modèle d'estimation de profondeur YOLO26 pré-entraîné ?#

Valide un modèle de profondeur YOLO26 pré-entraîné en fournissant le YAML du jeu de données utilisé pour l'évaluation :

from ultralytics import YOLO

# Load a pretrained model
model = YOLO("yolo26n-depth.pt")

# Validate the model
metrics = model.val(data="nyu-depth.yaml")
print("delta1:", metrics.delta1)
print("abs_rel:", metrics.abs_rel)
print("rmse:", metrics.rmse)

Link to this sectionComment puis-je exporter un modèle d'estimation de profondeur YOLO26 au format ONNX ?#

Exporte un modèle de profondeur YOLO26 vers ONNX avec Python ou l'interface CLI :

from ultralytics import YOLO

# Load a pretrained model
model = YOLO("yolo26n-depth.pt")

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

Pour plus de détails sur l'exportation vers divers formats, reporte-toi à la page Export.