# CHMv2 ## Aperçu Le modèle Canopy Height Maps v2 (CHMv2) a été proposé dans [CHMv2: Improvements in Global Canopy Height Mapping using DINOv3](https://huggingface.co/papers/2603.06382). En s'appuyant sur nos [cartes de hauteur de canopée haute résolution d'origine](https://sustainability.atmeta.com/blog/2024/04/22/using-artificial-intelligence-to-map-the-earths-forests/) publiées en 2024, CHMv2 apporte des améliorations substantielles en termes de précision, de détail et de cohérence mondiale grâce à l'utilisation de DINOv3, le modèle de vision auto-supervisé de Meta. Vous trouverez plus d’informations [ici](http://ai.meta.com/blog/world-resources-institute-dino-canopy-height-maps-v2), et le code original [ici](https://github.com/facebookresearch/dinov3). L'abstract de l'article est le suivant : *Des informations précises sur la hauteur de la canopée sont essentielles pour quantifier le carbone forestier, surveiller la restauration et la dégradation, et évaluer la structure des habitats, mais les mesures haute fidélité issues du balayage laser aéroporté (ALS) restent inégalement disponibles à l’échelle mondiale. Nous présentons ici CHMv2, une carte mondiale de la hauteur de la canopée à résolution métrique, dérivée d’images satellites optiques haute résolution à l’aide d’un modèle d’estimation de profondeur construit sur DINOv3 et entraîné sur des modèles de hauteur de canopée ALS. Par rapport aux produits existants, CHMv2 améliore considérablement la précision, réduit le biais dans les forêts hautes et préserve mieux la structure à fine échelle, telle que les bords de canopée et les ouvertures. Ces gains sont rendus possibles par une grande expansion des données d’entraînement géographiquement diversifiées, une curation et une enregistrement automatisés des données, ainsi que par une formulation de perte et une stratégie d’échantillonnage des données adaptées aux distributions de hauteur de canopée. Nous validons CHMv2 par rapport à des ensembles de test ALS indépendants et à des dizaines de millions d’observations GEDI et ICESat-2, démontrant des performances cohérentes à travers les principaux biomes forestiers.* ## Exemples d'utilisation Exécutez une inférence sur une image avec le code suivant : ```python import torch from PIL import Image from transformers import AutoImageProcessor, AutoModelForDepthEstimation processor = AutoImageProcessor.from_pretrained("facebook/dinov3-vitl16-chmv2-dpt-head") model = AutoModelForDepthEstimation.from_pretrained("facebook/dinov3-vitl16-chmv2-dpt-head", device_map="auto") image = Image.open("image.tif") inputs = processor(images=image, return_tensors="pt").to(model.device) with torch.no_grad(): outputs = model(**inputs) depth = processor.post_process_depth_estimation( outputs, target_sizes=[(image.height, image.width)] )[0]["predicted_depth"] ``` ## CHMv2Config[[transformers.CHMv2Config]] #### transformers.CHMv2Config[[transformers.CHMv2Config]] ```python transformers.CHMv2Config(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 = 16, initializer_range: float = 0.02, reassemble_factors: list[float | int] | None = None, post_process_channels: list[int] | None = None, fusion_hidden_size: int = 256, head_hidden_size: int = 128, number_output_channels: int = 256, readout_type: str = 'project', min_depth: float = 0.001, max_depth: float = 96.0, bins_strategy: typing.Literal['linear', 'log', 'chmv2_mixlog'] = 'chmv2_mixlog', norm_strategy: typing.Literal['linear', 'softmax', 'sigmoid', 'chmv2_mixlog'] = 'chmv2_mixlog') ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/chmv2/configuration_chmv2.py#L32) **Paramètres :** backbone_config (`Union[dict, "PreTrainedConfig"]`, *facultatif*) : La configuration du modèle de base. Seule DINOv3ViTConfig est actuellement prise en charge. patch_size (`int`, *facultatif*, valeur par défaut 16) : La taille des patches utilisée par le transformeur visuel de la structure de base. 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_factors (`list[float]`, *facultatif*, par défaut `[4, 2, 1, 0.5]`) : Les facteurs de suréchantillonnage/sous-échantillonnage des couches de réassemblage. post_process_channels (`list[int]`, *facultatif*, par défaut `[128, 256, 512, 1024]`) : Les tailles des canaux de sortie de l'étape de réassemblage pour chaque niveau de caractéristique du backbone. fusion_hidden_size (`int`, *facultatif*, valeur par défaut 256) : Le nombre de canaux avant la fusion. head_hidden_size (`int`, *facultatif*, par défaut 128) : Le nombre de canaux dans la couche cachée de la tête d'estimation de profondeur. number_output_channels (`int`, *facultatif*, par défaut 256) : Nombre de canaux de sortie pour la tête CHMv2 (nombre de bins de profondeur). readout_type (`str`, *facultatif*, valeur par défaut `"project"`) : Type d'opération de lecture pour le jeton CLS. L'une des valeurs `["ignore", "add", "project"]`. min_depth (`float`, *facultatif*, valeur par défaut 0.001) : valeur minimale de profondeur pour le calcul des intervalles de profondeur. max_depth (`float`, *facultatif*, valeur par défaut 96.0) : La valeur de profondeur maximale pour le calcul des intervalles de profondeur. bins_strategy (`str`, *facultatif*, valeur par défaut `"chmv2_mixlog"`) : La stratégie de distribution des intervalles de profondeur. L'une des valeurs `["linear", "log", "chmv2_mixlog"]`. norm_strategy (`str`, *facultatif*, valeur par défaut `"chmv2_mixlog"`) : La stratégie de normalisation pour la prédiction de la profondeur. L'une des valeurs `["linear", "softmax", "sigmoid", "chmv2_mixlog"]`. Il s’agit de la classe de configuration destinée à stocker la configuration d’un Chmv2Model. Elle est utilisée pour instancier un modèle Chmv2 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 [facebook/dinov3-vitl16-chmv2-dpt-head](https://huggingface.co/facebook/dinov3-vitl16-chmv2-dpt-head) 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. ```python >>> from transformers import CHMv2Config, CHMv2ForDepthEstimation >>> configuration = CHMv2Config() >>> model = CHMv2ForDepthEstimation(configuration) >>> configuration = model.config ``` ## CHMv2ImageProcessor[[transformers.CHMv2ImageProcessor]] #### transformers.CHMv2ImageProcessor[[transformers.CHMv2ImageProcessor]] ```python transformers.CHMv2ImageProcessor(**kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/chmv2/image_processing_chmv2.py#L99) **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 `False`) : Indique s'il faut redimensionner l'image. size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, par défaut `{'height' : 384, 'width': 384}`) : Décrit les dimensions d'entrée maximales du modèle. default_to_square (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut par défaut redimensionner l'image en un carré si la taille est un entier. crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, par défaut `None`) : Taille de l'image de sortie après application de `center_crop`. resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*, par défaut `3`) : Filtre de rééchantillonnage à utiliser lors du redimensionnement de l'image. Il peut s'agir de l'une des valeurs de l'énumération `PILImageResampling`. N'a un effet que si `do_resize` est défini sur `True`. do_rescale (`bool`, *kwargs*, *facultatif*, valeur 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.42, 0.411, 0.296]`) : 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.213, 0.156, 0.143]`) : É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*, valeur par défaut `True`) : Indique s'il faut ajouter un rembourrage à l'image. Le rembourrage est effectué soit jusqu'à la plus grande taille du lot, soit jusqu'à une taille carrée fixe par image. La stratégie de rembourrage 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 rembourrer les images. Elle doit être supérieure à la taille de n'importe quelle image fournie pour le prétraitement. Si `pad_size` n'est pas fourni, les images seront rembourrées à la hauteur et à la largeur maximales du lot. Appliqué uniquement lorsque `do_pad=True.` do_center_crop (`bool`, *kwargs*, *facultatif*, valeur par défaut `None`) : 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 assurer 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 (height, width, num_channels). - `"none"` ou `ChannelDimension.NONE` : image au format (height, width). 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*) : Renvoie des tenseurs empilés si la valeur est `'pt'`, sinon renvoie 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 sera 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. ensure_multiple_of (`int`, *kwargs*, *facultatif*, valeur par défaut 1) : si `do_resize` est `True`, l'image est redimensionnée à une taille qui est un multiple de cette valeur. Peut être remplacé par `ensure_multiple_of` dans `preprocess`. size_divisor (`int`, *kwargs*, par défaut `16`) : La taille par laquelle il faut s'assurer que la hauteur et la largeur sont divisibles. keep_aspect_ratio (`bool`, *kwargs*, *facultatif*, valeur par défaut `False`) : Si `True`, l'image est redimensionnée à la taille maximale possible tout en préservant le ratio d'aspect. Peut être remplacé par `keep_aspect_ratio` dans `preprocess`. do_reduce_labels (`bool`, *kwargs*, *facultatif*, valeur par défaut `self.do_reduce_labels`) : Indique s'il faut réduire de 1 toutes les valeurs d'étiquettes des cartes de segmentation. Utilisé généralement pour les jeux de données où 0 est utilisé pour l'arrière-plan, et où l'arrière-plan lui-même n'est pas inclus dans toutes les classes d'un jeu de données (par ex. ADE20k). L'étiquette d'arrière-plan sera remplacée par 255. Construit un processeur d’images CHMv2ImageProcessor. #### prétraiter[[transformers.CHMv2ImageProcessor.preprocess]] ```python preprocess(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']], segmentation_maps: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = None, **kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/chmv2/image_processing_chmv2.py#L125) **Paramètres :** images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`) : Image à prétraiter. Attend une image unique ou un lot d'images dont les valeurs de pixels sont comprises entre 0 et 255. Si vous transmettez des images dont les valeurs de pixels sont comprises entre 0 et 1, définissez `do_rescale=False`. segmentation_maps (`ImageInput`, *facultatif*) : Les cartes de segmentation à prétraiter. 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écrit les dimensions d'entrée maximales du modèle. default_to_square (`bool`, *kwargs*, *facultatif*) : Indique s'il faut par défaut redimensionner l'image en un carré lorsque 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 d'une des valeurs de l'énumération `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 redimensionnement à 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 ajouter un rembourrage à l'image. Le rembourrage est effectué soit jusqu'à la plus grande taille du lot, soit jusqu'à une taille carrée fixe par image. La stratégie de rembourrage 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 rembourrer les images. Elle doit être supérieure à la taille de n'importe quelle image fournie pour le prétraitement. Si `pad_size` n'est pas fourni, les images seront rembourrées à 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 assurer 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 (height, width, num_channels). - `"none"` ou `ChannelDimension.NONE` : image au format (height, width). 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*) : Renvoie des tenseurs empilés si la valeur est `'pt'`, sinon renvoie 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 sera 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. ensure_multiple_of (`int`, *kwargs*, *facultatif*, valeur par défaut 1) : si `do_resize` est `True`, l'image est redimensionnée à une taille qui est un multiple de cette valeur. Peut être remplacé par `ensure_multiple_of` dans `preprocess`. size_divisor (`int`, *kwargs*) : La taille par laquelle s'assurer que la hauteur et la largeur sont divisibles. keep_aspect_ratio (`bool`, *kwargs*, *facultatif*, valeur par défaut `False`) : Si `True`, l'image est redimensionnée à la taille maximale possible tout en préservant le ratio d'aspect. Peut être remplacé par `keep_aspect_ratio` dans `preprocess`. do_reduce_labels (`bool`, *kwargs*, *facultatif*, valeur par défaut `self.do_reduce_labels`) : Indique s'il faut réduire de 1 toutes les valeurs d'étiquettes des cartes de segmentation. Utilisé généralement pour les jeux de données où 0 est utilisé pour l'arrière-plan, et où l'arrière-plan lui-même n'est pas inclus dans toutes les classes d'un jeu de données (par ex. ADE20k). L'étiquette d'arrière-plan sera remplacée par 255. **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. #### post_process_depth_estimation[[transformers.CHMv2ImageProcessor.post_process_depth_estimation]] ```python post_process_depth_estimation(outputs: DepthEstimatorOutput, target_sizes: transformers.utils.generic.TensorType | list[tuple[int, int]] | None = None) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/chmv2/image_processing_chmv2.py#L385) **Paramètres :** outputs (`DepthEstimatorOutput`) : Sorties brutes du modèle. target_sizes (`TensorType` ou `List[Tuple[int, int]]`, *facultatif*) : Tenseur de forme `(batch_size, 2)` ou liste de tuples (`Tuple[int, int]`) contenant la taille cible (hauteur, largeur) de chaque image du lot. Si laissé à None, les prédictions ne seront pas redimensionnées. **Retourne :** `List[Dict[str, TensorType]]` Une liste de dictionnaires de tenseurs représentant les prédictions de profondeur traitées. Convertit la sortie brute de `DepthEstimatorOutput` en prédictions de profondeur finales et en images de profondeur PIL. Prend uniquement en charge PyTorch. ## CHMv2ForDepthEstimation[[transformers.CHMv2ForDepthEstimation]] #### transformers.CHMv2ForDepthEstimation[[transformers.CHMv2ForDepthEstimation]] ```python transformers.CHMv2ForDepthEstimation(config: CHMv2Config) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/chmv2/modeling_chmv2.py#L384) **Paramètres :** config ([CHMv2Config](/docs/transformers/main/fr/model_doc/chmv2#transformers.CHMv2Config)) : 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 CHMv2 avec une tête d'estimation de profondeur en haut (composée de couches convolutives), par exemple pour l'estimation de la hauteur de la canopée. 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.CHMv2ForDepthEstimation.forward]] ```python forward(pixel_values: Tensor, labels: typing.Optional[torch.LongTensor] = None, **kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/chmv2/modeling_chmv2.py#L397) **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 [CHMv2ImageProcessor](/docs/transformers/main/fr/model_doc/chmv2#transformers.CHMv2ImageProcessor). Voir [CHMv2ImageProcessor.__call__()](/docs/transformers/main/fr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) pour plus de détails (`processor_class` utilise [CHMv2ImageProcessor](/docs/transformers/main/fr/model_doc/chmv2#transformers.CHMv2ImageProcessor) 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. **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 ([CHMv2Config](/docs/transformers/main/fr/model_doc/chmv2#transformers.CHMv2Config)) et les entrées. La méthode forward de [CHMv2ForDepthEstimation](/docs/transformers/main/fr/model_doc/chmv2#transformers.CHMv2ForDepthEstimation) 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. Exemple : ```python >>> from transformers import AutoImageProcessor, CHMv2ForDepthEstimation >>> 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())).convert("RGB") >>> processor = AutoImageProcessor.from_pretrained("facebook/dinov3-vitl16-chmv2-dpt-head") >>> model = CHMv2ForDepthEstimation.from_pretrained("facebook/dinov3-vitl16-chmv2-dpt-head") >>> 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, [(image.height, image.width)], ... ) >>> predicted_depth = post_processed_output[0]["predicted_depth"] ```