# Convolutional Vision Transformer (CvT)

[Convolutional Vision Transformer (CvT)](https://huggingface.co/papers/2103.15808) é um modelo que combina as vantagens das redes neurais convolucionais (CNNs) e dos Vision Transformers para tarefas de visão computacional. Ele introduz camadas convolucionais na arquitetura do Vision Transformer, permitindo que capture padrões locais nas imagens enquanto mantém o contexto global fornecido pelos mecanismos de autoatenção.

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

> [!TIP]
> Este modelo foi contribuído por [anujunj](https://huggingface.co/anugunj).
>
> Clique nos modelos CvT na barra lateral à direita para ver mais exemplos de como aplicar o CvT a diferentes tarefas de visão computacional.

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/cvt-13",
    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/cvt-13")
model = AutoModelForImageClassification.from_pretrained(
    "microsoft/cvt-13",
    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}")
```

## Recursos

Consulte este conjunto de [notebooks](https://github.com/NielsRogge/Transformers-Tutorials/tree/master/VisionTransformer) de ViT para exemplos de inferência e ajuste fino em conjuntos de dados personalizados. Substitua `ViTFeatureExtractor` e [ViTForImageClassification](/docs/transformers/main/pt/model_doc/vit#transformers.ViTForImageClassification) nesses notebooks por [AutoImageProcessor](/docs/transformers/main/pt/model_doc/auto#transformers.AutoImageProcessor) e [CvtForImageClassification](/docs/transformers/main/pt/model_doc/cvt#transformers.CvtForImageClassification).

## CvtConfig[[transformers.CvtConfig]]

#### transformers.CvtConfig[[transformers.CvtConfig]]

```python
transformers.CvtConfig(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, num_channels: int = 3, patch_sizes: list[int] | tuple[int, ...] = (7, 3, 3), patch_stride: list[int] | tuple[int, ...] = (4, 2, 2), patch_padding: list[int] | tuple[int, ...] = (2, 1, 1), embed_dim: list[int] | tuple[int, ...] = (64, 192, 384), num_heads: list[int] | tuple[int, ...] = (1, 3, 6), depth: list[int] | tuple[int, ...] = (1, 2, 10), mlp_ratio: list[float] | tuple[float, ...] = (4.0, 4.0, 4.0), attention_drop_rate: list[float] | tuple[float, ...] = (0.0, 0.0, 0.0), drop_rate: list[float] | tuple[float, ...] = (0.0, 0.0, 0.0), drop_path_rate: list[float] | tuple[float, ...] = (0.0, 0.0, 0.1), qkv_bias: list[bool] | tuple[bool, ...] = (True, True, True), cls_token: list[bool] | tuple[bool, ...] = (False, False, True), qkv_projection_method: list[str] | tuple[str, ...] = ('dw_bn', 'dw_bn', 'dw_bn'), kernel_qkv: list[int] | tuple[int, ...] = (3, 3, 3), padding_kv: list[int] | tuple[int, ...] = (1, 1, 1), stride_kv: list[int] | tuple[int, ...] = (2, 2, 2), padding_q: list[int] | tuple[int, ...] = (1, 1, 1), stride_q: list[int] | tuple[int, ...] = (1, 1, 1), initializer_range: float = 0.02, layer_norm_eps: float = 1e-12)
```

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

**Parâmetros:**

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

patch_sizes (`Union[list[int], tuple[int, ...]]`, *opcional*, padrão `(7, 3, 3)`) : Tamanho do patch em cada estágio do modelo.

patch_stride (`list[int]`, *opcional*, padrão `[4, 2, 2]`) : O tamanho do stride de cada patch embedding do encoder.

patch_padding (`list[int]`, *opcional*, padrão `[2, 1, 1]`) : O tamanho do padding de cada patch embedding do encoder.

embed_dim (`Union[list[int], tuple[int, ...]]`, *opcional*, padrão `(64, 192, 384)`) : Dimensionalidade dos embeddings e dos estados ocultos.

num_heads (`Union[list[int], tuple[int, ...]]`, *opcional*, padrão `(1, 3, 6)`) : Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer.

depth (`list[int]`, *opcional*, padrão `[1, 2, 10]`) : O número de camadas em cada bloco do codificador.

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

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

drop_rate (`list[float]`, *opcional*, padrão `[0.0, 0.0, 0.0]`) : A taxa de dropout para as probabilidades dos embeddings de patch.

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

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

cls_token (`list[bool]`, *opcional*, padrão `[False, False, True]`) : Indica se um token de classificação deve ser adicionado à saída de cada uma das 3 últimas etapas.

qkv_projection_method (`list[string]`, *opcional*, padrão ["dw_bn", "dw_bn", "dw_bn"]`) : O método de projeção para query, key e value. O padrão é convoluções depth-wise com batch norm. Para projeção Linear, use "avg".

kernel_qkv (`list[int]`, *opcional*, padrão `[3, 3, 3]`) : O tamanho do kernel para query, key e value na camada de atenção

padding_kv (`list[int]`, *opcional*, padrão `[1, 1, 1]`) : O tamanho do padding para chave e valor na camada de atenção

stride_kv (`list[int]`, *opcional*, padrão `[2, 2, 2]`) : O tamanho do stride para chave e valor na camada de atenção

padding_q (`list[int]`, *opcional*, padrão `[1, 1, 1]`) : O tamanho do padding para a query na camada de atenção

stride_q (`list[int]`, *opcional*, padrão `[1, 1, 1]`) : O tamanho do stride para a query na camada de atenção

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-12`) : O epsilon usado pelas camadas de normalização de camada.

Esta é a classe de configuração para armazenar a configuração de um CvtModel. Ela é usada para instanciar um modelo Cvt 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/cvt-13](https://huggingface.co/microsoft/cvt-13)

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 CvtConfig, CvtModel

>>> # Initializing a Cvt msft/cvt style configuration
>>> configuration = CvtConfig()

>>> # Initializing a model (with random weights) from the msft/cvt style configuration
>>> model = CvtModel(configuration)

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

## CvtModel[[transformers.CvtModel]]

#### transformers.CvtModel[[transformers.CvtModel]]

```python
transformers.CvtModel(config: CvtConfig, add_pooling_layer = True)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/cvt/modeling_cvt.py#L499)

**Parâmetros:**

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

O modelo Cvt 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.CvtModel.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/cvt/modeling_cvt.py#L510)

**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 [ConvNextImageProcessor](/docs/transformers/main/pt/model_doc/convnext#transformers.ConvNextImageProcessor). Consulte [ConvNextImageProcessor.__call__()](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para obter detalhes (`processor_class` usa [ConvNextImageProcessor](/docs/transformers/main/pt/model_doc/convnext#transformers.ConvNextImageProcessor) 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:** `BaseModelOutputWithCLSToken` ou `tuple(torch.Tensor)`

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

O método forward da [CvtModel](/docs/transformers/main/pt/model_doc/cvt#transformers.CvtModel) 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.
- **cls_token_value** (`torch.Tensor` de forma `(batch_size, 1, hidden_size)`) -- Token de classificação 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` (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.

## CvtForImageClassification[[transformers.CvtForImageClassification]]

#### transformers.CvtForImageClassification[[transformers.CvtForImageClassification]]

```python
transformers.CvtForImageClassification(config: CvtConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/cvt/modeling_cvt.py#L549)

**Parâmetros:**

config ([CvtConfig](/docs/transformers/main/pt/model_doc/cvt#transformers.CvtConfig)) : 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 Cvt com uma cabeça de classificação de imagem no topo (uma camada linear sobre o estado oculto final do token [CLS]), 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.CvtForImageClassification.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/cvt/modeling_cvt.py#L564)

**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 [ConvNextImageProcessor](/docs/transformers/main/pt/model_doc/convnext#transformers.ConvNextImageProcessor). Consulte [ConvNextImageProcessor.__call__()](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para obter detalhes (`processor_class` usa [ConvNextImageProcessor](/docs/transformers/main/pt/model_doc/convnext#transformers.ConvNextImageProcessor) 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 ([CvtConfig](/docs/transformers/main/pt/model_doc/cvt#transformers.CvtConfig)) e das entradas.

O método forward da [CvtForImageClassification](/docs/transformers/main/pt/model_doc/cvt#transformers.CvtForImageClassification) 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, CvtForImageClassification
>>> import torch
>>> from datasets import load_dataset

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

>>> image_processor = AutoImageProcessor.from_pretrained("microsoft/cvt-13")
>>> model = CvtForImageClassification.from_pretrained("microsoft/cvt-13")

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