# Estimativa de profundidade monocular

A estimativa de profundidade monocular é uma tarefa de visão computacional que envolve prever as informações de profundidade de uma cena a partir de uma única imagem. Em outras palavras, é o processo de estimar a distância dos objetos em uma cena a partir de um único ponto de vista de câmera.

A estimativa de profundidade monocular tem diversas aplicações, incluindo reconstrução 3D, realidade aumentada, direção autônoma e robótica. Trata-se de uma tarefa desafiadora, pois exige que o modelo compreenda as relações complexas entre os objetos na cena e as informações de profundidade correspondentes, que podem ser afetadas por fatores como condições de iluminação, oclusão e textura.

Existem duas principais categorias de estimativa de profundidade:

- **Estimação de profundidade absoluta**: Essa variante de tarefa visa fornecer medições exatas de profundidade a partir da câmera. O termo é usado de forma intercambiável com a estimativa de profundidade métrica, na qual a profundidade é fornecida em medições precisas em metros ou pés. Os modelos de estimativa de profundidade absoluta geram mapas de profundidade com valores numéricos que representam distâncias do mundo real.

- **Estimativa de profundidade relativa**: A estimativa de profundidade relativa visa prever a ordem de profundidade dos objetos ou pontos em uma cena sem fornecer medições precisas. Esses modelos geram um mapa de profundidade que indica quais partes da cena estão mais próximas ou mais distantes em relação umas às outras, sem as distâncias reais entre A e B.

Neste guia, veremos como realizar inferência com [Depth Anything V2](https://huggingface.co/depth-anything/Depth-Anything-V2-Large), um modelo de estado da arte para estimativa relativa de profundidade zero-shot, e [ZoeDepth](../model_doc/zoedepth), um modelo de estimativa absoluta de profundidade.

Consulte a página da tarefa [Depth Estimation](https://huggingface.co/tasks/depth-estimation) para ver todas as arquiteturas e checkpoints compatíveis.

Antes de começarmos, precisamos instalar a versão mais recente do Transformers:

```bash
pip install -q -U transformers
```

## Pipeline de estimativa de profundidade

A maneira mais simples de testar a inferência com um modelo que suporta estimativa de profundidade é usar o [pipeline()](/docs/transformers/main/pt/main_classes/pipelines#transformers.pipeline) correspondente. Instancie um pipeline a partir de um [checkpoint no Hugging Face Hub](https://huggingface.co/models?pipeline_tag=depth-estimation&sort=downloads):

```py
>>> from transformers import pipeline
from accelerate import Accelerator
>>> import torch
>>> device = Accelerator().device
>>> checkpoint = "depth-anything/Depth-Anything-V2-base-hf"
>>> pipe = pipeline("depth-estimation", model=checkpoint, device=device)
```

Em seguida, escolha uma imagem para analisar:

```py
>>> from PIL import Image
>>> import requests

>>> url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/bee.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> image
```

     

Passe a imagem para o pipeline.

```py
>>> predictions = pipe(image)
```

O pipeline retorna um dicionário com duas entradas. A primeira, chamada `predicted_depth`, é um tensor com os valores representando a profundidade expressa em metros para cada pixel. A segunda, `depth`, é uma imagem PIL que visualiza o resultado da estimativa de profundidade.

Vamos dar uma olhada no resultado visualizado:

```py
>>> predictions["depth"]
```

     

## Inferência de estimativa de profundidade manualmente

Agora que você viu como usar o pipeline de estimativa de profundidade, vamos ver como podemos replicar o mesmo resultado manualmente.

Comece carregando o modelo e o processador associado de um [checkpoint no Hugging Face Hub](https://huggingface.co/models?pipeline_tag=depth-estimation&sort=downloads). Aqui, usaremos o mesmo checkpoint de antes:

```py
>>> from transformers import AutoImageProcessor, AutoModelForDepthEstimation

>>> checkpoint = "Intel/zoedepth-nyu-kitti"

>>> image_processor = AutoImageProcessor.from_pretrained(checkpoint)
>>> model = AutoModelForDepthEstimation.from_pretrained(checkpoint).to(device)
```

Prepare a entrada de imagem para o modelo usando o `image_processor`, que cuidará das transformações de imagem necessárias, como redimensionamento e normalização:

```py
>>> pixel_values = image_processor(image, return_tensors="pt").pixel_values.to(device)
```

Passe os dados de entrada preparados pelo modelo:

```py
>>> import torch

>>> with torch.no_grad():
...     outputs = model(pixel_values)
```

Vamos fazer o pós-processamento dos resultados para remover qualquer padding e redimensionar o mapa de profundidade para corresponder ao tamanho da imagem original. O `post_process_depth_estimation` retorna uma lista de dicts contendo o `"predicted_depth"`.

```py
>>> # ZoeDepth dynamically pads the input image. Thus we pass the original image size as argument
>>> # to `post_process_depth_estimation` to remove the padding and resize to original dimensions.
>>> post_processed_output = image_processor.post_process_depth_estimation(
...     outputs,
...     source_sizes=[(image.height, image.width)],
... )

>>> predicted_depth = post_processed_output[0]["predicted_depth"]
>>> depth = (predicted_depth - predicted_depth.min()) / (predicted_depth.max() - predicted_depth.min())
>>> depth = depth.detach().cpu().numpy() * 255
>>> depth = Image.fromarray(depth.astype("uint8"))
```

Na implementação original, o modelo ZoeDepth executa a inferência tanto nas imagens originais quanto nas imagens espelhadas e calcula a média dos resultados. A função post_process_depth_estimation pode lidar com isso para nós, passando as saídas espelhadas para o argumento opcional outputs_flipped: >>> with torch.no_grad(): ...     outputs = model(pixel_values) ...     outputs_flipped = model(pixel_values=torch.flip(inputs.pixel_values, dims=[3])) >>> post_processed_output = image_processor.post_process_depth_estimation( ...     outputs, ...     source_sizes=[(image.height, image.width)], ...     outputs_flipped=outputs_flipped, ... )