PEFT documentation
GraLoRA
GraLoRA
Granular Low-Rank Adaptation (GraLoRA) est une méthode PEFT conçue pour améliorer l'expressivité de l'adaptation de rang faible tout en renforçant la robustesse aux activations aberrantes, sur la base d'insights tirés de problèmes bien connus en quantification.
Contrairement à LoRA standard, qui applique un adaptateur de faible rang unique sur l'ensemble de l'espace de caractéristiques, GraLoRA introduit un schéma d'adaptation structuré et fin. Il divise l'espace d'adaptation en une grille de paires d'adaptateurs plus petites et indépendantes, chacune étant responsable d'un sous-ensemble localisé des dimensions d'entrée et de sortie. En conséquence, chaque adaptateur opère sur un sous-espace qui est fois plus petit dans les deux dimensions que l'adaptateur LoRA original.
Cette décomposition granulaire permet des mises à jour spatialement localisées et sensibles au contexte, augmentant efficacement la capacité de représentation sans paramètres supplémentaires ni coût de calcul. En isolant l'influence des activations extrêmes au sein de sous-espaces plus petits, GraLoRA atténue la distorsion des gradients et préserve l'équilibre inter-canaux lors de l'adaptation.
L'abstract de l'article est :
L’adaptation de rang faible (LoRA) est une méthode populaire pour l’ajustement fin efficace en paramètres (PEFT) des modèles génératifs, appréciée pour sa simplicité et son efficacité. Malgré les améliorations récentes, LoRA souffre encore d’une limitation fondamentale : le surapprentissage lorsque le goulot d’étranglement est élargi. Elle offre les meilleurs résultats aux rangs 32–64, mais sa précision stagne ou diminue aux rangs supérieurs, restant inférieure aux performances de l’ajustement fin complet (FFT). Nous identifions la cause racine comme étant le goulot d’étranglement structurel de LoRA, qui introduit un enchevêtrement des gradients vers les canaux d’entrée non liés et déforme la propagation des gradients. Pour y remédier, nous introduisons une nouvelle structure, l’adaptation de rang faible granulaire (GraLoRA), qui partitionne les matrices de poids en sous-blocs, chacun doté de son propre adaptateur de rang faible. Avec un coût de calcul ou de stockage négligeable, GraLoRA surmonte les limites de LoRA, augmente efficacement la capacité de représentation et s’approche davantage du comportement de FFT. Des expériences sur des benchmarks de génération de code, de raisonnement de bon sens, de raisonnement mathématique, de compréhension générale du langage et de génération d’images montrent que GraLoRA surpasse systématiquement LoRA et d’autres références, atteignant un gain absolu de +8,5 % en Pass@1 sur HumanEval+. Ces améliorations se maintiennent à travers les tailles de modèles et les configurations de rang, faisant de GraLoRA une solution évolutive et robuste pour le PEFT.
Aperçu des benchmarks
API
GraloraConfig
classe peft.GraloraConfig
< 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 = 32hybrid_r: int = 0target_modules: list[str] | str | None = Nonealpha: int = 64gralora_dropout: float = 0.0gralora_k: int = 2fan_in_fan_out: bool = Falsebias: str = 'none'modules_to_save: list[str] | None = Noneinit_weights: bool = Truelayers_to_transform: list[int] | int | None = Nonelayers_pattern: str | None = None )
Paramètres
- r (
int) — La dimension d’attention de GraLoRA détermine le rang de l’adaptateur GraLoRA. Le nombre total de paramètres de l’adaptateur GraLoRA est identique à celui de LoRA avec le même rang r, tandis que l’expressivité est multipliée par gralora_k. - hybrid_r (
int) — Le rang de Hybrid GraLoRA détermine le rang alloué à la méthode LoRA classique lors de l’utilisation de la méthode Hybrid GraLoRA. Hybrid GraLoRA, une combinaison de GraLoRA et de LoRA classique, devient disponible lorsque hybrid_r > 0. Le nombre de paramètres de l’adaptateur GraLoRA est r + hybrid_r. - target_modules (
Union[List[str], str]) — Liste de noms de modules ou expression régulière des noms de modules à remplacer par GraLoRA. Par exemple, [‘q’, ‘v’] ou ‘.decoder.(SelfAttention|EncDecAttention).*(q|v)$‘. Il peut également s’agir du joker ‘all-linear’, qui correspond à tous les linéaires/Conv1D (si le modèle est un PreTrainedModel, la couche de sortie est exclue). Si non 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. - alpha (
int) — alpha de GraLoRA. L’alpha de GraLoRA est le facteur d’échelle de l’adaptateur GraLoRA. L’échelle devient alpha / (r + hybrid_r). - gralora_dropout (
float) — Le dropout de GraLoRA est la probabilité de dropout pour l'adaptateur GraLoRA. Il est utilisé pour prévenir le surapprentissage et améliorer la généralisation de l'adaptateur GraLoRA. - gralora_k (
int) — GraLoRA k détermine le nombre de sous-blocs dans l’adaptateur GraLoRA. Le rang r doit être divisible par gralora_k pour que l’adaptateur GraLoRA soit valide. Le nombre total de paramètres est conservé quel que soit gralora_k. Le rang global de l’adaptateur GraLoRA est augmenté par gralora_k, tandis que le rang de chaque sous-bloc est réduit par gralora_k. gralora_k=2 est recommandé pour un rang inférieur ou égal à 32, et gralora_k=4 est recommandé pour un rang supérieur ou égal à 64. - fan_in_fan_out (
bool) — Définissez cette valeur sur True si la couche à remplacer stocke les poids sous la forme (fan_in, fan_out). Par exemple, gpt-2 utiliseConv1Dqui stocke les poids sous la forme (fan_in, fan_out) et il convient donc de définir cette valeur surTrue. - bias (
str) — Type de biais pour gralora. Peut être ‘none’, ‘all’ ou ‘gralora_only’. Si ‘all’ ou ‘gralora_only’, les biais correspondants seront mis à jour pendant l’entraînement. Notez que cela signifie que, même en désactivant les adaptateurs, le modèle ne produira pas la même sortie que le modèle de base sans adaptation. - modules_to_save (
Optional[list[str]]) — Liste des modules, à l'exception des couches gralora, qui doivent être définis comme entraînables et sauvegardés dans le point de contrôle final. Par exemple, dans les tâches de Classification de Séquence ou de Classification de Jeton, la couche finaleclassifier/scoreest initialisée aléatoirement et doit donc être entraînable et sauvegardée. - init_weights (
bool) — Indique s'il faut initialiser les poids des couches GraLoRA avec leur initialisation par défaut. Ne modifiez pas ce paramètre, sauf si vous savez exactement ce que vous faites. - layers_to_transform (
Union[List[int], int]) — Les index de couches à transformer. Si cet argument est spécifié, PEFT ne transformera que les index de couches indiqués dans cette liste. Si un entier unique est transmis, PEFT ne transformera que la couche située à cet index. Cela ne fonctionne que lorsque target_modules est une liste de str. - layers_pattern (
Optional[Union[List[str], str]]) — Le nom du motif de couche, utilisé uniquement silayers_to_transformest différent de None et si le motif de couche ne figure pas dans les motifs de couches courants. Cela ne fonctionne que lorsque target_modules est une liste de str. Cela doit cibler lenn.ModuleListdu modèle, souvent appelé'layers'ou'h'.
Ceci est la classe de configuration destinée à stocker la configuration d'un GraloraModel.
GraloraModel
classe peft.GraloraModel
< source >( 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 (PreTrainedModel) — Le modèle à adapter.
- config (GraloraConfig) — La configuration du modèle Gralora.
- adapter_name (
str) — Le nom de l'adaptateur, par défaut"default".
Retourne
torch.nn.Module
Le modèle Gralora.
Crée un modèle d'adaptation de matrice aléatoire basée sur des vecteurs (Gralora) à partir d'un modèle transformers pré-entraîné.
Exemple :
>>> from transformers import AutoModelForCausalLM
>>> from peft import GraloraConfig, get_peft_model
>>> base_model = AutoModelForCausalLM.from_pretrained("facebook/opt-125m")
>>> config = GraloraConfig(r=128)
>>> model = get_peft_model(base_model, config)Attributs :
- model (PreTrainedModel) — Le modèle à adapter.
- peft_config (GraloraConfig) : La configuration du modèle Gralora.