# PPLCNetV4 O PPLCNetV4 é fornecido apenas como uma rede backbone. Nenhum checkpoint pré-treinado para classificação de imagens foi oficialmente lançado. ## PPLCNetV4Config[[transformers.PPLCNetV4Config]] #### transformers.PPLCNetV4Config[[transformers.PPLCNetV4Config]] ```python transformers.PPLCNetV4Config(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: list[int] | tuple[int, ...] = (3, 48, 96), reduction: int = 4, hidden_act: str = 'relu', _out_features: list[str] | None = None, _out_indices: list[int] | None = None, num_channels: int = 3, stem_strides: Sequence = (2, 1, 1, 2, 1), stem_type: str = 'large', use_learnable_affine_block: bool = False) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pp_lcnet_v4/configuration_pp_lcnet_v4.py#L33) **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 (`list[int]`, *opcional*, padrão `[3, 48, 96]`) : Dimensões dos canais para as camadas do stem: - O primeiro número (3) são os canais da imagem de entrada - O segundo número (48) são os canais intermediários do stem - O terceiro número (96) são os canais de saída 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. 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. num_channels (`int`, *opcional*, padrão `3`) : O número de canais de entrada. 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. stem_type (`str`, *opcional*, padrão `large`) : O tipo de camada de caule a ser usado. Pode ser um dos seguintes: - `"large"`: Caule padrão do PP-LCNetV4. - `"small"`: Variante com dimensões de canal menores. 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. Esta é a classe de configuração para armazenar a configuração de um Pp Lcnet V4Model. Ela é usada para instanciar um modelo Pp Lcnet V4 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. ## PPLCNetV4Backbone[[transformers.PPLCNetV4Backbone]] #### transformers.PPLCNetV4Backbone[[transformers.PPLCNetV4Backbone]] ```python transformers.PPLCNetV4Backbone(config: PPLCNetV4Config) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pp_lcnet_v4/modeling_pp_lcnet_v4.py#L351) **Parâmetros:** config ([PPLCNetV4Config](/docs/transformers/main/pt/model_doc/pp_lcnet_v4#transformers.PPLCNetV4Config)) : 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 PPLCNetV4 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.PPLCNetV4Backbone.forward]] ```python forward(pixel_values: Tensor, **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pp_lcnet_v4/modeling_pp_lcnet_v4.py#L364) **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 ([PPLCNetV4Config](/docs/transformers/main/pt/model_doc/pp_lcnet_v4#transformers.PPLCNetV4Config)) e das entradas. O método forward do [PPLCNetV4Backbone](/docs/transformers/main/pt/model_doc/pp_lcnet_v4#transformers.PPLCNetV4Backbone) 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 PPLCNetV4Config, PPLCNetV4Backbone >>> import torch >>> config = PPLCNetV4Config() >>> model = PPLCNetV4Backbone(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) ```