# Hiera

## Visão geral

Hiera foi proposto em [Hiera: A Hierarchical Vision Transformer without the Bells-and-Whistles](https://huggingface.co/papers/2306.00989) por 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

O artigo apresenta o "Hiera", um Vision Transformer hierárquico que simplifica a arquitetura dos transformadores de visão hierárquicos modernos ao remover componentes desnecessários sem comprometer a precisão ou a eficiência. Diferentemente dos transformadores tradicionais, que adicionam componentes específicos de visão complexos para melhorar o desempenho em classificação supervisionada, o Hiera demonstra que tais adições, frequentemente chamadas de "bells-and-whistles", não são essenciais para alta precisão. Ao aproveitar uma tarefa de pré-treino visual forte (MAE) para o pré-treino, o Hiera mantém a simplicidade e atinge precisão e velocidade superiores tanto na inferência quanto no treinamento em diversas tarefas de reconhecimento de imagem e vídeo. A abordagem sugere que os vieses espaciais necessários para tarefas de visão podem ser aprendidos efetivamente por meio de um pré-treino adequado, eliminando a necessidade de complexidade arquitetural adicional.

O resumo do artigo é o seguinte:

*Os transformers hierárquicos modernos de visão adicionaram vários componentes específicos de visão na busca por desempenho em classificação supervisionada. Embora esses componentes resultem em precisões eficazes e contagens de FLOP atraentes, a complexidade adicionada torna esses transformers, na prática, mais lentos do que seus equivalentes ViT puros. Neste artigo, argumentamos que esse acréscimo é desnecessário. Ao fazer pré-treino com uma tarefa visual de pretexto forte (MAE), podemos remover todos os recursos extras de um transformer de visão multiestágio de estado da arte sem perder precisão. No processo, criamos o Hiera, um transformer de visão hierárquico extremamente simples que é mais preciso do que modelos anteriores, sendo significativamente mais rápido tanto na inferência quanto durante o treinamento. Avaliamos o Hiera em uma variedade de tarefas para reconhecimento de imagem e vídeo. Nosso código e modelos estão disponíveis em 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"/>

 Arquitetura Hiera. Retirada do artigo original.

Este modelo foi uma contribuição conjunta de [EduardoPacheco](https://huggingface.co/EduardoPacheco) e [namangarg110](https://huggingface.co/namangarg110). O código original pode ser encontrado [aqui] (https://github.com/facebookresearch/hiera).

## Recursos

Uma lista de recursos oficiais do Hugging Face e da comunidade (indicados por 🌎) para ajudar você a começar com o Hiera. Se você tiver interesse em enviar um recurso para ser incluído aqui, sinta-se à vontade para abrir um Pull Request e faremos a revisão! O recurso deve, idealmente, demonstrar algo novo, em vez de duplicar um recurso existente.

- [HieraForImageClassification](/docs/transformers/main/pt/model_doc/hiera#transformers.HieraForImageClassification) é suportado por este [notebook](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/image_classification.ipynb).
- Veja também: [Guia da tarefa de classificação de imagens](../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)
```

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

**Parâmetros:**

embed_dim (`int`, *opcional*, padrão `96`) : Dimensionalidade dos embeddings e dos estados ocultos.

image_size (`Union[list[int], tuple[int, ...]]`, *opcional*, padrão `(224, 224)`) : O tamanho (resolução) de cada imagem.

patch_size (`Union[list[int], tuple[int, ...]]`, *opcional*, padrão `(7, 7)`) : O tamanho (resolução) de cada patch.

patch_stride (`list(int)`, *opcional*, padrão `[4, 4]`) : O stride do patch.

patch_padding (`list(int)`, *opcional*, padrão `[3, 3]`) : O padding do patch.

mlp_ratio (`float`, *opcional*, padrão `4.0`) : Razão entre a dimensão oculta do MLP e a dimensão de incorporação.

depths (`Union[list[int], tuple[int, ...]]`, *opcional*, padrão `(2, 3, 16, 3)`) : Profundidade de cada camada no Transformer.

num_heads (`list(int)`, *opcional*, padrão `[1, 2, 4, 8]`) : Número de cabeças de atenção em cada camada do codificador do Transformer.

embed_dim_multiplier (`float`, *opcional*, padrão 2.0) : O multiplicador da dimensionalidade da incorporação de patches em cada camada do codificador Transformer.

num_query_pool (`int`, *opcional*, padrão 3) : O número de estágios de pool de consultas.

query_stride (`list(int)`, *opcional*, padrão `[2, 2]`) : O stride do pool de consulta.

masked_unit_size (`list(int)`, *opcional*, padrão `[8, 8]`) : O tamanho da unidade mascarada.

masked_unit_attention (`list(bool)`, *opcional*, padrão `[True, True, False, False]`) : Se deve usar atenção unitária mascarada em cada camada do codificador do Transformer.

drop_path_rate (`Union[float, int]`, *opcional*, padrão `0.0`) : Taxa de drop path para a fusão de patches.

num_channels (`int`, *opcional*, padrão `3`) : O número de canais de entrada.

hidden_act (`str`, *opcional*, padrão `gelu`) : A função de ativação não linear (função ou string) no decodificador. Por exemplo, `"gelu"`, `"relu"`, `"silu"`, etc.

initializer_range (`float`, *opcional*, padrão `0.02`) : O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos.

layer_norm_init (`float`, *opcional*, padrão 1.0) : O valor inicial de peso para as camadas de normalização de camada.

layer_norm_eps (`float`, *opcional*, padrão `1e-06`) : O epsilon usado pelas camadas de normalização de camada.

decoder_hidden_size (`int`, *opcional*) : Dimensão das representações ocultas.

decoder_depth (`int`, *opcional*) : Profundidade do decodificador para o pré-treinamento MAE.

decoder_num_heads (`int`, *opcional*) : Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer.

normalize_pixel_loss (`bool`, *opcional*, padrão `True`) : Se normalizar a perda de pixels pelo número de pixels.

mask_ratio (`float`, *opcional*, padrão 0.6) : A proporção de tokens mascarados na entrada.

Esta é a classe de configuração para armazenar a configuração de um HieraModel. Ela é usada para instanciar um modelo Hiera de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do [facebook/hiera-base-224](https://huggingface.co/facebook/hiera-base-224)

Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações.

Exemplo:

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

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

**Parâmetros:**

config ([HieraConfig](/docs/transformers/main/pt/model_doc/hiera#transformers.HieraConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo.

add_pooling_layer (`bool`, *opcional*, padrão `True`) : Se deve ou não aplicar a camada de pooling.

is_mae (`bool`, *opcional*, padrão `False`) : Se o modelo deve ser executado no modo MAE.

O modelo Hiera puro, que produz estados ocultos brutos sem nenhum cabeçalho específico no topo.

Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.).

Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais.

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

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

**Parâmetros:**

pixel_values (`torch.Tensor` de forma `(batch_size, num_channels, image_size, image_size)`, *opcional*) : Os tensores correspondentes às imagens de entrada. Os valores de pixels podem ser obtidos usando [BitImageProcessor](/docs/transformers/main/pt/model_doc/bit#transformers.BitImageProcessor). Consulte [BitImageProcessor.__call__()](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para obter detalhes (`processor_class` usa [BitImageProcessor](/docs/transformers/main/pt/model_doc/bit#transformers.BitImageProcessor) para processar imagens).

noise (`torch.Tensor` de forma `(batch_size, num_mask_units)`, *opcional*) : Usado principalmente para fins de teste, para controlar a aleatoriedade e manter a reprodutibilidade

output_attentions (`bool`, *opcional*) : Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulte `attentions` nos tensores retornados para mais detalhes.

output_hidden_states (`bool`, *opcional*) : Indica se os estados ocultos de todas as camadas devem ser retornados. Consulte `hidden_states` em tensores retornados para mais detalhes.

interpolate_pos_encoding (`bool`, *opcional*) : Se deve interpolar as codificações de posição pré-treinadas.

return_dict (`bool`, *opcional*) : Se deve ou não retornar um [ModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.utils.ModelOutput) em vez de uma tupla simples.

**Retorna:** [BaseModelOutputWithPooling](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou `tuple(torch.Tensor)`

Um [BaseModelOutputWithPooling](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos dependendo da configuração ([HieraConfig](/docs/transformers/main/pt/model_doc/hiera#transformers.HieraConfig)) e das entradas.

O método forward do [HieraModel](/docs/transformers/main/pt/model_doc/hiera#transformers.HieraModel) substitui o método especial `__call__`.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de `Module` em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

- **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Sequência de estados ocultos na saída da última camada do modelo.
- **pooler_output** (`torch.Tensor` de forma `(batch_size, hidden_size)`) -- Estado oculto da última camada do primeiro token da sequência (token de classificação) após processamento adicional pelas camadas usadas para a tarefa de pré-treinamento auxiliar. Por exemplo, para modelos da família BERT, isso retorna o token de classificação após o processamento por uma camada linear e uma função de ativação tanh. Os pesos da camada linear são treinados a partir do objetivo de previsão da próxima frase (classificação) durante o pré-treinamento.
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.
- **attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.

Exemplo:

```python
```

## HieraForPreTraining[[transformers.HieraForPreTraining]]

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

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

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

**Parâmetros:**

config ([HieraConfig](/docs/transformers/main/pt/model_doc/hiera#transformers.HieraConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo.

O transformer do modelo Hiera com o decoder no topo para pré-treinamento auto-supervisionado.

Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.).

Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais.

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

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

**Parâmetros:**

pixel_values (`torch.Tensor` de forma `(batch_size, num_channels, image_size, image_size)`, *opcional*) : Os tensores correspondentes às imagens de entrada. Os valores de pixels podem ser obtidos usando [BitImageProcessor](/docs/transformers/main/pt/model_doc/bit#transformers.BitImageProcessor). Consulte [BitImageProcessor.__call__()](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para obter detalhes (`processor_class` usa [BitImageProcessor](/docs/transformers/main/pt/model_doc/bit#transformers.BitImageProcessor) para processar imagens).

noise (`torch.Tensor` de forma `(batch_size, num_mask_units)`, *opcional*) : Usado principalmente para fins de teste, para controlar a aleatoriedade e manter a reprodutibilidade

output_attentions (`bool`, *opcional*) : Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulte `attentions` nos tensores retornados para mais detalhes.

output_hidden_states (`bool`, *opcional*) : Indica se os estados ocultos de todas as camadas devem ser retornados. Consulte `hidden_states` em tensores retornados para mais detalhes.

interpolate_pos_encoding (`bool`, *opcional*) : Se deve interpolar as codificações de posição pré-treinadas.

return_dict (`bool`, *opcional*) : Se deve ou não retornar um [ModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.utils.ModelOutput) em vez de uma tupla simples.

**Retorna:** `HieraForPreTrainingOutput` ou `tuple(torch.Tensor)`

Um `HieraForPreTrainingOutput` ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos, dependendo da configuração ([HieraConfig](/docs/transformers/main/pt/model_doc/hiera#transformers.HieraConfig)) e das entradas.

O método forward de [HieraForPreTraining](/docs/transformers/main/pt/model_doc/hiera#transformers.HieraForPreTraining) substitui o método especial `__call__`.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de `Module` em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

- **loss** (`torch.Tensor` de forma `(1,)`) -- Perda de reconstrução de pixels.
- **logits** (`torch.Tensor` de forma `(batch_size, sequence_length, patch_size ** 2 * num_channels)`) -- Logits de reconstrução de pixels.
- **bool_masked_pos** (`torch.BoolTensor` de forma `(batch_size, sequence_length)`) -- Tensor que indica quais patches estão mascarados (0) e quais não estão (1).
- **ids_restore** (`torch.LongTensor` de forma `(batch_size, sequence_length)`) -- Tensor contendo o índice original dos patches mascarados (embaralhados).
- **hidden_states** (`tuple[torch.Tensor]`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) de forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.
- **attentions** (`tuple[torch.Tensor]`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.
- **reshaped_hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings + um para a saída de cada camada) com forma `(batch_size, height, width, hidden_size)`. Hidden-states do modelo na saída de cada camada, além das saídas dos embeddings iniciais, remodelados para incluir as dimensões espaciais.

Exemplos:
```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)
```

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

**Parâmetros:**

config ([HieraConfig](/docs/transformers/main/pt/model_doc/hiera#transformers.HieraConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo.

Modelo Hiera transformer com uma cabeça de classificação de imagem no topo (uma camada linear no topo do estado oculto final com pooling médio), por exemplo, para ImageNet.

Observe que é possível fazer o fine-tuning do Hiera em imagens de resolução mais alta do que aquelas em que ele foi treinado, definindo `interpolate_pos_encoding` como `True` no forward do modelo. Isso interpola os embeddings de posição pré-treinados para a resolução mais alta.

Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.).

Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais.

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

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

**Parâmetros:**

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/pt/model_doc/bit#transformers.BitImageProcessor). See [BitImageProcessor.__call__()](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) for details (`processor_class` uses [BitImageProcessor](/docs/transformers/main/pt/model_doc/bit#transformers.BitImageProcessor) for processing images).

labels (`torch.LongTensor` de forma `(batch_size,)`, *opcional*) : Rótulos para o cálculo da perda de classificação/regressão de imagem. Os índices devem estar em `[0, ..., config.num_labels - 1]`. Se `config.num_labels == 1`, uma perda de regressão é calculada (perda de erro quadrático médio). Se `config.num_labels > 1`, uma perda de classificação é calculada (entropia cruzada).

output_attentions (`bool`, *opcional*) : Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulte `attentions` nos tensores retornados para mais detalhes.

output_hidden_states (`bool`, *opcional*) : Indica se os estados ocultos de todas as camadas devem ser retornados. Consulte `hidden_states` em tensores retornados para mais detalhes.

interpolate_pos_encoding (`bool`, *opcional*) : Se deve interpolar as codificações de posição pré-treinadas.

return_dict (`bool`, *opcional*) : Se deve ou não retornar um [ModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.utils.ModelOutput) em vez de uma tupla simples.

**Retorna:** `HieraForImageClassificationOutput` ou `tuple(torch.Tensor)`

Um `HieraForImageClassificationOutput` ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos, dependendo da configuração ([HieraConfig](/docs/transformers/main/pt/model_doc/hiera#transformers.HieraConfig)) e das entradas.

O método forward de [HieraForImageClassification](/docs/transformers/main/pt/model_doc/hiera#transformers.HieraForImageClassification) substitui o método especial `__call__`.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de `Module` em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

- **loss** (`torch.Tensor` de forma `(1,)`, *opcional*, retornado quando `labels` é fornecido) -- Perda de classificação (ou de regressão se config.num_labels==1).
- **logits** (`torch.Tensor` de forma `(batch_size, config.num_labels)`) -- Pontuações de classificação (ou regressão, se config.num_labels==1) (antes do SoftMax).
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (uma para a saída dos embeddings, se o modelo tiver uma camada de embedding, + uma para a saída de cada estágio) de forma `(batch_size, sequence_length, hidden_size)`. Hidden-states (também chamados de feature maps) do modelo na saída de cada estágio.
- **attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (uma para cada camada) de forma `(batch_size, num_heads, patch_size, sequence_length)`.

  Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.
- **reshaped_hidden_states** (`tuple(torch.Tensor)`, `optional`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings + um para a saída de cada estágio) com forma `(batch_size, height, width, hidden_size)`. Estes são os estados ocultos do modelo redimensionados e reorganizados.

  Estados ocultos do modelo na saída de cada camada, mais as saídas do embedding inicial, redimensionados para incluir as dimensões espaciais.

Exemplo:

```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])
...
```