LoHa

Le produit de Hadamard de rang faible (LoHa) est similaire à LoRA, à l'exception près qu'il approxime la grande matrice de poids avec plusieurs matrices de rang faible et les combine par le produit de Hadamard. Cette méthode est encore plus efficace en termes de paramètres que LoRA et atteint des performances comparables. LoHa a été initialement proposé pour l'apprentissage fédéré (FedPara), mais fonctionne bien comme méthode PEFT générale, et est particulièrement populaire pour l'ajustement fin de modèles de génération d'images tels que Stable Diffusion.

Remarque : LoHa fait partie de la famille d'adaptateurs LyCORIS. Son proche parent LoKr utilise le produit de Kronecker au lieu du produit de Hadamard.

L'abstract de l'article est :

Dans ce travail, nous proposons une paramétrisation efficace en termes de communication, FedPara, pour l'apprentissage fédéré (FL) afin de surmonter les contraintes liées aux téléversements et téléchargements fréquents de modèles. Notre méthode reparamétrise les paramètres de poids des couches en utilisant des poids de faible rang suivis du produit de Hadamard. Par rapport à la paramétrisation de faible rang conventionnelle, notre méthode FedPara n'est pas restreinte aux contraintes de faible rang, et possède donc une capacité bien plus importante. Cette propriété permet d'atteindre des performances comparables tout en nécessitant des coûts de communication 3 à 10 fois inférieurs à ceux du modèle avec les couches d'origine, ce qui n'est pas réalisable par les méthodes de faible rang traditionnelles. L'efficacité de notre méthode peut être encore améliorée en la combinant avec d'autres optimiseurs FL efficaces. De plus, nous étendons notre méthode à une application de FL personnalisé, pFedPara, qui sépare les paramètres en paramètres globaux et locaux. Nous montrons que pFedPara surpasse les méthodes de FL personnalisé concurrentes avec plus de trois fois moins de paramètres.

La décomposition de rang faible peut affecter les performances, car les mises à jour des poids sont limitées à l’espace de rang faible, ce qui peut contraindre l’expressivité d’un modèle. Cependant, il n’est pas nécessairement souhaitable d’utiliser un rang plus élevé, car cela augmente le nombre de paramètres entraînables. Pour remédier à cela, LoHa a été appliqué aux modèles de diffusion, où la capacité à générer des images variées est un aspect important. LoHa devrait également fonctionner avec des types de modèles généraux, mais la prise en charge des couches d’incorporation n’est pas actuellement implémentée dans PEFT.

LoHa utilise le produit de Hadamard (produit élément par élément) au lieu du produit matriciel. $\Delta W$ est représenté par quatre matrices plus petites au lieu de deux - comme dans LoRA - et chaque paire de ces matrices de faible rang est combinée par le produit de Hadamard. En conséquence, $\Delta W$ peut avoir le même nombre de paramètres entraînables, mais un rang et une expressivité plus élevés.

Quand utiliser LoHa

LoHa est un bon choix lorsque :

• Vous effectuez l’ajustement fin de modèles de génération d’images (UNet de Stable Diffusion ou encodeur de texte), ce qui en constitue l’usage le plus répandu.
• Vous souhaitez un rang effectif plus élevé que LoRA pour le même nombre de paramètres entraînables, car le produit de Hadamard de deux matrices de faible rang englobe un sous-espace plus large qu’un simple produit de faible rang.
• Vous souhaitez combiner différentes méthodes PEFT lors de l'inférence à l'aide de PeftMixedModel, par exemple LoHa avec LoKr.

LoHa prend en charge les couches linéaires et Conv2d. Pour les tâches qui nécessitent en plus l'adaptation de la couche d'embedding, envisagez plutôt LoRA.

Utilisation

from diffusers import StableDiffusionPipeline
from peft import LoHaConfig, get_peft_model

config_unet = LoHaConfig(
    r=8,
    alpha=8,
    target_modules=[
        "to_k",
        "to_q",
        "to_v",
        "to_out.0",
        "proj_in",
        "proj_out",
    ],
    rank_dropout=0.0,
    module_dropout=0.0,
    use_effective_conv2d=True,
)

pipeline = StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5")
pipeline.unet = get_peft_model(pipeline.unet, config_unet)
pipeline.unet.print_healthcheck()

Aperçu des benchmarks

API

LoHaConfig

LoHaModel

>>> from diffusers import StableDiffusionPipeline
>>> from peft import LoHaModel, LoHaConfig

>>> config_te = LoHaConfig(
...     r=8,
...     lora_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 = LoHaConfig(
...     r=8,
...     lora_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 = LoHaModel(model.text_encoder, config_te, "default")
>>> model.unet = LoHaModel(model.unet, config_unet, "default")