# Swin Transformer

O [Swin Transformer](https://huggingface.co/papers/2103.14030) é um transformer de visão hierárquico. As imagens são processadas em patches e a autoatenção com janelas é utilizada para capturar informações locais. Essas janelas são deslocadas pela imagem para permitir conexões entre janelas, capturando informações globais de forma mais eficiente. Essa abordagem hierárquica com janelas deslocadas permite que o Swin Transformer processe imagens de forma eficaz em diferentes escalas e alcance complexidade computacional linear em relação ao tamanho da imagem, tornando-o um backbone versátil para diversas tarefas de visão, como classificação de imagens e detecção de objetos.

Você pode encontrar todos os checkpoints oficiais do Swin Transformer na organização [Microsoft](https://huggingface.co/microsoft?search_models=swin).

> [!TIP]
> Clique nos modelos Swin Transformer na barra lateral à direita para ver mais exemplos de como aplicar o Swin Transformer a diferentes tarefas de imagem.

O exemplo abaixo demonstra como classificar uma imagem com [Pipeline](/docs/transformers/main/pt/main_classes/pipelines#transformers.Pipeline) ou a classe [AutoModel](/docs/transformers/main/pt/model_doc/auto#transformers.AutoModel).

```python
from transformers import pipeline

pipeline = pipeline(
    task="image-classification",
    model="microsoft/swin-tiny-patch4-window7-224",
    device=0
)
pipeline("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg")
```

```python
import requests
import torch
from PIL import Image

from transformers import AutoImageProcessor, AutoModelForImageClassification

image_processor = AutoImageProcessor.from_pretrained(
    "microsoft/swin-tiny-patch4-window7-224",
    use_fast=True,
)
model = AutoModelForImageClassification.from_pretrained(
    "microsoft/swin-tiny-patch4-window7-224",
    device_map="auto"
)

url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"
image = Image.open(requests.get(url, stream=True).raw)
inputs = image_processor(image, return_tensors="pt").to(model.device)

with torch.no_grad():
  logits = model(**inputs).logits
predicted_class_id = logits.argmax(dim=-1).item()

class_labels = model.config.id2label
predicted_class_label = class_labels[predicted_class_id]
print(f"The predicted class label is: {predicted_class_label}")
```

## Observações

- O Swin pode aplicar padding em entradas para qualquer altura e largura de entrada divisível por `32`.
- O Swin pode ser usado como [backbone](../backbones). Quando `output_hidden_states = True`, ele produz tanto `hidden_states` quanto `reshaped_hidden_states`. O `reshaped_hidden_states` tem a forma `(batch, num_channels, height, width)` em vez de `(batch_size, sequence_length, num_channels)`.

## SwinConfig[[transformers.SwinConfig]]

#### transformers.SwinConfig[[transformers.SwinConfig]]

```python
transformers.SwinConfig(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, depths: list[int] | tuple[int, ...] = (2, 2, 6, 2), num_heads: list[int] | tuple[int, ...] = (3, 6, 12, 24), window_size: int = 7, mlp_ratio: float | int = 4.0, qkv_bias: bool = True, hidden_dropout_prob: float | int = 0.0, attention_probs_dropout_prob: float | int = 0.0, drop_path_rate: float | int = 0.1, hidden_act: str = 'gelu', use_absolute_embeddings: 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/swin/configuration_swin.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.

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

num_heads (`list(int)`, *opcional*, padrão `[3, 6, 12, 24]`) : Número de cabeças de atenção em cada camada do codificador do Transformer.

window_size (`int`, *opcional*, padrão 7) : Tamanho das janelas.

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

qkv_bias (`bool`, *opcional*, padrão `True`) : Se deve adicionar um viés às queries, keys e values.

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

attention_probs_dropout_prob (`Union[float, int]`, *opcional*, padrão `0.0`) : A taxa de dropout para as probabilidades de atenção.

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

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.

use_absolute_embeddings (`bool`, *opcional*, padrão `False`) : Se deve usar embeddings de posição absoluta.

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 SwinModel. Ela é usada para instanciar um modelo Swin 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/swin-tiny-patch4-window7-224](https://huggingface.co/microsoft/swin-tiny-patch4-window7-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 SwinConfig, SwinModel

>>> # Initializing a Swin microsoft/swin-tiny-patch4-window7-224 style configuration
>>> configuration = SwinConfig()

>>> # Initializing a model (with random weights) from the microsoft/swin-tiny-patch4-window7-224 style configuration
>>> model = SwinModel(configuration)

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

## SwinModel[[transformers.SwinModel]]

#### transformers.SwinModel[[transformers.SwinModel]]

```python
transformers.SwinModel(config: SwinConfig, add_pooling_layer = True, use_mask_token = False)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/swin/modeling_swin.py#L825)

**Parâmetros:**

config ([SwinConfig](/docs/transformers/main/pt/model_doc/swin#transformers.SwinConfig)) : 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.

use_mask_token (`bool`, *opcional*, padrão `False`) : Se deve ou não criar e aplicar tokens de máscara na camada de incorporação.

O modelo Swin básico 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.SwinModel.forward]]

```python
forward(pixel_values: typing.Optional[torch.Tensor] = None, bool_masked_pos: typing.Optional[torch.BoolTensor] = None, interpolate_pos_encoding: bool = False, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/swin/modeling_swin.py#L847)

**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 [ViTImageProcessor](/docs/transformers/main/pt/model_doc/vit#transformers.ViTImageProcessor). Consulte [ViTImageProcessor.__call__()](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para obter detalhes (`processor_class` usa [ViTImageProcessor](/docs/transformers/main/pt/model_doc/vit#transformers.ViTImageProcessor) para processar imagens).

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

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

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

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

O método forward do [SwinModel](/docs/transformers/main/pt/model_doc/swin#transformers.SwinModel) 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` (uma para a saída dos embeddings, se o modelo tiver uma camada de embedding, + uma 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` (uma para cada camada) de 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 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
```

## SwinForMaskedImageModeling[[transformers.SwinForMaskedImageModeling]]

#### transformers.SwinForMaskedImageModeling[[transformers.SwinForMaskedImageModeling]]

```python
transformers.SwinForMaskedImageModeling(config: SwinConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/swin/modeling_swin.py#L897)

**Parâmetros:**

config ([SwinConfig](/docs/transformers/main/pt/model_doc/swin#transformers.SwinConfig)) : 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 Swin com um decodificador no topo para modelagem de imagem mascarada, conforme proposto em [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.SwinForMaskedImageModeling.forward]]

```python
forward(pixel_values: typing.Optional[torch.Tensor] = None, bool_masked_pos: typing.Optional[torch.BoolTensor] = None, interpolate_pos_encoding: bool = False, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/swin/modeling_swin.py#L914)

**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 [ViTImageProcessor](/docs/transformers/main/pt/model_doc/vit#transformers.ViTImageProcessor). Consulte [ViTImageProcessor.__call__()](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para obter detalhes (`processor_class` usa [ViTImageProcessor](/docs/transformers/main/pt/model_doc/vit#transformers.ViTImageProcessor) 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).

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

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

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

O método forward de [SwinForMaskedImageModeling](/docs/transformers/main/pt/model_doc/swin#transformers.SwinForMaskedImageModeling) 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 `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` (uma para a saída dos embeddings, se o modelo tiver uma camada de embedding, + uma 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` (uma para cada camada) de 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 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, SwinForMaskedImageModeling
>>> 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/swin-base-simmim-window6-192")
>>> model = SwinForMaskedImageModeling.from_pretrained("microsoft/swin-base-simmim-window6-192")

>>> 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.reconstruction
>>> list(reconstructed_pixel_values.shape)
[1, 3, 192, 192]
```

## SwinForImageClassification[[transformers.SwinForImageClassification]]

#### transformers.SwinForImageClassification[[transformers.SwinForImageClassification]]

```python
transformers.SwinForImageClassification(config: SwinConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/swin/modeling_swin.py#L1005)

**Parâmetros:**

config ([SwinConfig](/docs/transformers/main/pt/model_doc/swin#transformers.SwinConfig)) : 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 transformer Swin com uma cabeça de classificação de imagem no topo (uma camada linear no topo do estado oculto final do token [CLS]), por exemplo, para o ImageNet.

Observe que é possível fazer o ajuste fino do Swin em imagens de resolução maior do que aquelas em que ele foi treinado, definindo `interpolate_pos_encoding` como `True` no forward do modelo. Isso interpolará 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.SwinForImageClassification.forward]]

```python
forward(pixel_values: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, interpolate_pos_encoding: bool = False, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/swin/modeling_swin.py#L1020)

**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 [ViTImageProcessor](/docs/transformers/main/pt/model_doc/vit#transformers.ViTImageProcessor). Consulte [ViTImageProcessor.__call__()](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para obter detalhes (`processor_class` usa [ViTImageProcessor](/docs/transformers/main/pt/model_doc/vit#transformers.ViTImageProcessor) 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).

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

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

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

O método forward de [SwinForImageClassification](/docs/transformers/main/pt/model_doc/swin#transformers.SwinForImageClassification) 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` (uma para a saída dos embeddings, se o modelo tiver uma camada de embedding, + uma 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` (uma para cada camada) de 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 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, SwinForImageClassification
>>> import torch
>>> from datasets import load_dataset

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

>>> image_processor = AutoImageProcessor.from_pretrained("microsoft/swin-tiny-patch4-window7-224")
>>> model = SwinForImageClassification.from_pretrained("microsoft/swin-tiny-patch4-window7-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])
...
```