# Llama-Adapter

    

LLaMA-Adapter : Fine-tuning efficace des modèles de langage avec une attention initialisée à zéro

[Llama-Adapter](https://hf.co/papers/2303.16199) est une méthode PEFT conçue spécifiquement pour transformer Llama en un modèle suivant des instructions. Le modèle Llama est figé et seul un ensemble de prompts d’adaptation préfixés aux jetons d’instruction d’entrée est appris. Étant donné que l’insertion de modules initialisés aléatoirement dans le modèle peut entraîner la perte d’une partie de ses connaissances existantes, Llama-Adapter utilise une attention initialisée à zéro avec un gating nul pour ajouter progressivement les prompts d’instruction au modèle.

L'abstract de l'article est :

*Nous présentons LLaMA-Adapter, une méthode d'adaptation légère permettant d'ajuster finement LLaMA de manière efficace en un modèle suivant des instructions. En utilisant 52K démonstrations auto-instructives, LLaMA-Adapter n'introduit que 1,2M de paramètres apprenables sur le modèle LLaMA 7B figé, et coûte moins d'une heure pour l'ajustement fin sur 8 GPU A100. Plus précisément, nous adoptons un ensemble de prompts d'adaptation apprenables, que nous préfixons aux jetons de texte d'entrée aux couches supérieures du transformeur. Ensuite, un mécanisme d'attention initialisé à zéro avec un zéro de porte est proposé, qui injecte de manière adaptative les nouveaux indices instructionnels dans LLaMA, tout en préservant efficacement ses connaissances pré-entraînées. Grâce à un entraînement efficace, LLaMA-Adapter génère des réponses de haute qualité, comparables à Alpaca avec 7B paramètres entièrement ajustés finement. De plus, notre approche peut être simplement étendue à une entrée multi-modale, par exemple des images, pour un LLaMA conditionné par image, qui atteint une capacité de raisonnement supérieure sur ScienceQA. Nous publions notre code à https://github.com/ZrrSkywalker/LLaMA-Adapter*.

## Quand utiliser Llama-Adapter

Llama-Adapter est un bon choix lorsque :

- Vous souhaitez un point de contrôle très petit. Seuls les prompts d'adaptation et leurs portes sont entraînés et sauvegardés, ce qui représente `adapter_layers * (adapter_len * hidden_size + 1)` paramètres.
- Vous effectuez un instruction-tuning sur un modèle pris en charge (Llama, Mistral ou GPT-2), le cas d’usage sur lequel l’article se concentre.
- Vous souhaitez conserver plusieurs adaptateurs spécifiques à une tâche pour le même modèle de base et basculer entre eux à l’aide de `set_adapter`.

## Quand ne pas utiliser Llama-Adapter

Llama-Adapter peut ne pas être le meilleur choix lorsque :

- Votre modèle n'est pas un modèle Llama, Mistral ou GPT-2. Les autres architectures déclenchent une `ValueError`. Envisagez plutôt d'utiliser [LoRA](./lora).
- Vous avez besoin d'un surcoût d'inférence nul. L'adaptateur ne peut pas être fusionné dans les poids de base (`merge_and_unload()` n'est pas pris en charge), de sorte que chaque couche adaptée porte son attention sur `adapter_len` jetons supplémentaires au moment de l'inférence.
- Vous souhaitez que plusieurs adaptateurs soient actifs simultanément. Un seul adaptateur peut être actif, et les prompts d'adaptation ne peuvent pas être empilés sur le même module d'attention.

## Aperçu des benchmarks

<iframe src="https://peft-internal-testing-peft-method-comparison-embed.hf.space/?highlight[type]=ADAPTION_PROMPT" frameborder="0" width="850" height="1000"
>

# API

## AdaptionPromptConfig[[peft.AdaptionPromptConfig]]

#### peft.AdaptionPromptConfig[[peft.AdaptionPromptConfig]]

```python
peft.AdaptionPromptConfig(task_type: Optional[Union[str, TaskType]] = None, peft_type: Optional[Union[str, PeftType]] = None, auto_mapping: Optional[dict] = None, peft_version: Optional[str] = None, base_model_name_or_path: Optional[str] = None, revision: Optional[str] = None, inference_mode: bool = False, target_modules: str = None, adapter_len: int = None, adapter_layers: int = None)
```

[Source](https://github.com/huggingface/peft/blob/main/src/peft/tuners/adaption_prompt/config.py#L25)

Stocke la configuration d'un [AdaptionPromptModel](/docs/peft/main/fr/package_reference/llama_adapter#peft.AdaptionPromptModel).

## AdaptionPromptModel[[peft.AdaptionPromptModel]]

#### peft.AdaptionPromptModel[[peft.AdaptionPromptModel]]

```python
peft.AdaptionPromptModel(model, configs: dict, adapter_name: str)
```

[Source](https://github.com/huggingface/peft/blob/main/src/peft/tuners/adaption_prompt/model.py#L27)

Implémente les prompts d’adaptation tels que décrits dans https://huggingface.co/papers/2303.16199.

Les modules d'attention L supérieurs sont remplacés par des modules AdaptedAttention qui enveloppent les modules d'origine, mais insèrent des prompts entraînables avec des portes (pour une initialisation à zéro).

Remarques sur le motif multi-adapter :
- Nous stockons les états des différents adaptateurs en conservant un dictionnaire de modules AdaptedAttention indexés par le nom de l'adaptateur.
- Chaque fois que nous changeons d'adaptateur, nous retirons les modules de l'adaptateur actuellement actif du modèle, les stockons dans le dictionnaire, puis les remplaçons par les modules du nouvel adaptateur.
- Afin d'éviter un état dupliqué et potentiellement incohérent, l'adaptateur actuellement actif est toujours retiré du dictionnaire.
- Désactiver l'adaptateur entraînerait également le retrait des modules du modèle.

#### add_adapter[[peft.AdaptionPromptModel.add_adapter]]

```python
add_adapter(adapter_name: str, config: AdaptionPromptConfig)
```

[Source](https://github.com/huggingface/peft/blob/main/src/peft/tuners/adaption_prompt/model.py#L62)

Ajouter un adaptateur avec le nom et la configuration donnés.

#### delete_adapter[[peft.AdaptionPromptModel.delete_adapter]]

```python
delete_adapter(adapter_name: str)
```

[Source](https://github.com/huggingface/peft/blob/main/src/peft/tuners/adaption_prompt/model.py#L104)

Supprimer un adaptateur avec le nom donné.

#### disable_adapter_layers[[peft.AdaptionPromptModel.disable_adapter_layers]]

```python
disable_adapter_layers()
```

[Source](https://github.com/huggingface/peft/blob/main/src/peft/tuners/adaption_prompt/model.py#L168)

Désactiver les couches d'adaptateur en remplaçant les modules AdaptedAttention.

#### enable_adapter_layers[[peft.AdaptionPromptModel.enable_adapter_layers]]

```python
enable_adapter_layers()
```

[Source](https://github.com/huggingface/peft/blob/main/src/peft/tuners/adaption_prompt/model.py#L163)

Activez les couches d’adaptateur en remplaçant les modules AdaptedAttention mis en cache.

#### set_adapter[[peft.AdaptionPromptModel.set_adapter]]

```python
set_adapter(adapter_name: str, inference_mode: bool = False)
```

[Source](https://github.com/huggingface/peft/blob/main/src/peft/tuners/adaption_prompt/model.py#L148)

Définissez le modèle pour qu’il utilise l’adaptateur portant le nom indiqué.

