# ConvNeXt V2
## Visão geral
O modelo ConvNeXt V2 foi proposto em [ConvNeXt V2: Co-designing and Scaling ConvNets with Masked Autoencoders](https://huggingface.co/papers/2301.00808) por Sanghyun Woo, Shoubhik Debnath, Ronghang Hu, Xinlei Chen, Zhuang Liu, In So Kweon, Saining Xie. O ConvNeXt V2 é um modelo puramente convolucional (ConvNet), inspirado no design dos Vision Transformers, e é o sucessor do [ConvNeXT](convnext).
O resumo do artigo é o seguinte:
*Impulsionado por arquiteturas aprimoradas e melhores frameworks de aprendizado de representação, o campo de reconhecimento visual experimentou uma rápida modernização e um aumento de desempenho no início da década de 2020. Por exemplo, os ConvNets modernos, representados pelo ConvNeXt, demonstraram forte desempenho em diversos cenários. Embora esses modelos tenham sido originalmente projetados para aprendizado supervisionado com rótulos do ImageNet, eles também podem potencialmente se beneficiar de técnicas de aprendizado auto-supervisionado, como autoencoders mascarados (MAE). No entanto, descobrimos que simplesmente combinar essas duas abordagens leva a um desempenho inferior. Neste artigo, propomos um framework de autoencoder mascarado totalmente convolucional e uma nova camada de Global Response Normalization (GRN) que pode ser adicionada à arquitetura ConvNeXt para aprimorar a competição de recursos entre canais. Esse co-design de técnicas de aprendizado auto-supervisionado e melhoria arquitetônica resulta em uma nova família de modelos chamada ConvNeXt V2, que melhora significativamente o desempenho de ConvNets puros em diversos benchmarks de reconhecimento, incluindo classificação no ImageNet, detecção no COCO e segmentação no ADE20K. Também fornecemos modelos ConvNeXt V2 pré-treinados de vários tamanhos, variando de um modelo Atto eficiente com 3,7M de parâmetros e 76,7% de precisão top-1 no ImageNet, a um modelo Huge de 650M que atinge uma precisão state-of-the-art de 88,9% usando apenas dados de treinamento públicos.*
Arquitetura do ConvNeXt V2. Retirada do artigo original.
Este modelo foi contribuído por [adirik](https://huggingface.co/adirik). O código original pode ser encontrado [aqui](https://github.com/facebookresearch/ConvNeXt-V2).
## Recursos
Uma lista de recursos oficiais da Hugging Face e da comunidade (indicados por 🌎) para ajudar você a começar com o ConvNeXt V2.
- [ConvNextV2ForImageClassification](/docs/transformers/main/pt/model_doc/convnextv2#transformers.ConvNextV2ForImageClassification) é suportado por este [notebook](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/image_classification.ipynb).
Se você tiver interesse em enviar um recurso para ser incluído aqui, sinta-se à vontade para abrir um Pull Request e faremos a revisão! O recurso deve, idealmente, demonstrar algo novo, em vez de duplicar um recurso existente.
## ConvNextV2Config[[transformers.ConvNextV2Config]]
#### transformers.ConvNextV2Config[[transformers.ConvNextV2Config]]
```python
transformers.ConvNextV2Config(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_size: int | list[int] | tuple[int, int] = 4, num_stages: int = 4, hidden_sizes: list[int] | tuple[int, ...] | None = (96, 192, 384, 768), depths: list[int] | tuple[int, ...] | None = (3, 3, 9, 3), hidden_act: str = 'gelu', initializer_range: float = 0.02, layer_norm_eps: float = 1e-12, drop_path_rate: float | int = 0.0, image_size: int | list[int] | tuple[int, int] = 224, _out_features: list[str] | None = None, _out_indices: list[int] | None = None)
```
[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/convnextv2/configuration_convnextv2.py#L25)
**Parâmetros:**
num_channels (`int`, *opcional*, padrão `3`) : O número de canais de entrada.
patch_size (`Union[int, list[int], tuple[int, int]]`, *opcional*, padrão `4`) : O tamanho (resolução) de cada patch.
num_stages (`int`, *opcional*, padrão 4) : O número de estágios no modelo.
hidden_sizes (`Union[list[int], tuple[int, ...]]`, *opcional*, padrão `(96, 192, 384, 768)`) : Dimensionalidade (tamanho oculto) em cada etapa do modelo.
depths (`Union[list[int], tuple[int, ...]]`, *opcional*, padrão `(3, 3, 9, 3)`) : Profundidade de cada camada no Transformer.
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.
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.
drop_path_rate (`Union[float, int]`, *opcional*, padrão `0.0`) : Taxa de drop path para a fusão de patches.
image_size (`Union[int, list[int], tuple[int, int]]`, *opcional*, padrão `224`) : O tamanho (resolução) de cada imagem.
Esta é a classe de configuração para armazenar a configuração de um ConvNextV2Model. Ela é usada para instanciar um modelo Convnextv2 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 [facebook/convnextv2-tiny-1k-224](https://huggingface.co/facebook/convnextv2-tiny-1k-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 ConvNeXTV2Config, ConvNextV2Model
>>> # Initializing a ConvNeXTV2 convnextv2-tiny-1k-224 style configuration
>>> configuration = ConvNeXTV2Config()
>>> # Initializing a model (with random weights) from the convnextv2-tiny-1k-224 style configuration
>>> model = ConvNextV2Model(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config
```
## ConvNextV2Model[[transformers.ConvNextV2Model]]
#### transformers.ConvNextV2Model[[transformers.ConvNextV2Model]]
```python
transformers.ConvNextV2Model(config: ConvNextV2Config)
```
[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/convnextv2/modeling_convnextv2.py#L273)
**Parâmetros:**
config ([ConvNextV2Config](/docs/transformers/main/pt/model_doc/convnextv2#transformers.ConvNextV2Config)) : 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.
O modelo Convnextv2 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.ConvNextV2Model.forward]]
```python
forward(pixel_values: typing.Optional[torch.Tensor] = None, **kwargs: *)
```
[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/convnextv2/modeling_convnextv2.py#L287)
**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).
**Retorna:** `BaseModelOutputWithPoolingAndNoAttention` ou `tuple(torch.Tensor)`
Um `BaseModelOutputWithPoolingAndNoAttention` 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 ([ConvNextV2Config](/docs/transformers/main/pt/model_doc/convnextv2#transformers.ConvNextV2Config)) e das entradas.
O método forward do [ConvNextV2Model](/docs/transformers/main/pt/model_doc/convnextv2#transformers.ConvNextV2Model) 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, num_channels, height, width)`) -- Sequência de estados ocultos na saída da última camada do modelo.
- **pooler_output** (`torch.Tensor` de forma `(batch_size, hidden_size)`) -- Estado oculto da última camada após uma operação de pooling nas dimensões espaciais.
- **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
```
## ConvNextV2ForImageClassification[[transformers.ConvNextV2ForImageClassification]]
#### transformers.ConvNextV2ForImageClassification[[transformers.ConvNextV2ForImageClassification]]
```python
transformers.ConvNextV2ForImageClassification(config: ConvNextV2Config)
```
[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/convnextv2/modeling_convnextv2.py#L316)
**Parâmetros:**
config ([ConvNextV2Config](/docs/transformers/main/pt/model_doc/convnextv2#transformers.ConvNextV2Config)) : 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 ConvNextV2 com uma cabeça de classificação de imagem no topo (uma camada linear sobre os recursos agregados), por exemplo, para 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.ConvNextV2ForImageClassification.forward]]
```python
forward(pixel_values: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, **kwargs)
```
[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/convnextv2/modeling_convnextv2.py#L334)
**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).
**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 ([ConvNextV2Config](/docs/transformers/main/pt/model_doc/convnextv2#transformers.ConvNextV2Config)) e das entradas.
O método forward de [ConvNextV2ForImageClassification](/docs/transformers/main/pt/model_doc/convnextv2#transformers.ConvNextV2ForImageClassification) 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 `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, ConvNextV2ForImageClassification
>>> import torch
>>> from datasets import load_dataset
>>> dataset = load_dataset("huggingface/cats-image")
>>> image = dataset["test"]["image"][0]
>>> image_processor = AutoImageProcessor.from_pretrained("facebook/convnextv2-tiny-1k-224")
>>> model = ConvNextV2ForImageClassification.from_pretrained("facebook/convnextv2-tiny-1k-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])
...
```