# Fusión de modelos con Mergekit **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. {% hint style="success" %} Todos los ejemplos se pueden ejecutar en servidores GPU alquilados a través de [CLORE.AI Marketplace](https://clore.ai/marketplace). {% endhint %} *** ## ¿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 | {% hint style="info" %} 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. {% endhint %} *** ## 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 | {% hint style="warning" %} 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. {% endhint %} *** ## 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](https://clore.ai/marketplace) 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 ```bash ssh root@ -p ``` ### Paso 3 — Instalar entorno de Python ```bash # 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 ```bash # 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 ```bash pip install huggingface_hub huggingface-cli login # Introduce tu token de HF ``` ### Paso 6 — Verificar la instalación ```bash mergekit --help mergekit-yaml --help ``` *** ## Descargando modelos para fusionar ```bash # 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: ```yaml # 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 ``` ```bash 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: ```yaml # 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 ``` ```bash mergekit-yaml ties_merge.yaml merged-ties/ --lazy-unpickle ``` ### Ejemplo 3: Fusión DARE-TIES (Mejor en general) ```yaml # 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 ``` ```bash 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: ```yaml # 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: ```yaml # 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" ``` ```bash mergekit-moe moe_merge.yaml merged-moe/ --lazy-unpickle ``` *** ## Ejecutando la fusión ### Comando básico ```bash # 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 ```bash # 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 ```bash # 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 ```bash # 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: ```bash # 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 ```bash # 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` ```bash # 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 ```bash # 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 ```bash # 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 ```bash # 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 --local-dir models/ --force-download ``` *** ## Recetas de fusión populares ### Asistente general + Codificación ```yaml # 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 ```yaml # 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**: ⭐ 5K+ * **Documentación**: * **Modelos MergeKit en HuggingFace**: * **Discord de Arcee.ai**: * **Artículo TIES**: * **Artículo DARE**: * **Mercado de Clore.ai**: *** ## 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](https://clore.ai/marketplace) servidores GPU. Navega las GPUs disponibles y alquila por hora — sin compromisos, acceso root completo. --- # Agent Instructions: Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter: ``` GET https://docs.clore.ai/guides/guides_v2-es/entrenamiento/mergekit.md?ask= ``` The question should be specific, self-contained, and written in natural language. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.