# Depth Anything V2

## Aperçu

Depth Anything V2 a été présenté dans [l’article du même nom](https://huggingface.co/papers/2406.09414) par Lihe Yang et al. Il utilise la même architecture que le modèle [Depth Anything](depth_anything) original, mais s’appuie sur des données synthétiques et un modèle enseignant de plus grande capacité pour obtenir des prédictions de profondeur beaucoup plus fines et robustes.

L'abstract de l'article est le suivant :

*Ce travail présente Depth Anything V2. Sans recourir à des techniques élaborées, nous visons à révéler des résultats essentiels afin de préparer la voie vers la construction d'un modèle puissant d'estimation de profondeur monoculaire. Notamment, par rapport à la V1, cette version produit des prédictions de profondeur beaucoup plus fines et plus robustes grâce à trois pratiques clés : 1) le remplacement de toutes les images réelles étiquetées par des images synthétiques, 2) l'augmentation de la capacité de notre modèle enseignant, et 3) l'enseignement des modèles étudiants via le pont des images réelles pseudo-étiquetées à grande échelle. Par rapport aux derniers modèles construits sur Stable Diffusion, nos modèles sont significativement plus efficaces (plus de 10 fois plus rapides) et plus précis. Nous proposons des modèles de différentes tailles (allant de 25M à 1,3B de paramètres) pour soutenir des scénarios variés. Bénéficiant de leur forte capacité de généralisation, nous les affinons avec des étiquettes de profondeur métrique pour obtenir nos modèles de profondeur métrique. En plus de nos modèles, compte tenu de la diversité limitée et du bruit fréquent dans les ensembles de test actuels, nous construisons un banc d'évaluation polyvalent avec des annotations précises et des scènes diverses pour faciliter les recherches futures.*

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

 Aperçu de Depth Anything. Tiré de l'article original.

Les modèles Depth Anything ont été contribué par [nielsr](https://huggingface.co/nielsr). Le code original peut être trouvé [ici](https://github.com/DepthAnything/Depth-Anything-V2).

## Exemple d'utilisation

Il existe deux principales façons d’utiliser Depth Anything V2 : soit en utilisant l’API pipeline, qui abstrait toute la complexité pour vous, soit en utilisant vous-même la classe `DepthAnythingForDepthEstimation`.

### API Pipeline

Le pipeline permet d'utiliser le modèle en quelques lignes de code :

```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"]
```

### Utiliser le modèle vous-même

Si vous souhaitez effectuer vous-même le prétraitement et le post-traitement, voici comment faire :

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

## Ressources

Une liste de ressources officielles Hugging Face et de la communauté (indiquées par 🌎) pour vous aider à démarrer avec Depth Anything.

- [Guide de la tâche d'estimation de profondeur monoculaire](../tasks/monocular_depth_estimation)
- [Démo de Depth Anything V2](https://huggingface.co/spaces/depth-anything/Depth-Anything-V2).
- Un notebook illustrant l'inférence avec [DepthAnythingForDepthEstimation](/docs/transformers/main/fr/model_doc/depth_anything#transformers.DepthAnythingForDepthEstimation) est disponible [ici](https://github.com/NielsRogge/Transformers-Tutorials/blob/master/Depth%20Anything/Predicting_depth_in_an_image_with_Depth_Anything.ipynb). 🌎
- [Conversion Core ML de la variante `small` pour une utilisation sur Apple Silicon](https://huggingface.co/apple/coreml-depth-anything-v2-small).

Si vous souhaitez soumettre une ressource pour qu'elle soit incluse ici, n'hésitez pas à ouvrir une Pull Request et nous la examinerons ! La ressource devrait idéalement démontrer quelque chose de nouveau plutôt que de dupliquer une ressource existante.

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

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

**Paramètres :**

backbone_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *facultatif*) : La configuration du modèle de base.

patch_size (`Union[int, list[int], tuple[int, int]]`, *facultatif*, valeur par défaut `14`) : La taille (résolution) de chaque patch.

initializer_range (`float`, *facultatif*, valeur par défaut `0.02`) : L'écart-type de la truncated_normal_initializer utilisé pour l'initialisation de toutes les matrices de poids.

reassemble_hidden_size (`int`, *facultatif*, valeur par défaut : 384) : Le nombre de canaux d'entrée des couches de réassemblage.

reassemble_factors (`list[int]`, *facultatif*, par défaut `[4, 2, 1, 0.5]`) : Les facteurs de suréchantillonnage/sous-échantillonnage des couches de réassemblage.

neck_hidden_sizes (`list[str]`, *facultatif*, par défaut `[48, 96, 192, 384]`) : Les tailles cachées vers lesquelles projeter les cartes de caractéristiques du backbone.

fusion_hidden_size (`int`, *facultatif*, valeur par défaut : 64) : Le nombre de canaux avant la fusion.

head_in_index (`int`, *facultatif*, valeur par défaut : -1) : L'index des caractéristiques à utiliser dans la tête d'estimation de profondeur.

head_hidden_size (`int`, *facultatif*, valeur par défaut : 32) : Le nombre de canaux de sortie de la deuxième convolution de la tête d'estimation de profondeur.

depth_estimation_type (`str`, *facultatif*, par défaut `"relative"`) : Le type d'estimation de profondeur à utiliser. Peut être l'un des éléments de `["relative", "metric"]`.

max_depth (`float`, *facultatif*) : Profondeur maximale à utiliser pour la tête d'estimation de profondeur « metric ». La valeur 20 doit être utilisée pour les modèles d'intérieur et 80 pour les modèles d'extérieur. Pour l'estimation de profondeur « relative », cette valeur est ignorée.

Il s’agit de la classe de configuration destinée à stocker la configuration d’un Depth AnythingModel. Elle est utilisée pour instancier un modèle Depth Anything en fonction des arguments spécifiés, en définissant l’architecture du modèle. L’instanciation d’une configuration avec les valeurs par défaut produira une configuration similaire à celle de [LiheYoung/depth-anything-small-hf](https://huggingface.co/LiheYoung/depth-anything-small-hf)

Les objets de configuration héritent de [PreTrainedConfig](/docs/transformers/main/fr/main_classes/configuration#transformers.PreTrainedConfig) et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de [PreTrainedConfig](/docs/transformers/main/fr/main_classes/configuration#transformers.PreTrainedConfig) pour plus d’informations.

Exemple :

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

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

**Paramètres :**

config ([DepthAnythingConfig](/docs/transformers/main/fr/model_doc/depth_anything#transformers.DepthAnythingConfig)) : Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode [from_pretrained()](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle.

Modèle Depth Anything avec une tête d'estimation de profondeur au sommet (composée de 3 couches convolutives), par exemple pour KITTI, NYUv2.

Ce modèle hérite de [PreTrainedModel](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, l'élagage des têtes, etc.).

Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l’utilisation et le comportement généraux.

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

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

**Paramètres :**

pixel_values (`torch.Tensor` de forme `(batch_size, num_channels, image_size, image_size)`) : Les tenseurs correspondant aux images d’entrée. Les valeurs des pixels peuvent être obtenues à l’aide de [DPTImageProcessor](/docs/transformers/main/fr/model_doc/dpt#transformers.DPTImageProcessor). Voir [DPTImageProcessor.__call__()](/docs/transformers/main/fr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) pour plus de détails (`processor_class` utilise [DPTImageProcessor](/docs/transformers/main/fr/model_doc/dpt#transformers.DPTImageProcessor) pour le traitement des images).

labels (`torch.LongTensor` de forme `(batch_size, height, width)`, *facultatif*) : Cartes de profondeur de référence pour le calcul de la perte.

output_attentions (`bool`, *facultatif*) : Indique s'il faut ou non retourner les tenseurs d'attention de toutes les couches d'attention. Voir `attentions` sous les tenseurs retournés pour plus de détails.

output_hidden_states (`bool`, *facultatif*) : Indique s'il faut retourner les états cachés de toutes les couches. Voir `hidden_states` dans les tenseurs retournés pour plus de détails.

return_dict (`bool`, *facultatif*) : Indique s'il faut retourner un [ModelOutput](/docs/transformers/main/fr/main_classes/output#transformers.utils.ModelOutput) plutôt qu'un simple tuple.

**Retourne :** [DepthEstimatorOutput](/docs/transformers/main/fr/main_classes/output#transformers.modeling_outputs.DepthEstimatorOutput) ou `tuple(torch.Tensor)`

Un [DepthEstimatorOutput](/docs/transformers/main/fr/main_classes/output#transformers.modeling_outputs.DepthEstimatorOutput) ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([DepthAnythingConfig](/docs/transformers/main/fr/model_doc/depth_anything#transformers.DepthAnythingConfig)) et les entrées.

La méthode forward de [DepthAnythingForDepthEstimation](/docs/transformers/main/fr/model_doc/depth_anything#transformers.DepthAnythingForDepthEstimation) redéfinit la méthode spéciale `__call__`.

Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance `Module` plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.

- **loss** (`torch.Tensor` de forme `(1,)`, *facultatif*, renvoyé lorsque `labels` est fourni) -- Perte de classification (ou de régression si config.num_labels==1).
- **predicted_depth** (`torch.Tensor` de forme `(batch_size, height, width)`) -- Profondeur prédite pour chaque pixel.
- **hidden_states** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d'embedding, + un pour la sortie de chaque couche) de forme `(batch_size, num_channels, height, width)`.

  États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
- **attentions** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, patch_size, sequence_length)`.

  Pondérations des attentions après le softmax d'attention, utilisées pour calculer la moyenne pondérée dans les têtes d'auto-attention.

Exemples :
```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"))
```