PEFT documentation

Tuners

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Tuners

Un tuner (ou adaptateur) est un module qui peut être branché sur un torch.nn.Module. La classe de base BaseTuner pour les autres tuners fournit des méthodes et des attributs partagés pour préparer une configuration d’adaptateur et remplacer un module cible par le module d’adaptateur. BaseTunerLayer est une classe de base pour les couches d’adaptateurs. Elle offre des méthodes et des attributs pour gérer les adaptateurs, tels que l’activation et la désactivation des adaptateurs.

BaseTuner

classe peft.tuners.tuners_utils.BaseTuner

< >

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

Paramètres

  • model (torch.nn.Module) — Le modèle auquel les couches de l’adaptateur tuner seront attachées.
  • forward (Callable) — La méthode forward du modèle.
  • peft_config (Union[PeftConfig, dict[str, PeftConfig]]) — L'objet de configuration de l'adaptateur. Il doit s'agir d'un dictionnaire de str vers des objets PeftConfig. Il est également possible de passer un objet PeftConfig, auquel cas un nouvel adaptateur sera créé avec le nom par défaut adapter, ou de créer un nouveau dictionnaire avec une clé adapter_name et une valeur correspondant à cette configuration peft.
  • config (dict[str, Any]) — L'objet de configuration du modèle, qui doit être un dictionnaire d'objets str vers Any.
  • targeted_module_names (list[str]) — La liste des noms de modules qui ont réellement été adaptés. Peut être utile pour vérifier rapidement que les config.target_modules ont été spécifiés correctement.
  • targeted_parameter_names (list[str]) — La liste des noms de paramètres qui ont réellement été adaptés. Peut être utile pour vérifier rapidement que les config.target_parameters ont été spécifiés correctement.
  • prefix (str) — Préfixe unique spécifique à la méthode PEFT. Par exemple, "lora_" pour LoRA.

Un modèle de tuner de base qui fournit les méthodes et attributs communs à tous les tuners injectables dans un torch.nn.Module

Pour ajouter une nouvelle classe Tuner, il faut réécrire les méthodes suivantes :

  • _prepare_adapter_config : Méthode privée destinée à préparer la configuration de l'adaptateur, par exemple si le champ target_modules est manquant.
  • _create_and_replace : Méthode privée permettant de créer et de remplacer le module cible par le module adaptateur.
  • _check_target_module_exists : Méthode d’assistance privée permettant de vérifier si le nom de clé du module transmis correspond à l’un des modules cibles de l’ adapter_config.

La méthode la plus simple consiste à vérifier ce qui est fait dans la classe peft.tuners.lora.LoraModel.

delete_adapter

< >

( adapter_name: str )

Paramètres

  • adapter_name (str) — Nom de l'adaptateur à supprimer.

Supprime un adaptateur existant.

disable_adapter_layers

< >

( )

Désactiver tous les adaptateurs sur place.

Lors de la désactivation de tous les adaptateurs, la sortie du modèle correspond à la sortie du modèle de base.

enable_adapter_layers

< >

( )

Activer tous les adaptateurs sur place

get_model_config

< >

( model: nn.Module )

Paramètres

  • model (nn.Module) — Modèle dont la configuration doit être extraite.
  • default (dict|None, facultatif) —: Ce qui doit être renvoyé si le modèle ne possède pas d'attribut de configuration.

Cette méthode récupère la configuration d'un modèle sous forme de dictionnaire. Si le modèle n'a pas d'attribut config, cette méthode renvoie une configuration par défaut.

inject_adapter

< >

( model: nn.Moduleadapter_name: strautocast_adapter_dtype: bool = Truelow_cpu_mem_usage: bool = Falsestate_dict: Optional[dict[str, torch.Tensor]] = None )

Paramètres

  • model (nn.Module) — Le modèle à ajuster.
  • adapter_name (str) — Le nom de l'adaptateur.
  • autocast_adapter_dtype (bool, facultatif) — Indique s'il faut effectuer l'autocast du dtype de l'adaptateur. La valeur par défaut est True.
  • low_cpu_mem_usage (bool, optional, par défaut False) — Crée des poids d'adaptateurs vides sur l'appareil méta. Utile pour accélérer le processus de chargement.
  • state_dict (dict, facultatif, par défaut None) — Si un state_dict est transmis ici, les adaptateurs seront injectés en fonction des entrées du state_dict. Cela peut être utile lorsque les target_modules exacts de la méthode PEFT sont inconnus, par exemple parce que le point de contrôle a été créé sans métadonnées. Notez que les valeurs du state_dict ne sont pas utilisées, seules les clés sont utilisées pour déterminer les couches correctes qui doivent être adaptées.

Crée des couches d’adaptateurs et remplace les modules cibles par les couches d’adaptateurs. Cette méthode est appelée en interne par peft.mapping.get_peft_model lorsqu’une classe d’adaptateur non basée sur le prompt est transmise.

La configuration PEFT correspondante est récupérée directement à partir de l'attribut peft_config de la classe BaseTuner.

merge_adapter

< >

( adapter_names: Optional[list[str]] = Nonesafe_merge: bool = False )

Paramètres

  • adapter_names (list[str], facultatif) — La liste des noms d’adaptateurs à fusionner. Si None, tous les adaptateurs actifs seront fusionnés. Valeur par défaut : None.
  • safe_merge (bool, facultatif) — Si True, l’opération de fusion est effectuée sur une copie des poids d’origine et vérifie la présence de NaN avant de fusionner les poids. Cela est utile si vous souhaitez vérifier si l’opération de fusion produira des NaN. Valeur par défaut : False.

Cette méthode fusionne les couches d'adaptateur dans le modèle de base.

La fusion des adaptateurs peut accélérer le passage avant. Une copie des poids de l’adaptateur est conservée en mémoire, ce qui est nécessaire pour désactiver la fusion des adaptateurs. Pour fusionner les poids de l’adaptateur sans les conserver en mémoire, veuillez appeler merge_and_unload.

Une fois qu’une couche a fusionné les poids des adaptateurs, son passage avant n’utilise que ces poids. Par conséquent, si adapter_names ne couvre pas tous les adaptateurs actifs, les adaptateurs actifs restants ne sont pas appliqués silencieusement, bien qu’ils soient toujours signalés comme actifs. Fusionnez tous les adaptateurs actifs ou appelez d’abord unmerge_adapter. Notez que ce comportement est prévu pour changer dans la version v1.0.

merge_and_unload

< >

( progressbar: bool = Falsesafe_merge: bool = Falseadapter_names: Optional[list[str]] = None )

Paramètres

  • progressbar (bool) — indique s'il faut afficher une barre de progression indiquant le processus de déchargement et de fusion (par défaut : False).
  • safe_merge (bool) — indique s'il faut activer la vérification de fusion sécurisée afin de détecter d'éventuelles valeurs Nan dans les poids de l'adaptateur.
  • adapter_names (List[str], facultatif) — La liste des noms d’adaptateurs à fusionner. Si None, tous les adaptateurs actifs seront fusionnés. Valeur par défaut : None.

Cette méthode fusionne les couches d'adaptateur dans le modèle de base.

Ceci est nécessaire si quelqu'un souhaite utiliser le modèle de base comme modèle autonome. Le modèle renvoyé possède la même architecture que le modèle de base d'origine.

Il est important d'assigner le modèle retourné à une variable et de l'utiliser, il ne s'agit pas d'une opération en place !

Exemple :

>>> from transformers import AutoModelForCausalLM
>>> from peft import PeftModel

>>> model_id = ...
>>> base_model = AutoModelForCausalLM.from_pretrained(model_id)
>>> peft_model_id = ...
>>> model = PeftModel.from_pretrained(base_model, peft_model_id)
>>> merged_model = model.merge_and_unload()

set_adapter

< >

( adapter_name: str | list[str]inference_mode: bool = False )

Paramètres

  • adapter_name (str, list[str]) — Le(s) nom(s) de l'adaptateur (des adaptateurs) à définir comme actif(s)
  • inference_mode (bool, facultatif) — Indique si l’adaptateur activé doit être figé (c’est-à-dire requires_grad=False). La valeur par défaut est False.

Définir l’adaptateur ou les adaptateurs actifs.

set_requires_grad

< >

( adapter_names: str | Sequence[str]requires_grad: bool = True )

Paramètres

  • adapter_names (str ou Sequence[str]) — Le nom de l’adaptateur ou des adaptateurs dont les gradients doivent être activés/désactivés.
  • requires_grad (bool, facultatif) — Indique s'il faut activer (True, par défaut) ou désactiver (False).

Activer ou désactiver les gradients sur l’adaptateur ou les adaptateurs donnés.

supports_lora_conversion

< >

( adapter_name: str = 'default' )

S'il est possible de convertir l'adaptateur de ce modèle en LoRA.

Normalement, cela fonctionne si la méthode PEFT est additive, c’est-à-dire W’ = W_base + delta_weight.

décharger

< >

( )

Retourner le modèle de base en supprimant tous les modules PEFT.

Il est important d'assigner le modèle retourné à une variable et de l'utiliser, il ne s'agit pas d'une opération en place !

unmerge_adapter

< >

( )

Cette méthode désintègre toutes les couches d'adaptateur fusionnées à partir du modèle de base.

BaseTunerLayer

classe peft.tuners.tuners_utils.BaseTunerLayer

< >

( )

Paramètres

  • is_pluggable (bool, facultatif) — Indique si la couche d’adaptateur peut être branchée sur n’importe quel module PyTorch
  • active_adapters (Union[Liststr, str], facultatif) — Le nom de l'adaptateur actif.

Un mixin de couche de tuner qui fournit les méthodes et attributs communs à tous les tuners.

delete_adapter

< >

( adapter_name: str )

Paramètres

  • adapter_name (str) — Le nom de l'adaptateur à supprimer

Supprimer un adaptateur de la couche

Cela doit être appelé sur toutes les couches d'adaptateur, sinon nous obtiendrons un état incohérent.

Cette méthode définira également un nouvel adaptateur actif si l’adaptateur supprimé était un adaptateur actif. Il est important que le nouvel adaptateur soit choisi de manière déterministe, afin que le même adaptateur soit sélectionné sur toutes les couches.

enable_adapters

< >

( enabled: bool )

Paramètres

  • enabled (bool) — True pour activer les adaptateurs, False pour les désactiver

Activer et désactiver les adaptateurs

Gère la configuration du drapeau requires_grad pour les poids de l'adaptateur.

get_additive_delta

< >

( adapter_name: str = 'default' )

Paramètres

  • adapter_name (str) — Le nom de l'adaptateur. La valeur par défaut est "default".

Retourne le delta additif de poids W’ - W pour l’adaptateur donné, où W est le poids de base et W’ est le poids après fusion de l’adaptateur dans le poids de base. Cela signifie que le poids fusionné peut être reconstruit via base_weight + module.get_additive_delta(adapter_name).

Pour les méthodes PEFT additives (par exemple LoRA, LoKr, LoHa), cela équivaut à get_delta_weight. Pour les méthodes multiplicatives (par exemple OFT, BOFT), cette méthode construit le poids effectif W’ et soustrait le poids de base W.

L’appel de cette méthode alors qu’un adaptateur est fusionné lève une ValueError, car la fusion modifie le poids de base, ce qui rendrait la valeur de retour dépendante des adaptateurs actuellement fusionnés. Désfusionnez d’abord les adaptateurs.

Le tenseur renvoyé a le dtype des poids de la couche d'adaptateur (par exemple lora_A pour LoRA), et non le dtype du poids de la couche de base. C'est le dtype que l'adaptateur LoRA converti utilisera.

Le résultat est utilisé par convert_to_lora pour effectuer une approximation basée sur la SVD de l'adaptateur en tant qu'adaptateur LoRA.

Par défaut, cela lève une NotImplementedError. Les méthodes PEFT qui prennent en charge cette fonctionnalité doivent redéfinir la méthode _get_additive_delta pour retourner le delta additif.

get_base_layer

< >

( )

Obtenir (récursivement) la base_layer.

Ceci est nécessaire dans le cas où la couche de tuner enveloppe une autre couche de tuner.

get_base_weight

< >

( )

Retourner le poids de la couche de base.

Cela prend en charge la déquantification potentielle du poids s'il est quantifié.

set_adapter

< >

( adapter_names: str | list[str]inference_mode: bool = False )

Paramètres

  • adapter_names (str ou list[str]) — Le(s) nom(s) de l’adaptateur (ou des adaptateurs) à définir comme actif(s).
  • inference_mode (bool, facultatif) — Indique si l’adaptateur activé doit être figé (c’est-à-dire requires_grad=False). La valeur par défaut est False.

Définir l’adaptateur ou les adaptateurs actifs.

De plus, cette fonction rendra l'adaptateur spécifié entraînable (c'est-à-dire requires_grad=True) sauf si inference_mode est True.

set_base_weight

< >

( weight_data: torch.Tensor )

Définit le poids de base de la couche de base sur le nouveau tenseur

Cela fonctionne également avec des poids quantifiés.

set_requires_grad

< >

( adapter_names: str | Sequence[str]requires_grad: bool = True )

Paramètres

  • adapter_names (str ou Sequence[str]) — Le nom de l’adaptateur ou des adaptateurs dont les gradients doivent être activés/désactivés.
  • requires_grad (bool, facultatif) — Indique s'il faut activer (True, par défaut) ou désactiver (False).

Activer ou désactiver les gradients sur l’adaptateur ou les adaptateurs donnés.

set_training

< >

( adapter_names: str | Sequence[str]training: bool = True )

Paramètres

  • adapter_names (str ou Sequence[str]) — Le nom de l’adaptateur ou des adaptateurs dont le mode d’entraînement doit être mis à jour.
  • training (bool, facultatif) — Indique s'il faut activer (True, par défaut) ou désactiver (False) le mode d'entraînement.

Activer ou désactiver le mode d’entraînement sur les modules d’adaptateurs donnés.

supports_lora_conversion

< >

( adapter_name: str = 'default' )

Indique si ce type de couche peut être converti en LoRA.

Normalement, cela fonctionne si la méthode PEFT est additive, c’est-à-dire W’ = W_base + delta_weight.

Update on GitHub