# FocalNet

## Visão geral

O modelo FocalNet foi proposto em [Focal Modulation Networks](https://huggingface.co/papers/2203.11926) por Jianwei Yang, Chunyuan Li, Xiyang Dai, Lu Yuan e Jianfeng Gao. Os FocalNets substituem completamente a autoatenção (usada em modelos como [ViT](vit) e [Swin](swin)) por um mecanismo de modulação focal para modelar as interações entre tokens em visão. Os autores afirmam que os FocalNets superam modelos baseados em autoatenção com custos computacionais semelhantes nas tarefas de classificação de imagem, detecção de objetos e segmentação.

O resumo do artigo é o seguinte:

*Propomos as redes de modulação focal (FocalNets, em breve), nas quais a autoatenção (SA) é completamente substituída por um mecanismo de modulação focal para modelar as interações entre tokens em visão. A modulação focal compreende três componentes: (i) contextualização hierárquica, implementada usando uma pilha de camadas de convolução em profundidade, para codificar contextos visuais de curto a longo alcance, (ii) agregação com gate para coletar seletivamente contextos para cada token de consulta com base em seu conteúdo, e (iii) modulação elemento a elemento ou transformação afim para injetar o contexto agregado na consulta. Experimentos extensivos mostram que os FocalNets superam os equivalentes de SA do estado da arte (por exemplo, Swin e Focal Transformers) com custos computacionais semelhantes nas tarefas de classificação de imagem, detecção de objetos e segmentação. Especificamente, os FocalNets com tamanho tiny e base alcançam 82,3% e 83,9% de precisão top-1 no ImageNet-1K. Após o pré-treinamento no ImageNet-22K em resolução 224, ele atinge 86,5% e 87,3% de precisão top-1 quando ajustado com resolução 224 e 384, respectivamente. Quando transferidos para tarefas de baixo nível, os FocalNets exibem superioridade clara. Para detecção de objetos com Mask R-CNN, o FocalNet base treinado com 1\times supera o equivalente Swin em 2,1 pontos e já supera o Swin treinado com agendamento 3\times (49,0 v.s. 48,5). Para segmentação semântica com UPerNet, o FocalNet base em escala única supera o Swin em 2,4 e vence o Swin em multi-escala (50,5 v.s. 49,7). Usando o FocalNet grande e o Mask2former, alcançamos 58,5 mIoU para segmentação semântica ADE20K e 57,9 PQ para Segmentação Panóptica COCO. Usando o FocalNet enorme e o DINO, alcançamos 64,3 e 64,4 mAP no COCO minival e test-dev, respectivamente, estabelecendo novo SoTA em cima de modelos baseados em atenção muito maiores, como Swinv2-G e BEIT-3.*

Este modelo foi contribuído por [nielsr](https://huggingface.co/nielsr). O código original pode ser encontrado [aqui](https://github.com/microsoft/FocalNet).

## FocalNetConfig[[transformers.FocalNetConfig]]

#### transformers.FocalNetConfig[[transformers.FocalNetConfig]]

```python
transformers.FocalNetConfig(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, image_size: int | list[int] | tuple[int, int] = 224, patch_size: int | list[int] | tuple[int, int] = 4, num_channels: int = 3, embed_dim: int = 96, use_conv_embed: bool = False, hidden_sizes: list[int] | tuple[int, ...] = (192, 384, 768, 768), depths: list[int] | tuple[int, ...] = (2, 2, 6, 2), focal_levels: list[int] | tuple[int, ...] = (2, 2, 2, 2), focal_windows: list[int] | tuple[int, ...] = (3, 3, 3, 3), hidden_act: str = 'gelu', mlp_ratio: float = 4.0, hidden_dropout_prob: float | int = 0.0, drop_path_rate: float | int = 0.1, use_layerscale: bool = False, layerscale_value: float = 0.0001, use_post_layernorm: bool = False, use_post_layernorm_in_modulation: bool = False, normalize_modulator: bool = False, initializer_range: float = 0.02, layer_norm_eps: float = 1e-05, encoder_stride: int = 32, _out_features: list[str] | None = None, _out_indices: list[int] | None = None)
```

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

**Parâmetros:**

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

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

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

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

use_conv_embed (`bool`, *opcional*, padrão `False`) : Se deve usar incorporação convolucional. Os autores observaram que o uso de incorporação convolucional geralmente melhora o desempenho, mas não é usado por padrão.

hidden_sizes (`Union[list[int], tuple[int, ...]]`, *opcional*, padrão `(192, 384, 768, 768)`) : Dimensionalidade (tamanho oculto) em cada etapa do modelo.

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

focal_levels (`list(int)`, *opcional*, padrão `[2, 2, 2, 2]`) : Número de níveis focais em cada camada dos respectivos estágios no codificador.

focal_windows (`list(int)`, *opcional*, padrão `[3, 3, 3, 3]`) : Tamanho da janela focal em cada camada dos respectivos estágios no codificador.

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.

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

hidden_dropout_prob (`float`, *opcional*, padrão 0.0) : A probabilidade de dropout para todas as camadas totalmente conectadas nos embeddings e no codificador.

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

use_layerscale (`bool`, *opcional*, padrão `False`) : Se deve usar layer scale no encoder.

layerscale_value (`float`, *opcional*, padrão 0.0001) : O valor inicial da escala da camada.

use_post_layernorm (`bool`, *opcional*, padrão `False`) : Se deve usar a normalização pós-camada no codificador.

use_post_layernorm_in_modulation (`bool`, *opcional*, padrão `False`) : Se deve usar a normalização pós-camada na camada de modulação.

normalize_modulator (`bool`, *opcional*, padrão `False`) : Se deve normalizar o modulador.

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_eps (`float`, *opcional*, padrão `1e-05`) : O epsilon usado pelas camadas de normalização de camada.

encoder_stride (`int`, *opcional*, padrão 32) : Fator para aumentar a resolução espacial no cabeçalho do decodificador para modelagem de imagens mascaradas.

Esta é a classe de configuração para armazenar a configuração de um FocalNetModel. Ela é usada para instanciar um modelo Focalnet 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 [microsoft/focalnet-tiny](https://huggingface.co/microsoft/focalnet-tiny)

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 FocalNetConfig, FocalNetModel

>>> # Initializing a FocalNet microsoft/focalnet-tiny style configuration
>>> configuration = FocalNetConfig()

>>> # Initializing a model (with random weights) from the microsoft/focalnet-tiny style configuration
>>> model = FocalNetModel(configuration)

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

## FocalNetModel[[transformers.FocalNetModel]]

#### transformers.FocalNetModel[[transformers.FocalNetModel]]

```python
transformers.FocalNetModel(config: FocalNetConfig, add_pooling_layer = True, use_mask_token = False)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/focalnet/modeling_focalnet.py#L592)

**Parâmetros:**

config ([FocalNetConfig](/docs/transformers/main/pt/model_doc/focalnet#transformers.FocalNetConfig)) : 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 adicionar uma camada de pooling

use_mask_token (`bool`, *opcional*, padrão `False`) : Se deve usar um token de máscara para modelagem de imagem mascarada.

O modelo Focalnet 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.FocalNetModel.forward]]

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

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/focalnet/modeling_focalnet.py#L617)

**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).

bool_masked_pos (`torch.BoolTensor` de forma `(batch_size, num_patches)`) : Posições mascaradas booleanas. Indica quais patches estão mascarados (1) e quais não estão (0).

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.

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

Um `FocalNetModelOutput` 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 ([FocalNetConfig](/docs/transformers/main/pt/model_doc/focalnet#transformers.FocalNetConfig)) e das entradas.

O método forward do [FocalNetModel](/docs/transformers/main/pt/model_doc/focalnet#transformers.FocalNetModel) 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)`, *opcional*) -- Sequência de hidden-states na saída da última camada do modelo.
- **pooler_output** (`torch.Tensor` de forma `(batch_size, hidden_size)`, *opcional*, retornado quando `add_pooling_layer=True` é passado) -- Pooling médio do estado oculto da última camada.
- **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.
- **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 estágio) com forma `(batch_size, hidden_size, height, width)`.

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

## FocalNetForMaskedImageModeling[[transformers.FocalNetForMaskedImageModeling]]

#### transformers.FocalNetForMaskedImageModeling[[transformers.FocalNetForMaskedImageModeling]]

```python
transformers.FocalNetForMaskedImageModeling(config: FocalNetConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/focalnet/modeling_focalnet.py#L675)

**Parâmetros:**

config ([FocalNetConfig](/docs/transformers/main/pt/model_doc/focalnet#transformers.FocalNetConfig)) : 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 FocalNet com um decodificador no topo para modelagem de imagem mascarada.

Isso segue a mesma implementação do [SimMIM](https://huggingface.co/papers/2111.09886).

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

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

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/focalnet/modeling_focalnet.py#L693)

**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).

bool_masked_pos (`torch.BoolTensor` de forma `(batch_size, num_patches)`) : Posições mascaradas booleanas. Indica quais patches estão mascarados (1) e quais não estão (0).

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.

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

Um `FocalNetMaskedImageModelingOutput` 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 ([FocalNetConfig](/docs/transformers/main/pt/model_doc/focalnet#transformers.FocalNetConfig)) e das entradas.

O método forward de [FocalNetForMaskedImageModeling](/docs/transformers/main/pt/model_doc/focalnet#transformers.FocalNetForMaskedImageModeling) 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 `bool_masked_pos` é fornecido) -- Perda de modelagem de imagem mascarada (MLM).
- **reconstrução** (`torch.Tensor` de forma `(batch_size, num_channels, height, width)`) -- Valores de pixels reconstruídos.
- **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.
- **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 estágio) com forma `(batch_size, hidden_size, height, width)`.

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

Exemplos:
```python
>>> from transformers import AutoImageProcessor, FocalNetConfig, FocalNetForMaskedImageModeling
>>> 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("microsoft/focalnet-base-simmim-window6-192")
>>> config = FocalNetConfig()
>>> model = FocalNetForMaskedImageModeling(config)

>>> num_patches = (model.config.image_size // model.config.patch_size) ** 2
>>> pixel_values = image_processor(images=image, return_tensors="pt").pixel_values
>>> # create random boolean mask of shape (batch_size, num_patches)
>>> bool_masked_pos = torch.randint(low=0, high=2, size=(1, num_patches)).bool()

>>> outputs = model(pixel_values, bool_masked_pos=bool_masked_pos)
>>> loss, reconstructed_pixel_values = outputs.loss, outputs.logits
>>> list(reconstructed_pixel_values.shape)
[1, 3, 192, 192]
```

## FocalNetForImageClassification[[transformers.FocalNetForImageClassification]]

#### transformers.FocalNetForImageClassification[[transformers.FocalNetForImageClassification]]

```python
transformers.FocalNetForImageClassification(config: FocalNetConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/focalnet/modeling_focalnet.py#L782)

**Parâmetros:**

config ([FocalNetConfig](/docs/transformers/main/pt/model_doc/focalnet#transformers.FocalNetConfig)) : 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 FocalNet com uma cabeça de classificação de imagem no topo (uma camada linear sobre a saída agregada), por exemplo, para o ImageNet.

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

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

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/focalnet/modeling_focalnet.py#L798)

**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).

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_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.

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

Um `FocalNetImageClassifierOutput` 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 ([FocalNetConfig](/docs/transformers/main/pt/model_doc/focalnet#transformers.FocalNetConfig)) e das entradas.

O método forward de [FocalNetForImageClassification](/docs/transformers/main/pt/model_doc/focalnet#transformers.FocalNetForImageClassification) sobrescreve 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` (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.
- **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 estágio) com forma `(batch_size, hidden_size, height, width)`.

  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, FocalNetForImageClassification
>>> import torch
>>> from datasets import load_dataset

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

>>> image_processor = AutoImageProcessor.from_pretrained("microsoft/focalnet-tiny")
>>> model = FocalNetForImageClassification.from_pretrained("microsoft/focalnet-tiny")

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