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 se publicó en HF papers el 2024-01-19 y se contribuyó a Hugging Face Transformers el 2024-01-25.

Depth Anything

Depth Anything está diseñado para ser un modelo de base para la estimación de profundidad monocular (MDE). Se entrena de forma conjunta con imágenes etiquetadas y ~62M de imágenes sin etiquetar para mejorar el conjunto de datos. Utiliza un modelo DINOv2 preentrenado como codificador de imágenes para heredar sus ricos priorizados semánticos existentes, y DPT como decodificador. Se entrena un modelo maestro con imágenes sin etiquetar para crear pseudoetiquetas. El modelo estudiante se entrena con una combinación de pseudoetiquetas e imágenes etiquetadas. Para mejorar el rendimiento del modelo estudiante, se añaden perturbaciones fuertes a las imágenes sin etiquetar para desafiar al modelo estudiante a aprender más conocimiento visual de la imagen.

Puedes encontrar todos los checkpoints originales de Depth Anything en la colección Depth Anything.

Haz clic en los modelos Depth Anything en la barra lateral derecha para ver más ejemplos de cómo aplicar Depth Anything a diferentes tareas de visión.

El siguiente ejemplo demuestra cómo obtener un mapa de profundidad con Pipeline o la clase 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"]

Notas

  • DepthAnythingV2, publicado en junio de 2024, utiliza la misma arquitectura que Depth Anything y es compatible con todos los ejemplos de código y flujos de trabajo existentes. Utiliza datos sintéticos y un modelo teacher de mayor capacidad para lograr predicciones de profundidad mucho más finas y robustas.

DepthAnythingConfig

clase 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) — La configuración del modelo backbone.
  • patch_size (Union[int, list[int], tuple[int, int]], opcional, valor predeterminado 14) — El tamaño (resolución) de cada parche.
  • initializer_range (float, opcional, valor predeterminado 0.02) — La desviación estándar del truncated_normal_initializer para inicializar todas las matrices de pesos.
  • reassemble_hidden_size (int, opcional, valor predeterminado 384) — El número de canales de entrada de las capas de reensamblaje.
  • reassemble_factors (list[int], opcional, valor predeterminado [4, 2, 1, 0.5]) — Los factores de submuestreo/sobremuestreo de las capas de reensamblaje.
  • neck_hidden_sizes (list[str], opcional, valor predeterminado [48, 96, 192, 384]) — Los tamaños ocultos a los que proyectar los mapas de características del backbone.
  • fusion_hidden_size (int, opcional, valor predeterminado 64) — El número de canales antes de la fusión.
  • head_in_index (int, opcional, valor predeterminado -1) — El índice de las características que se usarán en la cabeza de estimación de profundidad.
  • head_hidden_size (int, opcional, valor predeterminado 32) — El número de canales de salida en la segunda convolución de la cabeza de estimación de profundidad.
  • depth_estimation_type (str, opcional, por defecto "relative") — El tipo de estimación de profundidad a utilizar. Puede ser uno de ["relative", "metric"].
  • max_depth (float, opcional) — La profundidad máxima a utilizar para la cabeza de estimación de profundidad “metric”. Debe usarse 20 para modelos de interiores y 80 para modelos de exteriores. Para la estimación de profundidad “relative”, este valor se ignora.

Esta es la clase de configuración para almacenar la configuración de un Depth AnythingModel. Se utiliza para instanciar un modelo Depth Anything según los argumentos especificados, definiendo la arquitectura del modelo. Instanciar una configuración con los valores predeterminados producirá una configuración similar a la de LiheYoung/depth-anything-small-hf

Los objetos de configuración heredan de PreTrainedConfig y se pueden usar para controlar las salidas del modelo. Lea la documentación de PreTrainedConfig para obtener más información.

Ejemplo:

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

clase transformers.DepthAnythingForDepthEstimation

< >

( config: DepthAnythingConfig )

Parámetros

  • config (DepthAnythingConfig) — Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método from_pretrained() para cargar los pesos del modelo.

Modelo Depth Anything con una cabeza de estimación de profundidad en la parte superior (compuesta por 3 capas convolucionales), por ejemplo, para KITTI, NYUv2.

Este modelo hereda de PreTrainedModel. Consulta la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

Este modelo también es una subclase de torch.nn.Module de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.

forward

< >

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

Parámetros

  • pixel_values (torch.Tensor de forma (batch_size, num_channels, image_size, image_size)) — Los tensores correspondientes a las imágenes de entrada. Los valores de píxeles se pueden obtener utilizando DPTImageProcessor. Consulte DPTImageProcessor.call() para más detalles (processor_class utiliza DPTImageProcessor para procesar las imágenes).
  • labels (torch.LongTensor de forma (batch_size, height, width), opcional) — Mapas de estimación de profundidad de referencia para calcular la pérdida.
  • output_attentions (bool, opcional) — Indica si se deben devolver los tensores de atención de todas las capas de atención. Consulte attentions en los tensores devueltos para obtener más detalles.
  • output_hidden_states (bool, opcional) — Indica si se deben devolver los estados ocultos de todas las capas. Consulte hidden_states en los tensores devueltos para obtener más detalles.
  • return_dict (bool, opcional) — Indica si se debe devolver un ModelOutput en lugar de una tupla simple.

Devuelve

DepthEstimatorOutput o tuple(torch.Tensor)

Un DepthEstimatorOutput o una tupla de torch.Tensor (si se pasa return_dict=False o cuando config.return_dict=False) que comprende varios elementos según la configuración (DepthAnythingConfig) y las entradas.

El método forward de DepthAnythingForDepthEstimation reemplaza el método especial __call__.

Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de Module después en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de pre y postprocesamiento, mientras que la segunda los ignora silenciosamente.

  • loss (torch.Tensor de forma (1,), opcional, se devuelve cuando se proporciona labels) — Pérdida de clasificación (o de regresión si config.num_labels==1).

  • predicted_depth (torch.Tensor de forma (batch_size, height, width)) — Profundidad predicha para cada píxel.

  • hidden_states (tuple(torch.Tensor), opcional, devuelto cuando se pasa output_hidden_states=True o cuando config.output_hidden_states=True) — Tupla de torch.Tensor (una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + una para la salida de cada capa) de forma (batch_size, num_channels, height, width).

    Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.

  • attentions (tuple(torch.Tensor), opcional, se devuelve cuando se pasa output_attentions=True o cuando config.output_attentions=True) — Tupla de torch.Tensor (una por cada capa) de forma (batch_size, num_heads, patch_size, sequence_length).

    Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

Ejemplos:

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