Estimación monocular de profundidad con Ultralytics YOLO#

La estimación monocular de profundidad predice un mapa de profundidad por píxel a partir de una única imagen RGB. Cada píxel de salida contiene un valor de profundidad en metros que representa la distancia estimada desde la cámara hasta ese punto de la superficie.

La salida de un modelo de profundidad es un mapa denso de valores float con forma (H, W), alineado con la imagen de entrada. Esta representación por píxel hace que la estimación monocular de profundidad sea idónea para la reconstrucción de escenas 3D, la navegación robótica, la creación de contenido de RA/RV y cualquier aplicación que requiera información sobre la disposición espacial a partir de una sola cámara.

Modelos#

A continuación se muestran modelos de profundidad YOLO26 preentrenados con una amplia combinación de varios conjuntos de datos (interiores + exteriores, ~2.19M imágenes). Las columnas de métricas corresponden a la partición de prueba Eigen de NYU Depth V2.

Los modelos se descargan automáticamente desde la versión más reciente de Ultralytics al usarlos por primera vez.

• delta1^NYU es la fracción de píxeles cuya profundidad predicha está dentro de un factor de 1.25 respecto a la referencia, en la partición de prueba Eigen de NYU Depth V2 (654 imágenes), con TTA multiescala + volteo horizontal y alineación por mínimos cuadrados en el espacio logarítmico.
• La precisión a escala única sin TTA se puede reproducir con yolo depth val model=yolo26n-depth.pt data=nyu-depth.yaml imgsz=768 device=0 (sustituye model= por cada tamaño), que usa una alineación por mediana (solo escala) y obtiene puntuaciones más bajas: delta1 0.783 (n), 0.793 (s), 0.840 (m), 0.853 (l), 0.860 (x).
• abs_rel es el error relativo absoluto medio entre los valores de profundidad predichos y los de referencia.
• rmse es la raíz del error cuadrático medio, en metros.
• Velocidad es la latencia de inferencia únicamente (sin incluir el preprocesamiento ni el posprocesamiento) a imgsz=768, batch=1, expresada como media ± desviación estándar de las ejecuciones cronometradas tras el calentamiento. CPU ONNX es ONNX Runtime fp32 en una CPU Intel Xeon de 32 núcleos (Skylake); T4 TensorRT10 es TensorRT fp16 en una Tesla T4.
• params y FLOPs se miden a 768×768, la resolución de entrenamiento de los pesos publicados.

Consulta la versión preliminar no publicada de YOLO27 para ver los resultados preliminares de NYU Depth V2.

Velocidad comparada con Depth Anything V2#

Depth Anything V2 es una referencia abierta muy utilizada para la estimación monocular de profundidad. Su Transformer de visión DINOv2 y el decodificador DPT requieren muchos recursos de cálculo, por lo que, en la misma Tesla T4 con TensorRT fp16, el modelo Depth Anything V2 más pequeño publicado es más lento que todos los modelos de profundidad YOLO26, incluido YOLO26x-depth, que tiene más del doble de parámetros.

A ~768 px — imgsz=768 para YOLO26, la resolución con la que se entrenan sus pesos publicados, y 770 px para Depth Anything V2, cuyo backbone DINOv2 requiere un múltiplo de su tamaño de parche de 14:

A ~640 px — imgsz=640 y 644 px, respectivamente — el orden no cambia y YOLO26n-depth es 5.9× más rápido que Depth Anything V2 Small:

• La latencia corresponde únicamente a la inferencia, batch=1, TensorRT fp16 en una Tesla T4, con el mismo entorno de pruebas que la tabla de modelos anterior, pero con dos decimales; los FPS son el inverso de la latencia sin redondear. Las columnas de Aceleración dividen las latencias de Depth Anything V2 Small (20.99 ms) y Base (55.40 ms) por la latencia de YOLO26.
• Depth Anything V2 Small y Base son los checkpoints ViT-S y ViT-B publicados.
• La comparación solo abarca la latencia: aquí no se evalúan las dos familias de modelos con un protocolo de precisión común.

Rango de profundidad y cabezal de profundidad logarítmica#

El cabezal de profundidad predice exp(logit) — sin límite (~0.02–150 m) — y desacopla la forma de la escena de la escala absoluta: la red predice un campo de profundidad logarítmica relativa, y los metros absolutos se establecen mediante una transformación independiente de dos parámetros (exp(a·log d + b)), que se obtiene durante la evaluación, mediante una calibración ligera o con ajuste fino. La alternativa habitual, un cabezal sigmoid × max_depth acotado, incorpora un límite máximo fijo en la arquitectura, por lo que cualquier profundidad superior a max_depth se recorta, lo que impide entrenar con escenas de mayor alcance y predecirlas.

Prueba A/B controlada: mismos datos, mismo programa, solo cambia el cabezal. Entrenamiento desde cero de ambos cabezales con una combinación idéntica de datos interiores (≤10 m) y exteriores (≤80 m):

El cabezal acotado no puede representar la mayoría de los píxeles exteriores, que están a más de 10 m, por lo que deja de mejorar casi de inmediato; el cabezal log aprende a partir del rango completo.

El problema que resuelve: ajuste fino en un único conjunto de datos, desglosado por rango. El ajuste fino de un cabezal acotado (10 m) en conjuntos de datos individuales funciona cuando los datos están dentro del límite y falla cuando lo superan:

El fallo se produce exactamente en el límite máximo. El cabezal log no tiene ese límite.

Modelos publicados: rendimiento en distintos rangos. La familia de cabezales log publicada, evaluada en benchmarks que abarcan desde 10 m (NYU, iBims-1) hasta 80 m (KITTI), con δ1 alineada por escala:

Ambas columnas se reproducen tal como se publicaron. El resto de las filas se puntúan con el protocolo TTA y de mínimos cuadrados logarítmicos descrito en las páginas de sus conjuntos de datos, que el validador de este repositorio no implementa; por tanto, la fila de KITTI no se puede volver a medir en las mismas condiciones. La página de KITTI muestra cifras medidas en la partición Eigen canónica de 652 fotogramas.

Las mayores mejoras se observan en los benchmarks exteriores de mayor alcance (KITTI, ETH3D), justo donde más perjudica un límite fijo de 10 m, y se mantiene el rendimiento en interiores.

Entrenar#

Entrena YOLO26n-depth con el conjunto de datos Depth8 durante 100 épocas con un tamaño de imagen de 640. Consulta la página de configuración para ver la lista completa de argumentos disponibles.

from ultralytics import YOLO

# Cargar un modelo
model = YOLO("yolo26n-depth.yaml")  # Crea un modelo nuevo a partir de YAML
model = YOLO("yolo26n-depth.pt")  # Carga un modelo preentrenado (recomendado para el entrenamiento)
model = YOLO("yolo26n-depth.yaml").load("yolo26n-depth.pt")  # Crea el modelo a partir de YAML y transfiere los pesos

# Entrenar el modelo
results = model.train(data="depth8.yaml", epochs=100, imgsz=640)

Consulta los detalles completos del modo train en la página de entrenamiento. También puedes entrenar modelos de profundidad con el entrenamiento en la nube de Ultralytics Platform.

Formato del conjunto de datos#

Los conjuntos de datos de estimación de profundidad emparejan cada imagen RGB con un mapa de profundidad PNG uint16 escalado o un mapa de profundidad NPY de coma flotante en metros. Por defecto, los valores PNG se expresan en milímetros; los conjuntos de datos que usan otra convención definen depth_scale en su YAML. El cargador obtiene la ruta de profundidad sustituyendo el componente images por depth; da prioridad a .png y, si no está disponible, usa .npy.

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

Por ejemplo, a la imagen images/train/scene_001.jpg le corresponde un mapa de profundidad en depth/train/scene_001.png. Consulta la guía de conjuntos de datos de estimación de profundidad para ver la especificación completa del formato.

Ajuste fino con tus propios datos#

Al adaptar un modelo de profundidad preentrenado a un conjunto de datos personalizado, reduce la tasa de aprendizaje y usa el optimizador AdamW. Los ajustes predeterminados del optimizador están pensados para entrenar desde cero; si los aplicas a un modelo de profundidad que ya ha convergido, pueden sobrescribir el conocimiento preentrenado y degradar los resultados, especialmente si haces el ajuste fino en un único dominio.

from ultralytics import YOLO

model = YOLO("yolo26s-depth.pt")  # partir de pesos preentrenados

model.train(
    data="path/to/your_dataset.yaml",
    epochs=20,
    imgsz=640,
    optimizer="AdamW",
    lr0=1e-4,  # ~100 veces por debajo del valor predeterminado desde cero
    warmup_bias_lr=1e-4,  # mantén también suave el calentamiento
)

Consejos adicionales:

• La ampliación de datos se controla mediante los argumentos estándar (degrees, translate, scale, shear, perspective, flipud, fliplr, hsv_h, hsv_s, hsv_v); la deformación geométrica y los volteos se aplican de forma idéntica al mapa de profundidad emparejado. Para ver la receta exacta utilizada con los pesos YOLO26-Depth publicados, inspecciona el train_args almacenado en el punto de control; consulta Inspección de los argumentos de entrenamiento de un punto de control de YOLO26.
• mosaic, mixup, cutmix y copy_paste no están implementados para la profundidad. El cargador del conjunto de datos de profundidad establece automáticamente estas probabilidades en 0, por lo que pasarlas no tiene ningún efecto. Estas ampliaciones no son compatibles porque combinan varias imágenes, lo que produciría mapas de profundidad emparejados no válidos.
• Cualquier intervalo de profundidad funciona directamente. Los modelos con cabeza log predicen una profundidad sin límites, por lo que se adaptan a datos de corto alcance (macro) o de largo alcance (exteriores/conducción) sin cambios. Al establecer max_depth: en el YAML del conjunto de datos (en metros), se limita qué píxeles GT cuentan para las métricas de validación.
• Mantén el rendimiento general. Si necesitas que el modelo siga siendo preciso en escenas que no estén en el conjunto de entrenamiento, mezcla una pequeña proporción (~5–10 %) de imágenes variadas de propósito general en los datos de entrenamiento; esto reduce sustancialmente el olvido durante el ajuste fino.
• Entrena desde cero (model=yolo26s-depth.yaml) solo si tu dominio es muy distinto y tienes un conjunto de datos grande; en ese caso, el valor predeterminado optimizer=auto es adecuado, ya que no hay pesos preentrenados que conservar.

Calibración de la escala de profundidad#

La cabeza de profundidad separa la forma (la estructura relativa de la escena) de la escala (los metros absolutos). Si un modelo ya produce una buena profundidad relativa en tus escenas, pero los valores absolutos no son correctos para tu cámara, puedes corregir la escala en segundos con model.calibrate(): un ajuste de forma cerrada, solo de escala, de la transformación log-afín de la cabeza frente a un pequeño conjunto etiquetado, que solo se conserva si mejora δ1 en la validación cruzada con datos reservados, sin entrenamiento por gradiente ni cambios en los pesos de la red, por lo que no puede degradar la estructura relativa.

from ultralytics import YOLO

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

# Ajusta la escala con una partición etiquetada (bastan ~100 imágenes o más) y, después, persístela
model.calibrate(data="path/to/your_dataset.yaml")
model.save("yolo26s-depth-calibrated.pt")

La calibración necesita la profundidad real de referencia para realizar el ajuste, por lo que se ejecuta en una partición etiquetada; no puede hacerse durante la inferencia a ciegas. Ajusta y evalúa los mismos píxeles que usan las métricas de validación: se excluye la profundidad GT igual o superior al valor max_depth del YAML del conjunto de datos (100 m de forma predeterminada). Úsala cuando la profundidad relativa ya sea buena y solo falle la escala/el alcance; si la estructura relativa en sí necesita cambiar para tu dominio, ajusta el modelo en su lugar.

El entrenamiento lo hace automáticamente: al terminar model.train(...), los mejores puntos de control y los últimos se calibran con el conjunto de validación para que generen directamente una profundidad con escala métrica.

Los puntos de control yolo26*-depth.pt publicados ya incluyen esta calibración, ajustada con la mezcla de validación del preentrenamiento. Se trata de una única escala global para todos los dominios, así que, para obtener la profundidad absoluta más precisa en una cámara o tipo de escena concretos, ejecuta model.calibrate() con una pequeña partición etiquetada de tus propios datos; esto sustituye el ajuste integrado.

Obtener profundidad de referencia sin una cámara de profundidad#

Si tu cámara no tiene sensor de profundidad, aun así puedes calibrarla. La calibración ajusta una única escala global e ignora los píxeles con profundidad 0, así que bastan unos pocos puntos medidos por imagen.

1. Recopila imágenes. Toma entre 50 y 150 imágenes con la cámara a la resolución y con los ajustes del objetivo que usarás en producción, y guárdalas en dataset/images/val/. La calibración lee la partición val.

2. Anota la profundidad. Usa uno de los dos métodos siguientes. Ambos escriben un mapa de profundidad por imagen en dataset/depth/val/, con el formato del conjunto de datos.

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. Escribe el YAML del conjunto de datos como calib.yaml. depth_scale: 100 lee los PNG en centímetros de los puntos medidos y se ignora para los mapas NPY:

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

4. Calibra y guarda; después, carga yolo26s-depth-calibrated.pt para predecir o exportar:

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

En las pruebas con yolo26s-depth.pt y 150 imágenes por cámara, la calibración publicada se desvió entre un 4 % y un 46 % del ajuste de escala con valores de referencia completos para NYU, KITTI y una cámara con un objetivo estrecho. La calibración con 5 puntos medidos por imagen se acercó a ese ajuste con una diferencia inferior al 1 %, y con las etiquetas de DA3METRIC-LARGE, con una diferencia inferior al 7 %. Añadir imágenes ayuda más que añadir puntos por imagen: 150 imágenes con 1 punto cada una se acercaron con una diferencia de aproximadamente el 3 %, mientras que 20 imágenes con 5 puntos cada una presentaron variaciones de hasta el 9 %.

Validar#

Valida la precisión de un modelo YOLO26n-depth entrenado en un conjunto de datos de estimación de profundidad. Pasa data explícitamente para que la validación use el YAML del conjunto de datos previsto. Los pesos publicados se entrenan con imgsz=768 en imágenes estiradas hasta formar un cuadrado, en lugar de imágenes ajustadas con bandas de relleno; por eso, valida y predice con ese tamaño para obtener la máxima precisión. La predicción, la validación y model.calibrate() estiran la entrada de la misma manera.

from ultralytics import YOLO

# Cargar un modelo
model = YOLO("yolo26n-depth.pt")  # carga un modelo oficial
model = YOLO("path/to/best.pt")  # cargar un modelo personalizado

# Valida el modelo
metrics = model.val(data="nyu-depth.yaml")
metrics.delta1  # fracción de píxeles dentro del umbral δ=1.25
metrics.abs_rel  # error relativo absoluto medio
metrics.rmse  # raíz del error cuadrático medio (metros)
metrics.silog  # error logarítmico invariante a la escala

Predecir#

Usa un modelo YOLO26n-depth entrenado para ejecutar predicciones en imágenes.

from ultralytics import YOLO

# Cargar un modelo
model = YOLO("yolo26n-depth.pt")  # carga un modelo oficial
model = YOLO("path/to/best.pt")  # cargar un modelo personalizado

# Haz predicciones con el modelo
results = model("https://ultralytics.com/images/bus.jpg")  # haz una predicción sobre una imagen

# Accede a los resultados
for result in results:
    depth_map = result.depth.data.cpu().numpy()  # torch.Tensor -> NumPy float32, forma (H, W), metros

Consulta todos los detalles del modo predict en la página de predicción.

Resultados de salida#

La estimación de profundidad de YOLO devuelve un objeto Results por imagen. Cada resultado almacena un mapa de profundidad denso de tipo float para toda la imagen.

Para consultar los campos Results específicos de cada tarea, visita la sección resultados de predicción por tarea.

Profundidad por objeto con segmentación de instancias#

Combina la segmentación de instancias con la profundidad para estimar a qué distancia está cada objeto detectado. Ejecuta ambos modelos en la misma imagen con retina_masks=True para que las máscaras compartan la resolución de la imagen original del mapa de profundidad y, después, calcula la mediana de los píxeles de profundidad válidos dentro de cada máscara.

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 mediana es robusta frente a los píxeles del fondo en los bordes de las máscaras, pero describe la superficie visible del objeto, no su centro, y su precisión depende de la escala de profundidad del modelo (consulta Calibrar la escala de profundidad).

Aplicar color al mapa de profundidad#

El mapa de profundidad sin procesar es una matriz float de un solo canal en metros: útil para los cálculos, pero difícil de interpretar directamente. Para convertirlo en una imagen en color, usa la función auxiliar colorize_depth de ultralytics.utils.plotting, que transforma la matriz de profundidad (H, W) en una imagen BGR uint8 de (H, W, 3) (los píxeles no válidos <= 0 se muestran en negro).

result.plot() ya superpone esta representación en color a la imagen de entrada con los valores predeterminados (cmap="jet", mode="disparity"); llama directamente a colorize_depth cuando quieras una imagen de profundidad en color independiente o una tabla de colores o normalización distintas.

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

# Aplica color con los objetos cercanos en tonos cálidos y guarda
cv2.imwrite("depth_colored.png", colorize_depth(depth, cmap="spectral"))  # (H, W, 3) BGR uint8

# Fija el intervalo en 0-20 m para que el mismo color represente la misma distancia en todos los fotogramas
cv2.imwrite("depth_metric.png", colorize_depth(depth, vmin=0.0, vmax=20.0, cmap="inferno", mode="metric"))

# Superposición combinada directamente desde el objeto Results (usa cmap="jet", mode="disparity")
result.save("depth_overlay.png")

Todas las tablas de colores van de tonos fríos/oscuros a cálidos/brillantes. mode determina qué extremo representa lo cercano, y vmin/vmax fijan el intervalo entre fotogramas para que un color siempre represente la misma distancia.

Exportar#

Exporta un modelo YOLO26n-depth a otro formato, como ONNX, CoreML, etc.

from ultralytics import YOLO

# Cargar un modelo
model = YOLO("yolo26n-depth.pt")  # carga un modelo oficial
model = YOLO("path/to/best.pt")  # cargar un modelo personalizado

# Exporta el modelo
model.export(format="onnx")

Los formatos de exportación disponibles para la estimación de profundidad con YOLO26 se muestran en la tabla siguiente. Puedes exportar a cualquier formato mediante el argumento format, por ejemplo, format='onnx' o format='engine'. Puedes predecir o validar directamente con los modelos exportados, por ejemplo, yolo predict model=yolo26n-depth.onnx. Cuando termine la exportación, se mostrarán ejemplos de uso para tu modelo.

nms=None usa de forma predeterminada salidas sin procesar para NMS externa. Establece nms=False para seleccionar una cabeza sin NMS disponible; los formatos no compatibles recurren a su ruta de salida nativa. Las entradas nms anteriores identifican los formatos que pueden integrar NMS con nms=True.

Consulta todos los detalles de export en la página Exportar.

Preguntas frecuentes#