> 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/llama-factory.md). # LLaMA-Factory Ajusta finamente más de 100 LLMs con LoRA/QLoRA y una interfaz web en GPUs de Clore.ai usando LLaMA-Factory LLaMA-Factory es el marco de ajuste fino de código abierto más completo, compatible con más de 100 modelos de lenguaje, incluidas todas las variantes de LLaMA, Qwen, Mistral, Phi, Falcon, ChatGLM y más. Ofrece LoRA, QLoRA, ajuste fino completo, RLHF, DPO y PPO, todo a través de una interfaz web intuitiva (LLaMA Board) o CLI. Los servidores GPU bajo demanda de CLORE.AI lo convierten en la plataforma perfecta para lanzar trabajos de ajuste fino a una fracción del costo de los proveedores de nube. {% 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 %} ## Requisitos del servidor | Parámetro | Mínimo | Recomendado | | --------- | ---------------- | -------------- | | RAM | 16 GB | 32 GB+ | | VRAM | 8 GB (QLoRA) | 24 GB+ | | Disco | 50 GB | 200 GB+ | | GPU | NVIDIA RTX 2080+ | A100, RTX 4090 | {% hint style="info" %} **El método de entrenamiento determina los requisitos de GPU:** * **QLoRA (4 bits)**: 8 GB de VRAM para modelos de 7B, 16 GB para 13B * **LoRA (float16)**: 16 GB de VRAM para modelos de 7B, 40 GB para 13B * **Ajuste fino completo**: \~14 GB de VRAM por cada parámetro de 7B (+ estados del optimizador) * Multi-GPU (DeepSpeed/FSDP) escala a cualquier número de GPUs {% endhint %} ## Despliegue rápido en CLORE.AI **Imagen de Docker:** `hiyouga/llamafactory:latest` **Puertos:** `22/tcp`, `7860/http` **Variables de entorno:** | Variable | Ejemplo | Descripción | | ---------------------- | ----------- | ---------------------------------------------------- | | `HF_TOKEN` | `hf_xxx...` | Token de HuggingFace para modelos restringidos | | `WANDB_API_KEY` | `xxx...` | Weights & Biases para el seguimiento de experimentos | | `CUDA_VISIBLE_DEVICES` | `0,1` | GPUs a usar | ## Configuración paso a paso ### 1. Alquila un servidor GPU en CLORE.AI Visita [Marketplace de CLORE.AI](https://clore.ai/marketplace) y selecciona según tu tarea: | Tarea | VRAM | GPU recomendada | | -------------- | ----- | ------------------ | | QLoRA 7B | 8 GB | RTX 3070/2080 | | QLoRA 13B | 16 GB | RTX 3090/A4000 | | LoRA 7B | 16 GB | RTX 3090/A4000 | | LoRA 13B | 40 GB | A6000/A100 40GB | | FT completo 7B | 80 GB | A100 80GB | | Multi-GPU | Varía | 2-8× cualquier GPU | ### 2. Conéctate por SSH a tu servidor ```bash ssh -p root@ ``` ### 3. Crear directorios de trabajo ```bash mkdir -p /root/llamafactory/{data,models,output,saves} ``` ### 4. Descargar la imagen de Docker ```bash docker pull hiyouga/llamafactory:latest ``` ### 5. Iniciar LLaMA-Factory **Iniciar con la interfaz web (LLaMA Board):** ```bash docker run -d \\ --name llamafactory \\ --gpus all \\ -p 7860:7860 \ -v /root/llamafactory/data:/app/LLaMA-Factory/data \\ -v /root/llamafactory/models:/root/.cache/huggingface \\ -v /root/llamafactory/output:/app/LLaMA-Factory/output \\ -v /root/llamafactory/saves:/app/LLaMA-Factory/saves \\ -e HF_TOKEN=hf_your_token_here \\ hiyouga/llamafactory:latest \\ llamafactory-cli webui ``` **Con seguimiento de Weights & Biases:** ```bash docker run -d \\ --name llamafactory \\ --gpus all \\ -p 7860:7860 \ -v /root/llamafactory/data:/app/LLaMA-Factory/data \\ -v /root/llamafactory/models:/root/.cache/huggingface \\ -v /root/llamafactory/output:/app/LLaMA-Factory/output \\ -v /root/llamafactory/saves:/app/LLaMA-Factory/saves \\ -e HF_TOKEN=hf_your_token_here \\ -e WANDB_API_KEY=your_wandb_key \\ hiyouga/llamafactory:latest \\ llamafactory-cli webui ``` **Multi-GPU con DeepSpeed (4 GPUs):** ```bash docker run -d \\ --name llamafactory \\ --gpus all \\ --shm-size 16g \\ --ipc host \\ -p 7860:7860 \ -v /root/llamafactory/data:/app/LLaMA-Factory/data \\ -v /root/llamafactory/models:/root/.cache/huggingface \\ -v /root/llamafactory/output:/app/LLaMA-Factory/output \\ -e CUDA_VISIBLE_DEVICES=0,1,2,3 \\ hiyouga/llamafactory:latest \\ bash -c \"llamafactory-cli webui\" ``` ### 6. Accede a la interfaz web Revisa los registros y obtén la URL: ```bash docker logs -f llamafactory ``` Tu URL http\_pub de CLORE.AI para el puerto 7860: ``` https://-7860.clore.ai/ ``` *** ## Ejemplos de uso ### Ejemplo 1: Ajuste fino LoRA mediante la interfaz web (LLaMA Board) 1. Abre LLaMA Board en tu URL de CLORE.AI 2. Ve a la **Entrenar** pestaña 3. Configura: * **Nombre del modelo**: `LLaMA-3` → `Meta-Llama-3-8B-Instruct` * **Etapa de entrenamiento**: `Ajuste fino supervisado` * **Conjunto de datos**: selecciona tu conjunto de datos (o sube uno personalizado) * **Método de ajuste fino**: `lora` * **Rango de LoRA**: `8` (más alto = más parámetros entrenados) * **Tasa de aprendizaje**: `1e-4` * **Épocas**: `3` * **Directorio de salida**: `llama3-finetuned` 4. Haz clic en **Iniciar** para comenzar el entrenamiento 5. Monitorea las curvas de pérdida en el **Pérdida** gráfico ### Ejemplo 2: Ajuste fino QLoRA basado en CLI Prepara un YAML de configuración de entrenamiento: ```bash docker exec -it llamafactory bash cat > /app/LLaMA-Factory/configs/qlora_mistral.yaml << 'EOF' ### Modelo model_name_or_path: mistralai/Mistral-7B-Instruct-v0.3 ### Método stage: sft do_train: true finetuning_type: lora lora_target: all lora_rank: 16 lora_alpha: 32 lora_dropout: 0.05 ### Conjunto de datos dataset: alpaca_en template: mistral cutoff_len: 2048 max_samples: 1000 overwrite_cache: true preprocessing_num_workers: 16 ### Salida output_dir: saves/mistral-qlora logging_steps: 10 save_steps: 500 plot_loss: true overwrite_output_dir: true ### Entrenamiento per_device_train_batch_size: 2 gradient_accumulation_steps: 8 learning_rate: 0.0001 num_train_epochs: 3.0 lr_scheduler_type: cosine warmup_ratio: 0.1 fp16: true ### Cuantización quantization_method: bitsandbytes quantization_bit: 4 EOF # Ejecutar entrenamiento llamafactory-cli train /app/LLaMA-Factory/configs/qlora_mistral.yaml ``` ### Ejemplo 3: Subir un conjunto de datos personalizado Crea un conjunto de datos personalizado en formato Alpaca: ```bash # Crear archivo de conjunto de datos cat > /root/llamafactory/data/my_dataset.json << 'EOF' [ { "instruction": "Eres un agente de atención al cliente para una empresa tecnológica. Responde de forma útil.", "input": "Mi portátil no se enciende después de la actualización. ¿Qué debo hacer?", "output": "Entiendo lo frustrante que puede ser. Vamos a solucionarlo paso a paso:\n\n1. **Mantén presionado el botón de encendido durante 10 segundos** para forzar el apagado\n2. **Desconecta el cable de alimentación** y la batería si es extraíble; espera 30 segundos\n3. **Vuelve a conectar la alimentación** e intenta encenderlo\n4. Si sigue sin responder, pulsa **F8/F11** durante el arranque para acceder al modo de recuperación\n\n¿Quieres que te guíe en detalle por alguno de estos pasos?" }, { "instruction": "Eres un agente de atención al cliente para una empresa tecnológica.", "input": "¿Cómo restablezco mi contraseña?", "output": "¡Restablecer tu contraseña es fácil! Así es como se hace:\n\n1. Ve a la página de inicio de sesión y haz clic en **'Olvidé mi contraseña'**\n2. Introduce tu **dirección de correo electrónico registrada**\n3. Revisa tu correo para encontrar un enlace de restablecimiento (comprueba también la carpeta de spam)\n4. Haz clic en el enlace y **crea una nueva contraseña**\n\nEl enlace de restablecimiento caduca en 24 horas. Si no recibes el correo en 5 minutos, contacta con nuestro equipo de soporte." } ] EOF # Registrar el conjunto de datos en dataset_info.json docker exec -it llamafactory bash -c \" cat >> /app/LLaMA-Factory/data/dataset_info.json << 'EOF2' , \"my_dataset\": { \"file_name\": \"/root/llamafactory/data/my_dataset.json\" } EOF2 " ``` Luego selecciona `my_dataset` en el menú desplegable de conjuntos de datos de LLaMA Board. ### Ejemplo 4: DPO (Optimización Directa de Preferencias) ```yaml ### configs/dpo_llama.yaml model_name_or_path: meta-llama/Meta-Llama-3-8B-Instruct ### Método - DPO stage: dpo do_train: true finetuning_type: lora lora_rank: 8 ### Específico de DPO pref_beta: 0.1 pref_loss: sigmoid # sigmoid, hinge, ipo ### Conjunto de datos (debe estar en formato de preferencias) dataset: dpo_en_demo template: llama3 cutoff_len: 2048 ### Salida output_dir: saves/llama3-dpo logging_steps: 10 save_steps: 100 ### Entrenamiento per_device_train_batch_size: 1 gradient_accumulation_steps: 8 learning_rate: 5e-5 num_train_epochs: 1.0 fp16: true ``` ```bash docker exec -it llamafactory bash -c \"llamafactory-cli train /configs/dpo_llama.yaml\" ``` ### Ejemplo 5: Inferencia con modelo ajustado Después del entrenamiento, prueba tu modelo: ```bash docker exec -it llamafactory bash # Chat interactivo llamafactory-cli chat \\ --model_name_or_path mistralai/Mistral-7B-Instruct-v0.3 \\ --adapter_name_or_path /app/LLaMA-Factory/saves/mistral-qlora \\ --template mistral \\ --finetuning_type lora ``` O exporta el modelo combinado: ```bash llamafactory-cli export \\ --model_name_or_path mistralai/Mistral-7B-Instruct-v0.3 \\ --adapter_name_or_path /app/LLaMA-Factory/saves/mistral-qlora \\ --template mistral \\ --finetuning_type lora \\ --export_dir /app/LLaMA-Factory/output/mistral-merged \\ --export_size 4 \\ --export_legacy_format false ``` *** ## Configuración ### Parámetros clave de entrenamiento | Parámetro | Valor típico | Descripción | | ----------------------------- | ------------ | ---------------------------------------- | | `lora_rank` | 8–64 | Rango de LoRA (más alto = más expresivo) | | `lora_alpha` | 2× rango | Escalado alfa de LoRA | | `lora_dropout` | 0.0–0.1 | Dropout para las capas LoRA | | `lora_target` | `all` | Qué capas aplicar con LoRA | | `learning_rate` | `1e-4` | Tasa de aprendizaje inicial | | `num_train_epochs` | 1–5 | Épocas de entrenamiento | | `per_device_train_batch_size` | 1–4 | Tamaño de lote por GPU | | `gradient_accumulation_steps` | 4–16 | Multiplicador efectivo del lote | | `cutoff_len` | 1024–4096 | Longitud máxima de secuencia | | `quantization_bit` | 4 u 8 | Bits de cuantización de QLoRA | | `warmup_ratio` | 0.05–0.1 | Fracción de calentamiento de LR | | `lr_scheduler_type` | `cosine` | Planificación de LR | ### Métodos de ajuste fino compatibles | Método | Uso de memoria | Calidad | Cuándo usar | | -------------------- | -------------- | --------- | --------------------- | | `full` | Muy alta | Mejor | VRAM ilimitada | | `freeze` | Medio | Bueno | Congelar capas base | | `lora` | Baja | Muy bueno | Opción predeterminada | | `qlora` (lora+quant) | Más bajo | Bueno | VRAM limitada | ### Entrenamiento DeepSpeed multi-GPU Para entrenar en múltiples GPUs, inicia con `torchrun`: ```bash docker exec -it llamafactory bash -c \" FORCE_TORCHRUN=1 NNODES=1 RANK=0 MASTER_ADDR=127.0.0.1 MASTER_PORT=29500 \\ llamafactory-cli train configs/qlora_mistral.yaml \\ --deepspeed examples/deepspeed/ds_z3_config.json " ``` *** ## Consejos de rendimiento ### 1. Configuración óptima de QLoRA por GPU **8 GB de VRAM (RTX 3070):** ```yaml quantization_bit: 4 per_device_train_batch_size: 1 gradient_accumulation_steps: 8 cutoff_len: 1024 ``` **24 GB de VRAM (RTX 3090/4090):** ```yaml quantization_bit: 4 # Sigue usando QLoRA para un tamaño de lote mayor per_device_train_batch_size: 4 gradient_accumulation_steps: 4 cutoff_len: 2048 ``` **80 GB de VRAM (A100):** ```yaml # No se necesita cuantización — usa LoRA directamente finetuning_type: lora per_device_train_batch_size: 8 gradient_accumulation_steps: 2 cutoff_len: 4096 fp16: true ``` ### 2. Flash Attention 2 para contextos más largos ```yaml flash_attn: fa2 # Requiere GPU Ampere+ ``` Esto permite entrenar con secuencias 2× más largas en la misma VRAM. ### 3. Checkpointing de gradiente Ahorra VRAM a costa de un entrenamiento \~20% más lento: ```yaml gradient_checkpointing: true ``` ### 4. Elige el objetivo de LoRA correcto ```yaml lora_target: all # Todas las capas lineales (predeterminado, mejor calidad) # o lora_target: q_proj,v_proj # Mínimo, más rápido, menor calidad ``` ### 5. Congela las capas superiores para una adaptación rápida ```yaml finetuning_type: freeze freeze_trainable_layers: 2 # Entrena solo las 2 capas superiores freeze_trainable_modules: all ``` Mucho más rápido que LoRA completo para una adaptación simple de tareas. ### 6. Monitorea con TensorBoard ```bash # En una terminal separada docker exec -it llamafactory bash -c \" tensorboard --logdir /app/LLaMA-Factory/saves --host 0.0.0.0 --port 6006 " ``` Añade el puerto 6006 a tu pedido de CLORE.AI para acceder a TensorBoard. *** ## Solución de problemas ### Problema: "CUDA out of memory" durante el entrenamiento 1. Reduce el tamaño del lote: `per_device_train_batch_size: 1` 2. Activa el checkpointing de gradiente: `gradient_checkpointing: true` 3. Reduce la longitud del contexto: `cutoff_len: 512` 4. Usa QLoRA (4 bits): `quantization_bit: 4` 5. Reduce el rango de LoRA: `lora_rank: 4` ### Problema: La pérdida de entrenamiento no disminuye * Comprueba la tasa de aprendizaje — prueba `5e-5` o `2e-4` * Verifica que el formato del conjunto de datos coincida con la plantilla * Aumenta `lora_rank` (8→16→32) * Comprueba que `lora_target: all` está configurado ### Problema: Velocidad de entrenamiento lenta ```bash # Comprueba la utilización de la GPU dentro del contenedor docker exec -it llamafactory bash -c \"watch -n 1 nvidia-smi\" ``` Si la GPU está utilizada en menos del 80%: * Aumenta el tamaño del lote * Usa Flash Attention: `flash_attn: fa2` * Elimina `gradient_checkpointing` si la VRAM lo permite ### Problema: El modelo no se encuentra en la interfaz web ```bash # Precargar en el volumen de caché docker exec -it llamafactory bash -c \" huggingface-cli download mistralai/Mistral-7B-Instruct-v0.3 " ``` Luego actualiza la lista de modelos en LLaMA Board. ### Problema: Errores de formato del conjunto de datos Todos los formatos de conjunto de datos deben coincidir con `dataset_info.json` la especificación: ```bash # Validar conjunto de datos docker exec -it llamafactory python3 -c \" import json with open('/app/LLaMA-Factory/data/my_dataset.json') as f: data = json.load(f) print(f'El conjunto de datos tiene {len(data)} muestras') print('Claves de la primera muestra:', list(data[0].keys())) " ``` ### Problema: El puerto de WebUI no es accesible Asegúrate de que LLaMA-Factory inició el servidor Gradio: ```bash docker logs llamafactory 2>&1 | grep -E \"Running on|Error|Traceback\" ``` Añade `--share` como alternativa, usa la bandera para una URL pública de Gradio. *** ## Enlaces * [GitHub](https://github.com/hiyouga/LLaMA-Factory) * [Documentación](https://llamafactory.readthedocs.io) * [Docker Hub (hiyouga)](https://hub.docker.com/r/hiyouga/llamafactory) * [Modelos compatibles](https://github.com/hiyouga/LLaMA-Factory?tab=readme-ov-file#supported-models) * [Formato del conjunto de datos](https://github.com/hiyouga/LLaMA-Factory/blob/main/data/README.md) * [Marketplace de CLORE.AI](https://clore.ai/marketplace) *** ## 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 | | Ajuste fino (7B–13B) | RTX 4090 (24GB) | $0.14–0.42/gpu/hr | | Modelos grandes (70B+) | A100 80GB | [bare metal](https://clore.ai/bare-metal) | | Entrenamiento multi-GPU | 2-4x A100 80GB | [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/llama-factory.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.