# RegNet

## Visão geral

O modelo RegNet foi proposto em [Designing Network Design Spaces](https://huggingface.co/papers/2003.13678) por Ilija Radosavovic, Raj Prateek Kosaraju, Ross Girshick, Kaiming He, Piotr Dollár.

Os autores projetam espaços de busca para executar a Busca de Arquitetura Neural (NAS). Inicialmente, partem de um espaço de busca de alta dimensão e reduzem iterativamente o espaço de busca aplicando empiricamente restrições com base nos modelos de melhor desempenho amostrados pelo espaço de busca atual.

O resumo do artigo é o seguinte:

*Neste trabalho, apresentamos um novo paradigma de design de redes. Nosso objetivo é ajudar a avançar a compreensão do design de redes e descobrir princípios de design que se generalizem entre diferentes cenários. Em vez de focar no design de instâncias individuais de redes, projetamos espaços de design de redes que parametrizam populações de redes. O processo geral é análogo ao design manual clássico de redes, mas elevado ao nível do espaço de design. Usando nossa metodologia, exploramos o aspecto estrutural do design de redes e chegamos a um espaço de design de baixa dimensão, composto por redes simples e regulares, que chamamos de RegNet. O insight central da parametrização do RegNet é surpreendentemente simples: as larguras e profundidades de boas redes podem ser explicadas por uma função linear quantizada. Analisamos o espaço de design do RegNet e chegamos a descobertas interessantes que não correspondem à prática atual de design de redes. O espaço de design do RegNet fornece redes simples e rápidas que funcionam bem em uma ampla faixa de regimes de flops. Em configurações de treinamento e flops comparáveis, os modelos RegNet superam os populares modelos EfficientNet, sendo até 5x mais rápidos em GPUs.*

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

O enorme modelo de 10B do [Self-supervised Pretraining of Visual Features in the Wild](https://huggingface.co/papers/2103.01988), treinado em um bilhão de imagens do Instagram, está disponível no [hub](https://huggingface.co/facebook/regnet-y-10b-seer)

## Recursos

Uma lista de recursos oficiais da Hugging Face e da comunidade (indicados por 🌎) para ajudar você a começar com o RegNet.

- [RegNetForImageClassification](/docs/transformers/main/pt/model_doc/regnet#transformers.RegNetForImageClassification) é suportado por este [notebook](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/image_classification.ipynb).
- Veja também: [Guia da tarefa de classificação de imagens](../tasks/image_classification)

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.

## RegNetConfig[[transformers.RegNetConfig]]

#### transformers.RegNetConfig[[transformers.RegNetConfig]]

```python
transformers.RegNetConfig(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, embedding_size: int = 32, hidden_sizes: list[int] | tuple[int, ...] = (128, 192, 512, 1088), depths: list[int] | tuple[int, ...] = (2, 6, 12, 2), groups_width: int = 64, layer_type: str = 'y', hidden_act: str = 'relu', downsample_in_first_stage: bool = True)
```

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

**Parâmetros:**

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

embedding_size (`int`, *opcional*, padrão `32`) : Dimensionalidade dos embeddings e dos estados ocultos.

hidden_sizes (`Union[list[int], tuple[int, ...]]`, *opcional*, padrão `(128, 192, 512, 1088)`) : Dimensionalidade (tamanho oculto) em cada etapa do modelo.

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

groups_width (`int`, *opcional*, padrão 64) : Largura do grupo para cada estágio.

layer_type (`str`, *optional*, defaults to `"y"`) : The layer to use, it can be either `"x" or `"y"`. An `x` layer is a ResNet's BottleNeck layer with `reduction` fixed to `1`. While a `y` layer is a `x` but with squeeze and excitation. Please refer to the paper for a detailed explanation of how these layers were constructed.

hidden_act (`str`, *opcional*, padrão `relu`) : A função de ativação não linear (função ou string) no decodificador. Por exemplo, `"gelu"`, `"relu"`, `"silu"`, etc.

downsample_in_first_stage (`bool`, *opcional*, padrão `False`) : Se `True`, a primeira etapa reduzirá a resolução das entradas usando um `stride` de 2.

Esta é a classe de configuração para armazenar a configuração de um RegNetModel. Ela é usada para instanciar um modelo Regnet 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/regnet-y-040](https://huggingface.co/facebook/regnet-y-040)

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 RegNetConfig, RegNetModel

>>> # Initializing a RegNet regnet-y-40 style configuration
>>> configuration = RegNetConfig()
>>> # Initializing a model from the regnet-y-40 style configuration
>>> model = RegNetModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config
```

## RegNetModel[[transformers.RegNetModel]]

#### transformers.RegNetModel[[transformers.RegNetModel]]

```python
transformers.RegNetModel(config: RegNetConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/regnet/modeling_regnet.py#L282)

**Parâmetros:**

config ([RegNetConfig](/docs/transformers/main/pt/model_doc/regnet#transformers.RegNetConfig)) : 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 Regret 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.RegNetModel.forward]]

```python
forward(pixel_values: Tensor, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/regnet/modeling_regnet.py#L292)

**Parâmetros:**

pixel_values (`torch.Tensor` de forma `(batch_size, num_channels, image_size, image_size)`) : 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). Veja [ConvNextImageProcessor.__call__()](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para 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:** `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 ([RegNetConfig](/docs/transformers/main/pt/model_doc/regnet#transformers.RegNetConfig)) e das entradas.

O método forward de [RegNetModel](/docs/transformers/main/pt/model_doc/regnet#transformers.RegNetModel) 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
```

## RegNetForImageClassification[[transformers.RegNetForImageClassification]]

#### transformers.RegNetForImageClassification[[transformers.RegNetForImageClassification]]

```python
transformers.RegNetForImageClassification(config: RegNetConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/regnet/modeling_regnet.py#L332)

**Parâmetros:**

config ([RegNetConfig](/docs/transformers/main/pt/model_doc/regnet#transformers.RegNetConfig)) : 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 RegNet com uma cabeça de classificação de imagem no topo (uma camada linear no topo dos 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.RegNetForImageClassification.forward]]

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

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/regnet/modeling_regnet.py#L345)

**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 classificação é calculada (Cross-Entropy).

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 ([RegNetConfig](/docs/transformers/main/pt/model_doc/regnet#transformers.RegNetConfig)) e das entradas.

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

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

>>> image_processor = AutoImageProcessor.from_pretrained("facebook/regnet-y-040")
>>> model = RegNetForImageClassification.from_pretrained("facebook/regnet-y-040")

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