# Depth Anything

[Depth Anything](https://huggingface.co/papers/2401.10891) foi projetado para ser um modelo de base para estimativa de profundidade monocular (MDE). Ele é treinado conjuntamente em imagens rotuladas e ~62M de imagens não rotuladas para aprimorar o conjunto de dados. Ele utiliza um modelo [DINOv2](./dinov2) pré-treinado como codificador de imagem para herdar seus ricos priors semânticos existentes, e [DPT](./dpt) como decodificador. Um modelo professor é treinado em imagens não rotuladas para criar pseudo-rótulos. O modelo aluno é treinado em uma combinação dos pseudo-rótulos e das imagens rotuladas. Para melhorar o desempenho do modelo aluno, perturbações fortes são adicionadas às imagens não rotuladas para desafiar o modelo aluno a aprender mais conhecimento visual a partir da imagem.

Você pode encontrar todos os checkpoints originais do Depth Anything na coleção [Depth Anything](https://huggingface.co/collections/LiheYoung/depth-anything-release-65b317de04eec72abf6b55aa).

> [!TIP]
> Clique nos modelos Depth Anything na barra lateral à direita para ver mais exemplos de como aplicar o Depth Anything a diferentes tarefas de visão.

O exemplo abaixo demonstra como obter um mapa de profundidade com [Pipeline](/docs/transformers/main/pt/main_classes/pipelines#transformers.Pipeline) ou a classe [AutoModel](/docs/transformers/main/pt/model_doc/auto#transformers.AutoModel).

```python
from transformers import pipeline

pipe = pipeline(task="depth-estimation", model="LiheYoung/depth-anything-base-hf", device=0)
pipe("http://images.cocodataset.org/val2017/000000039769.jpg")["depth"]
```

```python
import requests
import torch
from PIL import Image

from transformers import AutoImageProcessor, AutoModelForDepthEstimation

image_processor = AutoImageProcessor.from_pretrained("LiheYoung/depth-anything-base-hf")
model = AutoModelForDepthEstimation.from_pretrained("LiheYoung/depth-anything-base-hf", device_map="auto")
url = "http://images.cocodataset.org/val2017/000000039769.jpg"
image = Image.open(requests.get(url, stream=True).raw)
inputs = image_processor(images=image, return_tensors="pt").to(model.device)

with torch.no_grad():
    outputs = model(**inputs)

post_processed_output = image_processor.post_process_depth_estimation(
    outputs,
    target_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
Image.fromarray(depth.astype("uint8"))
```

## Observações

- [DepthAnythingV2](./depth_anything_v2), lançado em junho de 2024, utiliza a mesma arquitetura do Depth Anything e é compatível com todos os exemplos de código e fluxos de trabalho existentes. Ele usa dados sintéticos e um modelo teacher de maior capacidade para alcançar previsões de profundidade muito mais finas e robustas.

## DepthAnythingConfig[[transformers.DepthAnythingConfig]]

#### transformers.DepthAnythingConfig[[transformers.DepthAnythingConfig]]

```python
transformers.DepthAnythingConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, backbone_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, patch_size: int | list[int] | tuple[int, int] = 14, initializer_range: float = 0.02, reassemble_hidden_size: int = 384, reassemble_factors: list[int | float] | tuple[int | float, ...] = (4, 2, 1, 0.5), neck_hidden_sizes: list[int] | tuple[int, ...] = (48, 96, 192, 384), fusion_hidden_size: int = 64, head_in_index: int = -1, head_hidden_size: int = 32, depth_estimation_type: str = 'relative', max_depth: int | None = 1)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/depth_anything/configuration_depth_anything.py#L25)

**Parâmetros:**

backbone_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *opcional*) : A configuração do modelo backbone.

patch_size (`Union[int, list[int], tuple[int, int]]`, *opcional*, padrão `14`) : O tamanho (resolução) de cada patch.

initializer_range (`float`, *opcional*, padrão `0.02`) : O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos.

reassemble_hidden_size (`int`, *opcional*, padrão 384) : O número de canais de entrada das camadas de reassemble.

reassemble_factors (`list[int]`, *opcional*, padrão `[4, 2, 1, 0.5]`) : Os fatores de up/downsampling das camadas de reassemble.

neck_hidden_sizes (`list[str]`, *opcional*, padrão `[48, 96, 192, 384]`) : Os tamanhos ocultos para os quais projetar os mapas de características do backbone.

fusion_hidden_size (`int`, *opcional*, padrão 64) : O número de canais antes da fusão.

head_in_index (`int`, *opcional*, padrão -1) : O índice dos recursos a serem usados na cabeça de estimativa de profundidade.

head_hidden_size (`int`, *opcional*, padrão 32) : O número de canais de saída na segunda convolução da cabeça de estimativa de profundidade.

depth_estimation_type (`str`, *opcional*, padrão `"relative"`) : O tipo de estimativa de profundidade a ser usado. Pode ser um dos valores `["relative", "metric"]`.

max_depth (`float`, *opcional*) : A profundidade máxima a ser usada para a cabeça de estimativa de profundidade "metric". O valor 20 deve ser usado para modelos de ambientes internos e 80 para modelos de ambientes externos. Para a estimativa de profundidade "relative", esse valor é ignorado.

Esta é a classe de configuração para armazenar a configuração de um Depth AnythingModel. Ela é usada para instanciar um modelo Depth Anything de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do [LiheYoung/depth-anything-small-hf](https://huggingface.co/LiheYoung/depth-anything-small-hf)

Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações.

Exemplo:

```python
>>> from transformers import DepthAnythingConfig, DepthAnythingForDepthEstimation

>>> # Initializing a DepthAnything small style configuration
>>> configuration = DepthAnythingConfig()

>>> # Initializing a model from the DepthAnything small style configuration
>>> model = DepthAnythingForDepthEstimation(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config
```

## DepthAnythingForDepthEstimation[[transformers.DepthAnythingForDepthEstimation]]

#### transformers.DepthAnythingForDepthEstimation[[transformers.DepthAnythingForDepthEstimation]]

```python
transformers.DepthAnythingForDepthEstimation(config: DepthAnythingConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/depth_anything/modeling_depth_anything.py#L316)

**Parâmetros:**

config ([DepthAnythingConfig](/docs/transformers/main/pt/model_doc/depth_anything#transformers.DepthAnythingConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo.

Modelo Depth Anything com uma cabeça de estimativa de profundidade no topo (consistindo em 3 camadas convolucionais), por exemplo, para KITTI, NYUv2.

Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.).

Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais.

#### forward[[transformers.DepthAnythingForDepthEstimation.forward]]

```python
forward(pixel_values: FloatTensor, labels: typing.Optional[torch.LongTensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/depth_anything/modeling_depth_anything.py#L327)

**Parâmetros:**

pixel_values (`torch.FloatTensor` de forma `(batch_size, num_channels, image_size, image_size)`) : Os tensores correspondentes às imagens de entrada. Os valores de pixels podem ser obtidos usando [DPTImageProcessor](/docs/transformers/main/pt/model_doc/dpt#transformers.DPTImageProcessor). Consulte [DPTImageProcessor.__call__()](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para obter detalhes (`processor_class` usa [DPTImageProcessor](/docs/transformers/main/pt/model_doc/dpt#transformers.DPTImageProcessor) para processar imagens).

labels (`torch.LongTensor` de forma `(batch_size, height, width)`, *opcional*) : Mapas de estimativa de profundidade de verdade para o cálculo da perda.

output_attentions (`bool`, *opcional*) : Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulte `attentions` nos tensores retornados para mais detalhes.

output_hidden_states (`bool`, *opcional*) : Indica se os estados ocultos de todas as camadas devem ser retornados. Consulte `hidden_states` em tensores retornados para mais detalhes.

return_dict (`bool`, *opcional*) : Se deve ou não retornar um [ModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.utils.ModelOutput) em vez de uma tupla simples.

**Retorna:** [DepthEstimatorOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.DepthEstimatorOutput) ou `tuple(torch.FloatTensor)`

Um [DepthEstimatorOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.DepthEstimatorOutput) ou uma tupla de `torch.FloatTensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos, dependendo da configuração ([DepthAnythingConfig](/docs/transformers/main/pt/model_doc/depth_anything#transformers.DepthAnythingConfig)) e das entradas.

O método forward de [DepthAnythingForDepthEstimation](/docs/transformers/main/pt/model_doc/depth_anything#transformers.DepthAnythingForDepthEstimation) substitui o método especial `__call__`.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de `Module` em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

- **loss** (`torch.FloatTensor` de forma `(1,)`, *opcional*, retornado quando `labels` é fornecido) -- Perda de classificação (ou de regressão se config.num_labels==1).
- **predicted_depth** (`torch.FloatTensor` de forma `(batch_size, height, width)`) -- Profundidade prevista para cada pixel.
- **hidden_states** (`tuple(torch.FloatTensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.FloatTensor` (uma para a saída dos embeddings, se o modelo tiver uma camada de embedding, + uma para a saída de cada camada) com formato `(batch_size, num_channels, height, width)`.

  Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.
- **attentions** (`tuple(torch.FloatTensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.FloatTensor` (uma para cada camada) com formato `(batch_size, num_heads, patch_size, sequence_length)`.

  Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.

Exemplos:
```python
>>> from transformers import AutoImageProcessor, AutoModelForDepthEstimation
>>> import torch
>>> import numpy as np
>>> from PIL import Image
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> with httpx.stream("GET", url) as response:
...     image = Image.open(BytesIO(response.read()))

>>> image_processor = AutoImageProcessor.from_pretrained("LiheYoung/depth-anything-small-hf")
>>> model = AutoModelForDepthEstimation.from_pretrained("LiheYoung/depth-anything-small-hf")

>>> # prepare image for the model
>>> inputs = image_processor(images=image, return_tensors="pt")

>>> with torch.no_grad():
...     outputs = model(**inputs)

>>> # interpolate to original size
>>> post_processed_output = image_processor.post_process_depth_estimation(
...     outputs,
...     target_sizes=[(image.height, image.width)],
... )

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