PEFT documentation

Fusion de modèles

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v0.22.0).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Fusion de modèles

Entraîner un modèle pour chaque tâche peut être coûteux, occuper de l’espace de stockage, et les modèles ne sont pas en mesure d’apprendre de nouvelles informations pour améliorer leurs performances. L’apprentissage multitâche peut surmonter certaines de ces limitations en entraînant un modèle à apprendre plusieurs tâches, mais son entraînement est coûteux et la conception d’un jeu de données à cet effet est complexe. La fusion de modèles offre une solution à ces défis en combinant plusieurs modèles préentraînés en un seul modèle, lui conférant les capacités combinées de chaque modèle individuel sans entraînement supplémentaire.

PEFT fournit plusieurs méthodes pour fusionner des modèles, comme une combinaison linéaire ou par SVD. Ce guide se concentre sur deux méthodes plus efficaces pour fusionner des adaptateurs LoRA en éliminant les paramètres redondants :

  • TIES - TrIm, Elect, and Merge (TIES) est une méthode en trois étapes pour fusionner des modèles. D'abord, les paramètres redondants sont éliminés, puis les signes conflictuels sont résolus en un vecteur agrégé, et enfin les paramètres dont les signes sont identiques au signe agrégé sont moyennés. Cette méthode prend en compte le fait que certaines valeurs (redondance et désaccord de signe) peuvent dégrader les performances du modèle fusionné.
  • DARE - Drop And REscale est une méthode qui peut être utilisée pour préparer d'autres méthodes de fusion de modèles, comme TIES. Elle fonctionne en supprimant aléatoirement des paramètres selon un taux de suppression, puis en rééchelonnant les paramètres restants. Cela aide à réduire le nombre de paramètres redondants et potentiellement interférents entre plusieurs modèles.

Les modèles sont fusionnés à l'aide de la méthode add_weighted_adapter(), et la méthode de fusion spécifique est définie dans le paramètre combination_type.

Méthode de fusion

Avec TIES et DARE, la fusion est activée en définissant combination_type et density sur une valeur représentant les poids à conserver des modèles individuels. Par exemple, fusionnons trois modèles TinyLlama/TinyLlama-1.1B-intermediate-step-1431k-3T affinés : tinyllama_lora_nobots, tinyllama_lora_sql et tinyllama_lora_adcopy.

Lorsque vous tentez de fusionner des modèles entièrement entraînés avec TIES, vous devez être conscient des jetons spéciaux que chaque modèle a pu ajouter à la couche d’incorporation et qui ne font pas partie du vocabulaire du point de contrôle d’origine. Cela peut poser problème car chaque modèle a pu ajouter un jeton spécial à la même position d’incorporation. Dans ce cas, vous devez utiliser la méthode resize_token_embeddings pour éviter de fusionner les jetons spéciaux au même index d’incorporation.


Cela ne devrait pas poser de problème si vous ne fusionnez que des adaptateurs LoRA entraînés à partir du même modèle de base.

Chargez un modèle de base et utilisez la méthode load_adapter() pour charger et attribuer un nom à chaque adaptateur :

from peft import PeftConfig, PeftModel
from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

config = PeftConfig.from_pretrained("smangrul/tinyllama_lora_norobots")
model = AutoModelForCausalLM.from_pretrained(config.base_model_name_or_path, load_in_4bit=True, device_map="auto").eval()
tokenizer = AutoTokenizer.from_pretrained("smangrul/tinyllama_lora_norobots")

model.config.vocab_size = 32005
model.resize_token_embeddings(32005)

model = PeftModel.from_pretrained(model, "smangrul/tinyllama_lora_norobots", adapter_name="norobots")
_ = model.load_adapter("smangrul/tinyllama_lora_sql", adapter_name="sql")
_ = model.load_adapter("smangrul/tinyllama_lora_adcopy", adapter_name="adcopy")

Définissez les adaptateurs, les poids, adapter_name, combination_type et density à l'aide de la méthode add_weighted_adapter().

TIES
DARE

Les valeurs de poids supérieures à 1.0 produisent généralement de meilleurs résultats car elles préservent l'échelle correcte. Une valeur de départ par défaut appropriée pour les poids consiste à définir toutes les valeurs sur 1.0.

adapters = ["norobots", "adcopy", "sql"]
weights = [2.0, 1.0, 1.0]
adapter_name = "merge"
density = 0.2
model.add_weighted_adapter(adapters, weights, adapter_name, combination_type="ties", density=density)

Définissez le modèle nouvellement fusionné comme modèle actif à l'aide de la méthode set_adapter().

model.set_adapter("merge")

Vous pouvez maintenant utiliser le modèle fusionné comme modèle ajusté par instructions pour rédiger des publicités ou des requêtes SQL !

instruct
texte publicitaire
SQL
device = torch.accelerator.current_accelerator().type if hasattr(torch, "accelerator") else "cuda"
messages = [
    {"role": "user", "content": "Write an essay about Generative AI."},
]
text = tokenizer.apply_chat_template(messages, add_generation_prompt=True, tokenize=False)
inputs = tokenizer(text, return_tensors="pt")
inputs = {k: v.to(device) for k, v in inputs.items()}
outputs = model.generate(**inputs, max_new_tokens=256, do_sample=True, top_p=0.95, temperature=0.2, repetition_penalty=1.2, eos_token_id=tokenizer.eos_token_id)
print(tokenizer.decode(outputs[0]))

Fusion de modèles (IA)³

Les modèles (IA)³ facilitent la fusion linéaire des adaptateurs. Pour fusionner des adaptateurs dans un modèle (IA)³, utilisez la méthode add_weighted_adapter de la classe IA3Model. Cette méthode est analogue à la méthode add_weighted_adapter utilisée dans LoraModel, la différence principale étant l'absence du paramètre combination_type. Par exemple, pour fusionner trois adaptateurs (IA)³ dans un modèle PEFT, vous procédez comme suit :

adapters = ["adapter1", "adapter2", "adapter3"]
weights = [0.4, 0.3, 0.3]
adapter_name = "merge"
model.add_weighted_adapter(adapters, weights, adapter_name)

Il est recommandé que la somme des poids soit égale à 1.0 afin de préserver l'échelle du modèle. Le modèle fusionné peut ensuite être défini comme le modèle actif à l'aide de la méthode set_adapter :

model.set_adapter("merge")
Update on GitHub