# ViTDet

## Visão geral

O modelo ViTDet foi proposto em [Exploring Plain Vision Transformer Backbones for Object Detection](https://huggingface.co/papers/2203.16527) por Yanghao Li, Hanzi Mao, Ross Girshick, Kaiming He. O VitDet utiliza o [Vision Transformer](vit) puro para a tarefa de detecção de objetos.

O resumo do artigo é o seguinte:

*Exploramos o Vision Transformer (ViT) simples, não hierárquico, como uma rede backbone para detecção de objetos. Esse design permite que a arquitetura original do ViT seja ajustada para detecção de objetos sem a necessidade de redesenhar um backbone hierárquico para pré-treino. Com adaptações mínimas para o ajuste fino, nosso detector com backbone simples pode alcançar resultados competitivos. Surpreendentemente, observamos: (i) é suficiente construir uma pirâmide de recursos simples a partir de um mapa de recursos de escala única (sem o design comum de FPN) e (ii) é suficiente usar atenção de janela (sem deslocamento) auxiliada por um número muito pequeno de blocos de propagação entre janelas. Com backbones ViT simples pré-treinados como Autoencoders Mascarados (MAE), nosso detector, chamado ViTDet, pode competir com os métodos líderes anteriores, que eram todos baseados em backbones hierárquicos, alcançando até 61,3 AP_box no conjunto de dados COCO usando apenas pré-treino no ImageNet-1K. Esperamos que nosso estudo chame a atenção para a pesquisa sobre detectores com backbones simples.*

Este modelo foi contribuído por [nielsr](https://huggingface.co/nielsr). O código original pode ser encontrado [aqui](https://github.com/facebookresearch/detectron2/tree/main/projects/ViTDet).

Dicas:

- No momento, apenas o backbone está disponível.

## VitDetConfig[[transformers.VitDetConfig]]

#### transformers.VitDetConfig[[transformers.VitDetConfig]]

```python
transformers.VitDetConfig(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, hidden_size: int = 768, num_hidden_layers: int = 12, num_attention_heads: int = 12, mlp_ratio: int = 4, hidden_act: str = 'gelu', dropout_prob: float | int = 0.0, initializer_range: float = 0.02, layer_norm_eps: float = 1e-06, image_size: int | list[int] | tuple[int, int] = 224, pretrain_image_size: int | list[int] | tuple[int, int] = 224, patch_size: int | list[int] | tuple[int, int] = 16, num_channels: int = 3, qkv_bias: bool = True, drop_path_rate: float | int = 0.0, window_block_indices: list[int] | tuple[int, ...] = (), residual_block_indices: list[int] | tuple[int, ...] = (), use_absolute_position_embeddings: bool = True, use_relative_position_embeddings: bool = False, window_size: int = 0, _out_features: list[str] | None = None, _out_indices: list[int] | None = None)
```

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

**Parâmetros:**

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

num_hidden_layers (`int`, *opcional*, padrão `12`) : Número de camadas ocultas no decodificador do Transformer.

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

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

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.

dropout_prob (`Union[float, int]`, *opcional*, padrão `0.0`) : A proporção para todas as camadas de dropout.

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

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

pretrain_image_size (`int`, *opcional*, padrão 224) : O tamanho (resolução) de cada imagem durante o pré-treinamento.

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

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

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

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

window_block_indices (`list[int]`, *opcional*, padrão `[]`) : Lista de índices de blocos que devem ter atenção de janela em vez da autoatenção global regular.

residual_block_indices (`list[int]`, *opcional*, padrão `[]`) : Lista de índices de blocos que devem ter um bloco residual extra após o MLP.

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

use_relative_position_embeddings (`bool`, *opcional*, padrão `False`) : Se deve adicionar embeddings de posição relativa aos mapas de atenção.

window_size (`int`, *opcional*, padrão 0) : O tamanho da janela de atenção.

Esta é a classe de configuração para armazenar a configuração de um VitDetModel. Ela é usada para instanciar um modelo Vitdet 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 [google/vitdet-base-patch16-224](https://huggingface.co/google/vitdet-base-patch16-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 VitDetConfig, VitDetModel

>>> # Initializing a VitDet configuration
>>> configuration = VitDetConfig()

>>> # Initializing a model (with random weights) from the configuration
>>> model = VitDetModel(configuration)

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

## VitDetModel[[transformers.VitDetModel]]

#### transformers.VitDetModel[[transformers.VitDetModel]]

```python
transformers.VitDetModel(config: VitDetConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vitdet/modeling_vitdet.py#L600)

**Parâmetros:**

config ([VitDetConfig](/docs/transformers/main/pt/model_doc/vitdet#transformers.VitDetConfig)) : 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 Vitdet básico que gera os hidden-states 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.VitDetModel.forward]]

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

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vitdet/modeling_vitdet.py#L614)

**Parâmetros:**

pixel_values (`torch.Tensor` de forma `(batch_size, num_channels, image_size, image_size)`, *opcional*) : Os tensors correspondentes às imagens de entrada. Os valores de pixels podem ser obtidos usando `image_processor_class`. Consulte `image_processor_class.__call__` para mais detalhes (`processor_class` usa `image_processor_class` para processar as imagens).

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.

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

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

O método forward do [VitDetModel](/docs/transformers/main/pt/model_doc/vitdet#transformers.VitDetModel) 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.

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

Exemplos:

```python
>>> from transformers import VitDetConfig, VitDetModel
>>> import torch

>>> config = VitDetConfig()
>>> model = VitDetModel(config)

>>> pixel_values = torch.randn(1, 3, 224, 224)

>>> with torch.no_grad():
...     outputs = model(pixel_values)

>>> last_hidden_states = outputs.last_hidden_state
>>> list(last_hidden_states.shape)
[1, 768, 14, 14]
```