> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-es/entrenamiento/mergekit.md). # 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. {% hint style="success" %} Todos los ejemplos se pueden ejecutar en servidores GPU alquilados a través de [Marketplace de CLORE.AI](https://clore.ai/marketplace). {% endhint %} *** ## ¿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 | {% hint style="info" %} 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. {% endhint %} *** ## 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 | {% hint style="warning" %} 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. {% endhint %} *** ## 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](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 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 ```bash ssh root@ -p ``` ### Paso 3 — Instalar el 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 # 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 ```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 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: ```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 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 ``` ```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 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 ``` ```bash mergekit-yaml ties_merge.yaml merged-ties/ --lazy-unpickle ``` ### Ejemplo 3: Fusión DARE-TIES (la mejor opción 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 (añadir capacidades) Añade un "delta de habilidad" a un modelo base: ```yaml # 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: ```yaml # 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" ``` ```bash mergekit-moe moe_merge.yaml merged-moe/ --lazy-unpickle ``` *** ## Ejecutando la fusión ### Comando básico ```bash # 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 ```bash # 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 ```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 ``` *** ## Publicando en HuggingFace ```bash # 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: ```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 ### Memoria insuficiente (OOM) durante la fusión ```bash # 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` ```bash # 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 ```bash # 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 ```bash # 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 ```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 populares de fusión ### Asistente general + programación ```yaml # 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 ```yaml # 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**: ⭐ 5K+ * **Documentación**: * **Modelos MergeKit en HuggingFace**: * **Discord de Arcee.ai**: * **Paper de TIES**: * **Paper de DARE**: * **Marketplace de Clore.ai**: *** ## Recomendaciones de GPU para Clore.ai {% hint style="warning" %} **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](https://clore.ai/bare-metal) bajo pedido. Consulta [Precios y disponibilidad de GPU](/guides/guides_v2-es/primeros-pasos/pricing.md) antes de dimensionar un despliegue. {% endhint %} | 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](https://clore.ai/bare-metal) | | Fusión con varias GPU | 2-4x A100 de 80 GB | [bare metal](https://clore.ai/bare-metal) | > 💡 Todos los ejemplos de esta guía pueden desplegarse en [Clore.ai](https://clore.ai/marketplace) servidores GPU. Explora las GPUs disponibles y alquila por hora: sin compromisos, acceso root completo. --- # Agent Instructions This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com. ## 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, and the optional `goal` query parameter: ``` GET https://docs.clore.ai/guides/guides_v2-es/entrenamiento/mergekit.md?ask=&goal= ``` `ask` is the immediate question: it should be specific, self-contained, and written in natural language. `goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal. 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.