# Réglage de LayerNorm

Le réglage de LayerNorm ([LN Tuning](https://huggingface.co/papers/2312.11420)) est une méthode PEFT qui n’ajuste que les paramètres des couches LayerNorm d’un modèle. L’article a testé les performances de cette méthode sur de grands modèles de langage et a démontré qu’elle peut atteindre de bonnes performances avec une réduction significative du nombre de paramètres entraînables et de l’utilisation de la mémoire GPU. Toutefois, la méthode n’est pas limitée aux modèles de langage et peut être appliquée à tout modèle utilisant des couches LayerNorm. Dans cette implémentation, par défaut, toutes les couches layernorm à l’intérieur d’un modèle sont ajustées, mais il est possible de cibler d’autres types de couches, tels que les couches `MLP` ou `Attention`. Il suffit pour cela de spécifier les `target_modules` dans le `LNTuningConfig`.

L'abstract de l'article est :

*Cet article présente une stratégie efficace pour transformer les grands modèles de langage (LLM) en grands modèles de langage multimodaux (MLLM). En conceptualisant cette transformation comme un processus d'adaptation de domaine, c'est-à-dire le passage de la compréhension du texte à l'intégration de plusieurs modalités, nous notons avec intérêt que, au sein de chaque bloc d'attention, l'ajustement de LayerNorm suffit à obtenir de solides performances. De plus, lorsqu'il est comparé à d'autres approches d'ajustement telles que l'ajustement complet des paramètres ou LoRA, ses avantages en termes d'efficacité sont considérables. Par exemple, par rapport à LoRA à l'échelle d'un modèle de 13B, les performances peuvent être améliorées en moyenne de plus de 20 % sur cinq tâches multimodales, tout en réduisant significativement le nombre de paramètres ajustables de 41,9 % et en diminuant l'utilisation de la mémoire GPU de 17,6 %. En plus de cette stratégie LayerNorm, nous démontrons que l'ajustement sélectif uniquement avec des données conversationnelles peut améliorer encore davantage l'efficacité. Au-delà de ces résultats empiriques, nous fournissons une analyse complète pour explorer le rôle de LayerNorm dans l'adaptation des LLM au domaine multimodal et l'amélioration de la puissance expressive du modèle.*

## Aperçu des benchmarks

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

# API

## LNTuningConfig[[peft.LNTuningConfig]]

#### peft.LNTuningConfig[[peft.LNTuningConfig]]

```python
peft.LNTuningConfig(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: Optional[Union[list[str], str]] = None, exclude_modules: Optional[Union[list[str], str]] = None, modules_to_save: Optional[Union[list[str], str]] = None)
```

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

**Paramètres :**

target_modules (*Optional[Union[List[str], str]]*) : Liste de noms de modules ou expression régulière des noms de modules à remplacer par LNTuning. Par exemple, '.*decoder.*' ou '.*encoder.*'. Si ce paramètre n'est pas spécifié, les modules seront choisis en fonction de l'architecture du modèle. Si l'architecture est inconnue, une erreur sera levée — dans ce cas, vous devez spécifier manuellement les modules cibles.

exclude_modules (*Optional[Union[List[str], str]]*) : Les noms des modules auxquels l'adaptateur ne doit pas être appliqué. Lors du passage d'une chaîne de caractères, une correspondance par expression régulière est effectuée. Lors du passage d'une liste de chaînes de caractères, soit une correspondance exacte est effectuée, soit il est vérifié si le nom du module se termine par l'une des chaînes passées.

modules_to_save (*Optional[Union[List[str], str]]*) : Liste de modules à définir comme entraînables et à enregistrer dans le point de contrôle final. Par exemple, dans les tâches de classification de séquences ou de classification de jetons, la couche finale *classifier/score* est initialisée aléatoirement et doit donc être entraînable et enregistrée.

Ceci est la classe de configuration destinée à stocker la configuration d'un [LNTuningModel](/docs/peft/main/fr/package_reference/layernorm_tuning#peft.LNTuningModel).

## LNTuningModel[[peft.LNTuningModel]]

#### peft.LNTuningModel[[peft.LNTuningModel]]

```python
peft.LNTuningModel(model, peft_config: Union[PeftConfig, dict[str, PeftConfig]], adapter_name: str, low_cpu_mem_usage: bool = False, state_dict: Optional[dict[str, torch.Tensor]] = None)
```

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

**Paramètres :**

model (`torch.nn.Module`) : Le modèle à adapter.

config ([LNTuningConfig](/docs/peft/main/fr/package_reference/layernorm_tuning#peft.LNTuningConfig)) : La configuration du modèle de réglage LN.

adapter_name (`str`) : Le nom de l'adaptateur, par défaut `"default"`.

low_cpu_mem_usage (`bool`, `optional`, defaults to `False`) : Cette option n'a aucun effet sur l'ajustement LN, mais elle existe pour assurer la cohérence avec les autres méthodes PEFT.

**Retourne :** `'torch.nn.Module'`

Le modèle adapté avec LayerNorm activé.

Crée un réglage de LayerNorm à partir d'un modèle transformer préentraîné.

La méthode est décrite en détail dans https://huggingface.co/papers/2312.11420.

Exemple :

```py
>>> from transformers import AutoModelForCausalLM
>>> from peft import get_peft_model, TaskType, LNTuningConfig

>>> peft_config = LNTuningConfig(
...     task_type=TaskType.CAUSAL_LM,
... )

>>> model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-2-7b-hf")
>>> model = get_peft_model(model, peft_config)
>>> model.print_trainable_parameters()
```

**Attributs** :
- **model** ([PreTrainedModel](https://huggingface.co/docs/transformers/main/en/main_classes/model#transformers.PreTrainedModel)) -- Le modèle à adapter.
- **peft_config** ([LNTuningConfig](/docs/peft/main/fr/package_reference/layernorm_tuning#peft.LNTuningConfig)) : La configuration du modèle de réglage LN.

