# PPLCNetV3

[PPLCNetV3](https://huggingface.co/papers/2109.15099) é um backbone convolucional leve e otimizado para CPU, projetado para classificação de imagens eficiente e tarefas de visão computacional subsequentes. Ele se baseia na arquitetura PP-LCNet, com estratégias de treinamento aprimoradas e refinamentos estruturais para obter um melhor equilíbrio entre precisão e latência em hardware de CPU.

## Observações

- O PPLCNetV3 é fornecido apenas como uma rede backbone. Nenhum checkpoint pré-treinado para classificação de imagens foi oficialmente lançado.

## PPLCNetV3Config[[transformers.PPLCNetV3Config]]

#### transformers.PPLCNetV3Config[[transformers.PPLCNetV3Config]]

```python
transformers.PPLCNetV3Config(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, scale: float | int = 1.0, block_configs: list | None = None, stem_channels: int = 16, stem_stride: int = 2, reduction: int = 4, divisor: int = 8, hidden_act: str = 'hardswish', _out_features: list[str] | None = None, _out_indices: list[int] | None = None, conv_symmetric_num: int = 4)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pp_lcnet_v3/configuration_pp_lcnet_v3.py#L31)

**Parâmetros:**

scale (`float`, *opcional*, padrão 1.0) : O fator de escala para as dimensões de canal do modelo, usado para ajustar o tamanho do modelo e o custo computacional sem alterar a arquitetura geral (por exemplo, 0.25, 0.5, 1.0, 1.5).

block_configs (`list[list[tuple]]`, *opcional*, padrão `None`) : Configuração para cada bloco em cada estágio. Cada tupla contém: (kernel_size, in_channels, out_channels, stride, use_squeeze_excitation). Se `None`, usa a configuração padrão do PP-LCNet.

stem_channels (`int`, *opcional*, padrão 16) : O número de canais de saída para a camada stem.

stem_stride (`int`, *opcional*, padrão 2) : O stride para a camada de convolução do stem.

reduction (`int`, *opcional*, padrão 4) : O fator de redução para as dimensões dos canais de características nos blocos squeeze-and-excitation (SE), usado para reduzir o número de parâmetros do modelo e a complexidade computacional, mantendo a representatividade das características.

divisor (`int`, *opcional*, padrão 8) : O divisor usado para garantir que vários parâmetros do modelo (por exemplo, dimensões de canal, tamanhos de kernel) sejam múltiplos deste valor, promovendo uma implementação eficiente do modelo e o uso de recursos.

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

conv_symmetric_num (`int`, *opcional*, padrão `4`) : O número de ramos de convolução kxk na camada de reparametrização aprendível, usado para aprimorar a capacidade de extração de recursos por meio de uma arquitetura multiramo durante o treinamento, ao mesmo tempo que permite inferência eficiente por meio de reparametrização estrutural.

Esta é a classe de configuração para armazenar a configuração de um Pp Lcnet V3Model. Ela é usada para instanciar um modelo Pp Lcnet V3 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 [PaddlePaddle/Not_yet_released](https://huggingface.co/PaddlePaddle/Not_yet_released)

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.

## PPLCNetV3Backbone[[transformers.PPLCNetV3Backbone]]

#### transformers.PPLCNetV3Backbone[[transformers.PPLCNetV3Backbone]]

```python
transformers.PPLCNetV3Backbone(config: PPLCNetV3Config)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pp_lcnet_v3/modeling_pp_lcnet_v3.py#L327)

**Parâmetros:**

config ([PPLCNetV3Config](/docs/transformers/main/pt/model_doc/pp_lcnet_v3#transformers.PPLCNetV3Config)) : 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 de backbone PPLCNetV3 para extração de recursos.

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.PPLCNetV3Backbone.forward]]

```python
forward(pixel_values: Tensor, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pp_lcnet_v3/modeling_pp_lcnet_v3.py#L340)

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

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

O método forward de [PPLCNetV3Backbone](/docs/transformers/main/pt/model_doc/pp_lcnet_v3#transformers.PPLCNetV3Backbone) 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 PPLCNetV3Config, PPLCNetV3Backbone
>>> import torch

>>> config = PPLCNetV3Config()
>>> model = PPLCNetV3Backbone(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)
```