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.

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

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

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

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

ssh -p <PORT> root@<SERVER_IP>

3. Crear directorios de trabajo

mkdir -p /root/llamafactory/{data,models,output,saves}

4. Descargar la imagen de Docker

docker pull hiyouga/llamafactory:latest

5. Iniciar LLaMA-Factory

Iniciar con la interfaz web (LLaMA Board):

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:

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):

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:

docker logs -f llamafactory

Tu URL http_pub de CLORE.AI para el puerto 7860:

https://<order-id>-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:

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:

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

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

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:

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:

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:

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):

quantization_bit: 4
per_device_train_batch_size: 1
gradient_accumulation_steps: 8
cutoff_len: 1024

24 GB de VRAM (RTX 3090/4090):

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):

# 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

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:

gradient_checkpointing: true

4. Elige el objetivo de LoRA correcto

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

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

# 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

# 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

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

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

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

• Documentación

• Docker Hub (hiyouga)

• Modelos compatibles

• Formato del conjunto de datos

• Marketplace de CLORE.AI

---

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
Ajuste fino (7B–13B)	RTX 4090 (24GB)	$0.14–0.42/gpu/hr
Modelos grandes (70B+)	A100 80GB	bare metal
Entrenamiento multi-GPU	2-4x A100 80GB	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.