Model Merging

La fusione di modelli combina i pesi di due o più modelli addestrati in un unico modello, di solito calcolandone la media o sommando i parametri, così che il risultato mantenga le capacità di ciascuno senza eseguire più reti né riaddestrare su tutti i loro dati. Funziona quando i modelli condividono un'architettura e, per la maggior parte dei metodi, un punto di partenza preaddestrato comune: il fine-tuning sposta ogni copia solo di poco nello spazio dei pesi, così i pesi del modello continuano ad allinearsi parametro per parametro. La fusione è ampiamente usata per creare modelli linguistici di grandi dimensioni (LLM) open source e combinare adattatori LoRA o checkpoint di Stable Diffusion; nel post-addestramento, Meta ha mediato i modelli Llama 3 ottenuti con dati o iperparametri diversi in ciascuna fase.

Come funziona la fusione dei modelli#

I metodi di fusione differiscono per ciò che combinano e per il modo in cui risolvono i conflitti tra modelli:

• Model soups: calcolano la media dei pesi di modelli sottoposti a fine-tuning a partire dalla stessa base, ma con iperparametri diversi. Una model soup greedy di modelli ViT-G sottoposti a fine-tuning ha raggiunto un'accuratezza top-1 del 90,94% su ImageNet, un risultato all'avanguardia all'epoca.
• Media mobile stocastica dei pesi: calcola la media dei checkpoint salvati in punti diversi di una singola esecuzione di addestramento; tende così a stabilizzarsi in una regione più ampia e piatta della superficie della loss.
• Aritmetica dei task: sottrae i pesi di base da ciascun modello sottoposto a fine-tuning per ottenere un vettore del task, poi aggiunge alla base vettori del task scalati per combinare capacità oppure ne sottrae uno per eliminare un comportamento.
• TIES-Merging: riduce l'interferenza tra i vettori dei task in tre passaggi: azzera i parametri che sono cambiati solo leggermente durante il fine-tuning, sceglie un segno per ciascun parametro e fonde solo i valori concordi con quel segno.
• DARE: elimina casualmente la maggior parte dei valori di ciascun vettore del task e ridimensiona quelli rimanenti prima della fusione, rimuovendo così le modifiche ridondanti senza perdere le capacità di ciascun task.

Anche l'addestramento ordinario prevede il calcolo della media nel corso di un'unica esecuzione. Durante l'addestramento di Ultralytics YOLO26, si mantiene una media mobile esponenziale (EMA) dei pesi del modello insieme ai pesi ottimizzati; il fattore di decadimento aumenta progressivamente fino a 0.9999 e i checkpoint last.pt e best.pt salvati contengono questo modello medio.

I metodi basati sui vettori dei task condividono una stessa struttura: ogni modello sottoposto a fine-tuning è espresso come differenza rispetto alla base, le differenze vengono ripulite e combinate, quindi il risultato viene aggiunto di nuovo alla base:

Strumenti open source come mergekit implementano queste procedure per gli LLM, insieme all'interpolazione sferica (SLERP) tra due modelli.

Perché è importante condividere il punto di partenza#

Le unità nascoste di una rete neurale possono essere riordinate senza cambiare i calcoli della rete; perciò, due reti addestrate con inizializzazioni casuali diverse raramente memorizzano la stessa caratteristica nella stessa posizione e la loro media combina pesi non correlati. I modelli sottoposti a fine-tuning a partire dalla stessa base mantengono la disposizione della base e restano nella stessa regione a bassa loss, quindi la loro media continua a funzionare. Questo esempio addestra un piccolo classificatore PyTorch su cifre scritte a mano, sottopone a fine-tuning due copie usando metà diverse dei dati di addestramento rimanenti e confronta la loro fusione con quella di due modelli addestrati con inizializzazioni distinte:

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

Sulle 297 cifre di test, i due modelli sottoposti a fine-tuning a partire dalla stessa base ottengono 0.956 e 0.946, mentre la loro media ottiene 0.970, un punteggio superiore a entrambi perché combina ciò che ciascuno ha appreso dalla propria metà dei dati. I due modelli addestrati con inizializzazioni distinte ottengono 0.946 e 0.956, mentre la loro media scende a 0.808. Git Re-Basin fonde modelli addestrati indipendentemente permutando prima le unità nascoste di un modello per allinearle a quelle dell'altro.

Fusione dei modelli e concetti correlati#

• Ensemble di modelli: mantiene tutti i modelli e combina i loro output, perciò l'uso di memoria e la latenza di inferenza aumentano con il numero di modelli. Un modello fuso ha le dimensioni e la velocità di un singolo modello.
• Distillazione della conoscenza: addestra un nuovo modello studente a imitare uno o più modelli insegnanti, richiedendo dati di addestramento e risorse di calcolo. La fusione è un'operazione aritmetica diretta sui pesi esistenti.
• Addestramento multitask: addestra un modello su tutti i dati dei task contemporaneamente; in genere stabilisce l'accuratezza che la fusione cerca di raggiungere senza avere accesso a quei dati.
• Apprendimento federato: calcola a ogni round la media dei pesi di modelli addestrati su dispositivi distinti. Ogni round avvia tutti i client dallo stesso modello globale, il punto di partenza condiviso che consente alla media di funzionare.