Estimación de profundidad monocular con Ultralytics YOLO#

La estimación de profundidad monocular 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 de profundidad monocular sea adecuada para la reconstrucción de escenas 3D, la navegación de robots, la creación de contenido de RA/RV y cualquier aplicación que requiera la disposición espacial a partir de una única cámara.

Modelos#

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

Los modelos se descargan automáticamente de la versión más reciente de Ultralytics durante el primer uso.

• delta1^NYU es el porcentaje de píxeles cuya profundidad predicha se encuentra dentro de un factor de 1,25 respecto a la verdad terreno, en la partición de prueba Eigen de NYU Depth V2 (654 imágenes), con TTA multiescala y volteo horizontal, y alineación de mínimos cuadrados logarítmicos.
• 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 mediana (solo de escala) y obtiene puntuaciones inferiores: 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 verdad terreno.
• rmse es el error cuadrático medio de raíz en metros.
• Velocidad es la latencia exclusiva de inferencia (sin incluir el preprocesamiento ni el posprocesamiento) en imgsz=768, batch=1, expresada como media ± desviación estándar en ejecuciones cronometradas tras el calentamiento. CPU ONNX es ONNX Runtime fp32 en una 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 vista previa 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 profundidad monocular. Su backbone DINOv2 de vision transformer y su decodificador DPT requieren mucho procesamiento, por lo que, en la misma Tesla T4 con TensorRT fp16, el modelo más pequeño publicado de Depth Anything V2 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 píxeles — imgsz=768 para YOLO26, la resolución a la que se han entrenado sus pesos publicados, y 770 píxeles para Depth Anything V2, cuyo backbone DINOv2 requiere un múltiplo de su tamaño de parche de 14:

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

• La latencia corresponde exclusivamente a la inferencia, batch=1, TensorRT fp16 en una Tesla T4 — el mismo sistema de prueba que en la tabla de modelos anterior, mostrado aquí con dos decimales; los FPS son el recíproco de la latencia sin redondear. Las columnas de Aceleración dividen la latencia 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 abarca únicamente la latencia; aquí no se evalúan las dos familias de modelos con un protocolo de precisión común.

Rango de profundidad y la cabeza de log-profundidad#

La cabeza de profundidad predice exp(logit) — sin límites (~0,02–150 m) — y desacopla la forma de la escena de la escala absoluta: la red predice un campo de log-profundidad relativo y los metros absolutos se establecen mediante una transformación independiente de dos parámetros (exp(a·log d + b)), recuperada durante la evaluación, mediante una calibración ligera o mediante ajuste fino. La alternativa habitual, una cabeza sigmoid × max_depth acotada, incorpora en cambio un techo fijo en la arquitectura, por lo que cualquier profundidad superior a max_depth se recorta, lo que impide entrenar y predecir escenas de mayor alcance.

Por qué la cabeza no tiene límites: evidencias en distintos rangos de profundidad#

A/B controlado: mismos datos, mismo plan de entrenamiento, solo cambia la cabeza. Entrenamiento desde cero de ambas cabezas con una combinación idéntica de datos de interiores (≤10 m) y exteriores (≤80 m):

La cabeza acotada no puede representar la mayoría de los píxeles exteriores situados a más de 10 m, por lo que deja de mejorar casi inmediatamente; la cabeza log aprende de todo el rango.

El fallo que corrige: ajuste fino en un único conjunto de datos, estratificado por rango. El ajuste fino de una cabeza acotada (10 m) en conjuntos de datos individuales funciona cuando los datos caben dentro del límite y se degrada cuando lo superan:

El colapso se produce exactamente en el límite superior. La cabeza log no tiene ese límite.

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

Ambas columnas son las publicadas. Las demás filas se puntúan con el protocolo de TTA y mínimos cuadrados logarítmicos descrito en las páginas de sus respectivos conjuntos de datos, que el validador de este repositorio no implementa, por lo que la fila de KITTI no se puede volver a medir en igualdad de condiciones; la página de KITTI incluye las cifras medidas en la partición Eigen canónica de 652 fotogramas.

Las mayores mejoras se producen en los benchmarks exteriores de mayor alcance (KITTI, ETH3D), exactamente donde más perjudica un techo fijo de 10 m, mientras que se mantiene el rendimiento en interiores.

Entrenar#

Entrena YOLO26n-depth en el conjunto de datos Depth8 durante 100 épocas con un tamaño de imagen de 640. Para consultar la lista completa de argumentos disponibles, visita la página de Configuración.

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)

Consulta todos los detalles del modo train en la página de Entrenamiento.

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. La configuración predeterminada del optimizador está ajustada para entrenar desde cero (SGD con lr0=0.01); aplicada a un modelo de profundidad ya convergido, puede sobrescribir el conocimiento preentrenado y degradar los resultados, especialmente al realizar un ajuste fino en un único dominio.

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
)

Consejos adicionales:

• La aumentación 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 consultar la receta exacta utilizada para los pesos YOLO26-Depth publicados, inspecciona el train_args almacenado en el checkpoint; consulta Inspección de los argumentos de entrenamiento del checkpoint de YOLO26.
• mosaic, mixup, cutmix y copy_paste no están implementados para 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 aumentaciones no son compatibles porque combinan varias imágenes, lo que produciría mapas de profundidad emparejados no válidos.
• Cualquier rango 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 largo alcance (exteriores/conducción) sin cambios. Establecer max_depth: en el YAML de tu conjunto de datos (en metros) limita qué píxeles de verdad terreno cuentan para las métricas de validación.
• Conserva el rendimiento general. Si necesitas que el modelo siga siendo preciso en escenas que quedan fuera de tu conjunto de entrenamiento, mezcla una pequeña proporción (~5–10 %) de imágenes generales diversas en tus datos de entrenamiento; esto reduce considerablemente el olvido durante el ajuste fino.
• Entrena desde cero (model=yolo26s-depth.yaml) solo si tu dominio es muy diferente y tienes un conjunto de datos grande; en ese caso, el SGD predeterminado lr0=0.01 es adecuado, ya que no hay pesos preentrenados que conservar.

Calibración de la escala de profundidad#

La cabeza de profundidad separa la forma (estructura relativa de la escena) de la escala (metros absolutos). Si un modelo ya produce una buena profundidad relativa en tus escenas, pero los valores absolutos no son adecuados para tu cámara, puedes corregir la escala en cuestión de segundos con model.calibrate(): un ajuste de forma cerrada log-afín de dos parámetros sobre un pequeño conjunto etiquetado, sin entrenamiento mediante 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")

# 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 calibración necesita una profundidad de referencia con la que ajustarse, por lo que se ejecuta en una partición etiquetada; no puede realizarse durante una inferencia a ciegas. Ajusta y puntúa los mismos píxeles que evalúan las métricas de val: se excluye la GT igual o superior a max_depth del YAML del conjunto de datos (100 m de forma predeterminada). Úsala cuando la profundidad relativa ya sea buena y solo fallen la escala o el alcance; si la propia estructura relativa debe cambiar para tu dominio, haz fine-tuning.

El entrenamiento lo hace automáticamente: después de que se complete model.train(...), los checkpoints mejor y último se calibran en el conjunto de validación para que generen profundidad escalada métricamente desde el principio.

Los checkpoints publicados de yolo26*-depth.pt ya incluyen esta calibración, ajustada con la combinación de validación del preentrenamiento. Es 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 específicos, ejecuta model.calibrate() en una pequeña partición etiquetada de tus propios datos; esto sustituye el ajuste incluido.

Formato del conjunto de datos#

Los conjuntos de datos de estimación de profundidad emparejan cada imagen RGB con un PNG de profundidad uint16 escalado o un mapa de profundidad NPY de coma flotante en metros. De forma predeterminada, los valores PNG usan milímetros; los conjuntos de datos con otra convención establecen depth_scale en su YAML. El cargador obtiene la ruta de profundidad sustituyendo el componente images por depth, dando prioridad a .png y recurriendo a .npy.

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

Por ejemplo, una imagen en images/train/scene_001.jpg se empareja con 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.

Val#

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, así que valida y predice con ese tamaño para obtener la máxima precisión.

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

Predecir#

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

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

Consulta todos los detalles del modo predict en la página Predecir.

Salida de resultados#

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

Para consultar los campos específicos de la tarea de Results en todas las tareas, visita la sección Resultados de predicción por tarea.

Aplicar color al mapa de profundidad#

El mapa de profundidad sin procesar es un array de floats de un solo canal en metros: resulta útil para los cálculos, pero es difícil de interpretar directamente. Para convertirlo en una imagen en color, usa el ayudante colorize_depth de ultralytics.utils.plotting, que asigna el array de profundidad (H, W) a una imagen BGR (H, W, 3) de uint8 (los píxeles no válidos <= 0 se representan en negro).

result.plot() ya combina esta coloración con la imagen de entrada usando los valores predeterminados (cmap="jet", mode="disparity"); llama directamente a colorize_depth cuando quieras una imagen de profundidad coloreada independiente o un mapa de color o una normalización diferentes.

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

Todos los mapas de color van de tonos fríos/oscuros a cálidos/brillantes. mode decide qué extremo representa lo cercano, mientras que vmin/vmax fijan el rango entre fotogramas para que un color siempre signifique la misma distancia.

Exportar#

Exporta un modelo YOLO26n-depth a otro formato, como 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")

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

nms=None se establece por defecto en salidas sin procesar para la NMS externa. Configura nms=False para seleccionar una cabeza libre de NMS disponible; los formatos no compatibles recurren a su ruta de salida nativa. Las entradas nms anteriores identifican los formatos que pueden incrustar la NMS con nms=True.

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

Preguntas frecuentes#