PEFT documentation
Tuners
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
< source >( 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 destrvers des objetsPeftConfig. Il est également possible de passer un objet PeftConfig, auquel cas un nouvel adaptateur sera créé avec le nom par défautadapter, ou de créer un nouveau dictionnaire avec une cléadapter_nameet une valeur correspondant à cette configuration peft. - config (
dict[str, Any]) — L'objet de configuration du modèle, qui doit être un dictionnaire d'objetsstrversAny. - 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 lesconfig.target_modulesont é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 lesconfig.target_parametersont é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_modulesest 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
< source >( adapter_name: str )
Supprime un adaptateur existant.
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.
Activer tous les adaptateurs sur place
get_model_config
< source >( model: nn.Module )
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
< source >( 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 estTrue. - low_cpu_mem_usage (
bool,optional, par défautFalse) — 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éfautNone) — 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 lestarget_modulesexacts 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
< source >( adapter_names: Optional[list[str]] = Nonesafe_merge: bool = False )
Paramètres
- adapter_names (
list[str], facultatif) — La liste des noms d’adaptateurs à fusionner. SiNone, tous les adaptateurs actifs seront fusionnés. Valeur par défaut :None. - safe_merge (
bool, facultatif) — SiTrue, 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
< source >( 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
< source >( adapter_name: str | list[str]inference_mode: bool = False )
Définir l’adaptateur ou les adaptateurs actifs.
set_requires_grad
< source >( adapter_names: str | Sequence[str]requires_grad: bool = True )
Activer ou désactiver les gradients sur l’adaptateur ou les adaptateurs donnés.
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.
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 !
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
< source >( )
Un mixin de couche de tuner qui fournit les méthodes et attributs communs à tous les tuners.
delete_adapter
< source >( adapter_name: str )
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
< source >( enabled: bool )
Activer et désactiver les adaptateurs
Gère la configuration du drapeau requires_grad pour les poids de l'adaptateur.
get_additive_delta
< source >( adapter_name: str = '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.
Obtenir (récursivement) la base_layer.
Ceci est nécessaire dans le cas où la couche de tuner enveloppe une autre couche de tuner.
Retourner le poids de la couche de base.
Cela prend en charge la déquantification potentielle du poids s'il est quantifié.
set_adapter
< source >( adapter_names: str | list[str]inference_mode: bool = 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.
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
< source >( adapter_names: str | Sequence[str]requires_grad: bool = True )
Activer ou désactiver les gradients sur l’adaptateur ou les adaptateurs donnés.
set_training
< source >( adapter_names: str | Sequence[str]training: bool = True )
Activer ou désactiver le mode d’entraînement sur les modules d’adaptateurs donnés.
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.