# HGNet-V2

[HGNetV2](https://github.com/PaddlePaddle/PaddleClas/blob/v2.6.0/docs/zh_CN/models/ImageNet1k/PP-HGNetV2.md) é um backbone de rede neural convolucional (CNN) de próxima geração, projetado para o melhor compromisso entre precisão e latência em GPUs NVIDIA. Baseado no [HGNet](https://github.com/PaddlePaddle/PaddleClas/blob/v2.6.0/docs/en/models/PP-HGNet_en.md) original, o HGNetV2 oferece alta precisão com velocidades de inferência rápidas e apresenta bom desempenho em tarefas como classificação de imagens, detecção de objetos e segmentação, tornando-o uma escolha prática para aplicações de visão computacional baseadas em GPU.

Você pode encontrar todos os modelos originais do HGNet V2 na organização [USTC](https://huggingface.co/ustc-community/models?search=hgnet).

> [!TIP]
> Este modelo foi contribuído por [VladOS95-cyber](https://github.com/VladOS95-cyber). Clique nos modelos HGNet V2 na barra lateral à direita para ver mais exemplos de como aplicar o HGNet V2 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="ustc-community/hgnet-v2",
    device=0
)
pipeline("http://images.cocodataset.org/val2017/000000039769.jpg")
```

```python
import requests
import torch
from PIL import Image

from transformers import AutoImageProcessor, HGNetV2ForImageClassification

url = "http://images.cocodataset.org/val2017/000000039769.jpg"
image = Image.open(requests.get(url, stream=True).raw)

model = HGNetV2ForImageClassification.from_pretrained("ustc-community/hgnet-v2", device_map="auto")
processor = AutoImageProcessor.from_pretrained("ustc-community/hgnet-v2")

inputs = processor(images=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}")
```

## HGNetV2Config[[transformers.HGNetV2Config]]

#### transformers.HGNetV2Config[[transformers.HGNetV2Config]]

```python
transformers.HGNetV2Config(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 = 64, depths: list[int] | tuple[int, ...] = (3, 4, 6, 3), hidden_sizes: list[int] | tuple[int, ...] = (256, 512, 1024, 2048), hidden_act: str = 'relu', _out_features: list[str] | None = None, _out_indices: list[int] | None = None, stem_channels: list[int] | tuple[int, ...] = (3, 32, 48), stem_strides: Sequence = (2, 1, 1, 2, 1), stage_in_channels: list[int] | tuple[int, ...] = (48, 128, 512, 1024), stage_mid_channels: list[int] | tuple[int, ...] = (48, 96, 192, 384), stage_out_channels: list[int] | tuple[int, ...] = (128, 512, 1024, 2048), stage_num_blocks: list[int] | tuple[int, ...] = (1, 1, 3, 1), stage_downsample: list[bool] | tuple[bool, ...] = (False, True, True, True), stage_downsample_strides: Sequence = (2, 2, 2, 2), stage_light_block: list[bool] | tuple[bool, ...] = (False, False, True, True), stage_kernel_size: list[int] | tuple[int, ...] = (3, 3, 5, 5), stage_numb_of_layers: list[int] | tuple[int, ...] = (6, 6, 6, 6), use_learnable_affine_block: bool = False, initializer_range: float = 0.02)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/hgnet_v2/configuration_hgnet_v2.py#L35)

**Parâmetros:**

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

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

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

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

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.

stem_channels (`list[int]`, *opcional*, padrão `[3, 32, 48]`) : Dimensões dos canais para as camadas do stem: - O primeiro número (3) corresponde aos canais da imagem de entrada - O segundo número (32) corresponde aos canais intermediários do stem - O terceiro número (48) corresponde aos canais de saída do stem

stem_strides (`Sequence[int | list[int] | tuple[int, ...]]`, *opcional*, padrão `(2, 1, 1, 2, 1)`) : Padrões de stride para as camadas do stem.

stage_in_channels (`list[int]`, *opcional*, padrão `[48, 128, 512, 1024]`) : Dimensões dos canais de entrada para cada estágio do backbone. Isso define quantos canais a entrada de cada estágio terá.

stage_mid_channels (`list[int]`, *opcional*, padrão `[48, 96, 192, 384]`) : Dimensões dos canais intermediários para cada estágio do backbone. Isso define o número de canais usados nas camadas intermediárias de cada estágio.

stage_out_channels (`list[int]`, *opcional*, padrão `[128, 512, 1024, 2048]`) : Dimensões dos canais de saída para cada estágio do backbone. Isso define quantos canais a saída de cada estágio terá.

stage_num_blocks (`list[int]`, *opcional*, padrão `[1, 1, 3, 1]`) : Número de blocos a serem usados em cada estágio do backbone. Isso controla a profundidade de cada estágio, especificando quantos blocos convolucionais empilhar.

stage_downsample (`list[bool]`, *opcional*, padrão `[False, True, True, True]`) : Indica se as feature maps devem ser reduzidas em cada estágio. Se `True`, as dimensões espaciais das feature maps serão reduzidas.

stage_downsample_strides (`Sequence[int | list[int] | tuple[int, ...]]`, *opcional*, padrão `(2, 2, 2, 2)`) : Padrões de stride para cada camada de estágio.

stage_light_block (`list[bool]`, *opcional*, padrão `[False, False, True, True]`) : Indica se os blocos leves devem ser usados em cada estágio. Blocos leves são uma variante de blocos convolucionais que podem ter menos parâmetros.

stage_kernel_size (`list[int]`, *opcional*, padrão `[3, 3, 5, 5]`) : Tamanhos dos kernels para as camadas convolucionais em cada estágio.

stage_numb_of_layers (`list[int]`, *opcional*, padrão `[6, 6, 6, 6]`) : Número de camadas a serem usadas em cada bloco do estágio.

use_learnable_affine_block (`bool`, *opcional*, padrão `False`) : Se deve usar Learnable Affine Blocks (LAB) na rede. O LAB adiciona parâmetros de escala e viés aprendíveis após determinadas operações.

initializer_range (`float`, *opcional*, padrão `0.02`) : O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos.

Esta é a classe de configuração para armazenar a configuração de um HGNetV2Backbone. Ela é usada para instanciar um modelo Hgnet V2 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 [ustc-community/dfine_x_coco](https://huggingface.co/ustc-community/dfine_x_coco)

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.

## HGNetV2Backbone[[transformers.HGNetV2Backbone]]

#### transformers.HGNetV2Backbone[[transformers.HGNetV2Backbone]]

```python
transformers.HGNetV2Backbone(config: HGNetV2Config)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/hgnet_v2/modeling_hgnet_v2.py#L343)

#### forward[[transformers.HGNetV2Backbone.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/hgnet_v2/modeling_hgnet_v2.py#L356)

**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 `image_processor_class`. Consulte `image_processor_class.__call__` para obter detalhes (`processor_class` usa `image_processor_class` 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:** `BackboneOutput` ou `tuple(torch.Tensor)`

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

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

- **feature_maps** (`tuple(torch.Tensor)` de forma `(batch_size, num_channels, height, width)`) -- Mapas de características dos estágios.
- **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 + um para a saída de cada camada) de forma `(batch_size, sequence_length, hidden_size)` ou `(batch_size, num_channels, height, width)`, dependendo do backbone.

  Estados ocultos do modelo na saída de cada estágio, além das saídas 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)`. Aplicável apenas se o backbone usar atenção.

  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 HGNetV2Config, HGNetV2Backbone
>>> import torch

>>> config = HGNetV2Config()
>>> model = HGNetV2Backbone(config)

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

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

>>> feature_maps = outputs.feature_maps
>>> list(feature_maps[-1].shape)
[1, 2048, 7, 7]
```

## HGNetV2ForImageClassification[[transformers.HGNetV2ForImageClassification]]

#### transformers.HGNetV2ForImageClassification[[transformers.HGNetV2ForImageClassification]]

```python
transformers.HGNetV2ForImageClassification(config: HGNetV2Config)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/hgnet_v2/modeling_hgnet_v2.py#L420)

**Parâmetros:**

config ([HGNetV2Config](/docs/transformers/main/pt/model_doc/hgnet_v2#transformers.HGNetV2Config)) : 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 HGNetV2 com uma cabeça de classificação de imagem no topo (uma camada linear sobre os recursos agregados), 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.HGNetV2ForImageClassification.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/hgnet_v2/modeling_hgnet_v2.py#L436)

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

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

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

Exemplos:
```python
>>> import torch
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO
>>> from transformers import HGNetV2ForImageClassification, AutoImageProcessor
>>> from PIL import Image

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> with httpx.stream("GET", url) as response:
...     image = Image.open(BytesIO(response.read()))

>>> model = HGNetV2ForImageClassification.from_pretrained("ustc-community/hgnet-v2")
>>> processor = AutoImageProcessor.from_pretrained("ustc-community/hgnet-v2")

>>> inputs = processor(images=image, return_tensors="pt")
>>> with torch.no_grad():
...     outputs = model(**inputs)
>>> outputs.logits.shape
torch.Size([1, 2])
```