# Hiera

## Aperçu

Hiera a été proposé dans [Hiera: A Hierarchical Vision Transformer without the Bells-and-Whistles](https://huggingface.co/papers/2306.00989) par Chaitanya Ryali, Yuan-Ting Hu, Daniel Bolya, Chen Wei, Haoqi Fan, Po-Yao Huang, Vaibhav Aggarwal, Arkabandhu Chowdhury, Omid Poursaeed, Judy Hoffman, Jitendra Malik, Yanghao Li, Christoph Feichtenhofer

L’article présente « Hiera », un Vision Transformer hiérarchique qui simplifie l’architecture des transformers de vision hiérarchiques modernes en supprimant les composants inutiles sans compromettre la précision ni l’efficacité. Contrairement aux transformers traditionnels qui ajoutent des composants spécifiques à la vision pour améliorer les performances de classification supervisée, Hiera démontre que ces ajouts, souvent qualifiés de « gadgets », ne sont pas essentiels pour atteindre une haute précision. En s’appuyant sur une tâche de prétexte visuelle robuste (MAE) pour le pré-entraînement, Hiera conserve sa simplicité et atteint une précision et une vitesse supérieures, tant à l’inférence qu’à l’entraînement, sur diverses tâches de reconnaissance d’images et de vidéos. Cette approche suggère que les biais spatiaux nécessaires aux tâches de vision peuvent être appris efficacement par un pré-entraînement approprié, éliminant ainsi le besoin d’une complexité architecturale supplémentaire.

L'abstract de l'article est le suivant :

*Les transformeurs hiérarchiques modernes pour la vision ont ajouté plusieurs composants spécifiques à la vision dans le but d’améliorer les performances de classification supervisée. Bien que ces composants conduisent à des précisions efficaces et à des nombres de FLOP attractifs, la complexité ajoutée rend en réalité ces transformeurs plus lents que leurs équivalents ViT de base. Dans cet article, nous soutenons que cette surcharge supplémentaire est inutile. En effectuant un pré-entraînement avec une tâche visuelle de prétexte robuste (MAE), nous pouvons éliminer tous les éléments superflus d’un transformeur de vision multi-étapes de pointe sans perte de précision. Au passage, nous créons Hiera, un transformeur de vision hiérarchique extrêmement simple, plus précis que les modèles précédents tout en étant nettement plus rapide, tant à l’inférence qu’au cours de l’entraînement. Nous évaluons Hiera sur une variété de tâches de reconnaissance d’images et de vidéos. Notre code et nos modèles sont disponibles à l’adresse https://github.com/facebookresearch/hiera.*

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

 Architecture Hiera. Issue de l'article original.

Ce modèle est le fruit d’une contribution conjointe de [EduardoPacheco](https://huggingface.co/EduardoPacheco) et [namangarg110](https://huggingface.co/namangarg110). Le code d’origine est disponible [ici] (https://github.com/facebookresearch/hiera).

## Ressources

Une liste de ressources officielles de Hugging Face et de la communauté (indiquées par 🌎) pour vous aider à démarrer avec Hiera. 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.

- [HieraForImageClassification](/docs/transformers/main/fr/model_doc/hiera#transformers.HieraForImageClassification) est pris en charge par ce [notebook](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/image_classification.ipynb).
- Voir aussi : [Guide de la tâche de classification d'images](../tasks/image_classification)

## HieraConfig[[transformers.HieraConfig]]

#### transformers.HieraConfig[[transformers.HieraConfig]]

```python
transformers.HieraConfig(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, embed_dim: int = 96, image_size: list[int] | tuple[int, ...] = (224, 224), patch_size: list[int] | tuple[int, ...] = (7, 7), patch_stride: list[int] | tuple[int, ...] = (4, 4), patch_padding: list[int] | tuple[int, ...] = (3, 3), mlp_ratio: float = 4.0, depths: list[int] | tuple[int, ...] = (2, 3, 16, 3), num_heads: list[int] | tuple[int, ...] = (1, 2, 4, 8), embed_dim_multiplier: float | int = 2.0, num_query_pool: int = 3, query_stride: list[int] | tuple[int, ...] = (2, 2), masked_unit_size: list[int] | tuple[int, ...] = (8, 8), masked_unit_attention: list[bool] | tuple[bool, ...] = (True, True, False, False), drop_path_rate: float | int = 0.0, num_channels: int = 3, hidden_act: str = 'gelu', initializer_range: float = 0.02, layer_norm_init: float = 1.0, layer_norm_eps: float = 1e-06, decoder_hidden_size: int | None = None, decoder_depth: int | None = None, decoder_num_heads: int | None = None, normalize_pixel_loss: bool | None = True, mask_ratio: float = 0.6, _out_features: list[str] | None = None, _out_indices: list[int] | None = None)
```

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

**Paramètres :**

embed_dim (`int`, *facultatif*, valeur par défaut `96`) : Dimension des embeddings et des états cachés.

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

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

patch_stride (`list(int)`, *facultatif*, par défaut `[4, 4]`) : Le pas du patch.

patch_padding (`list(int)`, *facultatif*, par défaut `[3, 3]`) : Le padding du patch.

mlp_ratio (`float`, *facultatif*, par défaut `4.0`) : Ratio de la dimension cachée du MLP par rapport à la dimension d'embedding.

depths (`Union[list[int], tuple[int, ...]]`, *facultatif*, valeur par défaut `(2, 3, 16, 3)`) : Profondeur de chaque couche du Transformer.

num_heads (`list(int)`, *facultatif*, valeur par défaut `[1, 2, 4, 8]`) : Nombre de têtes d'attention dans chaque couche de l'encodeur Transformer.

embed_dim_multiplier (`float`, *facultatif*, valeur par défaut 2.0) : Le multiplicateur de la dimensionnalité de l'intégration de patch dans chaque couche de l'encodeur Transformer.

num_query_pool (`int`, *facultatif*, valeur par défaut : 3) : Le nombre d'étapes de pool de requêtes.

query_stride (`list(int)`, *facultatif*, valeur par défaut `[2, 2]`) : Le pas du pool de requêtes.

masked_unit_size (`list(int)`, *facultatif*, par défaut `[8, 8]`) : La taille de l'unité masquée.

masked_unit_attention (`list(bool)`, *facultatif*, valeur par défaut `[True, True, False, False]`) : Indique s'il faut utiliser l'attention unitaire masquée dans chaque couche de l'encodeur Transformer.

drop_path_rate (`Union[float, int]`, *facultatif*, valeur par défaut `0.0`) : Taux de drop path pour la fusion des patches.

num_channels (`int`, *facultatif*, par défaut `3`) : Le nombre de canaux d'entrée.

hidden_act (`str`, *facultatif*, par défaut `gelu`) : La fonction d'activation non linéaire (fonction ou chaîne de caractères) dans le décodeur. Par exemple, `"gelu"`, `"relu"`, `"silu"`, etc.

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.

layer_norm_init (`float`, *facultatif*, valeur par défaut 1.0) : La valeur initiale du poids pour les couches de normalisation de couche.

layer_norm_eps (`float`, *facultatif*, par défaut `1e-06`) : L'épsilon utilisé par les couches de normalisation par couche.

decoder_hidden_size (`int`, *facultatif*) : Dimension des représentations cachées.

decoder_depth (`int`, *facultatif*) : Profondeur du décodeur pour la préformation MAE.

decoder_num_heads (`int`, *facultatif*) : Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer.

normalize_pixel_loss (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut normaliser la perte des pixels par le nombre de pixels.

mask_ratio (`float`, *facultatif*, valeur par défaut 0,6) : Le ratio de jetons masqués dans l'entrée.

Ceci est la classe de configuration destinée à stocker la configuration d'un HieraModel. Elle est utilisée pour instancier un modèle Hiera 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/hiera-base-224](https://huggingface.co/facebook/hiera-base-224)

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 HieraConfig, HieraModel

>>> # Initializing a Hiera hiera-base-patch16-224 style configuration
>>> configuration = HieraConfig()

>>> # Initializing a model (with random weights) from the hiera-base-patch16-224 style configuration
>>> model = HieraModel(configuration)

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

## HieraModel[[transformers.HieraModel]]

#### transformers.HieraModel[[transformers.HieraModel]]

```python
transformers.HieraModel(config: HieraConfig, add_pooling_layer: bool = True, is_mae: bool = False)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/hiera/modeling_hiera.py#L800)

**Paramètres :**

config ([HieraConfig](/docs/transformers/main/fr/model_doc/hiera#transformers.HieraConfig)) : 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.

add_pooling_layer (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut appliquer la couche de pooling.

is_mae (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut exécuter le modèle en mode MAE.

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

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.HieraModel.forward]]

```python
forward(pixel_values: typing.Optional[torch.Tensor] = None, noise: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, interpolate_pos_encoding: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/hiera/modeling_hiera.py#L824)

**Paramètres :**

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

noise (`torch.Tensor` de forme `(batch_size, num_mask_units)`, *facultatif*) : Utilisé principalement à des fins de test pour contrôler l'aléatoire et maintenir la reproductibilité

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.

interpolate_pos_encoding (`bool`, *facultatif*) : Indique s'il faut interpoler les encodages de position pré-entraînés.

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 :** [BaseModelOutputWithPooling](/docs/transformers/main/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou `tuple(torch.Tensor)`

Un [BaseModelOutputWithPooling](/docs/transformers/main/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) 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 ([HieraConfig](/docs/transformers/main/fr/model_doc/hiera#transformers.HieraConfig)) et les entrées.

La méthode forward du modèle [HieraModel](/docs/transformers/main/fr/model_doc/hiera#transformers.HieraModel) 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.

- **last_hidden_state** (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`) -- Séquence d'états cachés à la sortie de la dernière couche du modèle.
- **pooler_output** (`torch.Tensor` de forme `(batch_size, hidden_size)`) -- État caché de la dernière couche du premier jeton de la séquence (jeton de classification) après un traitement supplémentaire par les couches utilisées pour la tâche de pré-entraînement auxiliaire. Par exemple, pour les modèles de la famille BERT, cela renvoie le jeton de classification après traitement par une couche linéaire et une fonction d'activation tanh. Les poids de la couche linéaire sont entraînés à partir de l'objectif de prédiction de la phrase suivante (classification) pendant le pré-entraînement.
- **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)`.

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

## HieraForPreTraining[[transformers.HieraForPreTraining]]

#### transformers.HieraForPreTraining[[transformers.HieraForPreTraining]]

```python
transformers.HieraForPreTraining(config: HieraConfig)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/hiera/modeling_hiera.py#L1061)

**Paramètres :**

config ([HieraConfig](/docs/transformers/main/fr/model_doc/hiera#transformers.HieraConfig)) : 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.

Le transformateur du modèle Hiera avec le décodeur en haut pour la pré-formation auto-supervisé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.HieraForPreTraining.forward]]

```python
forward(pixel_values: typing.Optional[torch.Tensor] = None, noise: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, interpolate_pos_encoding: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/hiera/modeling_hiera.py#L1102)

**Paramètres :**

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

noise (`torch.Tensor` de forme `(batch_size, num_mask_units)`, *facultatif*) : Utilisé principalement à des fins de test pour contrôler l'aléatoire et maintenir la reproductibilité

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.

interpolate_pos_encoding (`bool`, *facultatif*) : Indique s'il faut interpoler les encodages de position pré-entraînés.

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 :** `HieraForPreTrainingOutput` ou `tuple(torch.Tensor)`

Un `HieraForPreTrainingOutput` 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 ([HieraConfig](/docs/transformers/main/fr/model_doc/hiera#transformers.HieraConfig)) et les entrées.

La méthode forward de [HieraForPreTraining](/docs/transformers/main/fr/model_doc/hiera#transformers.HieraForPreTraining) 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,)`) -- Perte de reconstruction des pixels.
- **logits** (`torch.Tensor` de forme `(batch_size, sequence_length, patch_size ** 2 * num_channels)`) -- Logits de reconstruction des pixels.
- **bool_masked_pos** (`torch.BoolTensor` de forme `(batch_size, sequence_length)`) -- Tenseur indiquant quels patches sont masqués (0) et lesquels ne le sont pas (1).
- **ids_restore** (`torch.LongTensor` de forme `(batch_size, sequence_length)`) -- Tenseur contenant l'index d'origine des patches masqués (mélangé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)`.

  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.
- **reshaped_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 + un pour la sortie de chaque couche) de forme `(batch_size, height, width, hidden_size)`. États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'embeddings initiales, redimensionnés pour inclure les dimensions spatiales.

Exemples :
```python
>>> from transformers import AutoImageProcessor, HieraForPreTraining
>>> 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()))

>>> image_processor = AutoImageProcessor.from_pretrained("facebook/hiera-tiny-224-mae-hf")
>>> model = HieraForPreTraining.from_pretrained("facebook/hiera-tiny-224-mae-hf")

>>> inputs = image_processor(images=image, return_tensors="pt")

>>> outputs = model(**inputs)
>>> logits = outputs.logits
>>> loss = outputs.loss
>>> print(list(logits.shape))
[1, 196, 768]
```

## HieraForImageClassification[[transformers.HieraForImageClassification]]

#### transformers.HieraForImageClassification[[transformers.HieraForImageClassification]]

```python
transformers.HieraForImageClassification(config: HieraConfig)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/hiera/modeling_hiera.py#L1207)

**Paramètres :**

config ([HieraConfig](/docs/transformers/main/fr/model_doc/hiera#transformers.HieraConfig)) : 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.

Transformeur de modèle Hiera avec une tête de classification d'images au sommet (une couche linéaire au-dessus de l'état caché final avec un pooling moyen), par exemple pour ImageNet.

Notez qu'il est possible d'ajuster finement Hiera sur des images de résolution supérieure à celles utilisées pour son entraînement, en définissant `interpolate_pos_encoding` sur `True` dans le forward du modèle. Cela permet d'interpoler les embeddings de position pré-entraînés à la résolution supérieure.

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.HieraForImageClassification.forward]]

```python
forward(pixel_values, labels: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, interpolate_pos_encoding: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/hiera/modeling_hiera.py#L1222)

**Paramètres :**

pixel_values (`` of shape `(batch_size, num_channels, image_size, image_size)`) : The tensors corresponding to the input images. Pixel values can be obtained using [BitImageProcessor](/docs/transformers/main/fr/model_doc/bit#transformers.BitImageProcessor). See [BitImageProcessor.__call__()](/docs/transformers/main/fr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) for details (`processor_class` uses [BitImageProcessor](/docs/transformers/main/fr/model_doc/bit#transformers.BitImageProcessor) for processing images).

labels (`torch.LongTensor` de forme `(batch_size,)`, *facultatif*) : Étiquettes pour le calcul de la perte de classification/régression d'image. Les indices doivent être dans `[0, ..., config.num_labels - 1]`. Si `config.num_labels == 1`, une perte de régression est calculée (perte du carré moyen). Si `config.num_labels > 1`, une perte de classification est calculée (entropie croisée).

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.

interpolate_pos_encoding (`bool`, *facultatif*) : Indique s'il faut interpoler les encodages de position pré-entraînés.

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 :** `HieraForImageClassificationOutput` ou `tuple(torch.Tensor)`

Un `HieraForImageClassificationOutput` 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 ([HieraConfig](/docs/transformers/main/fr/model_doc/hiera#transformers.HieraConfig)) et les entrées.

La méthode forward de [HieraForImageClassification](/docs/transformers/main/fr/model_doc/hiera#transformers.HieraForImageClassification) 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).
- **logits** (`torch.Tensor` de forme `(batch_size, config.num_labels)`) -- Scores de classification (ou de régression si config.num_labels==1) (avant SoftMax).
- **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 étape) de forme `(batch_size, sequence_length, hidden_size)`. États cachés (également appelés cartes de caractéristiques) du modèle à la sortie de chaque étape.
- **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.
- **reshaped_hidden_states** (`tuple(torch.Tensor)`, `optional`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings + un pour la sortie de chaque étape) de forme `(batch_size, height, width, hidden_size)`. Il s'agit des états cachés du modèle, redimensionnés et re-roulés.

  États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d’incorporation initiales, redimensionnées pour inclure les dimensions spatiales.

Exemple :

```python
>>> from transformers import AutoImageProcessor, HieraForImageClassification
>>> import torch
>>> from datasets import load_dataset

>>> dataset = load_dataset("huggingface/cats-image")
>>> image = dataset["test"]["image"][0]

>>> image_processor = AutoImageProcessor.from_pretrained("facebook/hiera-base-224")
>>> model = HieraForImageClassification.from_pretrained("facebook/hiera-base-224")

>>> inputs = image_processor(image, return_tensors="pt")

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

>>> # model predicts one of the 1000 ImageNet classes
>>> predicted_label = logits.argmax(-1).item()
>>> print(model.config.id2label[predicted_label])
...
```