Fusión de modelos con Mergekit

Mergekit es el conjunto de herramientas definitivo para fusionar modelos de lenguaje grandes preentrenados. Con más de 5K estrellas en GitHub, implementa todos los principales algoritmos de fusión de modelos — SLERP, TIES, DARE, DARE-TIES, fusión MoE y más —, lo que te permite crear nuevos y potentes modelos sin ningún dato de entrenamiento ni tiempo de entrenamiento en GPU.

Todos los ejemplos se pueden ejecutar en servidores GPU alquilados a través de Marketplace de CLORE.AI.

---

¿Qué es Mergekit?

La fusión de modelos es una técnica potente que combina las fortalezas de múltiples LLM en un solo modelo:

• No requiere entrenamiento — la fusión ocurre en el espacio de pesos, no mediante backprop

• Combinar capacidades — combinar un modelo de programación con un modelo que sigue instrucciones

• Reducir debilidades — promediar los fallos individuales de los modelos en un conjunto

• Crear una mezcla de expertos — combinar modelos en una arquitectura MoE dispersa

• Adaptación al dominio — fusionar un modelo base con modelos especializados en un dominio

Mergekit implementa todos los algoritmos de última generación:

Algoritmo	Descripción	Ideal para
SLERP	Interpolación lineal esférica entre dos modelos	Mezcla suave de dos modelos similares
TIES	Recortar parámetros redundantes, elegir signos, fusionar	Combinar múltiples modelos con una interferencia mínima
DARE	Eliminar y reescalar parámetros aleatorios	Reducir la interferencia de parámetros en grandes fusiones
DARE-TIES	DARE + TIES combinados	La mejor opción general para fusiones de múltiples modelos
Lineal	Promedio ponderado simple	Fusiones rápidas de referencia
Aritmética de tareas	Sumar/restar vectores de tareas	Añadir/eliminar capacidades específicas
Paso directo	Copiar capas directamente	Construcción de MoE

La fusión de modelos es sorprendentemente eficaz. Los modelos fusionados a menudo superan a sus modelos de origen en los benchmarks al combinar conocimientos complementarios. La comunidad de MergeKit en HuggingFace aloja miles de modelos fusionados.

---

Requisitos del servidor

Componente	Mínimo	Recomendado
GPU	No es necesario (la fusión en CPU es posible)	A100 de 40 GB para modelos grandes
VRAM	—	80 GB para fusiones de modelos de 70B
RAM	32 GB	64 GB+ (los modelos se cargan en la RAM)
CPU	8 núcleos	16+ núcleos
Almacenamiento	100 GB	500 GB+
SO	Ubuntu 20.04+	Ubuntu 22.04
Python	3.10+	3.11

Para la fusión solo en CPU (el modo más común), la RAM es tu cuello de botella. Fusionar dos modelos de 7B en bf16 requiere ~28 GB de RAM como mínimo. Usa --lazy-unpickle para un menor uso de memoria.

---

Puertos

Puerto	Servicio	Notas
22	SSH	Acceso al terminal y transferencia de archivos

Mergekit se ejecuta como una herramienta de línea de comandos: no se necesita servidor web.

---

Instalación en Clore.ai

Paso 1 — Alquilar un servidor

1. Ve a Marketplace de Clore.ai

2. Filtra por RAM ≥ 64 GB (crítico para fusiones de modelos grandes)

3. Elige Almacenamiento ≥ 500 GB (los modelos fusionados necesitan espacio para 2-4 modelos de entrada + la salida)

4. La GPU es opcional, pero útil si quieres probar el modelo fusionado después

5. Abrir puerto 22 solo

Paso 2 — Conectarse por SSH

ssh root@<ip-del-servidor> -p <puerto-ssh>

Paso 3 — Instalar el entorno de Python

# Instalar Python 3.11
apt-get update
apt-get install -y python3.11 python3.11-venv python3.11-pip git

# Crear entorno virtual
python3.11 -m venv /opt/mergekit
source /opt/mergekit/bin/activate

Paso 4 — Instalar Mergekit

# Instala desde PyPI
pip install mergekit

# O instalar desde el código fuente (recomendado para las funciones más recientes)
git clone https://github.com/arcee-ai/mergekit.git
cd mergekit
pip install -e '.[everything]'

Paso 5 — Instalar la CLI de HuggingFace

pip install huggingface_hub
huggingface-cli login  # Introduce tu token de HF

Paso 6 — Verificar la instalación

mergekit --help
mergekit-yaml --help

---

Descargando modelos para fusionar

# Descarga los modelos que quieras fusionar
# Usando huggingface_hub

python3 << 'EOF'
from huggingface_hub import snapshot_download

# Descargar modelo 1
snapshot_download(
    repo_id="mistralai/Mistral-7B-Instruct-v0.3",
    local_dir="models/Mistral-7B-Instruct-v0.3"
)

# Descargar modelo 2
snapshot_download(
    repo_id="meta-llama/Llama-3.2-8B-Instruct",
    local_dir="models/Llama-3.2-8B-Instruct",
    token="hf_your-token"  # Requerido para modelos con acceso restringido
)
EOF

# O usa la CLI de huggingface_hub
huggingface-cli download mistralai/Mistral-7B-Instruct-v0.3 \\
  --local-dir models/Mistral-7B-Instruct-v0.3

---

Configuraciones de fusión

Mergekit utiliza archivos de configuración YAML para definir fusiones.

Ejemplo 1: Fusión SLERP (dos modelos)

SLERP mezcla dos modelos a lo largo de un arco esférico — mejor para modelos de la misma arquitectura:

# slerp_merge.yaml
models:
  - model: models/Mistral-7B-Instruct-v0.3
  - model: models/OpenHermes-2.5-Mistral-7B

merge_method: slerp
base_model: models/Mistral-7B-Instruct-v0.3

slices:
  - sources:
    - model: models/Mistral-7B-Instruct-v0.3
      layer_range: [0, 32]
    - model: models/OpenHermes-2.5-Mistral-7B
      layer_range: [0, 32]

parameters:
  t:
    - filter: self_attn
      value: 0.5  # mezcla 50/50 para las capas de atención
    - filter: mlp
      value: 0.3  # 30 % del modelo 2 para las capas MLP
    - value: 0.5  # valor predeterminado para todo lo demás

dtype: bfloat16

mergekit-yaml slerp_merge.yaml merged-model/ --lazy-unpickle

Ejemplo 2: Fusión TIES (múltiples modelos)

TIES maneja la interferencia entre múltiples modelos fusionados:

# ties_merge.yaml
models:
  - model: models/Mistral-7B-v0.3
    parameters:
      weight: 1.0    # Modelo base, peso completo
      density: 1.0

  - model: models/Mistral-7B-coding
    parameters:
      weight: 0.7    # Capacidad de programación
      density: 0.5   # Mantén el 50 % de los parámetros modificados

  - model: models/Mistral-7B-math
    parameters:
      weight: 0.5    # Capacidad matemática
      density: 0.3   # Mantén el 30 % de los parámetros modificados

merge_method: ties
base_model: models/Mistral-7B-v0.3

parameters:
  normalize: true
  int8_mask: true

dtype: bfloat16

mergekit-yaml ties_merge.yaml merged-ties/ --lazy-unpickle

Ejemplo 3: Fusión DARE-TIES (la mejor opción general)

# dare_ties_merge.yaml
models:
  - model: models/Llama-3.2-8B-Instruct
    parameters:
      weight: 1.0
      density: 0.7
      dare_linear: true

  - model: models/Llama-3.2-8B-code
    parameters:
      weight: 0.8
      density: 0.5
      dare_linear: true

  - model: models/Llama-3.2-8B-math
    parameters:
      weight: 0.6
      density: 0.4
      dare_linear: true

merge_method: dare_ties
base_model: models/Llama-3.2-8B-Instruct

parameters:
  normalize: true
  dare_density: 0.5
  dare_epsilon: 0.08

dtype: bfloat16

mergekit-yaml dare_ties_merge.yaml merged-dare-ties/ --lazy-unpickle

Ejemplo 4: Aritmética de tareas (añadir capacidades)

Añade un "delta de habilidad" a un modelo base:

# task_arithmetic.yaml
# Añade la habilidad matemática de un modelo ajustado para matemáticas a un modelo base general
models:
  - model: models/Llama-3.2-8B-Instruct
    parameters:
      weight: 1.0
  
  - model: models/Llama-3.2-8B-math
    parameters:
      weight: 0.7   # Positivo = añade esta capacidad
  
  # Para ELIMINAR una capacidad, usa un peso negativo:
  # - model: models/Llama-3.2-8B-harmful
  #   parameters:
  #     weight: -0.5

merge_method: task_arithmetic
base_model: models/Llama-3.2-8B-Instruct

dtype: bfloat16

Ejemplo 5: MoE (mezcla de expertos)

Combina modelos en una arquitectura MoE dispersa:

# moe_merge.yaml
base_model: models/Llama-3.2-8B-Instruct

gate_mode: hidden  # Usa estados ocultos para enrutar a los expertos
dtype: bfloat16
experts:
  - source_model: models/Llama-3.2-8B-coding
    positive_prompts:
      - "Escribe código"
      - "Depura esta función"
      - "Implementa un algoritmo"
    negative_prompts:
      - "Cuéntame una historia"
      - "Explica la historia"
  
  - source_model: models/Llama-3.2-8B-creative
    positive_prompts:
      - "Escribe una historia"
      - "Sé creativo"
      - "Imagina"
    negative_prompts:
      - "Escribe código"
      - "Calcula"

mergekit-moe moe_merge.yaml merged-moe/ --lazy-unpickle

---

Ejecutando la fusión

Comando básico

# Activar el entorno
source /opt/mergekit/bin/activate

# Ejecuta la fusión con lazy unpickling (ahorra RAM)
mergekit-yaml your_config.yaml output_model/ --lazy-unpickle

# Con aceleración CUDA (si hay GPU disponible)
mergekit-yaml your_config.yaml output_model/ \\
  --lazy-unpickle \\
  --cuda \\
  --copy-tokenizer

# Modo de baja memoria (más lento, pero funciona en servidores más pequeños)
mergekit-yaml your_config.yaml output_model/ \\
  --lazy-unpickle \\
  --low-cpu-memory

Supervisar el progreso

# Mergekit muestra el progreso de cada capa
# Salida típica:
# Cargando modelo 1...
# Cargando modelo 2...
# Fusionando la capa 0/32: embed_tokens
# Fusionando la capa 1/32: layers.0.self_attn
# ...
# Guardando el modelo fusionado...
# ¡Hecho! Guardado en output_model/

---

Probando el modelo fusionado

# Prueba rápida con transformers
python3 << 'EOF'
from transformers import AutoTokenizer, AutoModelForCausalLM
import torch

model_path = "output_model"
tokenizer = AutoTokenizer.from_pretrained(model_path)
model = AutoModelForCausalLM.from_pretrained(
    model_path,
    torch_dtype=torch.bfloat16,
    device_map="auto"
)

prompt = "Explica la diferencia entre LoRA y el fine-tuning completo:"
inputs = tokenizer(prompt, return_tensors="pt").to(model.device)

with torch.no_grad():
    outputs = model.generate(**inputs, max_new_tokens=200, temperature=0.7)

print(tokenizer.decode(outputs[0], skip_special_tokens=True))
EOF

---

Publicando en HuggingFace

# Iniciar sesión
huggingface-cli login

# Crear y enviar el repositorio
python3 << 'EOF'
from huggingface_hub import HfApi
api = HfApi()

# Crear repositorio
api.create_repo("my-merged-model-7b", private=False)

# Subir el modelo fusionado
api.upload_folder(
    folder_path="output_model/",
    repo_id="your-username/my-merged-model-7b",
    repo_type="model"
)
print("¡Subido!")
EOF

---

Avanzado: fusión evolutiva

Usa el optimizador evolutivo de Mergekit para encontrar los pesos óptimos de fusión:

# Instalar optimizador evolutivo
pip install 'mergekit[evo]'

# Ejecutar búsqueda evolutiva
mergekit-evolve evolve_config.yaml \\
  --storage-path ./evolve-workspace \\
  --n-iterations 100 \\
  --task mmlu  # Optimizar para el benchmark MMLU

---

Solución de problemas

Memoria insuficiente (OOM) durante la fusión

# Usa siempre --lazy-unpickle para modelos grandes
mergekit-yaml config.yaml out/ --lazy-unpickle

# Añade el indicador --low-cpu-memory
mergekit-yaml config.yaml out/ --lazy-unpickle --low-cpu-memory

# Comprueba la RAM disponible antes de fusionar
free -h

# Para modelos de 7B necesitas ~30 GB de RAM como mínimo
# Para modelos de 13B: ~60 GB de RAM
# Para modelos de 70B: ~280 GB de RAM (o usa un servidor CPU con mucha RAM)

ValueError: los modelos no son compatibles

# Los modelos deben tener la misma arquitectura
# No puedes fusionar Llama-3 con Mistral directamente
# Comprueba las configuraciones de los modelos
python3 -c "
import json
for path in ['models/model1/config.json', 'models/model2/config.json']:
    with open(path) as f:
        cfg = json.load(f)
    print(path, ':', cfg.get('model_type'), cfg.get('hidden_size'), cfg.get('num_hidden_layers'))
"

La fusión es muy lenta

# Usa la GPU para operaciones tensoriales más rápidas
mergekit-yaml config.yaml out/ --lazy-unpickle --cuda

# Asegúrate de que PyTorch con CUDA esté instalado
python3 -c "import torch; print(torch.cuda.is_available())"

# Si CUDA no está disponible, instálalo:
pip install torch --index-url https://download.pytorch.org/whl/cu128

El modelo fusionado produce galimatías

# Causas comunes:
# 1. Fusionar familias de modelos incompatibles (por ejemplo, Llama + Mistral)
# 2. Pesos demasiado extremos (t=0 o t=1 en lugar de 0.3-0.7 para SLERP)
# 3. Densidad demasiado alta en TIES (prueba density: 0.3-0.5)

# Diagnóstico: prueba primero cada modelo padre
# Luego intenta una fusión SLERP 50/50 como referencia

# Comprueba la configuración del modelo fusionado
cat output_model/config.json | python3 -m json.tool

FileNotFoundError de archivos del modelo

# Lista lo que se descargó
ls -la models/your-model/

# Archivos requeridos:
# config.json, tokenizer.json, *.safetensors (o *.bin)

# Volver a descargar con force
huggingface-cli download <repo_id> --local-dir models/<name> --force-download

---

Recetas populares de fusión

Asistente general + programación

# Ideal para desarrolladores que también quieren capacidad general
models:
  - model: mistralai/Mistral-7B-Instruct-v0.3
    parameters: {weight: 1.0, density: 0.7}
  - model: mistralai/Codestral-7B  
    parameters: {weight: 0.8, density: 0.5}

merge_method: dare_ties
base_model: mistralai/Mistral-7B-Instruct-v0.3
dtype: bfloat16

Refuerzo multilingüe

# Añade capacidades multilingües a un modelo en inglés
models:
  - model: meta-llama/Llama-3.2-8B-Instruct
    parameters: {weight: 1.0, density: 0.8}
  - model: utter-project/EuroLLM-9B-Instruct
    parameters: {weight: 0.6, density: 0.4}

merge_method: ties
base_model: meta-llama/Llama-3.2-8B-Instruct
dtype: bfloat16

---

Enlaces útiles

• GitHub: https://github.com/arcee-ai/mergekit ⭐ 5K+

• Documentación: https://github.com/arcee-ai/mergekit/wiki

• Modelos MergeKit en HuggingFace: https://huggingface.co/models?other=mergekit

• Discord de Arcee.ai: https://discord.gg/arcee

• Paper de TIES: https://arxiv.org/abs/2306.01708

• Paper de DARE: https://arxiv.org/abs/2311.03099

• Marketplace de Clore.ai: https://clore.ai/marketplace

---

Recomendaciones de GPU para Clore.ai

Los equipos multinodo de clase 80GB no aparecen listados en el marketplace de Clore.ai. Los equipos más grandes listados hoy son 4× RTX PRO 6000 Blackwell (96GB cada una, 380GB en total) y 8–11× RTX 5090 (32GB cada una). La capacidad A100 / H200 / B200 se vende como bare metal bajo pedido. Consulta Precios y disponibilidad de GPU antes de dimensionar un despliegue.

Caso de uso	GPU recomendada	Costo estimado en Clore.ai
Desarrollo/Pruebas	RTX 3090 (24GB)	$0.07–0.21/gpu/hr
Fusión de modelos (7B–13B)	RTX 4090 (24GB)	$0.14–0.42/gpu/hr
Modelos grandes (70B+)	A100 80GB	bare metal
Fusión con varias GPU	2-4x A100 de 80 GB	bare metal

💡 Todos los ejemplos de esta guía pueden desplegarse en Clore.ai servidores GPU. Explora las GPUs disponibles y alquila por hora: sin compromisos, acceso root completo.