Transformers documentation
Depth Anything
Ce modèle a été publié dans HF papers le 2024-01-19 et contribué à Hugging Face Transformers le 2024-01-25.
Depth Anything
Depth Anything est conçu pour être un modèle de fondation 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 pré-entraîné comme encodeur d'images afin d'hériter de ses a priori sémantiques riches existants, et DPT comme décodeur. Un modèle enseignant est entraîné sur des images non étiquetées pour créer des pseudo-étiquettes. Le modèle élève est entraîné sur une combinaison de 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 d'inciter le modèle élève à 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.
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 ou la classe 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"]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, 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
classe transformers.DepthAnythingConfig
< source >( 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 )
Paramètres
- backbone_config (
Union[dict, ~configuration_utils.PreTrainedConfig], facultatif) — La configuration du modèle backbone. - patch_size (
Union[int, list[int], tuple[int, int]], facultatif, par défaut14) — La taille (résolution) de chaque patch. - initializer_range (
float, facultatif, par défaut0.02) — L'écart-type de la truncated_normal_initializer utilisé pour initialiser 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 la 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) — La profondeur maximale à utiliser pour la tête d’estimation de profondeur « metric ». Il convient d’utiliser 20 pour les modèles intérieurs et 80 pour les modèles extérieurs. Pour l’estimation de profondeur « relative », cette valeur est ignorée.
Ceci est 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, définissant ainsi 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
Les objets de configuration héritent de PreTrainedConfig et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de PreTrainedConfig pour plus d’informations.
Exemple :
>>> 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.configDepthAnythingForDepthEstimation
classe transformers.DepthAnythingForDepthEstimation
< source >( config: DepthAnythingConfig )
Paramètres
- config (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() 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. 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, la taille des têtes, etc.)
Ce modèle est également une sous-classe de 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
< source >( 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)
Paramètres
- pixel_values (
torch.Tensorde forme(batch_size, num_channels, image_size, image_size)) — Les tenseurs correspondant aux images d’entrée. Les valeurs de pixels peuvent être obtenues à l’aide de DPTImageProcessor. Voir DPTImageProcessor.call() pour plus de détails (processor_classutilise DPTImageProcessor pour le traitement des images). - labels (
torch.LongTensorde forme(batch_size, height, width), facultatif) — Cartes d'estimation 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. Consultezattentionssous 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. Voirhidden_statessous les tenseurs retournés pour plus de détails. - return_dict (
bool, facultatif) — Indique s'il faut retourner un ModelOutput plutôt qu'un simple tuple.
Retourne
DepthEstimatorOutput ou tuple(torch.Tensor)
Un DepthEstimatorOutput ou un tuple de
torch.Tensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers
éléments en fonction de la configuration (DepthAnythingConfig) et des entrées.
La méthode forward de 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
Moduleplutô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.Tensorde forme(1,), facultatif, renvoyé lorsquelabelsest fourni) — Perte de classification (ou de régression si config.num_labels==1).predicted_depth (
torch.Tensorde forme(batch_size, height, width)) — Profondeur prédite pour chaque pixel.hidden_states (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.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é lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, num_heads, patch_size, sequence_length).Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
Exemples :
>>> 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"))