Mergekit Model Merging

Mergekit es el kit 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 — permitiéndote crear nuevos y potentes modelos sin datos de entrenamiento ni tiempo de entrenamiento en GPU.

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

---

¿Qué es Mergekit?

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

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

• Combinar capacidades — mezclar un modelo de codificación con un modelo que sigue instrucciones

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

• Crear Mezcla de Expertos — combinar modelos en una arquitectura MoE dispersa

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

Mergekit implementa todos los algoritmos de vanguardia:

Algoritmo	Descripción	Mejor 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 mínima interferencia
DARE	Eliminar y reescalar parámetros aleatorios	Reducir la interferencia de parámetros en fusiones grandes
DARE-TIES	DARE + TIES combinados	Mejor en general para fusiones de múltiples modelos
Lineal	Promedio ponderado simple	Fusiones de referencia rápidas
Aritmética de tareas	Sumar/restar vectores de tareas	Agregar/eliminar capacidades específicas
Paso directo	Copiar capas directamente	Construcción MoE

La fusión de modelos es sorprendentemente efectiva. Los modelos fusionados a menudo superan a sus progenitores en benchmarks al combinar conocimientos complementarios. La comunidad de MergeKit en HuggingFace alberga miles de modelos fusionados.

---

Requisitos del servidor

Componente	Mínimo	Recomendado
GPU	No es obligatorio (fusión en CPU posible)	A100 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 fusiones 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 a 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 — Alquila un servidor

1. Ve a Mercado de Clore.ai

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

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

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

5. Abrir puerto 22 solo

Paso 2 — Conéctate vía SSH

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

Paso 3 — Instalar 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

# Instalar desde PyPI
pip install mergekit

# O instalar desde la fuente (recomendado para las últimas funciones)
git clone https://github.com/arcee-ai/mergekit.git
cd mergekit
pip install -e '.[everything]'

Paso 5 — Instalar HuggingFace CLI

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 usar la CLI huggingface_hub
huggingface-cli download mistralai/Mistral-7B-Instruct-v0.3 \
  --local-dir models/Mistral-7B-Instruct-v0.3

---

Configuraciones de fusión

Mergekit usa 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 capas de atención
    - filter: mlp
      value: 0.3  # 30% del modelo 2 para capas MLP
    - value: 0.5  # 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 codificación
      density: 0.5   # Mantener 50% de los parámetros modificados

  - model: models/Mistral-7B-math
    parameters:
      weight: 0.5    # Capacidad matemática
      density: 0.3   # Mantener 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 (Mejor en 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 (Agregar capacidades)

Agregar una "delta de habilidad" a un modelo base:

# task_arithmetic.yaml
# Agrega la habilidad matemática de un modelo afinado en 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ñadir esta capacidad
  
  # Para ELIMINAR una capacidad, usa 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)

Combinar modelos en una arquitectura MoE dispersa:

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

gate_mode: hidden  # Usar estados ocultos para enrutar a los expertos
dtype: bfloat16
experts:
  - source_model: models/Llama-3.2-8B-coding
    positive_prompts:
      - "Write code"
      - "Debug this function"
      - "Implement an algorithm"
    negative_prompts:
      - "Tell me a story"
      - "Explain history"
  
  - source_model: models/Llama-3.2-8B-creative
    positive_prompts:
      - "Write a story"
      - "Be creative"
      - "Imagine"
    negative_prompts:
      - "Write code"
      - "Calculate"

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

---

Ejecutando la fusión

Comando básico

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

# Ejecutar fusión con deserialización perezosa (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 pequeños)
mergekit-yaml your_config.yaml output_model/ \
  --lazy-unpickle \
  --low-cpu-memory

Monitorear el progreso

# Mergekit muestra el progreso para cada capa
# Salida típica:
# Cargando modelo 1...
# Cargando modelo 2...
# Fusionando capa 0/32: embed_tokens
# Fusionando capa 1/32: layers.0.self_attn
# ...
# Guardando modelo fusionado...
# ¡Listo! 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

---

Publicar en HuggingFace

# Iniciar sesión
huggingface-cli login

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

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

# Subir 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 de fusión óptimos:

# 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

Agotamiento de memoria (OOM) durante la fusión

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

# Añade la bandera --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 del modelo
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 GPU para operaciones tensoriales más rápidas
mergekit-yaml config.yaml out/ --lazy-unpickle --cuda

# Asegúrate de tener PyTorch con CUDA 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/cu121

El modelo fusionado produce galimatías

# Causas comunes:
# 1. Fusionar familias de modelos incompatibles (p. ej., 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 cada modelo progenitor primero
# Luego prueba 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 para archivos de 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 de fusión populares

Asistente general + Codificación

# Excelente 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

Impulso multilingüe

# Agrega 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

• Artículo TIES: https://arxiv.org/abs/2306.01708

• Artículo DARE: https://arxiv.org/abs/2311.03099

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

---

Recomendaciones de GPU en Clore.ai

Caso de uso	GPU recomendada	Coste estimado en Clore.ai
Desarrollo/Pruebas	RTX 3090 (24GB)	~$0.12/gpu/hr
Fusión de modelos (7B–13B)	RTX 4090 (24GB)	~$0.70/gpu/hr
Modelos grandes (70B+)	A100 80GB	~$1.20/gpu/hr
Fusión con múltiples GPU	2-4x A100 80GB	~$2.40–$4.80/hr

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