# Modèles

La classe de base [PreTrainedModel](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel) implémente les méthodes communes pour charger/enregistrer un modèle depuis un fichier ou un répertoire local, ou depuis une configuration de modèle préentraînée fournie par la bibliothèque (téléchargée depuis le Hub de HuggingFace).

[PreTrainedModel](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel) implémente également quelques méthodes communes à tous les modèles :

- redimensionner les embeddings de jetons d'entrée lorsque de nouveaux jetons sont ajoutés au vocabulaire

Les autres méthodes communes à chaque modèle sont définies dans [ModuleUtilsMixin](/docs/transformers/main/fr/main_classes/model#transformers.modeling_utils.ModuleUtilsMixin) et [GenerationMixin](/docs/transformers/main/fr/main_classes/text_generation#transformers.GenerationMixin).

## PreTrainedModel[[transformers.PreTrainedModel]]

#### transformers.PreTrainedModel[[transformers.PreTrainedModel]]

```python
transformers.PreTrainedModel(config: PreTrainedConfig, *inputs, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L1068)

Classe de base pour tous les modèles.

[PreTrainedModel](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel) gère le stockage de la configuration des modèles et prend en charge les méthodes de chargement, de téléchargement et d’enregistrement des modèles, ainsi que quelques méthodes communes à tous les modèles :

- redimensionner les embeddings d'entrée

Attributs de classe (réécrits par les classes dérivées) :

- **config_class** ([PreTrainedConfig](/docs/transformers/main/fr/main_classes/configuration#transformers.PreTrainedConfig)) -- Une sous-classe de [PreTrainedConfig](/docs/transformers/main/fr/main_classes/configuration#transformers.PreTrainedConfig) à utiliser comme classe de configuration pour cette architecture de modèle.
- **base_model_prefix** (`str`) -- Une chaîne de caractères indiquant l'attribut associé au modèle de base dans les classes dérivées de la même architecture qui ajoutent des modules au-dessus du modèle de base.
- **main_input_name** (`str`) -- Le nom de l'entrée principale du modèle (souvent `input_ids` pour les modèles NLP, `pixel_values` pour les modèles de vision et `input_values` pour les modèles de parole).
- **can_record_outputs** (dict) :

#### push_to_hub[[transformers.PreTrainedModel.push_to_hub]]

```python
push_to_hub(repo_id: str, commit_message: str | None = None, commit_description: str | None = None, private: bool | None = None, token: bool | str | None = None, revision: str | None = None, create_pr: bool = False, max_shard_size: int | str | None = '50GB', tags: list[str] | None = None)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/hub.py#L822)

**Paramètres :**

repo_id (`str`) : Le nom du dépôt vers lequel vous souhaitez pousser votre modèle. Il doit contenir le nom de votre organisation lors d'une poussée vers une organisation donnée.

commit_message (`str`, *facultatif*) : Message à commiter lors de la poussée. La valeur par défaut est `"Upload model"`.

commit_description (`str`, *facultatif*) : La description du commit qui sera créé

private (`bool`, *facultatif*) : Indique s'il faut rendre le dépôt privé. Si la valeur est `None` (par défaut), le dépôt sera public, sauf si le défaut de l'organisation est privé. Cette valeur est ignorée si le dépôt existe déjà.

token (`bool` ou `str`, *facultatif*) : Jeton à utiliser comme autorisation HTTP bearer pour les fichiers distants. Si `True` (par défaut), le jeton généré lors de l'exécution de `hf auth login` (stocké dans `~/.huggingface`) sera utilisé.

revision (`str`, *facultatif*) : Branche vers laquelle pousser les fichiers téléversés.

create_pr (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut créer une PR avec les fichiers téléversés ou effectuer un commit direct.

max_shard_size (`int` ou `str`, *facultatif*, valeur par défaut `"50GB"`) : Ne s'applique qu'aux modèles. Taille maximale d'un point de contrôle avant son fractionnement. Les points de contrôle fractionnés auront chacun une taille inférieure à cette valeur. S'il est exprimé sous forme de chaîne, il doit être composé de chiffres suivis d'une unité (comme `"5MB"`).

tags (`list[str]`, *facultatif*) : Liste de tags à pousser sur le Hub.

Téléchargez le fichier du modèle sur le 🤗 Model Hub.

Exemples :

```python
from transformers import AutoModel

model = AutoModel.from_pretrained("google-bert/bert-base-cased")

# Push the model to your namespace with the name "my-finetuned-bert".
model.push_to_hub("my-finetuned-bert")

# Push the model to an organization with the name "my-finetuned-bert".
model.push_to_hub("huggingface/my-finetuned-bert")
```

#### activation_checkpointing_disable[[transformers.PreTrainedModel.activation_checkpointing_disable]]

```python
activation_checkpointing_disable()
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L3249)

Désactive le checkpointing d'activation pour le modèle actuel.

#### activation_checkpointing_enable[[transformers.PreTrainedModel.activation_checkpointing_enable]]

```python
activation_checkpointing_enable(activation_checkpointing_kwargs = None, every_n_layers: int = 1, offload: bool = False)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L3110)

**Paramètres :**

every_n_layers (`int`, *facultatif*, valeur par défaut : 1) : Effectue un checkpoint uniquement toutes les `every_n_layers` couches décodeur, en laissant les autres conserver leurs activations. `1` effectue un checkpoint à chaque couche, ce qui correspond au comportement habituel tout-ou-rien. Des valeurs plus élevées sacrifient la mémoire au profit de la vitesse, ce qui est avantageux lorsque la mémoire libérée par un checkpoint complet reste inutilisée.

offload (`bool`, *facultatif*, valeur par défaut `False`) : Conserver les activations enregistrées pour le recalcul en mémoire hôte épinglée plutôt que sur l'accélérateur. Cela libère `layers x sequence x hidden` octets de mémoire de l'appareil, ce qui prédomine pour les longueurs de séquence élevées, au prix d'une copie de l'appareil vers l'hôte lors du calcul avant et d'une copie de l'hôte vers l'appareil lors du calcul arrière. Les deux copies s'exécutent sur le flux de calcul, ce qui ralentit l'étape.

activation_checkpointing_kwargs (dict, *facultatif*) : Arguments supplémentaires transmis à la fonction `torch.utils.checkpoint.checkpoint`.

Active le checkpointing d’activation pour le modèle actuel.

Nous passons la méthode `__call__` des modules plutôt que `forward`, car `__call__` attache tous les hooks du module. https://discuss.pytorch.org/t/any-different-between-model-input-and-model-forward-input/3690/2

#### add_model_tags[[transformers.PreTrainedModel.add_model_tags]]

```python
add_model_tags(tags: list[str] | str)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L1360)

**Paramètres :**

tags (`Union[list[str], str]`) : Les étiquettes souhaitées à injecter dans le modèle

Ajoute des balises personnalisées au modèle qui est poussé sur le Hugging Face Hub. N'écrasera pas les balises existantes du modèle.

Exemples :

```python
from transformers import AutoModel

model = AutoModel.from_pretrained("google-bert/bert-base-cased")

model.add_model_tags(["custom", "custom-bert"])

# Push the model to your namespace with the name "my-custom-bert".
model.push_to_hub("my-custom-bert")
```

#### can_generate[[transformers.PreTrainedModel.can_generate]]

```python
can_generate()
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L1474)

**Retourne :** `bool`

Si ce modèle peut générer des séquences avec `.generate()`.

Indique si ce modèle peut générer des séquences avec `.generate()`, à partir de `GenerationMixin` ou d'une classe ayant une interface similaire.

En interne, pour les classes pour lesquelles cette fonction renvoie True, certaines modifications spécifiques à la génération sont déclenchées : par exemple, l'instance du modèle aura un attribut `generation_config` renseigné.

#### cuda[[transformers.PreTrainedModel.cuda]]

```python
cuda(*args, **kwargs)
```

Une valeur factice pour un chemin pointé (par ex. `torch.float32`) : les chaînes d'accès aux attributs et les appels se comportent comme des décorateurs de pass-through, `repr` est le chemin pointé, et son utilisation comme classe de base substitue une base de `type` ordinaire (PEP 560 `__mro_entries__`), de sorte que les vraies sous-classes conservent un métaclasse normal et que `inspect.signature` lit leur `__init__` réel plutôt que celui d'une valeur factice.

#### dequantize[[transformers.PreTrainedModel.dequantize]]

```python
dequantize(dtype = None)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L1342)

Déquantiser éventuellement le modèle s'il a été quantisé par une méthode de quantisation prenant en charge la déquantisation.

#### disable_input_require_grads[[transformers.PreTrainedModel.disable_input_require_grads]]

```python
disable_input_require_grads()
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L2181)

Supprime le `_require_grads_hook`.

#### enable_input_require_grads[[transformers.PreTrainedModel.enable_input_require_grads]]

```python
enable_input_require_grads()
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L2137)

Active les gradients pour les embeddings d’entrée. Cela est utile pour l’ajustement fin des poids d’adaptateurs tout en maintenant les poids du modèle fixes.

#### from_pretrained[[transformers.PreTrainedModel.from_pretrained]]

```python
from_pretrained(pretrained_model_name_or_path: str | os.PathLike | None, *model_args, config: transformers.configuration_utils.PreTrainedConfig | str | os.PathLike | None = None, cache_dir: str | os.PathLike | None = None, ignore_mismatched_sizes: bool = False, force_download: bool = False, local_files_only: bool = False, token: str | bool | None = None, revision: str = 'main', use_safetensors: bool | None = None, weights_only: bool = True, fusion_config: dict[str, bool | dict[str, typing.Any]] | None = None, disable_mmap: bool | None = None, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L3892)

**Paramètres :**

pretrained_model_name_or_path (`str` ou `os.PathLike`, *facultatif*) : Peut être l'un des éléments suivants :  - Une chaîne de caractères, l'*identifiant du modèle* d'un modèle pré-entraîné hébergé dans un dépôt de modèles sur huggingface.co. - Un chemin vers un *répertoire* contenant les poids du modèle enregistrés à l'aide de [save_pretrained()](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel.save_pretrained), par exemple `./my_model_directory/`. Les répertoires enregistrés avec `save_pretrained(..., distributed_checkpoint=True)` sont détectés et chargés avec le checkpointing distribué (DCP), en préservant le maillage et les placements actuels du modèle. Cela nécessite `torch>=2.7` et effectue un chargement strict : chaque clé du modèle doit être présente dans le checkpoint. - `None` si vous fournissez à la fois la configuration et le dictionnaire d'état (respectivement avec les arguments par mot-clé `config` et `state_dict`).

model_args (séquence d'arguments positionnels, *facultatifs*) : Tous les arguments positionnels restants seront transmis à la méthode `__init__` du modèle sous-jacent.

config (`Union[PreTrainedConfig, str, os.PathLike]`, *facultatif*) : Peut être :  - une instance d'une classe dérivée de [PreTrainedConfig](/docs/transformers/main/fr/main_classes/configuration#transformers.PreTrainedConfig), - une chaîne de caractères ou un chemin valide en tant qu'entrée pour [from_pretrained()](/docs/transformers/main/fr/main_classes/configuration#transformers.PreTrainedConfig.from_pretrained).  Configuration du modèle à utiliser à la place d'une configuration chargée automatiquement. La configuration peut être chargée automatiquement lorsque :  - le modèle est un modèle fourni par la bibliothèque (chargé avec la chaîne de caractères *model id* d'un modèle pré-entraîné). - le modèle a été enregistré à l'aide de [save_pretrained()](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel.save_pretrained) et est rechargé en fournissant le répertoire d'enregistrement. - le modèle est chargé en fournissant un répertoire local en tant que `pretrained_model_name_or_path` et un fichier JSON de configuration nommé *config.json* est trouvé dans le répertoire.

state_dict (`dict[str, torch.Tensor]`, *facultatif*) : Un dictionnaire d'état à utiliser à la place d'un dictionnaire d'état chargé depuis un fichier de poids sauvegardés. Cette option peut être utilisée si vous souhaitez créer un modèle à partir d'une configuration pré-entraînée tout en chargeant vos propres poids. Dans ce cas, toutefois, vous devriez vérifier si l'utilisation de [save_pretrained()](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel.save_pretrained) et [from_pretrained()](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) n'est pas une option plus simple.

cache_dir (`Union[str, os.PathLike]`, *facultatif*) : Chemin vers un répertoire dans lequel la configuration d'un modèle pré-entraîné téléchargé doit être mise en cache si le cache standard ne doit pas être utilisé.

ignore_mismatched_sizes (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut lever une erreur si certaines des poids du point de contrôle n'ont pas la même taille que les poids du modèle (par exemple, si vous instanciez un modèle avec 10 étiquettes à partir d'un point de contrôle avec 3 étiquettes).

force_download (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut forcer le (re)téléchargement des poids du modèle et des fichiers de configuration, en ignorant les versions mises en cache le cas échéant.

proxies (`dict[str, str]`, *facultatif*) : Un dictionnaire de serveurs proxy à utiliser par protocole ou point de terminaison, par exemple `{'http': 'foo.bar:3128', 'http://hostname': 'foo.bar:4012'}`. Les proxys sont utilisés pour chaque requête.

output_loading_info(`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut également retourner un dictionnaire contenant les clés manquantes, les clés inattendues et les messages d'erreur.

local_files_only(`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut uniquement consulter les fichiers locaux (c'est-à-dire ne pas tenter de télécharger le modèle).

token (`str` ou `bool`, *facultatif*) : Jeton à utiliser comme autorisation HTTP bearer pour les fichiers distants. Si `True`, ou non spécifié, le jeton généré lors de l'exécution de `hf auth login` (stocké dans `~/.huggingface`) sera utilisé.

revision (`str`, *facultatif*, valeur par défaut `"main"`) : La version spécifique du modèle à utiliser. Il peut s'agir d'un nom de branche, d'un nom de tag ou d'un identifiant de commit, car nous utilisons un système basé sur git pour stocker les modèles et autres artefacts sur huggingface.co, de sorte que `revision` peut être n'importe quel identifiant autorisé par git. Pour tester une pull request que vous avez créée sur le Hub, vous pouvez passer `revision="refs/pr/<pr_number>"`.

attn_implementation (`str`, *facultatif*) : L'implémentation de l'attention à utiliser dans le modèle (le cas échéant). Peut être l'une des valeurs suivantes - `"eager"` (implémentation manuelle de l'attention) - `"sdpa"` (en utilisant [`F.scaled_dot_product_attention`](https://pytorch.org/docs/master/generated/torch.nn.functional.scaled_dot_product_attention.html)) - `"flash_attention_2"` (en utilisant [Dao-AILab/flash-attention](https://github.com/Dao-AILab/flash-attention)) - `"flash_attention_3"` (en utilisant [Dao-AILab/flash-attention/hopper](https://github.com/Dao-AILab/flash-attention/tree/main/hopper)) - `"flash_attention_4"` (en utilisant [Dao-AILab/flash-attention/flash_attn/cute](https://github.com/Dao-AILab/flash-attention/tree/main/flash_attn/cute)). Par défaut, si disponible, SDPA sera utilisé. Sinon, l'implémentation manuelle `"eager"` est utilisée par défaut.  Accepte les références de noyaux HF sous la forme : /[@][:]  -  et  sont des séquences quelconques ne contenant ni "/" ni ":". - "@" est facultatif (branche, tag ou commit-ish), par exemple "@main", "@v1.2.0", "@abc123". - ":" est facultatif et sélectionne une fonction dans le dépôt du noyau. - Les deux options peuvent apparaître ensemble et uniquement dans cet ordre : @revision d'abord, puis :kernel_name. - Nous autorisons intentionnellement un préfixe "|" initial (par exemple, "flash|...") car le code le supprime avant le chargement ; '|' n'est pas exclu dans les classes de caractères ici.  Exemples qui correspondent : "org/model" "org/model@main" "org/model:custom_kernel" "org/model@v1.2.3:custom_kernel"

experts_implementation (`str`, *facultatif*) : L'implémentation des experts à utiliser dans le modèle (le cas échéant). Peut être l'un des éléments suivants :  - `"eager"` (implémentation séquentielle des multiplications de matrices des experts). - `"batched_mm"` (utilisant [`torch.bmm`](https://pytorch.org/docs/stable/generated/torch.bmm.html)). - `"grouped_mm"` (utilisant [`torch.nn.functional.grouped_mm`](https://docs.pytorch.org/docs/main/generated/torch.nn.functional.grouped_mm.html)).  Par défaut, si le modèle le prend en charge, `"grouped_mm"` sera utilisé. Sinon, l'implémentation manuelle `"eager"` est utilisée par défaut.

**Paramètres pour l'inférence de grands modèles :**

dtype (`str` ou `torch.dtype`, *facultatif*, valeur par défaut `"auto"`) : Remplace la valeur par défaut de `torch_dtype` et charge le modèle avec un `dtype` spécifique. Les différentes options sont :  1. `torch.float16` ou `torch.bfloat16` ou `torch.float` : charge le modèle avec le `dtype` spécifié, en ignorant le `config.dtype` du modèle s'il existe. S'il n'est pas spécifié, le modèle sera chargé en `torch.float` (fp32).  2. `"auto"` - Une entrée `dtype` ou `torch_dtype` dans le fichier `config.json` du modèle sera utilisée si elle est présente. Si cette entrée n'est pas trouvée, le `dtype` du premier poids du checkpoint de type point flottant est vérifié et utilisé comme `dtype`. Le modèle sera alors chargé avec le `dtype` dans lequel il a été enregistré à la fin de l'entraînement. Cela ne peut pas servir d'indicateur de la manière dont le modèle a été entraîné, car il est possible qu'il ait été entraîné en demi-précision mais enregistré en fp32.  3. Une chaîne de caractères correspondant à un `torch.dtype` valide. Par exemple, "float32" charge le modèle en `torch.float32`, "float16" en `torch.float16`, etc.    Pour certains modèles, le `dtype` utilisé pour l'entraînement est inconnu - vous pouvez consulter le papier du modèle ou contacter les auteurs pour leur demander d'ajouter cette information à la carte du modèle et d'insérer l'entrée `dtype` ou `torch_dtype` dans `config.json` sur le hub.

device_map (`str` ou `dict[str, Union[int, str, torch.device]]` ou `int` ou `torch.device`, *facultatif*) : Une carte qui spécifie l'emplacement de chaque sous-module. Elle n'a pas besoin d'être affinée au niveau de chaque nom de paramètre/buffer ; dès qu'un nom de module est inclus, tous ses sous-modules seront envoyés sur le même appareil. Si nous ne passons que l'appareil (*par ex.*, `"cpu"`, `"cuda:1"`, `"mps"`, ou un rang ordinal de GPU comme `1`) sur lequel le modèle sera alloué, la carte d'appareils mapera l'ensemble du modèle sur cet appareil. Passer `device_map = 0` signifie placer le modèle entier sur le GPU 0. Pour que Accelerate calcule automatiquement le `device_map` le plus optimisé, définissez `device_map="auto"`. Pour plus d'informations sur chaque option, consultez [concevoir une carte d'appareils](https://hf.co/docs/accelerate/main/en/usage_guides/big_modeling#designing-a-device-map).

max_memory (`Dict`, *facultatif*) : Un dictionnaire associant un identifiant de périphérique à la mémoire maximale à utiliser si `device_map` est employé. Par défaut, la valeur est la mémoire maximale disponible pour chaque GPU et la RAM CPU disponible, si elle n'est pas définie.

distributed_config ([DistributedConfig](/docs/transformers/main/fr/expert_parallelism#transformers.DistributedConfig), *facultatif*) : Configuration pour le chargement distribué natif avec parallélisme de tenseurs ou FSDP2. Passez `DistributedConfig(tp_size=N)` pour utiliser le plan de parallélisme de tenseurs prédéfini d'un modèle, `DistributedConfig(tp_plan=...)` pour spécifier un plan de parallélisme de tenseurs, ou `DistributedConfig(fsdp_size=N)` pour FSDP2. Nécessite `torchrun` et un groupe de processus initialisé lorsque `tp_size > 1` ou `fsdp_size > 1`. Mutuellement exclusif avec `device_map`.

device_mesh (`torch.distributed.DeviceMesh`, *facultatif*) : Un mesh de dispositifs torch. S'il n'est pas fourni, la taille du monde est utilisée par défaut. Utilisé uniquement pour le parallélisme de tenseurs pour le moment. S'il est fourni, il doit contenir une dimension nommée `"tp"` s'il est de dimension supérieure à 1 ; cette dimension sera utilisée pour le parallélisme de tenseurs.

offload_folder (`str` ou `os.PathLike`, *facultatif*) : Si la valeur `"disk"` est présente dans `device_map`, le dossier où les poids seront déchargés.

offload_buffers (`bool`, *facultatif*) : Indique s'il faut décharger les tampons avec les paramètres du modèle.

quantization_config (`Union[QuantizationConfigMixin,Dict]`, *facultatif*) : Un dictionnaire de paramètres de configuration ou un objet QuantizationConfigMixin pour la quantification (par exemple bitsandbytes, gptq).

subfolder (`str`, *facultatif*, valeur par défaut `""`) : si les fichiers concernés se trouvent dans un sous-dossier du dépôt de modèle sur huggingface.co, vous pouvez spécifier le nom du dossier ici.

variant (`str`, *facultatif*) : Si spécifié, charge les poids depuis le nom de fichier `variant`, *par ex.* pytorch_model..bin.

use_safetensors (`bool`, *facultatif*, par défaut `None`) : Indique s'il faut ou non utiliser des points de contrôle `safetensors`. La valeur par défaut est `None`. Si elle n'est pas spécifiée et que `safetensors` n'est pas installé, elle est définie sur `False`.

weights_only (`bool`, *facultatif*, valeur par défaut `True`) : Indique si l'unpickler doit être restreint au chargement de tenseurs, de types primitifs, de dictionnaires et de tout type ajouté via torch.serialization.add_safe_globals(). Lorsqu'il est défini sur False, il est possible de charger les poids des sous-classes de tenseurs enveloppés.

disable_mmap (`bool`, *facultatif*) : Indique s'il faut désactiver le mappage mémoire lors du chargement des points de contrôle safetensors. Lorsque la valeur est `None` (par défaut), la détection automatique définit la valeur sur `True` si le point de contrôle se trouve sur un système de fichiers FUSE `hf-mount` (utilisé par HF Spaces/Endpoints), car mmap + les défauts de page parallèles peuvent provoquer un blocage. Lorsque la valeur est `True`, les fichiers sont entièrement lus en mémoire et analysés avec `safetensors.torch.load`. Lorsque la valeur est `False`, le chargeur par défaut avec mappage mémoire est toujours utilisé.

fusion_config (`dict[str, bool | dict[str, Any]]`, *facultatif*) : Configuration de fusion facultative appliquée avant l'instantiation du modèle. Chaque clé active une famille de fusion et sa valeur peut être `True` pour activer cette fusion avec les options par défaut, ou un dictionnaire d'options spécifiques à la famille. Par exemple, `{"patch_embeddings": True}` active la fusion des patch embeddings. Cette option ne doit être utilisée que comme optimisation d'inférence, car elle peut légèrement modifier les sorties. Si elle est omise, `from_pretrained()` utilise `config.fusion_config` si celui-ci est disponible. Consultez le guide de correspondance des fusions dans `docs/source/en/fusion_mapping.md` pour plus de détails.

key_mapping (`dict[str, str], *optionnel*) : Un éventuel mappage des noms de poids si l'on utilise un modèle sur le Hub compatible avec une architecture Transformers, mais qui n'a pas été converti en conséquence.

kwargs (reste du dictionnaire des arguments par mot-clé, *facultatif*) : peut être utilisé pour mettre à jour l'objet de configuration (après son chargement) et initialiser le modèle (par ex. `output_attentions=True`). Le comportement varie selon qu'une `config` est fournie ou chargée automatiquement : - Si une configuration est fournie avec `config`, `**kwargs` est transmis directement à la méthode `__init__` du modèle sous-jacent (on suppose que toutes les mises à jour pertinentes de la configuration ont déjà été effectuées) - Si aucune configuration n'est fournie, `kwargs` est d'abord transmis à la fonction d'initialisation de la classe de configuration ([from_pretrained()](/docs/transformers/main/fr/main_classes/configuration#transformers.PreTrainedConfig.from_pretrained)). Chaque clé de `kwargs` correspondant à un attribut de configuration est utilisée pour remplacer ledit attribut par la valeur `kwargs` fournie. Les clés restantes qui ne correspondent à aucun attribut de configuration sont transmises à la fonction `__init__` du modèle sous-jacent.

Instanciez un modèle pytorch pré-entraîné à partir d'une configuration de modèle pré-entraîné.

Le modèle est défini par défaut en mode d'évaluation à l'aide de `model.eval()` (les modules Dropout sont désactivés). Pour entraîner le modèle, vous devez d'abord le remettre en mode d'entraînement avec `model.train()`.

L'avertissement *Weights from XXX not initialized from pretrained model* signifie que les poids de XXX ne sont pas pré-entraînés avec le reste du modèle. Il vous incombe d'entraîner ces poids avec une tâche de fine-tuning en aval.

L'avertissement *Weights from XXX not used in YYY* signifie que la couche XXX n'est pas utilisée par YYY, par conséquent ces poids sont ignorés.

Activez le mode spécial ["offline-mode"](https://huggingface.co/transformers/installation.html#offline-mode) pour utiliser cette méthode dans un environnement protégé par un pare-feu.

Exemples :

```python
>>> from transformers import BertConfig, BertModel

>>> # Download model and configuration from huggingface.co and cache.
>>> model = BertModel.from_pretrained("google-bert/bert-base-uncased")
>>> # Model was saved using *save_pretrained('./test/saved_model/')* (for example purposes, not runnable).
>>> model = BertModel.from_pretrained("./test/saved_model/")
>>> # Update configuration during loading.
>>> model = BertModel.from_pretrained("google-bert/bert-base-uncased", output_attentions=True)
>>> assert model.config.output_attentions == True
```

#### get_compiled_call[[transformers.PreTrainedModel.get_compiled_call]]

```python
get_compiled_call(compile_config: transformers.generation.configuration_utils.CompileConfig | None)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L4799)

Retourne une version compilée avec `torch.compile` de `self.__call__`. Cela est utile pour choisir dynamiquement entre `forward` non compilé et compilé pendant l’inférence, en particulier pour basculer entre le préremplissage (où l’on ne souhaite pas utiliser la version compilée afin d’éviter de recalculer le graphe avec de nouvelles formes) et le décodage itératif (où l’on souhaite bénéficier des gains de vitesse de la version compilée avec des formes statiques).

#### get_decoder[[transformers.PreTrainedModel.get_decoder]]

```python
get_decoder()
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L2254)

Recherche au mieux du module *decoder*.

Ordre des tentatives (couvre ~85 % des usages actuels) :

1. `self.decoder/self.language_model/self.text_model`
2. `self.base_model`                  (de nombreux wrappers stockent le décodeur ici)
3. `self.base_model.get_decoder()`    (enveloppes imbriquées)
4. fallback : lever une exception pour les quelques modèles exotiques qui nécessitent une règle sur mesure

#### get_encoder[[transformers.PreTrainedModel.get_encoder]]

```python
get_encoder(modality: str | None = None)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L2196)

Recherche au mieux du module *encoder*. Si l'argument `modality` est fourni, la fonction recherche un encodeur spécifique à la modalité dans les modèles multimodaux (par exemple, "image_encoder"). Par défaut, la fonction renvoie l'encodeur de texte du modèle s'il en existe un, et renvoie sinon `self`.

Les valeurs possibles de `modality` sont "image", "video" et "audio".

#### get_expanded_tied_weights_keys[[transformers.PreTrainedModel.get_expanded_tied_weights_keys]]

```python
get_expanded_tied_weights_keys(all_submodels: bool = False)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L2416)

Retourne les clés de poids liés développées (au cas où elles contiennent des modules ou des motifs regex) uniquement pour le modèle actuel, ou récursivement pour tous les sous-modèles si `all_submodels=True` (c’est-à-dire qu’il réexaminera les valeurs de configuration pour tous les sous-modèles).

Pour la quasi-totalité des modèles, il suffit de lier les embeddings, de sorte que le modèle possède une propriété interne `_tied_weights_keys = {"lm_head.weight": "model.embed_tokens.weight"}`. Dans ce cas, la correspondance est déjà « développée », c'est-à-dire qu'elle contient déjà les paramètres complets, et cette fonction renverra simplement une copie de la propriété. Pour des motifs plus complexes, par exemple pour `DFineForObjectDetection`, nous avons l'attribut suivant

```
_tied_weights_keys = {
    r"bbox_embed.(?![0])\d+": "bbox_embed.0",
    r"class_embed.(?![0])\d+": "class_embed.0",
    "model.decoder.class_embed": "class_embed",
    "model.decoder.bbox_embed": "bbox_embed",
}
```

Dans ce cas, la fonction recherche tous les paramètres et tampons du modèle, et associe tous les paramètres,

retournant ce qui suit :
```
{
    'bbox_embed.1.layers.0.bias': 'bbox_embed.0.layers.0.bias',
    'bbox_embed.1.layers.0.weight': 'bbox_embed.0.layers.0.weight',
    'bbox_embed.1.layers.1.bias': 'bbox_embed.0.layers.1.bias',
    'bbox_embed.1.layers.1.weight': 'bbox_embed.0.layers.1.weight',
    'bbox_embed.1.layers.2.bias': 'bbox_embed.0.layers.2.bias',
    'bbox_embed.1.layers.2.weight': 'bbox_embed.0.layers.2.weight',
    'bbox_embed.2.layers.0.bias': 'bbox_embed.0.layers.0.bias',
    'bbox_embed.2.layers.0.weight': 'bbox_embed.0.layers.0.weight',
    ...
    'class_embed.1.bias': 'class_embed.0.bias',
    'class_embed.1.weight': 'class_embed.0.weight',
    'class_embed.2.bias': 'class_embed.0.bias',
    'class_embed.2.weight': 'class_embed.0.weight',
    ...
    'model.decoder.class_embed.0.bias': 'class_embed.0.bias',
    'model.decoder.class_embed.0.weight': 'class_embed.0.weight',
    'model.decoder.class_embed.1.bias': 'class_embed.0.bias',
    'model.decoder.class_embed.1.weight': 'class_embed.0.weight',
    ...
    'model.decoder.bbox_embed.0.layers.0.bias': 'bbox_embed.0.layers.0.bias',
    'model.decoder.bbox_embed.0.layers.0.weight': 'bbox_embed.0.layers.0.weight',
    'model.decoder.bbox_embed.0.layers.1.bias': 'bbox_embed.0.layers.1.bias',
    'model.decoder.bbox_embed.0.layers.1.weight': 'bbox_embed.0.layers.1.weight',
    ...
}
```

c.-à-d. tous les paramètres correspondant aux motifs d'expressions régulières et de modules dans `_tied_weights_keys`

#### get_experts_implementation[[transformers.PreTrainedModel.get_experts_implementation]]

```python
get_experts_implementation()
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L2064)

Retourne l’implémentation des experts de ce modèle et de ses sous-modèles, sous forme d’un `dict` au format accepté par `set_experts_implementation` (`""` pour ce modèle, et une entrée par sous_configuration). C’est l’opération inverse de `set_experts_implementation`, par exemple pour capturer l’implémentation actuelle et la restaurer ultérieurement.

#### get_memory_footprint[[transformers.PreTrainedModel.get_memory_footprint]]

```python
get_memory_footprint(return_buffers = True)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L3676)

**Paramètres :**

return_buffers (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut inclure la taille des tenseurs de tampon dans le calcul de l'empreinte mémoire. Les tampons sont des tenseurs qui ne nécessitent pas de gradients et qui ne sont pas enregistrés en tant que paramètres. Par exemple, la moyenne et l'écart-type dans les couches de normalisation par lot. Voir : https://discuss.pytorch.org/t/what-pytorch-means-by-buffers/120266/2

Obtenir l’empreinte mémoire d’un modèle. Cette méthode renvoie l’empreinte mémoire du modèle actuel, exprimée en octets. Elle est utile pour mesurer l’empreinte mémoire du modèle en cours et concevoir des tests. Solution inspirée des discussions PyTorch : https://discuss.pytorch.org/t/gpu-memory-that-model-uses/56822/2

#### get_parameter_or_buffer[[transformers.PreTrainedModel.get_parameter_or_buffer]]

```python
get_parameter_or_buffer(target: str)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L4966)

Retourne le paramètre ou le tampon indiqué par `target` s'il existe, sinon lève une erreur. Cette fonction combine `get_parameter()` et `get_buffer()` en une seule fonction pratique. Si la cible est un attribut `_extra_state`, elle retourne l'état supplémentaire fourni par le module. Notez que cela ne fonctionne que si `target` est une feuille du modèle.

#### gradient_checkpointing_disable[[transformers.PreTrainedModel.gradient_checkpointing_disable]]

```python
gradient_checkpointing_disable()
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L3276)

Alias obsolète de [activation_checkpointing_disable()](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel.activation_checkpointing_disable), sera supprimé dans la v6.

#### gradient_checkpointing_enable[[transformers.PreTrainedModel.gradient_checkpointing_enable]]

```python
gradient_checkpointing_enable(gradient_checkpointing_kwargs = None, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L3191)

Alias obsolète de [activation_checkpointing_enable()](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel.activation_checkpointing_enable), sera supprimé dans la v6.

#### init_weights[[transformers.PreTrainedModel.init_weights]]

```python
init_weights()
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L3098)

Initialiser et lier les poids si nécessaire. Si vous utilisez un `PreTrainedModel` personnalisé, vous devez implémenter toute la logique d’initialisation dans `_init_weights`.

#### initialize_weights[[transformers.PreTrainedModel.initialize_weights]]

```python
initialize_weights()
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L2386)

Cela équivaut à appeler `self.apply(self._initialize_weights)`, mais gère correctement les modèles composites. Cette fonction dispatche dynamiquement la fonction `init_weights` appropriée aux modules au fur et à mesure que nous avançons dans le graphe de modules le long de la récursion. Elle peut gérer un nombre arbitraire de sous-modèles. Sans elle, chaque modèle composite devrait récursiver une seconde fois sur tous les sous-modèles explicitement dans le `_init_weights` le plus externe, ce qui est extrêmement sujet aux erreurs et inefficace.

#### is_custom_code[[transformers.PreTrainedModel.is_custom_code]]

```python
is_custom_code()
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L5020)

Indique si le modèle actuel est du code personnalisé, c'est-à-dire soit du code chargé depuis le hub, soit défini dans un module ou une session spécifique à l'utilisateur.

#### is_remote_code[[transformers.PreTrainedModel.is_remote_code]]

```python
is_remote_code()
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L5014)

Indique si le modèle actuel est un code personnalisé, c'est-à-dire un code chargé depuis le hub, ou une classe que nous venons d'enregistrer via `register_for_auto_class`.

#### mark_tied_weights_as_initialized[[transformers.PreTrainedModel.mark_tied_weights_as_initialized]]

```python
mark_tied_weights_as_initialized(loading_info)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L4938)

Ajoute le drapeau `_is_hf_initialized` sur les paramètres qui seront liés, afin d’éviter de les initialiser ultérieurement, puisqu’ils seront de toute façon liés (écrasés). C’est très important, car la plupart des embeddings sont liés et ce sont de très gros paramètres (les vocabulaires font souvent 256k), ce qui rend leur initialisation très coûteuse.

#### named_non_persistent_buffers[[transformers.PreTrainedModel.named_non_persistent_buffers]]

```python
named_non_persistent_buffers(recurse: bool = True, remove_duplicate: bool = True)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L4990)

Similaire à `named_buffers`, mais ne renvoie que les buffers non persistants. C’est pratique, car il n’est pas toujours évident de savoir s’ils sont persistants ou non.

#### post_init[[transformers.PreTrainedModel.post_init]]

```python
post_init()
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L1289)

Une méthode exécutée à la fin de l'initialisation de chaque modèle Transformer, afin d'exécuter le code qui nécessite que les modules du modèle soient correctement initialisés (comme l'initialisation des poids). Elle est également utilisée pour obtenir correctement toutes les propriétés statiques (plans de parallélisme, tied_weights_keys, _keep_in_fp32_modules, etc.) dans le cas des modèles composites (c'est-à-dire que le modèle de niveau supérieur doit connaître ces propriétés issues de ses enfants).

#### register_for_auto_class[[transformers.PreTrainedModel.register_for_auto_class]]

```python
register_for_auto_class(auto_class = 'AutoModel')
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L4645)

**Paramètres :**

auto_class (`str` ou `type`, *facultatif*, valeur par défaut `"AutoModel"`) : La classe auto avec laquelle enregistrer ce nouveau modèle.

Enregistrez cette classe avec une classe auto donnée. Cette opération ne doit être utilisée que pour les modèles personnalisés, car ceux de la bibliothèque sont déjà associés à une classe auto.

#### resize_token_embeddings[[transformers.PreTrainedModel.resize_token_embeddings]]

```python
resize_token_embeddings(new_num_tokens: int | None = None, pad_to_multiple_of: int | None = None, mean_resizing: bool = True)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L2633)

**Paramètres :**

new_num_tokens (`int`, *facultatif*) : Le nouveau nombre de jetons dans la matrice d'intégration. L'augmentation de la taille ajoutera de nouveaux vecteurs initialisés à la fin. La réduction de la taille supprimera des vecteurs à partir de la fin. S'il n'est pas fourni ou vaut `None`, renvoie simplement un pointeur vers le module `torch.nn.Embedding` des jetons d'entrée du modèle sans rien faire.

pad_to_multiple_of (`int`, *facultatif*) : Si défini, la matrice d'incorporation sera rembourrée jusqu'à un multiple de la valeur fournie. Si `new_num_tokens` est défini sur `None`, l'incorporation sera simplement rembourrée jusqu'à un multiple de `pad_to_multiple_of`.  Cela est particulièrement utile pour permettre l'utilisation des Tensor Cores sur le matériel NVIDIA avec une capacité de calcul `>= 7.5` (Volta), ou sur les TPU qui bénéficient d'avoir des longueurs de séquence qui sont des multiples de 128. Pour plus de détails à ce sujet, ou pour de l'aide sur le choix de la valeur correcte pour le redimensionnement, consultez ce guide : https://docs.nvidia.com/deeplearning/performance/dl-performance-matrix-multiplication/index.html#requirements-tc

mean_resizing (`bool`) : Indique s'il faut initialiser les embeddings ajoutés à partir d'une distribution normale multivariée ayant la moyenne et la covariance des anciens embeddings, ou s'il faut les initialiser avec une distribution normale de moyenne nulle et d'écart-type égal à `config.initializer_range`. Définir `mean_resizing` sur `True` est utile lors de l'augmentation de la taille des embeddings des modèles de langage causaux, car les probabilités des jetons générés ne seront pas affectées par les embeddings ajoutés, l'initialisation des nouveaux embeddings avec la moyenne des anciens réduisant la divergence de KL entre la probabilité du jeton suivant avant et après l'ajout des nouveaux embeddings. Consultez cet article pour plus d'informations : https://nlp.stanford.edu/~johnhew/vocab-expansion.html

**Retourne :** `torch.nn.Embedding`

Pointeur vers le module d'embeddings des jetons d'entrée du modèle.

Redimensionne la matrice des embeddings de jetons d'entrée du modèle si `new_num_tokens != config.vocab_size`.

Gère le rattachement des poids des embeddings par la suite si la classe du modèle dispose d'une méthode `tie_weights()`.

#### save_pretrained[[transformers.PreTrainedModel.save_pretrained]]

```python
save_pretrained(save_directory: str | os.PathLike, is_main_process: bool = True, state_dict: dict | None = None, push_to_hub: bool = False, max_shard_size: int | str = '50GB', variant: str | None = None, token: str | bool | None = None, save_peft_format: bool = True, save_original_format: bool = True, distributed_checkpoint: bool = False, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L3310)

**Paramètres :**

save_directory (`str` ou `os.PathLike`) : Répertoire de sauvegarde. Il sera créé s'il n'existe pas.

is_main_process (`bool`, *facultatif*, valeur par défaut `True`) : Indique si le processus qui effectue cet appel est le processus principal. Utile lors d'une formation distribuée, par exemple sur des TPU, où il est nécessaire d'appeler cette fonction sur tous les processus. Dans ce cas, définissez `is_main_process=True` uniquement sur le processus principal afin d'éviter les conditions de course.

state_dict (dictionnaire imbriqué de `torch.Tensor`) : Le dictionnaire d'état du modèle à enregistrer. Par défaut, il vaut `self.state_dict()`, mais il peut être utilisé pour n'enregistrer que certaines parties du modèle ou si des précautions particulières doivent être prises lors de la récupération du dictionnaire d'état d'un modèle (comme lors de l'utilisation du parallélisme de modèle).

push_to_hub (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut ou non publier votre modèle sur le Hugging Face model hub après l'avoir enregistré. Vous pouvez spécifier le dépôt de destination avec `repo_id` (par défaut, il s'agit du nom de `save_directory` dans votre espace de noms).

max_shard_size (`int` ou `str`, *facultatif*, valeur par défaut `"50GB"`) : La taille maximale d'un point de contrôle avant qu'il ne soit fractionné. Les points de contrôle fractionnés auront chacun une taille inférieure à cette valeur. S'il est exprimé sous forme de chaîne, il doit être composé de chiffres suivis d'une unité (comme `"5MB"`).    Si un seul poids du modèle est plus grand que `max_shard_size`, il sera placé dans sa propre fraction de point de contrôle, qui sera plus grande que `max_shard_size`.

variant (`str`, *facultatif*) : Si spécifié, les poids sont enregistrés au format model..safetensors.

token (`str` ou `bool`, *facultatif*) : Jeton à utiliser comme autorisation HTTP bearer pour les fichiers distants. Si `True`, ou non spécifié, le jeton généré lors de l'exécution de `hf auth login` (stocké dans `~/.huggingface`) sera utilisé.

save_peft_format (`bool`, *facultatif*, valeur par défaut `True`) : pour assurer la rétrocompatibilité avec la bibliothèque PEFT, si des poids d'adaptateurs sont attachés au modèle, toutes les clés du dictionnaire d'état des adaptateurs doivent être préfixées par `base_model.model`. Les utilisateurs avancés peuvent désactiver ce comportement en définissant `save_peft_format` sur `False`.

save_original_format (`bool`, *facultatif*, valeur par défaut `True`) : Pour des raisons de rétrocompatibilité avec les versions précédentes de `transformers`, vous pouvez enregistrer le point de contrôle avec sa correspondance inverse. La correspondance inverse doit exister, même si le modèle a été chargé à partir d'un point de contrôle legacy None.

distributed_checkpoint (`bool`, *facultatif*, valeur par défaut `False`) : lors de l'enregistrement d'un modèle sharded avec FSDP ou TP, écrit les safetensors avec le checkpointing distribué (DCP) au lieu de regrouper d'abord les poids sur le CPU. Chaque rang doit appeler cette méthode. Si `False`, les poids sont regroupés sur le CPU au rang 0 via `gather_full_state_dict` avant l'écriture. Cette option est destinée uniquement à l'enregistrement et à la reprise de l'entraînement ; définissez-la sur `False` si vous souhaitez bénéficier de toutes les fonctionnalités de `save_pretrained`. Avec `push_to_hub=True`, le rang 0 consolide le checkpoint dans un sous-répertoire `consolidated/` et téléverse ce répertoire. Nécessite `torch>=2.7`.

kwargs (`dict[str, Any]`, *facultatif*) : Arguments supplémentaires par mot-clé transmis à la méthode [push_to_hub()](/docs/transformers/main/fr/main_classes/model#transformers.utils.PushToHubMixin.push_to_hub).

Enregistrer un modèle et son fichier de configuration dans un répertoire, afin qu’il puisse être rechargé à l’aide de la méthode de classe [from_pretrained()](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained).

#### set_attn_implementation[[transformers.PreTrainedModel.set_attn_implementation]]

```python
set_attn_implementation(attn_implementation: str | dict, allow_all_kernels: bool = False)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L1960)

**Paramètres :**

attn_implementation (`str` ou `dict`) : L'implémentation de l'attention à définir pour ce modèle. Elle peut être soit une `str`, auquel cas elle sera appliquée à tous les sous-modèles le cas échéant, soit un `dict` dont les clés sont les noms des sub_configs, auquel cas chaque sous-modèle appliquera la valeur correspondante (à lui-même et à tous les sous-modèles imbriqués). Une valeur peut elle-même être un `dict` au même format, afin de cibler les sub_configs de ce sous-modèle (comme lors de l'initialisation d'une config avec un `attn_implementation` dict imbriqué).

allow_all_kernels (`bool`, optionnel) : Indique s'il faut charger les noyaux depuis des dépôts hub non vérifiés, si `attn_implementation` est un noyau personnalisé situé en dehors du dépôt hub `kernels-community`.

Définissez le `attn_implementation` demandé pour ce modèle.

#### set_decoder[[transformers.PreTrainedModel.set_decoder]]

```python
set_decoder(decoder)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L2277)

Définisseur symétrique. Reprend la logique de recherche utilisée dans `get_decoder`.

#### set_encoder[[transformers.PreTrainedModel.set_encoder]]

```python
set_encoder(encoder, modality: str | None = None)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L2228)

Définisseur symétrique. Reprend la logique de recherche utilisée dans `get_encoder`.

#### set_experts_implementation[[transformers.PreTrainedModel.set_experts_implementation]]

```python
set_experts_implementation(experts_implementation: str | dict)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L2077)

**Paramètres :**

experts_implementation (`str` ou `dict`) : L'implémentation des experts à définir pour ce modèle. Il peut s'agir d'une `str`, auquel cas elle sera distribuée à tous les sous-modèles le cas échéant, ou d'un `dict` dont les clés sont les noms des sous_configurations, auquel cas chaque sous-modèle distribuera la valeur correspondante.

Définissez l'`experts_implementation` demandé pour ce modèle.

#### set_use_kernels[[transformers.PreTrainedModel.set_use_kernels]]

```python
set_use_kernels(use_kernels, kernel_config: transformers.utils.kernel_config.KernelConfig | None = None, mode: Mode | None = None)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L3850)

**Paramètres :**

use_kernels (`bool`) : Indique s'il faut utiliser la bibliothèque `kernels` pour kerneliser certaines couches du modèle.

kernel_config (`KernelConfig`, *facultatif*) : La configuration du noyau à utiliser pour kerneliser le modèle. Si `None`, la correspondance de noyaux par défaut sera utilisée.

mode (`Mode`, *facultatif*) : le mode à appliquer lors de `kernelize`. Facultatif, par défaut il est défini sur le mode d'entraînement ou d'inférence en fonction du drapeau interne `training`.

Définir si la bibliothèque `kernels` doit être utilisée pour kerneliser certaines couches du modèle.

#### tie_weights[[transformers.PreTrainedModel.tie_weights]]

```python
tie_weights(missing_keys: set[str] | None = None, recompute_mapping: bool = True)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L2530)

Lier les poids du modèle. Si `recompute_mapping=False` (valeur par défaut lors d'un appel interne), il s'appuiera sur l'attribut `model.all_tied_weights_keys`, qui contient la correspondance `{target: source}` pour les paramètres liés. Si `recompute_mapping=True`, il réexaminera tous les sous-modèles internes et leur configuration pour déterminer les paramètres qui doivent être liés. C'est la valeur par défaut lorsque `model.tie_weights()` est appelé seul, en dehors de `__init__` et de `from_pretrained`, au cas où les valeurs de la configuration auraient été modifiées ailleurs.

Notez que lors de `from_pretrained`, le rattachement est *symétrique* : si la correspondance indique « rattachement cible -> source » mais que `source` est absent du point de contrôle tandis que `target` existe, nous *inversions* source et cible afin de pouvoir rattacher l'ensemble au paramètre qui existe réellement.

#### vers[[transformers.PreTrainedModel.to]]

```python
to(*args, **kwargs)
```

Une valeur factice pour un chemin pointé (par ex. `torch.float32`) : les chaînes d'accès aux attributs et les appels se comportent comme des décorateurs de pass-through, `repr` est le chemin pointé, et son utilisation comme classe de base substitue une base de `type` ordinaire (PEP 560 `__mro_entries__`), de sorte que les vraies sous-classes conservent un métaclasse normal et que `inspect.signature` lit leur `__init__` réel plutôt que celui d'une valeur factice.

#### warn_if_padding_and_no_attention_mask[[transformers.PreTrainedModel.warn_if_padding_and_no_attention_mask]]

```python
warn_if_padding_and_no_attention_mask(input_ids, attention_mask)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L4667)

Affiche un avertissement unique si les input_ids semblent contenir du padding et qu'aucun masque d'attention n'a été fourni.

Les modèles personnalisés doivent également inclure `_supports_assign_param_buffer`, qui détermine si l'initialisation superfast peut s'appliquer au modèle en question. Un signe que votre modèle en a besoin est l'échec de `test_save_and_load_from_pretrained`. Dans ce cas, définissez cette valeur sur `False`.

## ModuleUtilsMixin[[transformers.modeling_utils.ModuleUtilsMixin]]

#### transformers.modeling_utils.ModuleUtilsMixin[[transformers.modeling_utils.ModuleUtilsMixin]]

```python
transformers.modeling_utils.ModuleUtilsMixin()
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L894)

Quelques utilitaires pour `torch.nn.Modules`, à utiliser en tant que mixin.

#### num_parameters[[transformers.modeling_utils.ModuleUtilsMixin.num_parameters]]

```python
num_parameters(only_trainable: bool = False, exclude_embeddings: bool = False)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L914)

**Paramètres :**

only_trainable (`bool`, *facultatif*, par défaut `False`) : Indique s'il faut renvoyer uniquement le nombre de paramètres entraînables

exclude_embeddings (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut renvoyer uniquement le nombre de paramètres non liés aux embeddings.

**Retourne :** `int`

Le nombre de paramètres.

Obtenir le nombre de paramètres (facultativement, entraînables ou non-embeddings) du module.

## Pousser vers le Hub[[transformers.utils.PushToHubMixin]]

#### transformers.utils.PushToHubMixin[[transformers.utils.PushToHubMixin]]

```python
transformers.utils.PushToHubMixin()
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/hub.py#L728)

Un Mixin contenant la fonctionnalité permettant de pousser un modèle ou un tokenizer vers le hub.

#### push_to_hub[[transformers.utils.PushToHubMixin.push_to_hub]]

```python
push_to_hub(repo_id: str, commit_message: str | None = None, commit_description: str | None = None, private: bool | None = None, token: bool | str | None = None, revision: str | None = None, create_pr: bool = False, max_shard_size: int | str | None = '50GB', tags: list[str] | None = None)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/hub.py#L822)

**Paramètres :**

repo_id (`str`) : Le nom du dépôt vers lequel vous souhaitez pousser votre {object}. Il doit contenir le nom de votre organisation lors d'une poussée vers une organisation donnée.

commit_message (`str`, *facultatif*) : Message à commiter lors de la poussée. La valeur par défaut est `"Upload {object}"`.

commit_description (`str`, *facultatif*) : La description du commit qui sera créé

private (`bool`, *facultatif*) : Indique s'il faut rendre le dépôt privé. Si la valeur est `None` (par défaut), le dépôt sera public, sauf si le défaut de l'organisation est privé. Cette valeur est ignorée si le dépôt existe déjà.

token (`bool` ou `str`, *facultatif*) : Jeton à utiliser comme autorisation HTTP bearer pour les fichiers distants. Si `True` (par défaut), le jeton généré lors de l'exécution de `hf auth login` (stocké dans `~/.huggingface`) sera utilisé.

revision (`str`, *facultatif*) : Branche vers laquelle pousser les fichiers téléversés.

create_pr (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut créer une PR avec les fichiers téléversés ou effectuer un commit direct.

max_shard_size (`int` ou `str`, *facultatif*, valeur par défaut `"50GB"`) : Ne s'applique qu'aux modèles. Taille maximale d'un point de contrôle avant son fractionnement. Les points de contrôle fractionnés auront chacun une taille inférieure à cette valeur. S'il est exprimé sous forme de chaîne, il doit être composé de chiffres suivis d'une unité (comme `"5MB"`).

tags (`list[str]`, *facultatif*) : Liste de tags à pousser sur le Hub.

Téléversez {object_files} sur le 🤗 Model Hub.

Exemples :

```python
from transformers import {object_class}

{object} = {object_class}.from_pretrained("google-bert/bert-base-cased")

# Push the {object} to your namespace with the name "my-finetuned-bert".
{object}.push_to_hub("my-finetuned-bert")

# Push the {object} to an organization with the name "my-finetuned-bert".
{object}.push_to_hub("huggingface/my-finetuned-bert")
```