PEFT documentation

GLoRA

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

GLoRA

L'adaptation de rang faible généralisée (GLoRA) est une méthode PEFT qui généralise LoRA et les approches associées. GLoRA décompose les mises à jour en chemins configurables (A, B, C, D, E), où chaque chemin peut utiliser une paramétrisation de rang faible, vectorielle, constante ou désactivée, selon le chemin.

Chaque chemin prend en charge l’un des quatre modes de paramétrisation. Ils représentent un compromis entre le nombre de paramètres et l’expressivité (la richesse possible de la mise à jour) :

  • "lora" : Décomposition de rang faible (comme LoRA standard). Utilise r * (out + in) paramètres et peut exprimer des corrections de rang r. La plus expressive, le plus de paramètres.
  • "vector" : un vecteur unique (par ex. de forme (out, 1)), diffusé sur toute la matrice. Utilise O(out) paramètres ; uniquement un échelonnement ou un décalage par canal.
  • "constant" : un scalaire unique partagé par tous les éléments. Utilise 1 paramètre ; l’option la moins expressive parmi les options entraînables.
  • "none" : des zéros sans paramètres entraînables ; désactive entièrement ce chemin.

Tous les chemins n’acceptent pas tous les modes (par exemple, config_D_E ne prend pas en charge "lora"). Choisir "lora" sur davantage de chemins augmente la capacité et le nombre de paramètres entraînables ; "vector", "constant" ou "none" les réduisent.

GLoRA est particulièrement utile pour la recherche et les applications avancées où vous souhaitez expérimenter avec des motifs de mise à jour structurés et combiner plusieurs mécanismes d'adaptation dans une seule couche.

De manière générale, GLoRA modifie une couche linéaire figée avec : Weff=W0+W0⊙A+B W_{\mathrm{eff}} = W_0 + W_0 \odot A + B beff=b0+b0⊙D+E+W0C b_{\mathrm{eff}} = b_0 + b_0 \odot D + E + W_0 C

où chaque chemin est paramétré de manière indépendante.

GloraConfig

classe peft.GloraConfig

< >

( 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 = 8target_modules: list[str] | str | None = Nonebias: str = 'none'modules_to_save: list[str] | None = Noneconfig_A_B: typing.Literal['lora', 'vector', 'constant', 'none'] = 'lora'config_C: typing.Literal['lora', 'vector', 'none'] = 'lora'config_D_E: typing.Literal['vector', 'constant', 'none'] = 'constant'init_weights: bool = True )

Paramètres

  • r (int) — Rang de la décomposition de rang faible utilisée lorsqu’une configuration est définie sur lora.
  • target_modules (Optional[Union[List[str], str]]) — Les noms des modules auxquels appliquer Glora.
  • config_A_B (str) — Paramétrage des matrices A et B (corrections multiplicatives et additives des poids). Valeurs valides : lora, vector, constant, none.
  • config_C (str) — Paramétrage de la matrice C (couplage poids-biais : b += W0 @ C). Valeurs valides : lora, vector, none.
  • config_D_E (str) — Paramétrage pour les scalaires D et E (corrections multiplicatives et additives du biais). Ne prend pas en charge lora car D et E sont des vecteurs de taille biais, et non des matrices. Valeurs valides : vector, constant, none.
  • init_weights (bool) — Si True (par défaut), initialise GLoRA comme une opération nulle (zéros). Si False, utilise une initialisation kaiming pour que l'adaptateur ne soit pas une opération nulle.

Ceci est la classe de configuration destinée à stocker la configuration d'un GloraModel.

Glora modifie une couche linéaire figée W0 comme suit : W_eff = W0 + W0 * A + B et b_eff = b0 + b0 * D + E + W0 @ C.

Chaque matrice (A, B, C, D, E) peut être paramétrée de manière indépendante. Les valeurs de configuration contrôlent le nombre de paramètres utilisés et les formes qu’ils peuvent exprimer :

  • lora : Décomposition de rang faible Xd @ Xu avec les formes (out, r) et (r, in). Utilise r * (out + in) paramètres et peut exprimer toute correction de rang r. Comme le LoRA standard.
  • vector : un vecteur colonne unique de forme (out, 1), diffusé sur toute la matrice. Utilise out paramètres ; mise à l'échelle ou décalage uniquement par canal de sortie.
  • constant : un scalaire unique partagé par tous les éléments. Utilise 1 paramètre ; le plus contraint.
  • none : Zéros, aucun paramètre entraînable. Désactive effectivement ce chemin.

Options de configuration principales

  • r : rang utilisé lorsqu’un chemin est configuré en "lora" (par défaut : 8).
  • target_modules : Liste ou expression régulière des noms de modules à adapter (par exemple, ["q_proj", "v_proj"]).
  • config_A_B : Type de chemin pour A et B (« lora », « vector », « constant », « none »).
  • config_C : Type de chemin pour C (« lora », « vector », « none »).
  • config_D_E : Type de chemin pour D et E (« constant », « vector », « none »).
  • bias : Gestion des biais ("none", "all" ou "glora_only").
  • init_weights : Si True (par défaut), GLoRA est initialisé comme une opération nulle. Si False, une initialisation de type kaiming est utilisée.

Remarques :

  • config_D_E ne prend pas en charge "lora".
  • target_modules peut être omis pour les types de modèles pris en charge (les correspondances par défaut de PEFT sont utilisées).

GloraModel

classe peft.GloraModel

< >

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

Crée un modèle Generalized Low Rank Adapter (GLoRA) à partir d'un modèle transformers pré-entraîné.

  • Enveloppe un modèle de base et injecte des adaptateurs GLoRA dans les modules spécifiés.
  • Prend en charge plusieurs adaptateurs, le basculement d'adaptateurs, la fusion/défusion et l'inférence par lots mixtes.
  • Utilisez set_adapter, merge_and_unload et les méthodes associées pour la gestion des adaptateurs.

GloraLayer et GloraLinear

classe peft.tuners.glora.GloraLayer

< >

( base_layer: nn.Module**kwargs )

classe peft.tuners.glora.GloraLinear

< >

( base_layer: nn.Moduleadapter_name: strconfig**kwargs )

Adaptateur GLoRA enveloppant une couche de base base_layer dense ~torch.nn.Linear.

  • GloraLayer est la logique centrale de l'adaptation de rang généralisé, prenant en charge plusieurs adaptateurs et des configurations de chemins flexibles.
  • GloraLinear est un substitut direct de nn.Linear avec prise en charge de GLoRA.
  • GLoRA prend actuellement en charge les couches de base torch.nn.Linear simples.

Exemple d'utilisation

from transformers import AutoModelForCausalLM
from peft import GloraConfig, get_peft_model

model = AutoModelForCausalLM.from_pretrained("your-model-id")
glora_config = GloraConfig(
    r=8,
    target_modules=["q_proj", "v_proj"],
    config_A_B="lora",
    config_C="vector",
    config_D_E="constant",
    task_type="CAUSAL_LM",
)
model = get_peft_model(model, glora_config)
model.print_healthcheck()

# Switch adapters, merge, etc.
model.set_adapter("default")
model.merge_and_unload()

Notes

  • GLoRA est un sur-ensemble de LoRA : définir tous les chemins sur « lora » permet de retrouver le LoRA standard.
  • Vous pouvez utiliser différents types de chemins pour A/B/C/D/E afin d’expérimenter de nouvelles stratégies d’adaptation.
  • GLoRA prend en charge toutes les fonctionnalités standard de gestion des adaptateurs PEFT (ajout, suppression, basculement, fusion, etc.).

Voir aussi

Update on GitHub