Model Merging

Beim Modell-Merging werden die Gewichte von zwei oder mehr trainierten Modellen zu einem einzigen Modell kombiniert, in der Regel durch Mittelwertbildung oder Addition ihrer Parameter. So behält das Ergebnis Fähigkeiten aus allen Modellen, ohne mehrere Netze ausführen oder mit all ihren Daten neu trainieren zu müssen. Das funktioniert, wenn die Modelle dieselbe Architektur und – bei den meisten Methoden – denselben vortrainierten Ausgangspunkt haben: Beim Fine-Tuning bewegt sich jede Kopie nur ein kurzes Stück im Gewichtsraum, sodass ihre Modellgewichte weiterhin Parameter für Parameter übereinstimmen. Merging wird häufig verwendet, um offene große Sprachmodelle (LLMs) zu erstellen und LoRA-Adapter oder Stable Diffusion-Checkpoints zu kombinieren. Beim Post-Training von Metas Llama 3 wurden Modelle gemittelt, die in den einzelnen Phasen mit unterschiedlichen Daten oder Hyperparametern trainiert worden waren.

So funktioniert Modell-Merging#

Merging-Methoden unterscheiden sich darin, was sie kombinieren und wie sie Konflikte zwischen Modellen lösen:

• Model Soups: Mitteln die Gewichte von Modellen, die mit unterschiedlichen Hyperparametern auf derselben Basis feinabgestimmt wurden. Ein gieriges Soup aus feinabgestimmten ViT-G-Modellen erzielte auf ImageNet eine Top-1-Genauigkeit von 90,94 % – damals ein Ergebnis auf dem Stand der Technik.
• Stochastische Gewichtsmittelung: Mittelt Checkpoints, die zu verschiedenen Zeitpunkten eines Trainingslaufs gespeichert wurden. Dadurch landet das Modell tendenziell in einem breiteren, flacheren Bereich der Verlustlandschaft.
• Task-Arithmetik: Zieht die Basisgewichte von jedem feinabgestimmten Modell ab, um einen Aufgabenvektor zu erhalten. Anschließend werden skalierte Aufgabenvektoren zur Basis addiert, um Fähigkeiten zu kombinieren, oder einer davon wird abgezogen, um ein Verhalten zu entfernen.
• TIES-Merging: Verringert Störungen zwischen Aufgabenvektoren in drei Schritten: Parameter, die sich beim Fine-Tuning nur wenig verändert haben, werden zurückgesetzt, für jeden Parameter wird ein Vorzeichen bestimmt und nur Werte mit diesem Vorzeichen werden zusammengeführt.
• DARE: Entfernt zufällig die meisten Werte jedes Aufgabenvektors und skaliert die übrigen vor dem Merging neu. Dadurch werden redundante Änderungen entfernt, während die Fähigkeiten für jede Aufgabe erhalten bleiben.

Die Mittelung während eines einzelnen Trainingslaufs gehört ebenfalls zum regulären Training. Beim Training von Ultralytics YOLO26 wird neben den optimierten Gewichten auch ein exponentieller gleitender Mittelwert (EMA) der Modellgewichte geführt. Der Zerfallsfaktor steigt im Verlauf des Trainings auf 0.9999 an. Die gespeicherten Checkpoints last.pt und best.pt enthalten dieses gemittelte Modell.

Aufgabenvektor- Methoden folgen alle demselben Prinzip: Jedes feinabgestimmte Modell wird als Differenz zur Basis ausgedrückt, die Differenzen werden bereinigt und kombiniert, und das Ergebnis wird wieder zur Basis addiert:

Open-Source-Tools wie mergekit setzen diese Rezepte für LLMs um, ebenso wie die sphärische Interpolation (SLERP) zwischen zwei Modellen.

Warum ein gemeinsamer Ausgangspunkt wichtig ist#

Die verborgenen Einheiten eines neuronalen Netzes lassen sich umordnen, ohne die Berechnungen des Netzes zu verändern. Deshalb speichern zwei Netze, die mit unterschiedlichen zufälligen Initialisierungen trainiert wurden, dasselbe Merkmal selten an derselben Position, und beim Mitteln werden nicht zusammengehörige Gewichte vermischt. Modelle, die auf derselben Basis feinabgestimmt wurden, behalten deren Anordnung bei und bleiben im selben Bereich niedriger Verluste, sodass ihr Mittelwert weiterhin funktioniert. Dieses Beispiel trainiert einen kleinen PyTorch-Klassifikator für handgeschriebene Ziffern, stimmt zwei Kopien auf unterschiedlichen Hälften der übrigen Trainingsdaten fein ab und vergleicht ihr Merging mit dem zweier Modelle, die mit getrennten Initialisierungen trainiert wurden:

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

Bei den 297 zurückgehaltenen Ziffern erreichen die beiden auf derselben Basis feinabgestimmten Modelle Werte von 0.956 und 0.946; ihr Mittelwert erreicht 0.970 und liegt damit über beiden, weil er das Gelernte aus den jeweiligen Datenhälften kombiniert. Die beiden mit getrennten Initialisierungen trainierten Modelle erreichen 0.946 und 0.956, ihr Mittelwert fällt jedoch auf 0.808. Git Re-Basin führt das Merging unabhängig trainierter Modelle durch, indem zunächst die verborgenen Einheiten eines Modells so permutiert werden, dass sie zu denen des anderen passen.

Modell-Merging und verwandte Begriffe#

• Modell-Ensemble: Behält alle Modelle bei und kombiniert ihre Ausgaben. Dadurch steigen Speicherbedarf und Inferenzlatenz mit der Anzahl der Modelle. Ein zusammengeführtes Modell hat die Größe und Geschwindigkeit eines einzelnen Modells.
• Wissensdestillation: Trainiert ein neues Schülermodell darauf, einen oder mehrere Lehrer nachzuahmen. Dafür werden Trainingsdaten und Rechenleistung benötigt. Merging ist eine direkte arithmetische Operation auf vorhandenen Gewichten.
• Multitasking-Training: Trainiert ein Modell gemeinsam mit den Daten aller Aufgaben. Damit wird meist die Genauigkeit festgelegt, die Merging ohne Zugriff auf diese Daten zu erreichen versucht.
• Föderiertes Lernen: Mittelt in jeder Runde die Gewichte von Modellen, die auf getrennten Geräten trainiert wurden. Jede Runde startet alle Clients mit demselben globalen Modell – dem gemeinsamen Ausgangspunkt, der das Mitteln ermöglicht.