Hugging Face's logo

Transformers documentation

Depth Anything

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.22.1).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Este modelo foi publicado em papers do HF em 2024-01-19 e contribuído para o Hugging Face Transformers em 2024-01-25.

Depth Anything

Depth Anything 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 pré-treinado como codificador de imagem para herdar seus ricos priors semânticos existentes, e 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.

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 ou a classe AutoModel.

Pipeline
AutoModel
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"]

Observações

  • DepthAnythingV2, 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

classe transformers.DepthAnythingConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonebackbone_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonepatch_size: int | list[int] | tuple[int, int] = 14initializer_range: float = 0.02reassemble_hidden_size: int = 384reassemble_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 = 64head_in_index: int = -1head_hidden_size: int = 32depth_estimation_type: str = 'relative'max_depth: int | None = 1 )

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]) — 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 as feature maps do backbone devem ser projetadas.
  • 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”. Deve-se usar 20 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

Os objetos de configuração herdam de PreTrainedConfig e podem ser usados para controlar as saídas do modelo. Consulte a documentação de PreTrainedConfig para mais informações.

Exemplo:

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

classe transformers.DepthAnythingForDepthEstimation

< >

( config: DepthAnythingConfig )

Parâmetros

  • config (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() 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. 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 do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.

forward

< >

( pixel_values: FloatTensorlabels: typing.Optional[torch.LongTensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → DepthEstimatorOutput or tuple(torch.FloatTensor)

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. Consulte DPTImageProcessor.call() para detalhes (processor_class usa DPTImageProcessor para processar imagens).
  • labels (torch.LongTensor de forma (batch_size, height, width), opcional) — Mapas de estimativa de profundidade reais 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 as hidden states de todas as camadas devem ser retornadas. Consulte hidden_states em tensors retornados para mais detalhes.
  • return_dict (bool, opcional) — Indica se deve retornar um ModelOutput em vez de uma tupla simples.

Retorna

DepthEstimatorOutput ou tuple(torch.FloatTensor)

Um 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) e das entradas.

O método forward de 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 (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) de forma (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 forma (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 nos cabeçalhos de autoatenção.

Exemplos:

>>> 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"))
Update on GitHub

←DeiT Depth Anything V2→