# 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](https://hf.co/papers/2306.01708) - 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](https://hf.co/papers/2311.03099) - 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()](/docs/peft/v0.22.0/fr/package_reference/lora#peft.LoraModel.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](https://huggingface.co/TinyLlama/TinyLlama-1.1B-intermediate-step-1431k-3T) affinés : [tinyllama_lora_nobots](https://huggingface.co/smangrul/tinyllama_lora_norobots), [tinyllama_lora_sql](https://huggingface.co/smangrul/tinyllama_lora_sql) et [tinyllama_lora_adcopy](https://huggingface.co/smangrul/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](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/model#transformers.PreTrainedModel.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()](/docs/peft/v0.22.0/fr/package_reference/peft_model#peft.PeftModel.load_adapter) pour charger et attribuer un nom à chaque adaptateur :

```py
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()](/docs/peft/v0.22.0/fr/package_reference/lora#peft.LoraModel.add_weighted_adapter).

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`.

```py
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)
```

```py
adapters = ["norobots", "adcopy", "sql"]
weights = [2.0, 0.3, 0.7]
adapter_name = "merge"
density = 0.2
model.add_weighted_adapter(adapters, weights, adapter_name, combination_type="dare_ties", density=density)
```

Définissez le modèle nouvellement fusionné comme modèle actif à l'aide de la méthode [set_adapter()](/docs/peft/v0.22.0/fr/package_reference/tuners#peft.tuners.tuners_utils.BaseTuner.set_adapter).

```py
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 !

```py
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]))
```

```py
device = torch.accelerator.current_accelerator().type if hasattr(torch, "accelerator") else "cuda"
messages = [
    {"role": "system", "content": "Create a text ad given the following product and description."},
    {"role": "user", "content": "Product: Sony PS5 PlayStation Console\nDescription: The PS5 console unleashes new gaming possibilities that you never anticipated."},
]
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=128, 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]))
```

```py
device = torch.accelerator.current_accelerator().type if hasattr(torch, "accelerator") else "cuda"

text = """Table: 2-11365528-2
Columns: ['Team', 'Head Coach', 'President', 'Home Ground', 'Location']
Natural Query: Who is the Head Coach of the team whose President is Mario Volarevic?
SQL Query:"""

inputs = tokenizer(text, return_tensors="pt")
inputs = {k: v.to(device) for k, v in inputs.items()}
outputs = model.generate(**inputs, max_new_tokens=64, repetition_penalty=1.1, eos_token_id=tokenizer("</s>").input_ids[-1])
print(tokenizer.decode(outputs[0]))
```

## Merging Modèles (IA)³
The 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`, avec la différence principale que le paramètre `combination_type` est absent. Par exemple, pour fusionner trois adaptateurs (IA)³ dans un modèle PEFT, vous procédez comme suit :

```py
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` :

```py
model.set_adapter("merge")
```

