Fusão de modelos

Treinar um modelo para cada tarefa pode ser custoso, ocupar espaço de armazenamento e os modelos não conseguem aprender novas informações para melhorar seu desempenho. O aprendizado multitarefa pode superar algumas dessas limitações ao treinar um modelo para aprender várias tarefas, mas o treinamento é caro e o projeto de um conjunto de dados para isso é desafiador. Merging de modelos oferece uma solução para esses desafios ao combinar vários modelos pré-treinados em um único modelo, conferindo-lhe as capacidades combinadas de cada modelo individual sem nenhum treinamento adicional.

O PEFT fornece vários métodos para mesclar modelos, como uma combinação linear ou SVD. Este guia se concentra em dois métodos que são mais eficientes para mesclar adaptadores LoRA, eliminando parâmetros redundantes:

• TIES - TrIm, Elect, and Merge (TIES) é um método de três etapas para mesclar modelos. Primeiro, os parâmetros redundantes são removidos; em seguida, os sinais conflitantes são resolvidos em um vetor agregado; e, por fim, os parâmetros cujos sinais são iguais ao sinal agregado são média. Este método leva em consideração que alguns valores (redundância e divergência de sinal) podem degradar o desempenho no modelo mesclado.
• DARE - Drop And REscale é um método que pode ser usado para preparar outras técnicas de mesclagem de modelos, como TIES. Ele funciona removendo aleatoriamente parâmetros de acordo com uma taxa de remoção e reescalando os parâmetros restantes. Isso ajuda a reduzir o número de parâmetros redundantes e potencialmente interferentes entre vários modelos.

Os modelos são mesclados com o método add_weighted_adapter(), e o método específico de mesclagem de modelos é especificado no parâmetro combination_type.

Método de mesclagem

Com TIES e DARE, a fusão é habilitada ao definir combination_type e density para um valor dos pesos a serem mantidos dos modelos individuais. Por exemplo, vamos fundir três modelos TinyLlama/TinyLlama-1.1B-intermediate-step-1431k-3T ajustados finamente: tinyllama_lora_nobots, tinyllama_lora_sql e tinyllama_lora_adcopy.

Ao tentar mesclar modelos totalmente treinados com TIES, você deve estar ciente de quaisquer tokens especiais que cada modelo possa ter adicionado à camada de incorporação que não fazem parte do vocabulário do checkpoint original. Isso pode causar um problema, pois cada modelo pode ter adicionado um token especial à mesma posição de incorporação. Se esse for o caso, você deve usar o método resize_token_embeddings para evitar a mesclagem dos tokens especiais no mesmo índice de incorporação.

Isso não deve ser um problema se você estiver mesclando apenas adaptadores LoRA treinados a partir do mesmo modelo base.

Carregue um modelo base e pode usar o método load_adapter() para carregar e atribuir um nome a cada adaptador:

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")

Defina os adaptadores, pesos, adapter_name, combination_type e density com o método add_weighted_adapter().

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)

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)

Defina o modelo recém-fusionado como o modelo ativo com o método set_adapter().

model.set_adapter("merge")

Agora você pode usar o modelo mesclado como um modelo ajustado por instruções para escrever textos publicitários ou consultas 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]))

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

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

Mesclando modelos (IA)³

Os modelos (IA)³ facilitam a mesclagem linear de adaptadores. Para mesclar adaptadores em um modelo (IA)³, utilize o método add_weighted_adapter da classe IA3Model. Este método é análogo ao método add_weighted_adapter usado em LoraModel, com a principal diferença sendo a ausência do parâmetro combination_type. Por exemplo, para mesclar três adaptadores (IA)³ em um modelo PEFT, você deve proceder da seguinte forma:

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

Recomenda-se que a soma dos pesos seja 1.0 para preservar a escala do modelo. O modelo mesclado pode então ser definido como o modelo ativo usando o método set_adapter:

model.set_adapter("merge")