Link to this sectionEstimativa 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 com formato (H, W) alinhado à 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 o layout espacial a partir de uma única câmera.

Link to this sectionModelos#

Modelos de profundidade YOLO26 pré-treinados em uma ampla mistura de conjuntos de dados (interior + exterior, ~2,19 milhões de imagens) são mostrados abaixo. As colunas de métricas são reportadas no split de teste Eigen do NYU Depth V2.

Os Modelos são baixados automaticamente da versão 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 (substitua model= para cada tamanho), que usa alinhamento de mediana (apenas escala) e pontuações mais baixas: delta1 0,785 (n), 0,786 (s), 0,827 (m), 0,839 (l), 0,843 (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.
• params e FLOPs são medidos em 768×768, a resolução de treinamento dos pesos liberados.

Link to this sectionAlcance de profundidade e o cabeçalho de log-profundidade#

O cabeçalho de profundidade prevê exp(logit) — sem limites (~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çalho sigmoid × max_depth limitado, insere um teto fixo na arquitetura, portanto, qualquer profundidade além de max_depth é cortada — o que impede o treinamento e a previsão de cenas de longo alcance.

Link to this sectionPor 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çalho limitado não consegue representar a maioria dos pixels externos >10 m, então ele para de melhorar quase imediatamente; o cabeçalho log aprende a partir de todo o alcance.

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 acontece exatamente no limite do teto. O cabeçalho log não tem esse limite.

Modelos liberados — desempenho em diversos alcances. A família de cabeçalho log distribuída, avaliada em benchmarks que variam de 10 m (NYU, iBims-1) a 80 m (KITTI), com δ1 alinhado por escala:

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.

Link to this sectionTreinar#

Treine o YOLO26n-depth no conjunto de dados Depth8 por 100 épocas em tamanho de imagem 640. Para uma lista completa de argumentos disponíveis, veja 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)

Veja os detalhes completos do modo train na página Treinar.

Link to this sectionAjuste fino em seus próprios dados#

When adapting a pretrained depth model to a custom dataset, lower the learning rate and use the AdamW optimizer. The default optimizer settings are tuned for training from scratch (SGD with lr0=0.01); applied to an already-converged depth model they can overwrite the pretrained knowledge and degrade results — especially when fine-tuning on a single domain.

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:

• O aumento de dados é controlado 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 identicamente ao mapa de profundidade pareado. Para ver a receita exata usada para os pesos YOLO26-Depth liberados, inspecione os train_args armazenados no ponto de verificação — veja Inspecionando Argumentos de Treinamento de Ponto de Verificação YOLO26.
• mosaic, mixup, cutmix e copy_paste não são implementados para profundidade. O carregador de conjunto de dados de profundidade define automaticamente essas probabilidades como 0, então passá-las não tem efeito. Esses aumentos não são suportados porque combinam várias imagens, o que produziria mapas de profundidade pareados inválidos.
• Qualquer alcance de profundidade funciona nativamente. Os modelos de cabeçalho log preveem profundidade sem limites, então eles se adaptam a dados de curto alcance (macro) ou longo alcance (exterior/condução) sem alterações. Definir max_depth: no YAML do seu conjunto de dados (em metros) limita quais pixels da verdade fundamental 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.
• Train from scratch (model=yolo26s-depth.yaml) only if your domain is very different and you have a large dataset — there the default SGD lr0=0.01 is appropriate, since there are no pretrained weights to preserve.

Link to this sectionCalibrando a escala de profundidade#

O cabeçalho de profundidade separa a forma (estrutura de cena relativa) da escala (metros absolutos). Se um modelo já produz boa profundidade relativa em suas cenas, mas os valores absolutos estão incorretos para sua câmera, você pode 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 da verdade fundamental para se ajustar, então ela roda em um split rotulado — não é algo que pode acontecer em inferência cega. Use-a quando a profundidade relativa já estiver boa e apenas a escala/alcance estiverem errados; se a própria estrutura relativa precisar mudar para o seu domínio, faça o ajuste fino em vez disso.

O treinamento faz isso para você automaticamente: após a conclusão de model.train(...), os melhores e últimos pontos de verificação são calibrados no conjunto de validação para que produzam profundidade em escala métrica nativamente.

Os pontos de verificação yolo26*-depth.pt liberados já vêm com essa calibração embutida, ajustada na mistura de validação de pré-treinamento. É uma escala global única em todos os domínios, portanto, para a profundidade absoluta mais precisa em uma câmera ou tipo de cena específica, execute model.calibrate() em um pequeno split rotulado dos seus próprios dados — ele substitui o ajuste embutido.

Link to this sectionFormato do conjunto de dados#

Os conjuntos de dados de estimativa de profundidade pareiam cada imagem RGB com 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 substituindo a extensão da imagem por .npy.

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

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

Link to this sectionValidar#

Valide a precisão de um modelo YOLO26n-depth treinado em um conjunto de dados de estimativa de profundidade. Passe data explicitamente para que a validação use o YAML do conjunto de dados pretendido. Os pesos liberados são treinados em imgsz=768, então valide e preveja 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

Link to this sectionPrever#

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

Veja os detalhes completos do modo predict na página Previsão.

Link to this sectionSaída de Resultados#

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

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

Link to this sectionExportar#

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 YOLO26 disponíveis estão na tabela abaixo. Você pode exportar para qualquer formato usando o argumento format, i.e., format='onnx' ou format='engine'. Você pode prever ou validar diretamente em modelos exportados, i.e., yolo predict model=yolo26n-depth.onnx. Exemplos de uso são mostrados para o seu modelo após a conclusão da exportação.

Veja detalhes completos de export na página Export.

Link to this sectionFAQ#

Link to this sectionComo treino um modelo de estimativa de profundidade YOLO26 em um conjunto de dados personalizado?#

Prepare pares de imagens RGB e arquivos de profundidade .npy, depois crie um YAML de conjunto de dados apontando para o seu diretório images/. O carregador encontra os arquivos de profundidade automaticamente substituindo images por depth no caminho e trocando a extensão da imagem por .npy.

Comece a partir de pesos pré-treinados e use uma taxa de aprendizado baixa com AdamW para que o ajuste fino retenha o que o modelo já conhece (veja Ajuste fino nos seus próprios dados para saber o motivo):

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

Verifique a página de Configuração para mais argumentos disponíveis.

Link to this sectionQuais métricas o YOLO26 de estimativa de profundidade reporta?#

A validação de estimativa de profundidade reporta o conjunto de métricas usado pelo Depth Anything e trabalhos relacionados de profundidade monocular:

• delta1 / delta2 / delta3 — porcentagem de pixels onde a razão da profundidade prevista para a profundidade real (ou seu inverso) é inferior a 1,25, 1,25² e 1,25³ respectivamente. Quanto maior, melhor.
• abs_rel — erro relativo absoluto médio. Quanto menor, melhor.
• rmse — erro quadrático médio em metros. Quanto menor, melhor.
• silog — erro logarítmico invariante de escala. Quanto menor, melhor.

Cada previsão é alinhada pela mediana com seu valor real por imagem, e as estatísticas são então agregadas sobre cada pixel válido do conjunto de validação (imagens com mais pixels de profundidade válidos pesam proporcionalmente mais). Artigos que, em vez disso, calculam a média das métricas por imagem podem relatar valores ligeiramente diferentes nas mesmas previsões.

Link to this sectionQual é o formato de saída do mapa de profundidade?#

O mapa de profundidade é armazenado como um torch.Tensor com forma (H, W), onde cada valor é a profundidade prevista em metros (use result.depth.data.cpu().numpy() para um array NumPy float32). Acesse-o através de result.depth.data após executar a previsão. O mapa é alinhado à resolução da imagem de entrada.

Link to this sectionQuais conjuntos de dados são suportados para estimativa de profundidade?#

O Ultralytics YOLO26 fornece configurações YAML de conjunto de dados integradas para vários conjuntos de dados de estimativa de profundidade, incluindo NYU Depth V2, KITTI, Hypersim, SUN RGB-D e ARKitScenes. Veja o Guia de Conjuntos de Dados de Estimativa de Profundidade para a lista completa e detalhes de formato.

Link to this sectionComo valido um modelo de estimativa de profundidade YOLO26 pré-treinado?#

Valide um modelo de profundidade YOLO26 pré-treinado fornecendo o YAML do conjunto de dados usado para avaliação:

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 sectionComo posso exportar um modelo de estimativa de profundidade YOLO26 para o formato ONNX?#

Exporte um modelo de profundidade YOLO26 para ONNX com Python ou CLI:

from ultralytics import YOLO

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

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

Para mais detalhes sobre exportação para vários formatos, consulte a página de Exportação.