# Depth Anything

[Depth Anything](https://huggingface.co/papers/2401.10891) est conçu pour être un modèle de base pour l'estimation de profondeur monoculaire (MDE). Il est entraîné conjointement sur des images étiquetées et ~62M d'images non étiquetées pour enrichir le jeu de données. Il utilise un modèle [DINOv2](./dinov2) pré-entraîné comme encodeur d'images afin d'hériter de ses a priori sémantiques riches existants, et [DPT](./dpt) comme décodeur. Un modèle enseignant est entraîné sur des images non étiquetées pour générer des pseudo-étiquettes. Le modèle élève est entraîné sur une combinaison de ces pseudo-étiquettes et d'images étiquetées. Pour améliorer les performances du modèle élève, de fortes perturbations sont ajoutées aux images non étiquetées afin de le pousser à acquérir davantage de connaissances visuelles à partir de l'image.

Vous pouvez trouver tous les points de contrôle originaux de Depth Anything dans la collection [Depth Anything](https://huggingface.co/collections/LiheYoung/depth-anything-release-65b317de04eec72abf6b55aa).

> [!TIP]
> Cliquez sur les modèles Depth Anything dans la barre latérale droite pour plus d’exemples sur la façon d’appliquer Depth Anything à différentes tâches de vision.

L'exemple ci-dessous montre comment obtenir une carte de profondeur avec [Pipeline](/docs/transformers/main/fr/main_classes/pipelines#transformers.Pipeline) ou la classe [AutoModel](/docs/transformers/main/fr/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"))
```

## Notes

- [DepthAnythingV2](./depth_anything_v2), publié en juin 2024, utilise la même architecture que Depth Anything et est compatible avec tous les exemples de code et les flux de travail existants. Il exploite 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.

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