PEFT documentation

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

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v0.21.0).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

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

Bridging The Gap between Low-rank and Orthogonal Adaptation via Householder Reflection Adaptation

HRA 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 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. De plus, 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 la régularité, un régulariseur d'orthogonalité des plans HR est ajouté à la fonction de perte. Le poidsλ\lambda peut 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 et HRA.

API

HRAConfig

classe peft.HRAConfig

< >

( task_type: Optional[Union[str, TaskType]] = Nonepeft_type: Optional[Union[str, PeftType]] = Noneauto_mapping: Optional[dict] = Nonepeft_version: Optional[str] = Nonebase_model_name_or_path: Optional[str] = Nonerevision: Optional[str] = Noneinference_mode: bool = Falser: int = 8apply_GS: bool = Falsetarget_modules: Optional[Union[list[str], str]] = Noneexclude_modules: Optional[Union[list[str], str]] = Noneinit_weights: bool = Truelayers_to_transform: Optional[Union[list[int], int]] = Nonelayers_pattern: Optional[Union[list[str], str]] = Nonebias: str = 'none'modules_to_save: Optional[list[str]] = None )

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 cas de chaîne de caractères, une correspondance par expression régulière est effectuée. En cas de liste de chaînes de caractères, une correspondance exacte est réalisée ou il est vérifié si le nom du module se termine par l’une des chaînes fournies. Si la valeur est « 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 choisis en fonction de l’architecture du modèle. Si l’architecture est inconnue, 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é. Si une chaîne de caractères est transmise, une correspondance par expression régulière est effectuée. Si une liste de chaînes de caractères est transmise, une correspondance exacte est effectuée ou il est vérifié si le nom du module se termine par l’une des chaînes transmises.
  • 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, en dehors 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.

HRAModel

classe peft.HRAModel

< >

( modelpeft_config: Union[PeftConfig, dict[str, PeftConfig]]adapter_name: strlow_cpu_mem_usage: bool = Falsestate_dict: Optional[dict[str, torch.Tensor]] = None ) → torch.nn.Module

Paramètres

  • model (torch.nn.Module) — Le modèle auquel les couches d’adaptation du tuner seront attachées.
  • config (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'adaptateurs 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 :

>>> 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) : La configuration du modèle HRA.
Update on GitHub