Hugging Face's logo

PEFT documentation

FRoD : Fine-Tuning efficace de rang complet avec des degrés de rotation

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

FRoD : Fine-Tuning efficace de rang complet avec des degrés de rotation

FRoD est une méthode de fine-tuning à efficacité paramétrique qui combine une base de rang complet partagée avec des degrés de rotation apprenables et creux. La mise à jour de l'adaptateur est exprimée à travers des tenseurs de projection fixes et des coefficients entraînables, ce qui permet à FRoD d'appliquer des mises à jour de rang complet tout en gardant le nombre de paramètres entraînés faible.

Article : Full-Rank Efficient Fine-Tuning with Rotational Degrees.

Lors de l’enregistrement des paramètres de l’adaptateur, il est possible d’éviter de stocker les tenseurs de projection en définissant save_projection=False sur FrodConfig. Dans ce cas, les projections sont restaurées à partir des poids du modèle de base et de la graine aléatoire fixe de projection_prng_key. Cela réduit la taille du point de contrôle, mais la valeur par défaut est save_projection=True afin de rendre le chargement du point de contrôle indépendant des détails de la régénération.

Par rapport à LoRA, FRoD peut exprimer une mise à jour de rang complet dans chaque couche linéaire adaptée, tout en n'entraînant que les coefficients diagonaux et un ensemble sparse de coefficients de rotation hors diagonale. Cela peut s'avérer utile lorsqu'une mise à jour de rang faible est trop restrictive. Le compromis est que FRoD calcule des tenseurs de projection fixes à partir des poids de base lors de l'injection de l'adaptateur, ce qui rend la configuration plus coûteuse et l'implémentation moins largement prise en charge que LoRA.

L’initialisation par projection peut être lente sur les grands modèles, car FRoD effectue des décompositions matricielles sur les catégories de modules cibles avant d’injecter les adaptateurs. Une barre de progression est affichée par défaut et peut être désactivée avec FrodConfig(progressbar=False).

Pour l’entraînement contraint en mémoire, runtime_offload_base_weight=True conserve les poids de base cibles sur le CPU lorsque le chemin FRoD actif n’en a pas besoin. Cette option est activable manuellement car les méthodes PEFT conservent généralement tous les paramètres de base sur l’accélérateur après le déplacement du modèle et après les passes avant.

FRoD présente actuellement la contrainte suivante :

  • Seules les couches nn.Linear et transformers.pytorch_utils.Conv1D sont prises en charge.

Démarrage rapide

from transformers import AutoModelForSequenceClassification

from peft import FrodConfig, TaskType, get_peft_model

model = AutoModelForSequenceClassification.from_pretrained("google-bert/bert-base-uncased", num_labels=2)

peft_config = FrodConfig(
    task_type=TaskType.SEQ_CLS,
    target_modules=["query", "value"],
    modules_to_save=["classifier"],
    sparse_rate=0.02,
    frod_dropout=0.0,
    runtime_offload_base_weight=True,
)

model = get_peft_model(model, peft_config)
model.print_healthcheck()

FrodConfig

classe peft.FrodConfig

< >

( 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 = Falsetarget_modules: Optional[Union[list[str], str]] = Noneprojection_prng_key: int = 0save_projection: bool = Truefrod_dropout: float = 0.0fan_in_fan_out: bool = Falsebias: str = 'none'modules_to_save: Optional[list[str]] = Noneinit_weights: bool = Truelayers_to_transform: Optional[Union[list[int], int]] = Nonelayers_pattern: Optional[Union[list[str], str]] = Nonesparse_rate: float = 0.01regularization_alpha: float = 0.001progressbar: bool = Trueruntime_offload_base_weight: bool = False )

Paramètres

  • target_modules (Union[List[str], str]) — Les noms des modules auxquels appliquer FRoD. Seules les couches linéaires sont prises en charge.
  • projection_prng_key (int) — Graine aléatoire utilisée lors de l'initialisation du motif COO FRoD creux.
  • save_projection (bool) — Indique s'il faut enregistrer les tenseurs de projection FRoD dans le dictionnaire d'état. Cela augmente la taille du point de contrôle, mais rend le rechargement de l'adaptateur indépendant de la régénération du cache local. La valeur par défaut est True.
  • frod_dropout (float) — Probabilité de dropout pour les couches FRoD.
  • 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 utilise Conv1D qui stocke les poids sous la forme (fan_in, fan_out) et il convient donc de définir cette valeur sur True.
  • bias (str) — Type de biais pour FRoD. Peut être ‘none’, ‘all’ ou ‘frod_only’. Si ‘all’ ou ‘frod_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 (List[str]) — Liste des modules, à l'exception des couches FRoD, à définir comme entraînables et à enregistrer dans le point de contrôle final.
  • init_weights (bool) — Indique s'il faut initialiser les poids des couches FRoD 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é, les transformations FRoD sont appliquées aux index de couches indiqués dans cette liste. Si un entier unique est transmis, les transformations FRoD sont 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'.
  • sparse_rate (float) — Fraction des éléments hors diagonale dans la matrice de rotation creuse entraînable. Des valeurs plus élevées augmentent la capacité et le nombre de paramètres entraînants ; des valeurs plus basses sont moins coûteuses. Valeur par défaut : 0.01.
  • regularization_alpha (float) — Petite valeur positive utilisée lors de la construction de la base partagée à partir des poids de base. Elle stabilise l'inverse de la matrice lorsque les couches de la même catégorie ont des poids corrélés. Valeur par défaut : 1e-3.
  • progressbar (bool) — Indique s'il faut afficher une barre de progression pendant la construction des projections FRoD. L'initialisation des projections peut être lente sur les grands modèles, car elle exécute des décompositions matricielles sur les catégories de modules cibles. La valeur par défaut est True.
  • runtime_offload_base_weight (bool) — Indique s'il faut conserver les poids de base cibles sur le CPU lorsque le chemin FRoD actif n'en a pas besoin. Cela peut réduire la mémoire GPU, car FRoD reconstruit directement le poids adapté, mais cela modifie la convention habituelle de PEFT selon laquelle tous les paramètres de base restent sur l'accélérateur après le déplacement du modèle ou l'exécution du forward. La valeur par défaut est False.

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

Article : https://doi.org/10.1609/aaai.v40i31.39813.

FrodModel

classe peft.FrodModel

< >

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

Update on GitHub

←FourierFT GLoRA→