PEFT documentation
GLoRA
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). Utiliser * (out + in)paramètres et peut exprimer des corrections de rangr. La plus expressive, le plus de paramètres."vector": un vecteur unique (par ex. de forme(out, 1)), diffusé sur toute la matrice. UtiliseO(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 :
où chaque chemin est paramétré de manière indépendante.
GloraConfig
classe peft.GloraConfig
< source >( 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 surlora. - 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 chargeloracar 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 faibleXd @ Xuavec les formes(out, r)et(r, in). Utiliser * (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. Utiliseoutparamè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: SiTrue(par défaut), GLoRA est initialisé comme une opération nulle. SiFalse, une initialisation de type kaiming est utilisée.
Remarques :
config_D_Ene prend pas en charge"lora".target_modulespeut ê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
< source >( 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_unloadet les méthodes associées pour la gestion des adaptateurs.
GloraLayer et GloraLinear
classe peft.tuners.glora.GloraLinear
< source >( base_layer: nn.Moduleadapter_name: strconfig**kwargs )
Adaptateur GLoRA enveloppant une couche de base base_layer dense ~torch.nn.Linear.
GloraLayerest la logique centrale de l'adaptation de rang généralisé, prenant en charge plusieurs adaptateurs et des configurations de chemins flexibles.GloraLinearest un substitut direct denn.Linearavec prise en charge de GLoRA.- GLoRA prend actuellement en charge les couches de base
torch.nn.Linearsimples.
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.).