# Comblant l'écart entre l'adaptation de rang faible et l'adaptation orthogonale via l'adaptation par réflexion de Householder (HRA)

    

Comblant l'écart entre l'adaptation de rang faible et l'adaptation orthogonale via l'adaptation par réflexion de Householder

[HRA](https://huggingface.co/papers/2405.17484) offre une nouvelle perspective reliant LoRA à OFT, ce qui lui permet de tirer parti des avantages des deux stratégies en exploitant les [réflexions de Householder](https://en.wikipedia.org/wiki/Householder_transformation) pour réduire le nombre de paramètres et les coûts de calcul, tout en pénalisant la perte des connaissances acquises lors du pré-entraînement. Il obtient systématiquement de meilleures performances avec moins de paramètres entraînables et surpasse les adaptateurs de pointe sur différents modèles, y compris les grands modèles de langage (LLM) et les générateurs d'images conditionnels.

HRA construit une chaîne de `r` réflexions de Householder (HR) entraînables. Étant donné que la matrice de réflexion de Householder est une matrice orthogonale et que le produit de matrices orthogonales est également une matrice orthogonale, HRA satisfait la garantie théorique de l'Orthogonal Finetuning (OFT). Parallèlement, HRA peut également être considéré comme un adaptateur de fine-tuning de faible rang. Plus `r` est élevé, plus il y a de paramètres entraînables, ce qui entraîne une capacité de modèle plus importante et de meilleures performances. En outre, en raison de la structure en chaîne, l'orthogonalité des plans HR influence la capacité et la régularité de HRA. Pour atteindre un compromis entre la capacité du modèle et sa régularité, un régulariseur d'orthogonalité des plans HR est ajouté à la fonction de perte. Le poids \\(\lambda\\) permet de contrôler l'intensité du régulariseur.

L'abstract de l'article est :

> Bien que suivant des approches techniques distinctes, les techniques d'adaptation de faible rang et orthogonales permettent toutes deux d'adapter efficacement les modèles de pré-entraînement à grande échelle à des tâches ou des domaines spécifiques, à partir d'un petit nombre de paramètres entraînables. Dans cette étude, nous comblons le fossé entre ces deux techniques en proposant une méthode d'adaptation simple mais efficace, basée sur les réflexions de Householder. À partir d'un modèle pré-entraîné, notre méthode ajuste ses couches en multipliant chaque matrice de poids figée par une matrice orthogonale construite à l'aide d'une chaîne de réflexions de Householder (HR) apprenables. Cet ajustement orthogonal basé sur les HR est équivalent à une adaptation de faible rang adaptative. De plus, nous montrons que l'orthogonalité des plans de réflexion correspondant aux HR influence la capacité et la régularité du modèle. Cette analyse nous motive à régulariser l'orthogonalité des HR, ce qui conduit à différentes implémentations de la méthode d'adaptation par réflexion de Householder (HRA) proposée. Comparée aux méthodes de l'état de l'art, HRA atteint des performances supérieures avec moins de paramètres apprenables lors de l'adaptation de grands modèles de langage et de générateurs d'images conditionnels. Le code est disponible sur [peft](https://github.com/huggingface/peft/tree/main/src/peft/tuners/hra) et [HRA](https://github.com/DaShenZi721/HRA).

# API

## HRAConfig[[peft.HRAConfig]]

#### peft.HRAConfig[[peft.HRAConfig]]

```python
peft.HRAConfig(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, r: int = 8, apply_GS: bool = False, target_modules: Optional[Union[list[str], str]] = None, exclude_modules: Optional[Union[list[str], str]] = None, init_weights: bool = True, layers_to_transform: Optional[Union[list[int], int]] = None, layers_pattern: Optional[Union[list[str], str]] = None, bias: str = 'none', modules_to_save: Optional[list[str]] = None)
```

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

**Paramètres :**

r (`int`) : Le rang de HRA à travers les différentes couches. Il est préférable de définir 'r' sur un nombre pair ; sinon, la méthode d'initialisation par défaut ne fonctionnera pas.

apply_GS (`bool`) : Indique s'il faut appliquer l'orthogonalisation de Gram-Schmidt.

target_modules (`Optional[Union[List[str], str]]`) : Les noms des modules auxquels appliquer l'adaptateur. Si ce paramètre est spécifié, seuls les modules portant les noms indiqués seront remplacés. En passant une chaîne de caractères, une correspondance par expression régulière est effectuée. En passant une liste de chaînes de caractères, une correspondance exacte est effectuée ou il est vérifié si le nom du module se termine par l'une des chaînes passées. Si ce paramètre est spécifié comme 'all-linear', tous les modules linéaires sont sélectionnés, à l'exception de la couche de sortie. Si ce paramètre n'est pas spécifié, les modules sont sélectionnés en fonction de l'architecture du modèle. Si l'architecture n'est pas connue, une erreur est 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.

init_weights (`bool`) : Indique s'il faut effectuer l'initialisation des poids HRA.

layers_to_transform (`Union[List[int], int]`) : Les indices de couches à transformer. Si une liste d'entiers est transmise, l'adaptateur sera appliqué aux indices de couches spécifiés dans cette liste. Si un seul entier est transmis, les transformations seront appliquées à la couche située à cet index.

layers_pattern (`Optional[Union[List[str], str]]`) : Le nom du motif de couche, utilisé uniquement si `layers_to_transform` est différent de `None`. Il doit cibler le `nn.ModuleList` du modèle, souvent appelé `'layers'` ou `'h'`.

bias (`str`) : Type de biais pour HRA. Peut être `'none'`, `'all'` ou `'hra_only'`.

modules_to_save (`List[str]`) : Liste des modules, à l'exception des couches d'adaptateur, à définir comme entraînables et à enregistrer dans le point de contrôle final.

Ceci est la classe de configuration destinée à stocker la configuration d'un [HRAModel](/docs/peft/v0.22.0/fr/package_reference/hra#peft.HRAModel).

## HRAModel[[peft.HRAModel]]

#### peft.HRAModel[[peft.HRAModel]]

```python
peft.HRAModel(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/v0.22.0/src/peft/tuners/hra/model.py#L24)

**Paramètres :**

model (`torch.nn.Module`) : Le modèle auquel les couches d'adaptation du tuner seront attachées.

config ([HRAConfig](/docs/peft/v0.22.0/fr/package_reference/hra#peft.HRAConfig)) : La configuration du modèle HRA.

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

low_cpu_mem_usage (`bool`, `optional`, par défaut `False`) : Crée des poids d'adaptateur vides sur l'appareil méta. Utile pour accélérer le processus de chargement.

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

Le modèle HRA.

Crée un modèle d'adaptation par réflexion de Householder (HRA) à partir d'un modèle pré-entraîné. La méthode est décrite dans https://huggingface.co/papers/2405.17484

Exemple :
```py
>>> from diffusers import StableDiffusionPipeline
>>> from peft import HRAConfig, get_peft_model

>>> config_te = HRAConfig(
...     r=8,
...     target_modules=["k_proj", "q_proj", "v_proj", "out_proj", "fc1", "fc2"],
...     init_weights=True,
... )
>>> config_unet = HRAConfig(
...     r=8,
...     target_modules=[
...         "proj_in",
...         "proj_out",
...         "to_k",
...         "to_q",
...         "to_v",
...         "to_out.0",
...         "ff.net.0.proj",
...         "ff.net.2",
...     ],
...     init_weights=True,
... )

>>> model = StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5")
>>> model.text_encoder = get_peft_model(model.text_encoder, config_te)
>>> model.unet = get_peft_model(model.unet, config_unet)
```

**Attributs** :
- **model** (`~torch.nn.Module`) -- Le modèle à adapter.
- **peft_config** ([HRAConfig](/docs/peft/v0.22.0/fr/package_reference/hra#peft.HRAConfig)) : La configuration du modèle HRA.

