Model Merging

La fusión de modelos combina los pesos de dos o más modelos entrenados en un único modelo, normalmente promediando o sumando sus parámetros, de modo que el resultado conserva capacidades de cada uno sin ejecutar varias redes ni volver a entrenar con todos sus datos. Funciona cuando los modelos comparten arquitectura y, con la mayoría de métodos, un punto de partida preentrenado común: el ajuste fino desplaza cada copia solo una distancia corta en el espacio de pesos, por lo que los pesos del modelo siguen alineados parámetro a parámetro. La fusión se utiliza ampliamente para crear modelos de lenguaje grandes (LLM) abiertos y combinar adaptadores LoRA o puntos de control de Stable Diffusion; el ajuste posterior al entrenamiento de Llama 3 de Meta promedió modelos obtenidos con datos o hiperparámetros distintos en cada etapa.

Cómo funciona la fusión de modelos#

Los métodos de fusión se diferencian por lo que combinan y por cómo resuelven los conflictos entre modelos:

• Sopas de modelos: promedia los pesos de modelos ajustados a partir de la misma base con distintos hiperparámetros. Una sopa voraz de modelos ViT-G ajustados alcanzó una precisión top-1 del 90,94 % en ImageNet, un resultado de vanguardia en aquel momento.
• Promediado estocástico de pesos: promedia los puntos de control guardados en distintos momentos de una ejecución de entrenamiento, lo que suele hacer que el modelo se estabilice en una región más amplia y plana de la superficie de pérdida.
• Aritmética de tareas: resta los pesos base de cada modelo ajustado para obtener un vector de tarea y, después, suma vectores de tarea escalados a la base para combinar habilidades, o resta uno para eliminar un comportamiento.
• TIES-Merging: reduce la interferencia entre vectores de tarea en tres pasos: restablece los parámetros que apenas cambiaron durante el ajuste fino, elige un signo para cada parámetro y fusiona solo los valores que coinciden con ese signo.
• DARE: descarta aleatoriamente la mayoría de los valores de cada vector de tarea y reescala el resto antes de fusionarlos, lo que elimina cambios redundantes y conserva la capacidad de cada tarea.

El promediado a lo largo de una ejecución de entrenamiento también forma parte del entrenamiento habitual. El entrenamiento de Ultralytics YOLO26 mantiene una media móvil exponencial (EMA) de los pesos del modelo junto con los pesos que se están optimizando, con una tasa de decaimiento que aumenta hasta 0.9999 a medida que avanza el entrenamiento; los puntos de control last.pt y best.pt que guarda contienen este modelo promediado.

Los métodos de vector de tarea comparten una misma estructura: cada modelo ajustado se expresa como la diferencia con respecto al modelo base, las diferencias se depuran y combinan, y el resultado se vuelve a sumar al modelo base:

Herramientas de código abierto como mergekit implementan estas recetas para LLM, junto con la interpolación esférica (SLERP) entre dos modelos.

Por qué importa compartir un punto de partida#

Las unidades ocultas de una red neuronal se pueden reordenar sin cambiar los cálculos de la red, por lo que dos redes entrenadas con inicializaciones aleatorias distintas rara vez almacenan la misma característica en la misma posición, y promediarlas mezcla pesos que no guardan relación. Los modelos ajustados a partir de una misma base conservan la disposición de esta y permanecen en la misma región de baja pérdida, por lo que su promedio sigue funcionando. Este ejemplo entrena un clasificador pequeño de PyTorch con dígitos manuscritos, ajusta dos copias con mitades distintas de los datos de entrenamiento restantes y compara su fusión con la de dos modelos entrenados desde inicializaciones distintas:

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

Con los 297 dígitos reservados, los dos modelos ajustados a partir de una misma base obtienen 0.956 y 0.946, y su promedio alcanza 0.970, por encima de ambos, porque combina lo que cada uno aprendió de su mitad de los datos. Los dos modelos entrenados desde inicializaciones distintas obtienen 0.946 y 0.956, y su promedio baja a 0.808. Git Re-Basin fusiona modelos entrenados de forma independiente permutando primero las unidades ocultas de uno de ellos para que coincidan con las del otro.

Fusión de modelos frente a conceptos relacionados#

• Ensamblado de modelos: conserva todos los modelos y combina sus salidas, por lo que el uso de memoria y la latencia de inferencia aumentan con el número de modelos. Un modelo fusionado tiene el tamaño y la velocidad de un único modelo.
• Destilación de conocimiento: entrena un nuevo modelo estudiante para que imite a uno o varios modelos profesores, lo que requiere datos de entrenamiento y capacidad de cálculo. La fusión es una operación aritmética directa sobre pesos existentes.
• Entrenamiento multitarea: entrena un modelo con los datos de todas las tareas a la vez y suele establecer la precisión que la fusión intenta alcanzar sin acceso a esos datos.
• Aprendizaje federado: promedia en cada ronda los pesos de modelos entrenados en dispositivos distintos. Cada ronda inicia todos los clientes desde el mismo modelo global, el punto de partida compartido que permite que el promedio funcione.