# PPLCNetV4

PPLCNetV4 est fourni uniquement en tant que réseau de base. Aucun point de contrôle pré-entraîné pour la classification d'images n'a été officiellement publié.

## 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)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pp_lcnet_v4/configuration_pp_lcnet_v4.py#L33)

**Paramètres :**

scale (`float`, *facultatif*, valeur par défaut 1.0) : Facteur d'échelle appliqué aux dimensions de canaux du modèle, utilisé pour ajuster la taille du modèle et le coût de calcul sans modifier l'architecture globale (par exemple, 0.25, 0.5, 1.0, 1.5).

block_configs (`list[list[tuple]]`, *facultatif*, valeur par défaut `None`) : Configuration de chaque bloc de chaque étape. Chaque tuple contient : (kernel_size, in_channels, out_channels, stride, use_squeeze_excitation). Si `None`, utilise la configuration PP-LCNet par défaut.

stem_channels (`list[int]`, *facultatif*, par défaut `[3, 48, 96]`) : Dimensions des canaux pour les couches de tige : - Le premier nombre (3) correspond aux canaux de l'image d'entrée - Le deuxième nombre (48) correspond aux canaux intermédiaires de la tige - Le troisième nombre (96) correspond aux canaux de sortie de la tige

reduction (`int`, *facultatif*, valeur par défaut : 4) : Facteur de réduction des dimensions des canaux de caractéristiques dans les blocs squeeze-and-excitation (SE), utilisé pour réduire le nombre de paramètres du modèle et la complexité de calcul tout en conservant la capacité de représentation des caractéristiques.

hidden_act (`str`, *facultatif*, par défaut `relu`) : Fonction d'activation non linéaire (fonction ou chaîne de caractères) du décodeur. Par exemple, `"gelu"`, `"relu"`, `"silu"`, etc.

num_channels (`int`, *facultatif*, par défaut `3`) : Le nombre de canaux d'entrée.

stem_strides (`Sequence[int | list[int] | tuple[int, ...]]`, *facultatif*, valeur par défaut `(2, 1, 1, 2, 1)`) : Motifs de pas pour les couches de tige.

stem_type (`str`, *facultatif*, par défaut `large`) : Le type de couche de tige à utiliser. Peut être l'un des éléments suivants : - `"large"` : Tige PP-LCNetV4 standard. - `"small"` : Variante avec des dimensions de canaux plus petites.

use_learnable_affine_block (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut utiliser des blocs affines apprenables (LAB) dans le réseau. LAB ajoute des paramètres d'échelle et de biais apprenables après certaines opérations.

Ceci est la classe de configuration destinée à stocker la configuration d'un Pp Lcnet V4Model. Elle est utilisée pour instancier un modèle Pp Lcnet V4 en fonction des arguments spécifiés, définissant ainsi l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de [PaddlePaddle/Not_yet_released](https://huggingface.co/PaddlePaddle/Not_yet_released)

Les objets de configuration héritent de [PreTrainedConfig](/docs/transformers/main/fr/main_classes/configuration#transformers.PreTrainedConfig) et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de [PreTrainedConfig](/docs/transformers/main/fr/main_classes/configuration#transformers.PreTrainedConfig) pour plus d’informations.

## PPLCNetV4Backbone[[transformers.PPLCNetV4Backbone]]

#### transformers.PPLCNetV4Backbone[[transformers.PPLCNetV4Backbone]]

```python
transformers.PPLCNetV4Backbone(config: PPLCNetV4Config)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pp_lcnet_v4/modeling_pp_lcnet_v4.py#L351)

**Paramètres :**

config ([PPLCNetV4Config](/docs/transformers/main/fr/model_doc/pp_lcnet_v4#transformers.PPLCNetV4Config)) : Classe de configuration du modèle contenant tous les paramètres du modèle. L'initialisation à partir d'un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode [from_pretrained()](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle.

Modèle de tronc PPLCNetV4 pour l'extraction de caractéristiques.

Ce modèle hérite de [PreTrainedModel](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, l'élagage des têtes, etc.).

Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l’utilisation et le comportement généraux.

#### forward[[transformers.PPLCNetV4Backbone.forward]]

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

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pp_lcnet_v4/modeling_pp_lcnet_v4.py#L364)

**Paramètres :**

pixel_values (`torch.Tensor` de forme `(batch_size, num_channels, image_size, image_size)`) : Les tenseurs correspondant aux images d'entrée. Les valeurs des pixels peuvent être obtenues à l'aide de `image_processor_class`. Consultez `image_processor_class.__call__` pour plus de détails (`processor_class` utilise `image_processor_class` pour le traitement des images).

**Retourne :** `BackboneOutput` ou `tuple(torch.Tensor)`

Un `BackboneOutput` ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([PPLCNetV4Config](/docs/transformers/main/fr/model_doc/pp_lcnet_v4#transformers.PPLCNetV4Config)) et les entrées.

La méthode forward de [PPLCNetV4Backbone](/docs/transformers/main/fr/model_doc/pp_lcnet_v4#transformers.PPLCNetV4Backbone) redéfinit la méthode spéciale `__call__`.

Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance `Module` plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.

- **feature_maps** (`tuple(torch.Tensor)` de forme `(batch_size, num_channels, height, width)`) -- Cartes de caractéristiques des étapes.
- **hidden_states** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings + un pour la sortie de chaque couche) de forme `(batch_size, sequence_length, hidden_size)` ou `(batch_size, num_channels, height, width)`, selon le backbone.

  États cachés du modèle à la sortie de chaque étape, ainsi que les sorties des embeddings initiaux.
- **attentions** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`. Applicable uniquement si le backbone utilise l'attention.

  Pondérations des attentions après le softmax d'attention, utilisées pour calculer la moyenne pondérée dans les têtes d'auto-attention.

Exemples :

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