Estimativa de Profundidade Monocular#

A estimativa de profundidade monocular prevê um mapa de profundidade por pixel a partir de uma única imagem RGB. Cada pixel de saída contém um valor de profundidade em metros, representando a distância estimada da câmera até esse ponto da superfície.

A saída de um modelo de profundidade é um mapa de ponto flutuante denso de formato (H, W) alinhado com a imagem de entrada. Essa representação por pixel torna a estimativa de profundidade monocular ideal para reconstrução de cenas 3D, navegação de robôs, criação de conteúdo AR/VR e qualquer aplicação que exija layout espacial a partir de uma única câmera.

Modelos#

Os modelos de profundidade do YOLO26 pré-treinados em uma ampla mistura de vários conjuntos de dados (interno + externo, ~2,19M de imagens) são mostrados abaixo. As colunas de métricas são relatadas na divisão de teste Eigen do NYU Depth V2.

Os Modelos são baixados automaticamente do lançamento mais recente do Ultralytics no primeiro uso.

• delta1^NYU é a porcentagem de pixels onde a profundidade prevista está dentro de um fator de 1,25 da verdade fundamental (ground truth), no split de teste Eigen do NYU Depth V2 (654 imagens) com TTA multi-escala + inversão horizontal e alinhamento de log-mínimos-quadrados.
• A precisão de escala única sem TTA é reproduzível com yolo depth val model=yolo26n-depth.pt data=nyu-depth.yaml imgsz=768 device=0 (substitui model= para cada tamanho), que utiliza alinhamento de mediana (apenas escala) e pontua mais baixo: delta1 0.783 (n), 0.793 (s), 0.840 (m), 0.853 (l), 0.860 (x).
• abs_rel é o erro relativo médio absoluto entre os valores de profundidade previstos e os reais.
• rmse é a raiz do erro quadrático médio em metros.
• A velocidade é a latência apenas de inferência (pré/pós-processamento excluído) em imgsz=768, batch=1, relatada como média ± desvio padrão em execuções com controle de tempo após o aquecimento. CPU ONNX é o ONNX Runtime fp32 em um Intel Xeon de 32 núcleos (Skylake); T4 TensorRT10 é o TensorRT fp16 em uma Tesla T4.
• params e FLOPs são medidos em 768×768, a resolução de treinamento dos pesos liberados.

Velocidade em comparação com o Depth Anything V2#

O Depth Anything V2 é uma base aberta amplamente utilizada para profundidade monocular. Seu backbone do transformador de visão DINOv2 e seu decodificador DPT exigem muito processamento, portanto, no mesmo Tesla T4 com TensorRT fp16, o menor modelo Depth Anything V2 lançado é mais lento do que qualquer modelo de profundidade YOLO26 — incluindo o YOLO26x-depth, que possui mais do que o dobro de parâmetros.

A ~768 px — imgsz=768 para o YOLO26, a resolução em que seus pesos lançados são treinados, e 770 px para o Depth Anything V2, cujo backbone DINOv2 requer um múltiplo do tamanho de seu patch de 14:

A ~640 px — imgsz=640 e 644 px respectivamente — a ordem permanece inalterada, e o YOLO26n-depth é 5,9× mais rápido que o Depth Anything V2 Small:

• A latência é apenas de inferência, batch=1, TensorRT fp16 em uma Tesla T4 — o mesmo ambiente de testes da tabela de modelos acima, mostrada aqui com duas casas decimais; o FPS é o recíproco da latência não arredondada. As colunas de Aceleração dividem a latência do Depth Anything V2 Small (20,99 ms) e Base (55,40 ms) pela latência do YOLO26.
• O Depth Anything V2 Small e Base são os pontos de verificação ViT-S e ViT-B lançados.
• A comparação abrange apenas a latência — as duas famílias de modelos não são avaliadas aqui sob um protocolo de precisão partilhado.

Alcance de profundidade e o cabeçalho de log-profundidade#

O cabeçote de profundidade prevê exp(logit) — ilimitado (~0,02–150 m) — e desacopla a forma da cena da escala absoluta: a rede prevê um campo de log-profundidade relativo, e os metros absolutos são definidos por uma transformação separada de dois parâmetros (exp(a·log d + b)) recuperada na avaliação, por calibração leve ou por ajuste fino. A alternativa comum, um cabeçote sigmoid × max_depth limitado, em vez disso impõe um limite fixo na arquitetura, de modo que qualquer profundidade além de max_depth é cortada — o que impede o treinamento e a previsão em cenas de maior alcance.

Por que o cabeçalho não tem limites: evidências em diferentes alcances de profundidade#

A/B Controlado — mesmos dados, mesmo cronograma, apenas o cabeçalho difere. Treinando ambos os cabeçalhos do zero em uma mistura idêntica de dados de interior (≤10 m) e exterior (≤80 m):

O cabeçote limitado não consegue representar a maioria de pixels externos >10 m, por isso para de melhorar quase imediatamente; o cabeçote log aprende com toda a faixa.

O modo de falha que ele corrige — ajuste fino de conjunto de dados único, estratificado por alcance. Fazer o ajuste fino de um cabeçalho limitado (10 m) em conjuntos de dados individuais funciona quando os dados se ajustam ao limite e colapsa quando o excedem:

O colapso ocorre exatamente no limite máximo. O cabeçote log não possui tal limite.

Modelos lançados — desempenho em diferentes alcances. A família enviada com o cabeçote log, avaliada em benchmarks que variam de 10 m (NYU, iBims-1) a 80 m (KITTI), com δ1 alinhado à escala:

Ambas as colunas são conforme publicadas. As outras linhas são pontuadas com o protocolo TTA e log-least-squares descrito nas respetivas páginas de conjuntos de dados, que o validador neste repositório não implementa, pelo que a linha KITTI não pode ser reavaliada nas mesmas bases; a página do KITTI apresenta valores medidos no split canónico de 652 fotogramas de Eigen.

Os maiores ganhos estão nos benchmarks externos de maior alcance (KITTI, ETH3D) — exatamente onde um teto fixo de 10 m mais prejudica — enquanto o desempenho interno é mantido.

Treinar#

Treina o YOLO26n-depth no conjunto de dados Depth8 por 100 épocas com um tamanho de imagem de 640. Para obter uma lista completa de argumentos disponíveis, consulta a página de Configuração.

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 os detalhes do modo train na página Treinar.

Ajuste fino em seus próprios dados#

Ao adaptar um modelo de profundidade pré-treinado a um conjunto de dados personalizado, reduz a taxa de aprendizado e usa o otimizador AdamW. As configurações padrão do otimizador são ajustadas para treinamento do zero (SGD com lr0=0.01); aplicadas a um modelo de profundidade já convergido, elas podem sobrescrever o conhecimento pré-treinado e degradar os resultados — especialmente ao fazer o ajuste fino em um único domínio.

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
)

Dicas adicionais:

• A augmentação é controlada pelos argumentos padrão (degrees, translate, scale, shear, perspective, flipud, fliplr, hsv_h, hsv_s, hsv_v); a distorção geométrica e as inversões são aplicadas de forma idêntica ao mapa de profundidade emparelhado. Para ver a receita exata usada para os pesos de YOLO26-Depth lançados, inspeciona o train_args armazenado no ponto de verificação — consulta Inspecionando os argumentos de treinamento do ponto de verificação do YOLO26.
• mosaic, mixup, cutmix e copy_paste não estão implementados para profundidade. O carregador de conjuntos de dados de profundidade define automaticamente essas probabilidades como 0, portanto, passá-las não tem efeito. Essas augmentações não são suportadas porque combinam várias imagens, o que geraria mapas de profundidade emparelhados inválidos.
• Qualquer intervalo de profundidade funciona nativamente. Os modelos com o cabeçote log preveem profundidade ilimitada, portanto, eles se adaptam a dados de curto alcance (macro) ou longo alcance (externos/direção) sem alterações. Definir max_depth: no YAML do seu conjunto de dados (em metros) limita quais pixels de GT contam para as métricas de validação.
• Mantenha o desempenho geral. Se você precisar que o modelo permaneça preciso em cenas além do seu conjunto de treinamento, misture uma pequena fração (~5–10%) de imagens de propósito geral diversas em seus dados de treinamento; isso reduz substancialmente o esquecimento durante o ajuste fino.
• Treinar do zero (model=yolo26s-depth.yaml) apenas se o teu domínio for muito diferente e tiveres um grande conjunto de dados — nesse caso, o SGD padrão lr0=0.01 é apropriado, já que não há pesos pré-treinados para preservar.

Calibrando a escala de profundidade#

O cabeçote de profundidade separa a forma (estrutura relativa da cena) da escala (metros absolutos). Se um modelo já produz uma boa profundidade relativa em suas cenas, mas os valores absolutos estão incorretos para a tua câmera, podes corrigir a escala em segundos com model.calibrate() — um ajuste de forma fechada de um log-afim de dois parâmetros em um pequeno conjunto rotulado, sem treinamento de gradiente e sem alteração nos pesos da rede, portanto, não pode degradar a estrutura 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")

A calibração precisa de profundidade de verdade básica (ground-truth) para realizar o ajuste, portanto, ela é executada em uma divisão rotulada — não é algo que possa acontecer em inferência cega. Ela ajusta e pontua nos mesmos pixels que as métricas de validação avaliam: o GT em ou além do max_depth do YAML do conjunto de dados (padrão de 100 m) é excluído. Usa-a quando a profundidade relativa já estiver boa e apenas a escala/intervalo estiver incorreto; se a própria estrutura relativa precisar mudar para o teu domínio, ajusta finamente em vez disso.

O treinamento faz isso automaticamente para ti: após a conclusão de model.train(...), os pontos de verificação melhores e mais recentes são calibrados no conjunto de validação para que produzam profundidade dimensionada por métrica nativamente.

Os pontos de verificação lançados de yolo26*-depth.pt já vêm com essa calibração integrada, ajustada na mistura de validação de pré-treinamento. É uma escala global única em todos os domínios, portanto, para obter a profundidade absoluta mais precisa em uma câmera ou tipo de cena específico, executa model.calibrate() em uma pequena divisão rotulada a partir de seus próprios dados — isso substitui o ajuste integrado.

Formato do conjunto de dados#

Os conjuntos de dados de estimativa de profundidade associam cada imagem RGB a um arquivo de profundidade correspondente. Os alvos de profundidade são armazenados como matrizes .npy contendo valores float32 em metros. O YAML do conjunto de dados aponta para um diretório images/; o carregador deriva o caminho do arquivo de profundidade substituindo o componente images por depth e trocando a extensão da imagem por .npy.

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

Por exemplo, uma imagem em images/train/scene_001.jpg é associada a um mapa de profundidade em depth/train/scene_001.npy. Consulta o Guia de Conjunto de Dados de Estimativa de Profundidade para ver a especificação completa do formato.

Validar#

Valida a precisão de um modelo YOLO26n-depth treinado em um conjunto de dados de estimativa de profundidade. Passa data explicitamente para que a validação use o YAML do conjunto de dados pretendido. Os pesos lançados são treinados em imgsz=768, portanto, valida e prevê nesse tamanho para obter a melhor precisão.

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

Prever#

Use um modelo YOLO26n-depth treinado para executar previsões em imagens.

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 os detalhes do modo predict na página Prever.

Saída de Resultados#

A estimativa de profundidade do YOLO retorna um objeto Results por imagem. Cada resultado armazena um mapa de profundidade em ponto flutuante denso para a imagem inteira.

Para campos de Results específicos de tarefas em cada tarefa, consulta a seção Resultados de Previsão por Tarefa.

Colorindo o mapa de profundidade#

O mapa de profundidade bruto é um array de ponto flutuante de canal único em metros — útil para computação, mas difícil de ler diretamente. Para transformá-lo em uma imagem colorida, usa o auxiliar colorize_depth em ultralytics.utils.plotting, que mapeia o array de profundidade (H, W) para uma imagem BGR uint8 (H, W, 3) (pixels inválidos <= 0 são renderizados em preto).

result.plot() já mescla essa colorização sobre a imagem de entrada usando os padrões (cmap="jet", mode="disparity"); chama colorize_depth diretamente quando quiseres uma imagem de profundidade colorida independente ou um mapa de cores ou normalização diferente.

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

Cada mapa de cores vai de frio/escuro → quente/brilhante. O mode decide qual extremidade está próxima, e vmin/vmax travam o intervalo entre os quadros para que uma cor sempre signifique a mesma distância.

Exportar#

Exporte um modelo YOLO26n-depth para um formato diferente 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")

Os formatos de exportação de estimativa de profundidade do YOLO26 disponíveis estão na tabela abaixo. Podes exportar para qualquer formato usando o argumento format, ou seja, format='onnx' ou format='engine'. Podes prever ou validar diretamente em modelos exportados, ou seja, yolo predict model=yolo26n-depth.onnx. Exemplos de uso são mostrados para o teu modelo após a conclusão da exportação.

Consulta todos os detalhes de export na página Exportar.

FAQ#