PEFT documentation
LoKr
LoKr
Le produit de Kronecker de faible rang (LoKr) est une variante de LoRA qui approxime la grande matrice de poids à l'aide de deux matrices de faible rang et les combine par le produit de Kronecker. LoKr fournit également une troisième matrice de faible rang optionnelle pour un meilleur contrôle lors de l'ajustement fin. En exprimant la matrice de mise à jour des poids comme une décomposition d'un produit de Kronecker, créant ainsi une matrice par blocs, LoKr est capable de préserver le rang de la matrice de poids d'origine. La taille des matrices plus petites est déterminée par son rang ou r. Un autre avantage du produit de Kronecker est qu'il peut être vectorisé en empilant les colonnes de la matrice. Cela peut accélérer le processus car vous évitez de reconstruire entièrement ∆W.
L'abstract de l'article est :
Les modèles génératifs texte-vers-image ont suscité un intérêt considérable grâce à leur capacité à produire des images haute fidélité à partir de prompts textuels. Parmi eux, Stable Diffusion se distingue comme un modèle open source de référence dans ce domaine en pleine croissance. Toutefois, les subtilités du fine-tuning de ces modèles posent de multiples défis, de l'intégration de nouvelles méthodologies à l'évaluation systématique. Pour répondre à ces enjeux, cet article présente LyCORIS Lora beYond Conventional methods, Other Rank adaptation Implementations for Stable diffusion, une bibliothèque open source qui propose une large sélection de méthodologies de fine-tuning pour Stable Diffusion. De plus, nous présentons un cadre rigoureux pour l'évaluation systématique de diverses techniques de fine-tuning. Ce cadre utilise un ensemble varié de métriques et explore plusieurs facettes du fine-tuning, notamment l'ajustement des hyperparamètres et l'évaluation avec différents types de prompts à travers diverses catégories de concepts. Grâce à cette approche complète, notre travail fournit des insights essentiels sur les effets nuancés des paramètres de fine-tuning, comblant le fossé entre la recherche de pointe et l'application pratique.
Utilisation
from peft import LoKrConfig, get_peft_model
config = LoKrConfig(
r=16,
alpha=16,
target_modules=["query", "value"],
module_dropout=0.1,
modules_to_save=["classifier"],
)
model = get_peft_model(model, config)
model.print_healthcheck()Aperçu des benchmarks
API
LoKrConfig
classe peft.LoKrConfig
< 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 = Falserank_pattern: Optional[dict] = <factory>alpha_pattern: Optional[dict] = <factory>r: int = 8alpha: int = 8rank_dropout: float = 0.0module_dropout: float = 0.0use_effective_conv2d: bool = Falsedecompose_both: bool = Falsedecompose_factor: int = -1rank_dropout_scale: bool = Falsetarget_modules: Optional[Union[list[str], str]] = Noneexclude_modules: Optional[Union[list[str], str]] = Noneinit_weights: Union[bool, Literal['lycoris']] = Truelayers_to_transform: Optional[Union[list[int], int]] = Nonelayers_pattern: Optional[Union[list[str], str]] = Nonemodules_to_save: Optional[list[str]] = None )
Paramètres
- r (
int) — Rang LoKr. - alpha (
int) — Le paramètre alpha pour le mise à l'échelle de LoKr. - rank_dropout (
float) — Probabilité de dropout pour la dimension de rang pendant l'entraînement. - module_dropout (
float) — Probabilité de dropout pour désactiver les modules LoKr pendant l’entraînement. - use_effective_conv2d (
bool) — Utilise la décomposition effective des paramètres pour Conv2d (et Conv1d) avec ksize > 1 (« Proposition 3 » du papier FedPara). - decompose_both (
bool) — Effectue la décomposition en rang de la matrice du produit de Kronecker gauche. - decompose_factor (
int) — Facteur de décomposition du produit de Kronecker. - rank_dropout_scale (‘bool) —
Indique s'il faut mettre à l'échelle le dropout de rang pendant l'entraînement, la valeur par défaut est
False. - target_modules (
Optional[Union[List[str], str]]) — Les noms des modules auxquels appliquer l’adaptateur. Si ce paramètre est spécifié, seuls les modules portant les noms indiqués seront remplacés. En cas de chaîne de caractères, une correspondance par expression régulière est effectuée. En cas de liste de chaînes de caractères, une correspondance exacte est réalisée ou il est vérifié si le nom du module se termine par l’une des chaînes fournies. Si la valeur est « all-linear », tous les modules linéaires/Conv1D sont sélectionnés, à l’exception de la couche de sortie. Si ce paramètre n’est pas spécifié, les modules sont choisis en fonction de l’architecture du modèle. Si l’architecture est inconnue, une erreur est 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. - init_weights (
bool) — Indique s'il faut effectuer l'initialisation des poids de l'adaptateur. La valeur par défaut estTrue. Utilisez « lycoris » pour initialiser les poids dans le style du dépôt LYCORIS. Il est déconseillé de passerFalse. - layers_to_transform (
Union[List[int], int]) — Les indices de couches à transformer. Si une liste d'entiers est transmise, l'adaptateur sera appliqué aux indices de couches spécifiés dans cette liste. Si un seul entier est transmis, les transformations seront appliquées à la couche située à cet index. - layers_pattern (
Optional[Union[List[str], str]]) — Le nom du motif de couche, utilisé uniquement silayers_to_transformest différent deNone. Il doit cibler lenn.ModuleListdu modèle, souvent appelé'layers'ou'h'. - rank_pattern (
dict) — La correspondance entre les noms de couches ou les expressions régulières et les rangs qui diffèrent du rang par défaut spécifié parr. Par exemple,{'^model.decoder.layers.0.encoder_attn.k_proj': 16}. - alpha_pattern (
dict) — La correspondance entre les noms de couches ou les expressions régulières et les alphas qui diffèrent de l'alpha par défaut spécifié paralpha. Par exemple,{'^model.decoder.layers.0.encoder_attn.k_proj': 16}. - modules_to_save (
Optional[List[str]]) — Liste des modules, autres que les couches d’adaptateur, à définir comme entraînables et à enregistrer dans le point de contrôle final.
Classe de configuration de LoKrModel.
LoKrModel
classe peft.LoKrModel
< 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 auquel les couches d’adaptation du tuner seront attachées. - config (LoKrConfig) — La configuration du modèle LoKr.
- adapter_name (
str) — Le nom de l'adaptateur, par défaut"default". - 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.
Retourne
torch.nn.Module
Le modèle LoKr.
Crée un modèle à produit de Kronecker de rang faible à partir d'un modèle pré-entraîné. La méthode d'origine est partiellement décrite dans https://huggingface.co/papers/2108.06098 et dans https://huggingface.co/papers/2309.14859 L'implémentation actuelle s'inspire largement de https://github.com/KohakuBlueleaf/LyCORIS/blob/eb460098187f752a5d66406d3affade6f0a07ece/lycoris/modules/lokr.py
Exemple :
>>> from diffusers import StableDiffusionPipeline
>>> from peft import LoKrConfig, get_peft_model
>>> config_te = LoKrConfig(
... r=8,
... alpha=32,
... target_modules=["k_proj", "q_proj", "v_proj", "out_proj", "fc1", "fc2"],
... rank_dropout=0.0,
... module_dropout=0.0,
... init_weights=True,
... )
>>> config_unet = LoKrConfig(
... r=8,
... alpha=32,
... target_modules=[
... "proj_in",
... "proj_out",
... "to_k",
... "to_q",
... "to_v",
... "to_out.0",
... "ff.net.0.proj",
... "ff.net.2",
... ],
... rank_dropout=0.0,
... module_dropout=0.0,
... init_weights=True,
... use_effective_conv2d=True,
... )
>>> model = StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5")
>>> model.text_encoder = get_peft_model(model.text_encoder, config_te)
>>> model.unet = get_peft_model(model.unet, config_unet)Attributs :
- model (
~torch.nn.Module) — Le modèle à adapter. - peft_config (LoKrConfig) : La configuration du modèle LoKr.