PEFT documentation
Réglage de LayerNorm
Réglage de LayerNorm
Le réglage de LayerNorm (LN Tuning) est une méthode PEFT qui n’ajuste que les paramètres des couches LayerNorm d’un modèle.
L’article a testé les performances de cette méthode sur de grands modèles de langage et a montré qu’elle peut obtenir de bonnes performances avec une réduction significative du nombre de paramètres entraînables et de l’utilisation de la mémoire GPU.
Cependant, la méthode n’est pas limitée aux modèles de langage et peut être appliquée à tout modèle utilisant des couches LayerNorm.
Dans cette implémentation, par défaut, toutes les couches layernorm à l’intérieur d’un modèle sont ajustées, mais il est possible de cibler d’autres types de couches, tels que les couches MLP ou Attention. Cela peut être fait en spécifiant les target_modules dans le LNTuningConfig.
L'abstract de l'article est :
Cet article présente une stratégie efficace pour transformer les grands modèles de langage (LLM) en grands modèles de langage multimodaux (MLLM). En conceptualisant cette transformation comme un processus d'adaptation de domaine, c'est-à-dire le passage de la compréhension du texte à l'intégration de plusieurs modalités, nous notons avec intérêt que, au sein de chaque bloc d'attention, l'ajustement de LayerNorm suffit à obtenir de solides performances. De plus, lorsqu'il est comparé à d'autres approches d'ajustement telles que l'ajustement complet des paramètres ou LoRA, ses avantages en termes d'efficacité sont considérables. Par exemple, par rapport à LoRA à l'échelle d'un modèle de 13B, les performances peuvent être améliorées en moyenne de plus de 20 % sur cinq tâches multimodales, tout en réduisant significativement le nombre de paramètres ajustables de 41,9 % et en diminuant l'utilisation de la mémoire GPU de 17,6 %. En plus de cette stratégie LayerNorm, nous démontrons que l'ajustement sélectif uniquement avec des données conversationnelles peut améliorer encore davantage l'efficacité. Au-delà de ces résultats empiriques, nous fournissons une analyse complète pour explorer le rôle de LayerNorm dans l'adaptation des LLM au domaine multimodal et l'amélioration de la puissance expressive du modèle.
Aperçu des benchmarks
API
LNTuningConfig
classe peft.LNTuningConfig
< 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 = Falsetarget_modules: Optional[Union[list[str], str]] = Noneexclude_modules: Optional[Union[list[str], str]] = Nonemodules_to_save: Optional[Union[list[str], str]] = None )
Paramètres
- target_modules (Optional[Union[List[str], str]]) — Liste de noms de modules ou expression régulière des noms de modules à remplacer par LNTuning. Par exemple, ‘.decoder.’ ou ‘.encoder.’. Si ce paramètre n’est pas 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.
- 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.
- modules_to_save (Optional[Union[List[str], str]]) — Liste des modules à définir comme entraînables et à enregistrer dans le point de contrôle final. Par exemple, dans les tâches de classification de séquences ou de classification de jetons, la couche finale classifier/score est initialisée aléatoirement et doit donc être entraînable et enregistrée.
Ceci est la classe de configuration destinée à stocker la configuration d'un LNTuningModel.
LNTuningModel
classe peft.LNTuningModel
< 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 (
torch.nn.Module) — Le modèle à adapter. - config (LNTuningConfig) — La configuration du modèle de réglage LN.
- adapter_name (
str) — Le nom de l'adaptateur, par défaut"default". - low_cpu_mem_usage (
bool,optional, defaults toFalse) — Cette option n'a aucun effet sur l'ajustement LN, mais elle existe pour assurer la cohérence avec les autres méthodes PEFT.
Retourne
‘torch.nn.Module’
Le modèle adapté avec LayerNorm activé.
Crée un réglage de LayerNorm à partir d'un modèle transformer préentraîné.
La méthode est décrite en détail dans https://huggingface.co/papers/2312.11420.
Exemple :
>>> from transformers import AutoModelForCausalLM
>>> from peft import get_peft_model, TaskType, LNTuningConfig
>>> peft_config = LNTuningConfig(
... task_type=TaskType.CAUSAL_LM,
... )
>>> model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-2-7b-hf")
>>> model = get_peft_model(model, peft_config)
>>> model.print_trainable_parameters()Attributs :
- model (PreTrainedModel) — Le modèle à adapter.
- peft_config (LNTuningConfig) : La configuration du modèle de réglage LN.