# SwiftFormer

## Visão geral

O modelo SwiftFormer foi proposto em [SwiftFormer: Efficient Additive Attention for Transformer-based Real-time Mobile Vision Applications](https://huggingface.co/papers/2303.15446) por Abdelrahman Shaker, Muhammad Maaz, Hanoona Rasheed, Salman Khan, Ming-Hsuan Yang, Fahad Shahbaz Khan.

O artigo SwiftFormer apresenta um novo mecanismo de atenção aditiva eficiente que substitui efetivamente as operações de multiplicação de matrizes quadráticas no cálculo da autoatenção por multiplicações elementares lineares. Com base nisso, é construída uma série de modelos chamada 'SwiftFormer', que atinge desempenho de estado da arte em termos de precisão e velocidade de inferência em dispositivos móveis. Mesmo sua variante pequena atinge 78,5% de precisão top-1 no ImageNet1K com apenas 0,8 ms de latência no iPhone 14, sendo mais precisa e 2× mais rápida em comparação com o MobileViT-v2.

O resumo do artigo é o seguinte:

*A autoatenção tornou-se a escolha padrão para capturar o contexto global em diversas aplicações de visão computacional. No entanto, sua complexidade computacional quadrática em relação à resolução da imagem limita seu uso em aplicações em tempo real, especialmente para implantação em dispositivos móveis com recursos limitados. Embora abordagens híbridas tenham sido propostas para combinar as vantagens das convoluções e da autoatenção para um melhor compromisso entre velocidade e precisão, as operações de multiplicação de matrizes caras na autoatenção permanecem como um gargalo. Neste trabalho, introduzimos um novo mecanismo de atenção aditiva eficiente que substitui efetivamente as operações de multiplicação de matrizes quadráticas por multiplicações elementares lineares. Nosso design demonstra que a interação chave-valor pode ser substituída por uma camada linear sem sacrificar nenhuma precisão. Diferentemente dos métodos state-of-the-art anteriores, nossa formulação eficiente da autoatenção permite seu uso em todos os estágios da rede. Usando nossa atenção aditiva eficiente proposta, construímos uma série de modelos chamados "SwiftFormer", que alcançam desempenho state-of-the-art em termos de precisão e velocidade de inferência móvel. Nossa variante pequena alcança 78,5% de precisão top-1 no ImageNet-1K com apenas 0,8 ms de latência no iPhone 14, sendo mais precisa e 2x mais rápida em comparação com o MobileViT-v2.*

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

## SwiftFormerConfig[[transformers.SwiftFormerConfig]]

#### transformers.SwiftFormerConfig[[transformers.SwiftFormerConfig]]

```python
transformers.SwiftFormerConfig(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, num_channels: int = 3, depths: list[int] | tuple[int, ...] = (3, 3, 6, 4), embed_dims: list[int] | tuple[int, ...] = (48, 56, 112, 220), mlp_ratio: int = 4, downsamples: list[bool] | tuple[bool, ...] = (True, True, True, True), hidden_act: str = 'gelu', down_patch_size: int | list[int] | tuple[int, int] = 3, down_stride: int = 2, down_pad: int = 1, drop_path_rate: float | int = 0.0, drop_mlp_rate: float | int = 0.0, drop_conv_encoder_rate: float | int = 0.0, use_layer_scale: bool = True, layer_scale_init_value: float = 1e-05, batch_norm_eps: float = 1e-05)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/swiftformer/configuration_swiftformer.py#L24)

**Parâmetros:**

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

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

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

embed_dims (`list[int]`, *opcional*, padrão `[48, 56, 112, 220]`) : A dimensão do embedding em cada etapa

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

downsamples (`list[bool]`, *opcional*, padrão `[True, True, True, True]`) : Se deve ou não reduzir a amostragem das entradas entre dois estágios.

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.

down_patch_size (`int`, *opcional*, padrão 3) : O tamanho dos patches nas camadas de downsampling.

down_stride (`int`, *opcional*, padrão 2) : O stride dos kernels de convolução nas camadas de downsampling.

down_pad (`int`, *opcional*, padrão 1) : Preenchimento nas camadas de downsampling.

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

drop_mlp_rate (`float`, *opcional*, padrão 0.0) : Taxa de dropout para o componente MLP do SwiftFormer.

drop_conv_encoder_rate (`float`, *opcional*, padrão 0.0) : Taxa de dropout para o componente ConvEncoder do SwiftFormer.

use_layer_scale (`bool`, *opcional*, padrão `True`) : Se deve escalar as saídas dos misturadores de tokens.

layer_scale_init_value (`float`, *opcional*, padrão `1e-05`) : Escala a ser usada nas camadas de autoatenção. 0.1 para base, 1e-6 para grande. Defina 0 para desativar a escala da camada.

batch_norm_eps (`float`, *opcional*, padrão `1e-05`) : O epsilon usado pelas camadas de normalização de lote.

Esta é a classe de configuração para armazenar a configuração de um SwiftFormerModel. Ela é usada para instanciar um modelo Swiftformer 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 [MBZUAI/swiftformer-xs](https://huggingface.co/MBZUAI/swiftformer-xs)

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 SwiftFormerConfig, SwiftFormerModel

>>> # Initializing a SwiftFormer swiftformer-base-patch16-224 style configuration
>>> configuration = SwiftFormerConfig()

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

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

## SwiftFormerModel[[transformers.SwiftFormerModel]]

#### transformers.SwiftFormerModel[[transformers.SwiftFormerModel]]

```python
transformers.SwiftFormerModel(config: SwiftFormerConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/swiftformer/modeling_swiftformer.py#L405)

**Parâmetros:**

config ([SwiftFormerConfig](/docs/transformers/main/pt/model_doc/swiftformer#transformers.SwiftFormerConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. Inicializar 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 modelo Swiftformer básico que produz estados ocultos brutos, sem nenhum head 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.SwiftFormerModel.forward]]

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

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/swiftformer/modeling_swiftformer.py#L416)

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

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

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

O método forward do [SwiftFormerModel](/docs/transformers/main/pt/model_doc/swiftformer#transformers.SwiftFormerModel) 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, num_channels, height, width)`) -- Sequência de estados ocultos na saída da última camada do modelo.
- **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, num_channels, height, width)`.

  Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.

Exemplo:

```python
```

## SwiftFormerForImageClassification[[transformers.SwiftFormerForImageClassification]]

#### transformers.SwiftFormerForImageClassification[[transformers.SwiftFormerForImageClassification]]

```python
transformers.SwiftFormerForImageClassification(config: SwiftFormerConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/swiftformer/modeling_swiftformer.py#L449)

**Parâmetros:**

config ([SwiftFormerConfig](/docs/transformers/main/pt/model_doc/swiftformer#transformers.SwiftFormerConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. Inicializar 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 modelo Swiftformer com uma cabeça de classificação de imagem no topo, 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.SwiftFormerForImageClassification.forward]]

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

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/swiftformer/modeling_swiftformer.py#L466)

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

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

Um [ImageClassifierOutputWithNoAttention](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.ImageClassifierOutputWithNoAttention) 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 ([SwiftFormerConfig](/docs/transformers/main/pt/model_doc/swiftformer#transformers.SwiftFormerConfig)) e das entradas.

O método forward de [SwiftFormerForImageClassification](/docs/transformers/main/pt/model_doc/swiftformer#transformers.SwiftFormerForImageClassification) 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 estágio) de forma `(batch_size, num_channels, height, width)`. Estados ocultos (também chamados de mapas de características) do modelo na saída de cada estágio.

Exemplo:

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("MBZUAI/swiftformer-xs")
>>> model = SwiftFormerForImageClassification.from_pretrained("MBZUAI/swiftformer-xs")

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