# PEFT[[transformers.integrations.PeftAdapterMixin]]

Le [PeftAdapterMixin](/docs/transformers/v5.23.0/fr/main_classes/peft#transformers.integrations.PeftAdapterMixin) fournit les fonctions de la bibliothèque [PEFT](https://huggingface.co/docs/peft/index) pour la gestion des adaptateurs avec Transformers. Ce mixin prend en charge toutes les méthodes PEFT non basées sur l'apprentissage de prompts (LoRA, IA3, AdaLoRA, etc.). Les méthodes de prefix tuning (prompt tuning, prompt learning) ne sont pas prises en charge, car elles ne peuvent pas être injectées dans un module torch.

#### transformers.integrations.PeftAdapterMixin[[transformers.integrations.PeftAdapterMixin]]

```python
transformers.integrations.PeftAdapterMixin()
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/integrations/peft.py#L57)

Une classe contenant toutes les fonctions de chargement et d'utilisation des poids d'adaptateurs pris en charge par la bibliothèque PEFT. Pour plus de détails sur les adaptateurs et leur injection dans un modèle basé sur un transformer, consultez la documentation de la bibliothèque PEFT : https://huggingface.co/docs/peft/index

Les méthodes PEFT actuellement prises en charge sont toutes des méthodes d'apprentissage non basées sur les prompts (LoRA, IA³, etc.). D'autres modèles PEFT, tels que le prompt tuning et le prompt learning, sont hors périmètre, car ces adaptateurs ne sont pas « injectables » dans un module torch. Pour utiliser ces méthodes, veuillez consulter le guide d'utilisation de la bibliothèque PEFT.

Avec ce mixin, si la version correcte de PEFT est installée (>= 0.20.0), il est possible de :

- Charger un adaptateur stocké sur un chemin local ou dans un dépôt distant du Hub, et l’injecter dans le modèle
- Attachez de nouveaux adaptateurs au modèle et entraînez-les avec Trainer ou par vous-même.
- Attacher plusieurs adaptateurs et les activer / désactiver de manière itérative
- Activer / désactiver tous les adaptateurs du modèle.
- Obtenir le `state_dict` de l'adaptateur actif.

#### load_adapter[[transformers.integrations.PeftAdapterMixin.load_adapter]]

```python
load_adapter(peft_model_id: str | None = None, adapter_name: str | None = None, peft_config: dict[str, typing.Any] | None = None, adapter_state_dict: dict[str, 'torch.Tensor'] | None = None, low_cpu_mem_usage: bool = False, is_trainable: bool = False, hotswap: typing.Union[bool, typing.Literal['auto']] = 'auto', local_files_only: bool = False, adapter_kwargs: dict[str, typing.Any] | None = None, load_config: typing.Optional[ForwardRef('LoadStateDictConfig')] = None, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/integrations/peft.py#L80)

**Paramètres :**

peft_model_id (`str`, *facultatif*) : L'identifiant du modèle à rechercher sur le Hub, ou un chemin local vers le fichier de configuration de l'adaptateur et les poids de l'adaptateur enregistrés.

adapter_name (`str`, *facultatif*) : Le nom de l'adaptateur à utiliser. S'il n'est pas défini, le nom "default" sera utilisé.

load_config (`LoadStateDictConfig`, *facultatif*) : une configuration de chargement à réutiliser lors de l'extraction des poids de l'adaptateur, généralement depuis `from_pretrained`.

kwargs (`dict[str, Any]`, *facultatif*) : Champs supplémentaires de `LoadStateDictConfig` passés en tant qu'arguments nommés.

peft_config (`dict[str, Any]`, *facultatif*) : La configuration de l'adaptateur à ajouter. Les adaptateurs pris en charge sont toutes les configurations d'apprentissage non basées sur les prompts (LoRA, IA³, etc.). Cet argument est utilisé lorsque les utilisateurs transmettent directement des dictionnaires d'état PEFT.

adapter_state_dict (`dict[str, torch.Tensor]`, *facultatif*) : Le state dict de l'adaptateur à charger. Cet argument est utilisé lorsque les utilisateurs transmettent directement des state dicts PEFT.

low_cpu_mem_usage (`bool`, *facultatif*, valeur par défaut `False`) : Réduit l'utilisation de la mémoire lors du chargement de l'adaptateur PEFT. Cela devrait également accélérer le processus de chargement.

is_trainable (`bool`, *facultatif*, valeur par défaut `False`) : Indique si l'adaptateur doit être entraînable ou non. Si `False`, l'adaptateur sera figé et ne pourra être utilisé que pour l'inférence.

hotswap : (`"auto"` ou `bool`, *facultatif*, par défaut `"auto"`) Indique s'il faut remplacer un adaptateur (LoRA) existant par l'adaptateur nouvellement chargé, en place. Cela signifie que, au lieu de charger un adaptateur supplémentaire, les poids de l'adaptateur existant sont remplacés par ceux du nouvel adaptateur. Cette approche peut être plus rapide et plus économe en mémoire. Cependant, l'avantage principal du hotswap est que, lorsque le modèle est compilé avec torch.compile, le chargement du nouvel adaptateur ne nécessite pas de recompiler le modèle. Lors de l'utilisation du hotswap, le `adapter_name` transmis doit correspondre au nom d'un adaptateur déjà chargé. Si le nouvel adaptateur et l'ancien ont des rangs et/ou des alphas LoRA (c'est-à-dire des coefficients de mise à l'échelle) différents, il faut appeler une méthode supplémentaire avant de charger l'adaptateur : ```py model = AutoModel.from_pretrained(...) max_rank = ...  # the highest rank among all LoRAs that you want to load # call *before* compiling and loading the LoRA adapter model.enable_peft_hotswap(target_rank=max_rank) model.load_adapter(file_name_1, adapter_name="default") # optionally compile the model now model = torch.compile(model, ...) output_1 = model(...) # now you can hotswap the 2nd adapter, use the same name as for the 1st # hotswap is activated by default since enable_peft_hotswap was called model.load_adapter(file_name_2, adapter_name="default") output_2 = model(...) ``` Par défaut, le hotswap est désactivé et nécessite de passer `hotswap=True`. Si vous avez d'abord appelé `enable_peft_hotswap`, il est activé. Vous pouvez néanmoins le désactiver manuellement dans ce cas en passant `hotswap=False`. Notez que le hotswap comporte quelques limitations, documentées ici : https://huggingface.co/docs/peft/main/en/package_reference/hotswap

adapter_kwargs (`dict[str, Any]`, *facultatif*) : Arguments supplémentaires transmis à la méthode `from_pretrained` de la configuration de l'adaptateur et à la méthode `find_adapter_config_file`.

Chargez les poids de l’adaptateur depuis un fichier ou un dossier distant du Hub. Si vous n’êtes pas familier avec les adaptateurs et les méthodes PEFT, nous vous invitons à en savoir plus dans la documentation officielle de PEFT : https://huggingface.co/docs/peft

Nécessite l’installation de PEFT en tant que backend pour charger les poids de l’adaptateur.

#### add_adapter[[transformers.integrations.PeftAdapterMixin.add_adapter]]

```python
add_adapter(adapter_config, adapter_name: str | None = None)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/integrations/peft.py#L390)

**Paramètres :**

adapter_config (`~peft.PeftConfig`) : La configuration de l'adaptateur à ajouter. Les adaptateurs pris en charge sont les méthodes d'apprentissage sans prompt (LoRA, IA³, etc.).

adapter_name (`str`, *facultatif*, valeur par défaut `"default"`) : Le nom de l'adaptateur à ajouter. Si aucun nom n'est transmis, un nom par défaut est attribué à l'adaptateur.

Si vous n’êtes pas familier avec les adaptateurs et les méthodes PEFT, nous vous invitons à en savoir plus dans la documentation officielle de PEFT : https://huggingface.co/docs/peft

Ajoute un nouvel adaptateur au modèle actuel à des fins d'entraînement. Si aucun nom d'adaptateur n'est fourni, un nom par défaut est attribué à l'adaptateur afin de respecter la convention de la bibliothèque PEFT (dans PEFT, « default » est utilisé comme nom d'adaptateur par défaut).

Notez que l'adaptateur nouvellement ajouté n'est pas activé automatiquement. Pour l'activer, utilisez `model.set_adapter`.

#### set_adapter[[transformers.integrations.PeftAdapterMixin.set_adapter]]

```python
set_adapter(adapter_name: list[str] | str)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/integrations/peft.py#L430)

**Paramètres :**

adapter_name (`Union[list[str], str]`) : Le nom de l'adaptateur à définir. Peut également être une liste de chaînes de caractères pour définir plusieurs adaptateurs.

Si vous n’êtes pas familier avec les adaptateurs et les méthodes PEFT, nous vous invitons à en savoir plus dans la documentation officielle de PEFT : https://huggingface.co/docs/peft

Définit un adaptateur spécifique en forçant le modèle à utiliser cet adaptateur et à désactiver les autres adaptateurs.

#### disable_adapters[[transformers.integrations.PeftAdapterMixin.disable_adapters]]

```python
disable_adapters()
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/integrations/peft.py#L471)

Si vous n’êtes pas familier avec les adaptateurs et les méthodes PEFT, nous vous invitons à en savoir plus dans la documentation officielle de PEFT : https://huggingface.co/docs/peft

Désactivez tous les adaptateurs attachés au modèle. Cela entraîne une inférence avec le modèle de base uniquement.

#### enable_adapters[[transformers.integrations.PeftAdapterMixin.enable_adapters]]

```python
enable_adapters()
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/integrations/peft.py#L490)

Si vous n’êtes pas familier avec les adaptateurs et les méthodes PEFT, nous vous invitons à en savoir plus dans la documentation officielle de PEFT : https://huggingface.co/docs/peft

Activer les adaptateurs attachés au modèle.

#### enable_peft_hotswap[[transformers.integrations.PeftAdapterMixin.enable_peft_hotswap]]

```python
enable_peft_hotswap(target_rank: int = 128, check_compiled: typing.Literal['error', 'warn', 'ignore'] = 'error')
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/integrations/peft.py#L353)

**Paramètres :**

target_rank (`int`, *facultatif*, valeur par défaut `128`) : Le rang maximal parmi tous les adaptateurs qui seront chargés.

check_compiled (`str`, *facultatif*, valeur par défaut `"error"`) : Méthode de gestion du cas où le modèle est déjà compilé, ce qui devrait généralement être évité. Les options sont : - "error" (par défaut) : lever une erreur - "warn" : émettre un avertissement - "ignore" : ne rien faire

Permet de remplacer à chaud les adaptateurs PEFT par d'autres de rangs différents, ou, si le modèle est compilé, sans déclencher de recompilation.

Actuellement, le hotswapping n'est pris en charge que pour LoRA.

L'appel de cette méthode n'est requis que lors du remplacement à chaud des adaptateurs et si le modèle est compilé ou si les rangs des adaptateurs chargés diffèrent. Si les rangs sont tous identiques et que le modèle n'est pas compilé, le remplacement à chaud fonctionne sans avoir à appeler cette méthode au préalable.

#### active_adapters[[transformers.integrations.PeftAdapterMixin.active_adapters]]

```python
active_adapters()
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/integrations/peft.py#L508)

Si vous n’êtes pas familier avec les adaptateurs et les méthodes PEFT, nous vous invitons à en savoir plus dans la documentation officielle de PEFT : https://huggingface.co/docs/peft

Renvoie les adaptateurs actuellement actifs du modèle. En cas d'inférence multi-adaptateurs (combinaison de plusieurs adaptateurs pour l'inférence), renvoie la liste de tous les adaptateurs actifs afin que les utilisateurs puissent les gérer en conséquence.

Pour les versions antérieures de PEFT (qui ne prennent pas en charge l’inférence multi-adapter), `module.active_adapter` renvoie une seule chaîne de caractères.

#### get_adapter_state_dict[[transformers.integrations.PeftAdapterMixin.get_adapter_state_dict]]

```python
get_adapter_state_dict(adapter_name: str | None = None, state_dict: dict | None = None)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/integrations/peft.py#L537)

**Paramètres :**

adapter_name (`str`, *facultatif*) : Le nom de l'adaptateur dont extraire le dictionnaire d'état. Si aucun nom n'est fourni, l'adaptateur actif est utilisé.

state_dict (dictionnaire imbriqué de `torch.Tensor`, *facultatif*) : Le dictionnaire d'état du modèle. La valeur par défaut est `self.state_dict()`, mais il peut être utilisé si des précautions particulières sont nécessaires 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).

Si vous n’êtes pas familier avec les adaptateurs et les méthodes PEFT, nous vous invitons à en savoir plus dans la documentation officielle de PEFT : https://huggingface.co/docs/peft

Renvoie le dictionnaire d'état de l'adaptateur, qui ne doit contenir que les tenseurs de poids de l'adaptateur adapter_name spécifié. Si aucun adapter_name n'est transmis, l'adaptateur actif est utilisé.

#### delete_adapter[[transformers.integrations.PeftAdapterMixin.delete_adapter]]

```python
delete_adapter(adapter_names: list[str] | str)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/integrations/peft.py#L622)

**Paramètres :**

adapter_names (`Union[list[str], str]`) : Le(s) nom(s) de l'adaptateur (ou des adaptateurs) à supprimer.

Supprimer un adaptateur PEFT du modèle sous-jacent.

