Model Merging

A fusão de modelos combina os pesos de dois ou mais modelos treinados num único modelo, geralmente calculando a média ou somando os seus parâmetros, para que o resultado preserve capacidades de cada modelo sem executar várias redes ou voltar a treiná-las com todos os respetivos dados. Funciona quando os modelos partilham uma arquitetura e, na maioria dos métodos, um ponto de partida pré-treinado comum: o ajuste fino desloca cada cópia apenas uma pequena distância no espaço dos pesos, pelo que os pesos do modelo continuam alinhados parâmetro a parâmetro. A fusão é amplamente usada para criar modelos de linguagem de grande porte (LLMs) abertos e combinar adaptadores LoRA ou checkpoints do Stable Diffusion; no pós-treino do Llama 3, a Meta calculou a média de modelos obtidos com diferentes dados ou hiperparâmetros em cada etapa.

Como funciona a fusão de modelos#

Os métodos de fusão diferem naquilo que combinam e na forma como resolvem conflitos entre modelos:

• Sopas de modelos: calculam a média dos pesos de modelos ajustados a partir da mesma base com hiperparâmetros diferentes. Uma sopa gulosa de modelos ViT-G ajustados alcançou 90,94% de precisão top-1 no ImageNet, um resultado de ponta na altura.
• Média estocástica dos pesos: calcula a média de checkpoints guardados em diferentes momentos de uma execução de treino, o que tende a fazer com que o modelo se estabilize numa região mais ampla e plana da superfície de perda.
• Aritmética de tarefas: subtrai os pesos-base de cada modelo ajustado para obter um vetor de tarefa; em seguida, soma vetores de tarefa escalados à base para combinar competências, ou subtrai um vetor para remover um comportamento.
• TIES-Merging: reduz a interferência entre vetores de tarefa em três etapas: redefine parâmetros que mudaram apenas ligeiramente durante o ajuste fino, escolhe um sinal para cada parâmetro e funde apenas os valores que concordam com esse sinal.
• DARE: elimina aleatoriamente a maioria dos valores de cada vetor de tarefa e reescala os restantes antes da fusão, removendo alterações redundantes e preservando a capacidade de cada tarefa.

O cálculo da média durante uma única execução de treino também faz parte do treino normal. O treino da Ultralytics YOLO26 mantém uma média móvel exponencial (EMA) dos pesos do modelo juntamente com os pesos que estão a ser otimizados, com uma taxa de decaimento que aumenta até 0.9999 à medida que o treino avança; os checkpoints last.pt e best.pt que guarda contêm este modelo com pesos médios.

Os métodos de vetores de tarefa partilham a mesma estrutura: cada modelo ajustado é representado pela diferença em relação à base, as diferenças são depuradas e combinadas, e o resultado é somado novamente à base:

Ferramentas de código aberto como o mergekit implementam estas receitas para LLMs, além da interpolação esférica (SLERP) entre dois modelos.

Porque é importante partilhar um ponto de partida#

As unidades ocultas de uma rede neural podem ser reordenadas sem alterar os cálculos da rede; por isso, duas redes treinadas com inicializações aleatórias diferentes raramente armazenam a mesma característica na mesma posição, e calcular a média entre elas mistura pesos sem relação. Os modelos ajustados a partir da mesma base preservam a disposição original e permanecem na mesma região de baixa perda, pelo que a sua média continua a funcionar. Este exemplo treina um classificador pequeno em PyTorch com dígitos escritos à mão, ajusta duas cópias com metades diferentes dos dados de treino restantes e compara a fusão entre elas com a fusão de dois modelos treinados a partir de inicializações separadas:

import copy

import torch
from sklearn.datasets import load_digits
from torch import nn

torch.manual_seed(0)
X, y = load_digits(return_X_y=True)
order = torch.randperm(len(X))
X, y = torch.tensor(X / 16, dtype=torch.float32)[order], torch.tensor(y)[order]


def mlp():
    """Return a small classifier for 8x8 digit images."""
    return nn.Sequential(nn.Linear(64, 64), nn.ReLU(), nn.Linear(64, 64), nn.ReLU(), nn.Linear(64, 10))


def train(model, rows, steps):
    """Train a model with SGD on the given rows and return it."""
    optimizer = torch.optim.SGD(model.parameters(), lr=0.1, momentum=0.9)
    for _ in range(steps):
        optimizer.zero_grad()
        nn.functional.cross_entropy(model(X[rows]), y[rows]).backward()
        optimizer.step()
    return model


base = train(mlp(), slice(0, 300), 400)  # shared pretrained starting point
halves = (slice(300, 900), slice(900, 1500))  # two different fine-tuning datasets
for name, (a, b) in [
    ("fine-tuned from one base", [train(copy.deepcopy(base), rows, 100) for rows in halves]),
    ("trained from separate inits", [train(mlp(), rows, 400) for rows in halves]),
]:
    # Merge: average every weight tensor of the two models
    merged = copy.deepcopy(a)
    merged.load_state_dict({k: (a.state_dict()[k] + b.state_dict()[k]) / 2 for k in a.state_dict()})
    accuracy = [(m(X[1500:]).argmax(1) == y[1500:]).float().mean().item() for m in (a, b, merged)]
    print(f"{name}: {accuracy[0]:.3f} and {accuracy[1]:.3f}, merged {accuracy[2]:.3f}")

Nos 297 dígitos reservados para teste, os dois modelos ajustados a partir da mesma base obtêm pontuações de 0.956 e 0.946, e a média obtém 0.970, acima de ambos, porque combina o que cada um aprendeu com a sua metade dos dados. Os dois modelos treinados a partir de inicializações separadas obtêm 0.946 e 0.956, e a média desce para 0.808. O Git Re-Basin funde modelos treinados de forma independente permutando primeiro as unidades ocultas de um modelo para as alinhar com as do outro.

Fusão de modelos e conceitos relacionados#

• Ensemble de modelos: mantém todos os modelos e combina os respetivos resultados, pelo que o consumo de memória e a latência de inferência aumentam com o número de modelos. Um modelo fundido tem o tamanho e a velocidade de um único modelo.
• Destilação de conhecimento: treina um novo modelo aluno para imitar um ou mais modelos professores, o que exige dados de treino e recursos computacionais. A fusão é uma operação aritmética direta sobre pesos existentes.
• Treino multitarefa: treina um modelo com os dados de todas as tarefas em conjunto, o que geralmente define a precisão que a fusão procura alcançar sem acesso a esses dados.
• Aprendizagem federada: calcula a média dos pesos de modelos treinados em dispositivos separados em cada ronda. Todas as rondas começam com os clientes a partir do mesmo modelo global, o ponto de partida partilhado que permite que a média funcione.