# Depth Anything V2

## Resumen

Depth Anything V2 se presentó en [el artículo homónimo](https://huggingface.co/papers/2406.09414) de Lihe Yang et al. Utiliza la misma arquitectura que el modelo original [Depth Anything](depth_anything), pero emplea datos sintéticos y un modelo teacher de mayor capacidad para lograr predicciones de profundidad mucho más finas y robustas.

El resumen del artículo es el siguiente:

*Este trabajo presenta Depth Anything V2. Sin recurrir a técnicas elaboradas, nuestro objetivo es revelar hallazgos cruciales para allanar el camino hacia la construcción de un modelo potente de estimación de profundidad monocular. Cabe destacar que, en comparación con la V1, esta versión produce predicciones de profundidad mucho más finas y robustas mediante tres prácticas clave: 1) reemplazar todas las imágenes reales etiquetadas con imágenes sintéticas, 2) aumentar la capacidad de nuestro modelo maestro y 3) enseñar a los modelos estudiante a través del puente de imágenes reales pseudoetiquetadas a gran escala. En comparación con los modelos más recientes basados en Stable Diffusion, nuestros modelos son significativamente más eficientes (más de 10 veces más rápidos) y más precisos. Ofrecemos modelos de diferentes escalas (que van desde 25M hasta 1.3B de parámetros) para soportar escenarios extensos. Gracias a su fuerte capacidad de generalización, los ajustamos finamente con etiquetas de profundidad métrica para obtener nuestros modelos de profundidad métrica. Además de nuestros modelos, considerando la diversidad limitada y el ruido frecuente en los conjuntos de prueba actuales, construimos un benchmark de evaluación versátil con anotaciones precisas y escenas diversas para facilitar la investigación futura.*

<img src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/model_doc/depth_anything_overview.jpg"
alt="drawing" width="600"/>

 Resumen de Depth Anything. Tomado del artículo original.

Los modelos Depth Anything fueron aportados por [nielsr](https://huggingface.co/nielsr). El código original se puede encontrar [aquí](https://github.com/DepthAnything/Depth-Anything-V2).

## Ejemplo de uso

Hay 2 formas principales de usar Depth Anything V2: ya sea mediante la API de pipeline, que abstrae toda la complejidad por ti, o usando la clase `DepthAnythingForDepthEstimation` directamente.

### API de Pipeline

El pipeline permite utilizar el modelo en unas pocas líneas de código:

```python
import requests
from PIL import Image

from transformers import pipeline

# load pipe
pipe = pipeline(task="depth-estimation", model="depth-anything/Depth-Anything-V2-Small-hf")

# load image
url = 'http://images.cocodataset.org/val2017/000000039769.jpg'
image = Image.open(requests.get(url, stream=True).raw)

# inference
depth = pipe(image)["depth"]
```

### Usando el modelo por su cuenta

Si desea realizar el preprocesamiento y el posprocesamiento usted mismo, aquí se explica cómo hacerlo:

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

from transformers import AutoImageProcessor, AutoModelForDepthEstimation

url = "http://images.cocodataset.org/val2017/000000039769.jpg"
image = Image.open(requests.get(url, stream=True).raw)

image_processor = AutoImageProcessor.from_pretrained("depth-anything/Depth-Anything-V2-Small-hf")
model = AutoModelForDepthEstimation.from_pretrained("depth-anything/Depth-Anything-V2-Small-hf", device_map="auto")

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

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

# interpolate to original size and visualize the prediction
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
depth = Image.fromarray(depth.astype("uint8"))
```

## Recursos

Una lista de recursos oficiales de Hugging Face y de la comunidad (indicados por 🌎) para ayudarte a empezar con Depth Anything.

- [Guía de la tarea de estimación de profundidad monocular](../tasks/monocular_depth_estimation)
- [Demo de Depth Anything V2](https://huggingface.co/spaces/depth-anything/Depth-Anything-V2).
- Puede encontrar un cuaderno que muestra la inferencia con [DepthAnythingForDepthEstimation](/docs/transformers/main/es/model_doc/depth_anything#transformers.DepthAnythingForDepthEstimation) [aquí](https://github.com/NielsRogge/Transformers-Tutorials/blob/master/Depth%20Anything/Predicting_depth_in_an_image_with_Depth_Anything.ipynb). 🌎
- [Conversión a Core ML de la variante `small` para su uso en Apple Silicon](https://huggingface.co/apple/coreml-depth-anything-v2-small).

Si te interesa enviar un recurso para que se incluya aquí, no dudes en abrir una Pull Request y lo revisaremos. Lo ideal es que el recurso demuestre algo nuevo en lugar de duplicar un recurso existente.

## 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)
```

[Fuente](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*) : La configuración del modelo de base.

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 de 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 se proyectarán 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*, valor predeterminado `"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. En el caso de 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](https://huggingface.co/LiheYoung/depth-anything-small-hf)

Los objetos de configuración heredan de [PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig) y se pueden utilizar para controlar las salidas del modelo. Consulte la documentación de [PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig) para obtener más información.

Ejemplo:

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

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

**Parámetros:**

config ([DepthAnythingConfig](/docs/transformers/main/es/model_doc/depth_anything#transformers.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()](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel.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](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel). Consulte 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](https://pytorch.org/docs/stable/nn.html#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[[transformers.DepthAnythingForDepthEstimation.forward]]

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

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

**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 usando [DPTImageProcessor](/docs/transformers/main/es/model_doc/dpt#transformers.DPTImageProcessor). Consulte [DPTImageProcessor.__call__()](/docs/transformers/main/es/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para más detalles (`processor_class` usa [DPTImageProcessor](/docs/transformers/main/es/model_doc/dpt#transformers.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](/docs/transformers/main/es/main_classes/output#transformers.utils.ModelOutput) en lugar de una tupla simple.

**Devuelve:** [DepthEstimatorOutput](/docs/transformers/main/es/main_classes/output#transformers.modeling_outputs.DepthEstimatorOutput) o `tuple(torch.Tensor)`

Un [DepthEstimatorOutput](/docs/transformers/main/es/main_classes/output#transformers.modeling_outputs.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](/docs/transformers/main/es/model_doc/depth_anything#transformers.DepthAnythingConfig)) y las entradas.

El método forward de [DepthAnythingForDepthEstimation](/docs/transformers/main/es/model_doc/depth_anything#transformers.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 preprocesamiento y posprocesamiento, 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 los embeddings, si el modelo tiene una capa de embedding, + 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:
```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"))
```