Hugging Face's logo

Transformers documentation

DepthPro

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.22.2).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Ce modèle a été publié dans HF papers le 2024-10-02 et contribué à Hugging Face Transformers le 2025-02-10.

DepthPro

Aperçu

Le modèle DepthPro a été proposé dans Depth Pro: Sharp Monocular Metric Depth in Less Than a Second par Aleksei Bochkovskii, Amaël Delaunoy, Hugo Germain, Marcel Santos, Yichao Zhou, Stephan R. Richter, Vladlen Koltun.

DepthPro est un modèle de base pour l'estimation métrique de la profondeur monoculaire en zéro tirage, conçu pour générer des cartes de profondeur haute résolution avec une netteté remarquable et des détails fins. Il utilise une architecture multi-échelle basée sur Vision Transformer (ViT), dans laquelle les images sont sous-échantillonnées, divisées en patches et traitées à l'aide d'un encodeur Dinov2 partagé. Les caractéristiques au niveau des patches extraites sont fusionnées, suréchantillonnées et affinées à l'aide d'une étape de fusion de type DPT, permettant une estimation précise de la profondeur.

L'abstract de l'article est le suivant :

Nous présentons un modèle de fond pour l'estimation métrique de la profondeur monoculaire en zéro tirage. Notre modèle, Depth Pro, synthétise des cartes de profondeur haute résolution avec une netteté inégalée et des détails haute fréquence. Les prédictions sont métriques, avec une échelle absolue, sans dépendre de la disponibilité de métadonnées telles que les intrinsèques de la caméra. Et le modèle est rapide, produisant une carte de profondeur de 2,25 mégapixels en 0,3 seconde sur un GPU standard. Ces caractéristiques sont rendues possibles par un certain nombre de contributions techniques, notamment un transformeur de vision multi-échelle efficace pour la prédiction dense, un protocole d'entraînement qui combine des jeux de données réels et synthétiques pour atteindre une précision métrique élevée tout en traçant finement les contours, des métriques d'évaluation dédiées à la précision des contours dans les cartes de profondeur estimées, et une estimation de la focale de pointe à partir d'une seule image. Des expériences exhaustives analysent des choix de conception spécifiques et démontrent que Depth Pro surpasse les travaux antérieurs sur plusieurs dimensions.

drawing DepthPro Outputs. Taken from the official code.

Ce modèle a été contribué par geetu040. Le code d'origine peut être trouvé ici.

Conseils d'utilisation

Le modèle DepthPro traite une image d’entrée en la sous-échantillonnant d’abord à plusieurs échelles et en découpant chaque version mise à l’échelle en patches. Ces patches sont ensuite encodés à l’aide d’un encodeur de patches Dinov2 basé sur un Vision Transformer (ViT) partagé, tandis que l’image complète est traitée par un encodeur d’image distinct. Les caractéristiques de patch extraites sont fusionnées en cartes de caractéristiques, remises à l’échelle et combinées à l’aide d’un décodeur de type DPT pour générer l’estimation finale de la profondeur. Si activé, un encodeur de champ de vision (FOV) supplémentaire traite l’image pour estimer le champ de vision de la caméra, ce qui contribue à améliorer la précision de la profondeur.

import requests
import torch
from PIL import Image

from transformers import DepthProForDepthEstimation, DepthProImageProcessor


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

image_processor = DepthProImageProcessor.from_pretrained("apple/DepthPro-hf")
model = DepthProForDepthEstimation.from_pretrained("apple/DepthPro-hf", device_map="auto")

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)],
)

field_of_view = post_processed_output[0]["field_of_view"]
focal_length = post_processed_output[0]["focal_length"]
depth = post_processed_output[0]["predicted_depth"]
depth = (depth - depth.min()) / depth.max()
depth = depth * 255.
depth = depth.detach().cpu().numpy()
depth = Image.fromarray(depth.astype("uint8"))

Architecture et configuration

drawing DepthPro architecture. Taken from the original paper.

Le modèle DepthProForDepthEstimation utilise un DepthProEncoder pour encoder l'image d'entrée et un FeatureFusionStage pour fusionner les fonctionnalités de sortie issues de l'encodeur.

Le DepthProEncoder utilise en outre deux encodeurs :

  • patch_encoder
    • L'image d'entrée est mise à l'échelle avec plusieurs ratios, comme spécifié dans la configuration scaled_images_ratios.
    • Chaque image mise à l'échelle est découpée en patches plus petits de taille patch_size, avec des zones de chevauchement déterminées par scaled_images_overlap_ratios.
    • Ces patches sont traités par le patch_encoder
  • image_encoder
    • L'image d'entrée est également redimensionnée à patch_size et traitée par le image_encoder

Ces deux encodeurs peuvent être configurés respectivement via patch_model_config et image_model_config, qui sont par défaut deux Dinov2Model distincts.

Les sorties des deux encodeurs (last_hidden_state) et les états intermédiaires sélectionnés (hidden_states) de patch_encoder sont fusionnées par un FeatureFusionStage basé sur DPT pour l'estimation de la profondeur.

Prédiction du champ de vision (FOV)

Le réseau est complété par une tête d’estimation de la focale. Une petite tête convolutive ingère des caractéristiques figées issues du réseau d’estimation de la profondeur ainsi que des caractéristiques spécifiques à la tâche issues d’un encodeur d’images ViT distinct, afin de prédire le champ de vision angulaire horizontal.

Le paramètre use_fov_model dans DepthProConfig contrôle si la prédiction du FOV est activée. Par défaut, il est défini sur False afin d'économiser la mémoire et les calculs. Lorsqu'il est activé, le codeur FOV est instancié en fonction du paramètre fov_model_config, dont la valeur par défaut est un Dinov2Model. Le paramètre use_fov_model peut également être transmis lors de l'initialisation du modèle DepthProForDepthEstimation.

Le modèle préentraîné au point de contrôle apple/DepthPro-hf utilise l’encodeur FOV. Pour utiliser le modèle préentraîné sans encodeur FOV, définissez use_fov_model=False lors du chargement du modèle, ce qui réduit les calculs.

from transformers import DepthProForDepthEstimation


model = DepthProForDepthEstimation.from_pretrained("apple/DepthPro-hf", use_fov_model=False, device_map="auto")

Pour instancier un nouveau modèle avec un encodeur FOV, définissez use_fov_model=True dans la configuration.

from transformers import DepthProConfig, DepthProForDepthEstimation


config = DepthProConfig(use_fov_model=True)
model = DepthProForDepthEstimation(config)

Ou définissez use_fov_model=True lors de l'initialisation du modèle, ce qui écrase la valeur dans la configuration.

from transformers import DepthProConfig, DepthProForDepthEstimation


config = DepthProConfig()
model = DepthProForDepthEstimation(config, use_fov_model=True)

Utilisation de l'attention à produit scalaire mis à l'échelle (SDPA)

PyTorch intègre un opérateur natif d'attention par produit scalaire mis à l'échelle (SDPA) au sein de torch.nn.functional. Cette fonction englobe plusieurs implémentations qui peuvent être appliquées en fonction des entrées et du matériel utilisé. Consultez la documentation officielle ou la page GPU Inference pour plus d'informations.

SDPA est utilisé par défaut pour torch>=2.1.1 lorsqu’une implémentation est disponible, mais vous pouvez également définir attn_implementation="sdpa" dans from_pretrained() pour demander explicitement l’utilisation de SDPA.

from transformers import DepthProForDepthEstimation


model = DepthProForDepthEstimation.from_pretrained("apple/DepthPro-hf", attn_implementation="sdpa", device_map="auto")

Pour obtenir les accélérations optimales, nous recommandons de charger le modèle en demi-précision (par exemple torch.float16 ou torch.bfloat16).

Sur un benchmark local (A100-40GB, PyTorch 2.3.0, OS Ubuntu 22.04) avec float32 et le modèle google/vit-base-patch16-224, nous avons observé les accélérations suivantes lors de l'inférence.

Taille du lotTemps d'inférence moyen (ms), mode eagerTemps d'inférence moyen (ms), modèle sdpaAccélération, Sdpa / Eager (x)
1761.17
2861.33
4861.33
8861.33

Ressources

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

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.

DepthProConfig

classe transformers.DepthProConfig

< >

( 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 = Nonefusion_hidden_size: int = 256patch_size: int | list[int] | tuple[int, int] = 384initializer_range: float = 0.02intermediate_hook_ids: list[int] | tuple[int, ...] = (11, 5)intermediate_feature_dims: list[int] | tuple[int, ...] = (256, 256)scaled_images_ratios: list[int | float] | tuple[int | float, ...] = (0.25, 0.5, 1)scaled_images_overlap_ratios: list[float] | tuple[float, ...] = (0.0, 0.5, 0.25)scaled_images_feature_dims: list[int] | tuple[int, ...] = (1024, 1024, 512)merge_padding_value: int = 3use_batch_norm_in_fusion_residual: bool = Falseuse_bias_in_fusion_residual: bool = Trueuse_fov_model: bool = Falsenum_fov_head_layers: int = 2image_model_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonepatch_model_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonefov_model_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None )

Paramètres

  • fusion_hidden_size (int, facultatif, valeur par défaut 256) — Le nombre de canaux avant la fusion.
  • patch_size (Union[int, list[int], tuple[int, int]], facultatif, par défaut 384) — La taille (résolution) de chaque patch.
  • initializer_range (float, facultatif, par défaut 0.02) — L'écart-type de la truncated_normal_initializer utilisé pour initialiser toutes les matrices de poids.
  • intermediate_hook_ids (list[int], facultatif, par défaut [11, 5]) — Indices des états cachés intermédiaires du codeur de patch à utiliser pour la fusion.
  • intermediate_feature_dims (list[int], facultatif, par défaut [256, 256]) — Dimensions des états cachés lors du rééchantillonnage par interpolation (upsampling) pour chaque état caché intermédiaire de intermediate_hook_ids.
  • scaled_images_ratios (list[float], facultatif, par défaut [0.25, 0.5, 1]) — Ratios des images redimensionnées à utiliser par l’encodeur de patches.
  • scaled_images_overlap_ratios (list[float], facultatif, par défaut [0.0, 0.5, 0.25]) — Ratios de chevauchement entre les patches pour chaque image mise à l'échelle dans scaled_images_ratios.
  • scaled_images_feature_dims (list[int], facultatif, par défaut [1024, 1024, 512]) — Dimensions des états cachés lors du rééchantillonnage par interpolation ascendante pour chaque image mise à l'échelle dans scaled_images_ratios.
  • merge_padding_value (int, facultatif, valeur par défaut 3) — Lors de la fusion des petits patches pour revenir à la taille de l'image, les sections chevauchantes de cette taille sont supprimées.
  • use_batch_norm_in_fusion_residual (bool, facultatif, valeur par défaut False) — Indique s'il faut utiliser la normalisation par lot dans les unités résiduelles pré-activation des blocs de fusion.
  • use_bias_in_fusion_residual (bool, facultatif, par défaut True) — Indique s'il faut utiliser un biais dans les unités résiduelles pré-activation des blocs de fusion.
  • use_fov_model (bool, facultatif, valeur par défaut False) — Indique s'il faut utiliser DepthProFovModel pour générer le champ de vision.
  • num_fov_head_layers (int, facultatif, valeur par défaut 2) — Nombre de couches de convolution dans la tête de DepthProFovModel.
  • image_model_config (Union[dict[str, Any], PreTrainedConfig], facultatif) — La configuration du modèle d’encodeur d’images, qui est chargée à l’aide de l’API AutoModel. Par défaut, le modèle Dinov2 est utilisé comme backbone.
  • patch_model_config (Union[dict[str, Any], PreTrainedConfig], facultatif) — La configuration du modèle d’encodeur de patch, qui est chargée à l’aide de l’API AutoModel. Par défaut, le modèle Dinov2 est utilisé comme backbone.
  • fov_model_config (Union[dict[str, Any], PreTrainedConfig], facultatif) — La configuration du modèle encodeur fov, qui est chargée à l'aide de l'API AutoModel. Par défaut, le modèle Dinov2 est utilisé comme backbone.

Ceci est la classe de configuration destinée à stocker la configuration d'un DepthProModel. Elle est utilisée pour instancier un modèle Depth Pro 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 apple/DepthPro

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 DepthProConfig, DepthProModel

>>> # Initializing a DepthPro apple/DepthPro style configuration
>>> configuration = DepthProConfig()

>>> # Initializing a model (with random weights) from the apple/DepthPro style configuration
>>> model = DepthProModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config

DepthProImageProcessor

classe transformers.DepthProImageProcessor

< >

( **kwargs: *<class 'transformers.processing_utils.ImagesKwargs'> )

Paramètres

  • do_convert_rgb (bool, kwargs, facultatif) — Indique s'il faut convertir l'image en RGB.
  • do_resize (bool, kwargs, facultatif, valeur par défaut True) — Indique s'il faut redimensionner l'image.
  • size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs, par défaut {'height' -- 1536, 'width': 1536}) : Définit les dimensions d'entrée maximales pour le modèle.
  • default_to_square (bool, kwargs, facultatif, valeur par défaut True) — Indique s'il faut utiliser une image carrée par défaut lors du redimensionnement, si la taille est un entier.
  • crop_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Taille de l'image de sortie après application de center_crop.
  • resample (Annotated[Union[int, PILImageResampling, NoneType], None], kwargs, par défaut 2) — Filtre de rééchantillonnage à utiliser lors du redimensionnement de l’image. Il peut s’agir de l’une des valeurs de l’enum PILImageResampling. N’a un effet que si do_resize est défini sur True.
  • do_rescale (bool, kwargs, facultatif, par défaut True) — Indique s'il faut rééchelonner l'image.
  • rescale_factor (float, kwargs, facultatif, valeur par défaut 0.00392156862745098) — Facteur de remise à l'échelle appliqué à l'image si do_rescale est défini sur True.
  • do_normalize (bool, kwargs, facultatif, valeur par défaut True) — Indique s'il faut normaliser l'image.
  • image_mean (Union[float, list[float], tuple[float, ...]], kwargs, facultatif, valeur par défaut [0.5, 0.5, 0.5]) — Moyenne de l'image à utiliser pour la normalisation. N'a un effet que si do_normalize est défini sur True.
  • image_std (Union[float, list[float], tuple[float, ...]], kwargs, facultatif, valeur par défaut [0.5, 0.5, 0.5]) — Écart-type de l'image à utiliser pour la normalisation. N'a un effet que si do_normalize est défini sur True.
  • do_pad (bool, kwargs, facultatif) — Indique s'il faut effectuer un bourrage (padding) de l'image. Le bourrage est effectué soit jusqu'à la plus grande taille du lot, soit jusqu'à une taille carrée fixe par image. La stratégie de bourrage exacte dépend du modèle.
  • pad_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — La taille au format {"height": int, "width" int} à laquelle les images doivent être remplies. Elle doit être supérieure à la taille de n'importe quelle image fournie pour la prétraitement. Si pad_size n'est pas fourni, les images seront remplies jusqu'à la hauteur et la largeur maximales du lot. Appliqué uniquement lorsque do_pad=True.
  • do_center_crop (bool, kwargs, facultatif) — Indique s'il faut effectuer un recadrage centré de l'image.
  • data_format (Union[str, ~image_utils.ChannelDimension], kwargs, facultatif) — Seul ChannelDimension.FIRST est pris en charge. Ajouté pour la compatibilité avec les processeurs lents.
  • input_data_format (Union[str, ~image_utils.ChannelDimension], kwargs, facultatif) — Le format de la dimension des canaux pour l'image d'entrée. Si non défini, le format de la dimension des canaux est déduit de l'image d'entrée. Peut être l'un des éléments suivants :
    • "channels_first" ou ChannelDimension.FIRST : image au format (num_channels, height, width).
    • "channels_last" ou ChannelDimension.LAST : image au format (hauteur, largeur, nombre de canaux).
    • "none" ou ChannelDimension.NONE : image au format (hauteur, largeur).
  • device (Annotated[Union[str, torch.device, NoneType], None], kwargs) — L’appareil sur lequel traiter les vidéos. Si non défini, l’appareil est déduit des vidéos d’entrée.
  • return_tensors (Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — Retourne des tenseurs empilés si défini sur 'pt', sinon retourne une liste de tenseurs.
  • disable_grouping (bool, kwargs, facultatif) — Indique s'il faut désactiver le regroupement des images par taille afin de les traiter individuellement plutôt que par lots. Si la valeur est None, elle est définie sur True si les images sont sur CPU, et sur False dans le cas contraire. Ce choix repose sur des observations empiriques, comme détaillé ici : https://github.com/huggingface/transformers/pull/38157
  • image_seq_length (int, kwargs, facultatif) — Le nombre de jetons d’image à utiliser pour chaque image de l’entrée. Ajouté pour la compatibilité ascendante, mais cela devrait être défini comme un attribut du processeur dans les futurs modèles. Retourne des tenseurs empilés si défini sur 'pt', sinon retourne une liste de tenseurs.
  • disable_grouping (bool, kwargs, facultatif) — Indique s'il faut désactiver le regroupement des images par taille afin de les traiter individuellement plutôt que par lots. Si la valeur est None, elle est définie sur True si les images sont sur CPU, et sur False dans le cas contraire. Ce choix repose sur des observations empiriques, comme détaillé ici : https://github.com/huggingface/transformers/pull/38157
  • image_seq_length (int, kwargs, facultatif) — Le nombre de jetons d’image à utiliser pour chaque image de l’entrée. Ajouté pour la compatibilité ascendante, mais cela devrait être défini comme un attribut du processeur dans les futurs modèles.
  • Returns des tenseurs empilés si défini sur 'pt', sinon retourne une liste de tenseurs. —

Construit un processeur d’image DepthPro.

disable_grouping (bool, kwargs, facultatif) : Indique s'il faut désactiver le regroupement des images par taille afin de les traiter individuellement et non par lots. Si la valeur est None, elle est définie sur True si les images sont sur CPU, et sur False dans le cas contraire. Ce choix repose sur des observations empiriques, comme détaillé ici : https://github.com/huggingface/transformers/pull/38157 image_seq_length (int, kwargs, facultatif) : Le nombre de jetons d'image à utiliser pour chaque image de l'entrée. Ajouté pour la compatibilité ascendante, mais cette valeur devrait être définie comme un attribut du processeur dans les futurs modèles.

prétraiter

< >

( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']]*argsimage_like_kwargs: dict[str, typing.Any] | None = None**kwargs: *<class 'transformers.processing_utils.ImagesKwargs'> ) → ~image_processing_base.BatchFeature

Paramètres

  • images (Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]) — Image à prétraiter. S'attend à une image unique ou à un lot d'images dont les valeurs de pixels vont de 0 à 255. Si vous passez des images dont les valeurs de pixels sont comprises entre 0 et 1, définissez do_rescale=False.
  • image_like_kwargs (dict[str, Any], facultatif) — Drapeau de développement pour des entrées supplémentaires de type image qui seront également prétraitées. N'utilisez ce paramètre que si le passage des entrées en tant que mot-clé ne fonctionne pas. Par exemple, preprocess(images, masks=masks) est l'option recommandée, mais elle peut entraîner des problèmes de priorité des arguments pour certains modèles. Dans ces cas, preprocess(images, image_like_inputs={"masks": masks}) peut être utilisé à la place.
  • do_convert_rgb (bool, kwargs, facultatif) — Indique s'il faut convertir l'image en RGB.
  • do_resize (bool, kwargs, facultatif) — Indique s'il faut redimensionner l'image.
  • size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Définit les dimensions maximales des entrées du modèle.
  • default_to_square (bool, kwargs, facultatif) — Indique s'il faut par défaut redimensionner l'image en carré si la taille est un entier.
  • crop_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Taille de l'image de sortie après application de center_crop.
  • resample (Annotated[Union[int, PILImageResampling, NoneType], None], kwargs) — Filtre de rééchantillonnage à utiliser lors du redimensionnement de l’image. Il peut s’agir de l’une des valeurs de l’enum PILImageResampling. N’a un effet que si do_resize est défini sur True.
  • do_rescale (bool, kwargs, facultatif) — Indique s'il faut rééchelonner l'image.
  • rescale_factor (float, kwargs, facultatif) — Facteur de remise à l'échelle à appliquer à l'image si do_rescale est défini sur True.
  • do_normalize (bool, kwargs, facultatif) — Indique s'il faut normaliser l'image.
  • image_mean (Union[float, list[float], tuple[float, ...]], kwargs, facultatif) — Moyenne de l'image à utiliser pour la normalisation. N'a un effet que si do_normalize est défini sur True.
  • image_std (Union[float, list[float], tuple[float, ...]], kwargs, facultatif) — Écart-type de l'image à utiliser pour la normalisation. N'a un effet que si do_normalize est défini sur True.
  • do_pad (bool, kwargs, facultatif) — Indique s'il faut effectuer un bourrage (padding) de l'image. Le bourrage est effectué soit jusqu'à la plus grande taille du lot, soit jusqu'à une taille carrée fixe par image. La stratégie de bourrage exacte dépend du modèle.
  • pad_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — La taille au format {"height": int, "width" int} à laquelle les images doivent être remplies. Elle doit être supérieure à la taille de n'importe quelle image fournie pour la prétraitement. Si pad_size n'est pas fourni, les images seront remplies jusqu'à la hauteur et la largeur maximales du lot. Appliqué uniquement lorsque do_pad=True.
  • do_center_crop (bool, kwargs, facultatif) — Indique s'il faut effectuer un recadrage centré de l'image.
  • data_format (Union[str, ~image_utils.ChannelDimension], kwargs, facultatif) — Seul ChannelDimension.FIRST est pris en charge. Ajouté pour la compatibilité avec les processeurs lents.
  • input_data_format (Union[str, ~image_utils.ChannelDimension], kwargs, facultatif) — Le format de la dimension des canaux pour l'image d'entrée. Si non défini, le format de la dimension des canaux est déduit de l'image d'entrée. Peut être l'un des éléments suivants :
    • "channels_first" ou ChannelDimension.FIRST : image au format (num_channels, height, width).
    • "channels_last" ou ChannelDimension.LAST : image au format (hauteur, largeur, nombre de canaux).
    • "none" ou ChannelDimension.NONE : image au format (hauteur, largeur).
  • device (Annotated[Union[str, torch.device, NoneType], None], kwargs) — L’appareil sur lequel traiter les vidéos. Si non défini, l’appareil est déduit des vidéos d’entrée.
  • return_tensors (Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — Retourne des tenseurs empilés si défini sur 'pt', sinon retourne une liste de tenseurs.
  • disable_grouping (bool, kwargs, facultatif) — Indique s'il faut désactiver le regroupement des images par taille afin de les traiter individuellement plutôt que par lots. Si la valeur est None, elle est définie sur True si les images sont sur CPU, et sur False dans le cas contraire. Ce choix repose sur des observations empiriques, comme détaillé ici : https://github.com/huggingface/transformers/pull/38157
  • image_seq_length (int, kwargs, facultatif) — Le nombre de jetons d’image à utiliser pour chaque image de l’entrée. Ajouté pour la compatibilité ascendante, mais cela devrait être défini comme un attribut du processeur dans les futurs modèles.

Retourne

~image_processing_base.BatchFeature

  • data (dict) — Dictionnaire de listes/tableaux/tenseurs renvoyé par la méthode call (« pixel_values », etc.).
  • tensor_type (Union[None, str, TensorType], facultatif) — Vous pouvez spécifier un tensor_type ici pour convertir les listes d'entiers en tenseurs PyTorch/Numpy lors de l'initialisation.

Prétraitez une image ou un lot d'images.

post_process_depth_estimation

< >

( outputs: DepthProDepthEstimatorOutputtarget_sizes: transformers.utils.generic.TensorType | list[tuple[int, int]] | None = None )

Post-traite les prédictions de profondeur brutes issues du modèle.

DepthProModel

classe transformers.DepthProModel

< >

( config: DepthProConfig )

Paramètres

  • config (DepthProConfig) — 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.

Le modèle Depth Pro brut, qui produit des états cachés bruts sans aucune tête spécifique au sommet.

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

< >

( pixel_values: Tensoroutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → DepthProOutput or tuple(torch.Tensor)

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 de pixels peuvent être obtenues à l’aide de DepthProImageProcessor. Voir DepthProImageProcessor.call() pour plus de détails (processor_class utilise DepthProImageProcessor pour le traitement des images).
  • output_attentions (bool, facultatif) — Indique s'il faut ou non retourner les tenseurs d'attention de toutes les couches d'attention. Consultez 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 sous 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

DepthProOutput ou tuple(torch.Tensor)

Un DepthProOutput 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 (DepthProConfig) et des entrées.

La méthode forward du modèle DepthProModel surcharge 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.

  • last_hidden_state (torch.Tensor de forme (batch_size, n_patches_per_batch, sequence_length, hidden_size)) — Séquence d'états cachés à la sortie de la dernière couche du modèle.

  • features (Union[torch.Tensor, List[torch.Tensor]], facultatif) — Fonctionnalités issues des encodeurs. Peut s'agir d'une seule fonctionnalité ou d'une liste de fonctionnalités.

  • 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, sequence_length, hidden_size).

    É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, sequence_length, 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 :

>>> import torch
>>> from PIL import Image
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO
>>> from transformers import AutoProcessor, DepthProModel

>>> url = "https://www.ilankelman.org/stopsigns/australia.jpg"
>>> with httpx.stream("GET", url) as response:
...     image = Image.open(BytesIO(response.read()))

>>> checkpoint = "apple/DepthPro-hf"
>>> processor = AutoProcessor.from_pretrained(checkpoint)
>>> model = DepthProModel.from_pretrained(checkpoint)

>>> # prepare image for the model
>>> inputs = processor(images=image, return_tensors="pt")

>>> with torch.no_grad():
...     output = model(**inputs)

>>> output.last_hidden_state.shape
torch.Size([1, 35, 577, 1024])

DepthProForDepthEstimation

classe transformers.DepthProForDepthEstimation

< >

( config: DepthProConfiguse_fov_model = None )

Paramètres

  • config (DepthProConfig) — 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.
  • use_fov_model (bool, facultatif) — Indique s'il faut utiliser le modèle de champ de vision.

Modèle DepthPro avec une tête d'estimation de profondeur au sommet (composée de 3 couches convolutives).

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

< >

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

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 de pixels peuvent être obtenues à l’aide de DepthProImageProcessor. Voir DepthProImageProcessor.call() pour plus de détails (processor_class utilise DepthProImageProcessor pour le traitement des images).
  • labels (torch.LongTensor de 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. Consultez 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 sous 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

DepthProDepthEstimatorOutput ou tuple(torch.Tensor)

Un DepthProDepthEstimatorOutput 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 (DepthProConfig) et des entrées.

La méthode forward de DepthProForDepthEstimation 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), facultatif) — Profondeur prédite pour chaque pixel.

  • field_of_view (torch.Tensor de forme (batch_size,), facultatif, renvoyé lorsque use_fov_model est fourni) — Facteur d'échelle du champ de vision.

  • 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, sequence_length, hidden_size).

    É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, sequence_length, 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, DepthProForDepthEstimation
>>> import torch
>>> 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()))

>>> checkpoint = "apple/DepthPro-hf"
>>> processor = AutoImageProcessor.from_pretrained(checkpoint)
>>> model = DepthProForDepthEstimation.from_pretrained(checkpoint)

>>> device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
>>> model.to(device)

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

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

>>> # interpolate to original size
>>> post_processed_output = processor.post_process_depth_estimation(
...     outputs, target_sizes=[(image.height, image.width)],
... )

>>> # get the field of view (fov) predictions
>>> field_of_view = post_processed_output[0]["field_of_view"]
>>> focal_length = post_processed_output[0]["focal_length"]

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

←Depth Anything V2 DETR→