Model Merging

La fusion de modèles combine les poids de deux modèles entraînés ou plus en un seul modèle, généralement en faisant la moyenne de leurs paramètres ou en les additionnant. Le modèle obtenu conserve ainsi les capacités de chacun sans exécuter plusieurs réseaux ni les réentraîner sur l’ensemble de leurs données. Cette méthode fonctionne lorsque les modèles partagent la même architecture et, pour la plupart des méthodes, un même point de départ préentraîné : le réglage fin ne déplace chaque copie que d’une courte distance dans l’espace des poids, de sorte que leurs poids de modèle restent alignés paramètre par paramètre. La fusion est largement utilisée pour créer des grands modèles de langage (LLM) ouverts et combiner des adaptateurs LoRA ou des points de contrôle Stable Diffusion. Après l’entraînement, Meta a moyenné les modèles Llama 3 obtenus avec des données ou des hyperparamètres différents à chaque étape.

Fonctionnement de la fusion de modèles#

Les méthodes de fusion diffèrent selon ce qu’elles combinent et la façon dont elles résolvent les conflits entre modèles :

• Model soups : fait la moyenne des poids de modèles réglés finement à partir du même modèle de base avec différents hyperparamètres. Une fusion gloutonne de modèles ViT-G réglés finement a atteint une précision top-1 de 90,94 % sur ImageNet, un résultat de pointe à l’époque.
• Moyennage stochastique des poids : fait la moyenne de points de contrôle enregistrés à différents moments d’une même exécution d’entraînement, ce qui tend à stabiliser le modèle dans une région plus large et plus plate de la surface de perte.
• Arithmétique des tâches : soustrait les poids de base de chaque modèle réglé finement pour obtenir un vecteur de tâche, puis ajoute au modèle de base des vecteurs de tâche mis à l’échelle afin de combiner des compétences, ou en soustrait un pour supprimer un comportement.
• TIES-Merging : réduit les interférences entre les vecteurs de tâche en trois étapes : réinitialiser les paramètres qui ont peu changé pendant le réglage fin, choisir un signe pour chaque paramètre et fusionner uniquement les valeurs qui concordent avec ce signe.
• DARE : élimine aléatoirement la plupart des valeurs de chaque vecteur de tâche et redimensionne les valeurs restantes avant la fusion, ce qui supprime les changements redondants tout en préservant les capacités liées à chaque tâche.

Le moyennage au cours d’une même exécution d’entraînement fait aussi partie de l’entraînement courant. L’entraînement Ultralytics YOLO26 conserve une moyenne mobile exponentielle (EMA) des poids du modèle en parallèle des poids optimisés. Son taux de décroissance augmente jusqu’à 0,9999 au fil de l’entraînement, et les points de contrôle last.pt et best.pt enregistrés contiennent ce modèle moyenné.

Les méthodes fondées sur les vecteurs de tâche partagent la même structure : chaque modèle réglé finement est exprimé comme sa différence par rapport au modèle de base, les différences sont nettoyées et combinées, puis le résultat est ajouté au modèle de base :

Des outils open source comme mergekit implémentent ces méthodes pour les LLM, ainsi que l’interpolation sphérique (SLERP) entre deux modèles.

Pourquoi un point de départ commun est important#

Les unités cachées d’un réseau de neurones peuvent être réordonnées sans modifier les calculs du réseau. Deux réseaux entraînés à partir d’initialisations aléatoires différentes stockent donc rarement la même caractéristique à la même position, et leur moyennage mélange des poids sans rapport. Les modèles réglés finement à partir d’un même modèle de base conservent son agencement et restent dans la même région de faible perte, si bien que leur moyenne reste fonctionnelle. Cet exemple entraîne un petit classifieur PyTorch sur des chiffres manuscrits, règle finement deux copies sur différentes moitiés des données d’entraînement restantes, puis compare leur fusion à celle de deux modèles entraînés à partir d’initialisations distinctes :

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

Sur les 297 chiffres réservés à l’évaluation, les deux modèles réglés finement à partir d’un même modèle de base obtiennent des scores de 0,956 et 0,946, et leur moyenne atteint 0,970, un résultat supérieur à chacun des deux modèles, car elle combine ce que chacun a appris à partir de sa moitié des données. Les deux modèles entraînés à partir d’initialisations distinctes obtiennent des scores de 0,946 et 0,956, tandis que leur moyenne tombe à 0,808. Git Re-Basin fusionne des modèles entraînés indépendamment en permutant d’abord les unités cachées de l’un pour les faire correspondre à celles de l’autre.

Fusion de modèles et notions connexes#

• Ensemble de modèles : conserve chaque modèle et combine leurs sorties ; l’utilisation mémoire et la latence d’inférence augmentent donc avec le nombre de modèles. Un modèle fusionné a la taille et la vitesse d’un seul modèle.
• Distillation des connaissances : entraîne un nouveau modèle étudiant à imiter un ou plusieurs modèles enseignants, ce qui nécessite des données d’entraînement et des ressources de calcul. La fusion est une opération arithmétique directe sur des poids existants.
• Entraînement multitâche : entraîne un modèle sur les données de toutes les tâches à la fois, ce qui définit généralement la précision que la fusion cherche à atteindre sans avoir accès à ces données.
• Apprentissage fédéré : fait la moyenne des poids de modèles entraînés sur des appareils distincts à chaque cycle. Chaque cycle fait repartir tous les clients du même modèle global, le point de départ commun qui permet au moyennage de fonctionner.