Afinado Universal Axolotl

Afinado de LLMs impulsado por YAML con Axolotl en Clore.ai — LoRA, QLoRA, DPO, multi-GPU

Axolotl integra HuggingFace Transformers, PEFT, TRL y DeepSpeed en una única interfaz dirigida por YAML. Defines tu modelo, conjunto de datos, método de entrenamiento y hiperparámetros en un solo archivo de configuración — luego inicias con un solo comando. No se requiere scripting en Python para flujos de trabajo estándar.

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

Características clave

• Configuración solo en YAML — define todo en un archivo, no se necesita Python

• Todos los métodos de entrenamiento — LoRA, QLoRA, ajuste fino completo, DPO, ORPO, KTO, RLHF

• Multi-GPU listo para usar — DeepSpeed ZeRO 1/2/3 y FSDP con una sola bandera

• Empaquetado de muestras — concatena ejemplos cortos para llenar la longitud de la secuencia, ganancia de rendimiento de 3–5×

• Flash Attention 2 — ahorro automático de VRAM en hardware compatible

• Compatibilidad amplia de modelos — Llama 3.x, Mistral, Qwen 2.5, Gemma 2, Phi-4, DeepSeek, Falcon

• Formatos de dataset incorporados — alpaca, sharegpt, chat_template, completion y personalizado

Requisitos

Componente	Mínimo	Recomendado
GPU	RTX 3060 12 GB	RTX 4090 24 GB (×2+)
VRAM	12 GB	24+ GB
RAM	16 GB	64 GB
Disco	50 GB	100 GB
CUDA	11.8	12.1+
Python	3.10	3.11

Precios de Clore.ai: RTX 4090 ≈ $0.5–2/día · RTX 3090 ≈ $0.3–1/día · RTX 3060 ≈ $0.15–0.3/día

Inicio rápido

1. Instala Axolotl

# Clona e instala
git clone https://github.com/OpenAccess-AI-Collective/axolotl.git
cd axolotl

pip install packaging ninja
pip install -e '.[flash-attn,deepspeed]'

O usa la imagen Docker (recomendado para reproducibilidad):

docker run --gpus all -it --rm \
  -v /workspace:/workspace \
  winglian/axolotl:main-latest

2. Crea un archivo de configuración

Guarda esto como config.yml:

base_model: meta-llama/Meta-Llama-3.1-8B-Instruct
model_type: LlamaForCausalLM
tokenizer_type: AutoTokenizer

load_in_4bit: true
adapter: qlora
lora_r: 32
lora_alpha: 16
lora_dropout: 0.05
lora_target_linear: true

datasets:
  - path: yahma/alpaca-cleaned
    type: alpaca

sequence_len: 2048
sample_packing: true
pad_to_sequence_len: true

wandb_project: axolotl-clore
wandb_name: llama3-qlora

output_dir: /workspace/axolotl-output

gradient_accumulation_steps: 4
micro_batch_size: 2
num_epochs: 1
learning_rate: 2e-4
optimizer: adamw_bnb_8bit
lr_scheduler: cosine
warmup_steps: 10

bf16: auto
flash_attention: true
gradient_checkpointing: true

logging_steps: 10
save_strategy: steps
save_steps: 500
eval_steps: 500

evals_per_epoch:
val_set_size: 0.02

3. Inicia el entrenamiento

# GPU única
accelerate launch -m axolotl.cli.train config.yml

# Multi-GPU (todas las GPUs disponibles)
accelerate launch --multi_gpu -m axolotl.cli.train config.yml

Registros de progreso del entrenamiento en stdout y opcionalmente en Weights & Biases.

Análisis profundo de la configuración

Formatos de dataset

Axolotl soporta múltiples formatos de entrada de forma nativa:

# Estilo Alpaca (instrucción / entrada / salida)
datasets:
  - path: yahma/alpaca-cleaned
    type: alpaca

# ShareGPT chat multi-turno
datasets:
  - path: anon8231489123/ShareGPT_Vicuna_unfiltered
    type: sharegpt
    conversation: chatml

# Plantilla de chat (detección automática por el tokenizador)
datasets:
  - path: HuggingFaceH4/ultrachat_200k
    type: chat_template
    field_messages: messages
    message_field_role: role
    message_field_content: content

# Archivo JSONL local
datasets:
  - path: /workspace/data/my_dataset.jsonl
    type: alpaca
    ds_type: json

Multi-GPU con DeepSpeed

Crear deepspeed_zero2.json:

{
  "bf16": { "enabled": true },
  "zero_optimization": {
    "stage": 2,
    "offload_optimizer": { "device": "cpu" },
    "allgather_partitions": true,
    "allgather_bucket_size": 5e8,
    "reduce_scatter": true,
    "reduce_bucket_size": 5e8,
    "overlap_comm": true,
    "contiguous_gradients": true
  },
  "train_micro_batch_size_per_gpu": "auto",
  "gradient_accumulation_steps": "auto",
  "gradient_clipping": 1.0
}

Añade a tu configuración:

deepspeed: deepspeed_zero2.json

Luego lanza:

accelerate launch --num_processes 4 -m axolotl.cli.train config.yml

Alineamiento DPO / ORPO

base_model: meta-llama/Meta-Llama-3.1-8B-Instruct
rl: dpo
# o: rl: orpo

datasets:
  - path: argilla/ultrafeedback-binarized-preferences
    type: chat_template.default
    field_messages: chosen
    field_chosen: chosen
    field_rejected: rejected

dpo_beta: 0.1

Ajuste fino completo (sin LoRA)

base_model: meta-llama/Meta-Llama-3.1-8B-Instruct

# Sin adaptador, sin cuantización
adapter:
load_in_4bit: false
load_in_8bit: false

learning_rate: 5e-6
micro_batch_size: 1
gradient_accumulation_steps: 8
gradient_checkpointing: true
flash_attention: true
bf16: auto

deepspeed: deepspeed_zero3.json  # requerido para ajuste fino completo de 8B+

Ejemplos de uso

Inferencia después del entrenamiento

# Inicia inferencia interactiva
accelerate launch -m axolotl.cli.inference config.yml \
  --lora_model_dir /workspace/axolotl-output

Fusionar LoRA en el modelo base

accelerate launch -m axolotl.cli.merge_lora config.yml \
  --lora_model_dir /workspace/axolotl-output \
  --output_dir /workspace/merged-model

Preprocesar dataset (validar antes del entrenamiento)

python -m axolotl.cli.preprocess config.yml

Esto tokeniza y valida el dataset. Útil para detectar errores de formato antes de una larga sesión de entrenamiento.

Referencia de uso de VRAM

Modelo	Método	GPUs	VRAM/GPU	Configuración
Llama 3.1 8B	QLoRA 4bit	1	~12 GB	r=32, seq_len=2048
Llama 3.1 8B	LoRA 16bit	1	~20 GB	r=16, seq_len=2048
Llama 3.1 8B	Completo	2	~22 GB	DeepSpeed ZeRO-3
Qwen 2.5 14B	QLoRA 4bit	1	~16 GB	r=16, seq_len=2048
Llama 3.3 70B	QLoRA 4bit	2	~22 GB	r=16, seq_len=2048
Llama 3.3 70B	Completo	4	~40 GB	DeepSpeed ZeRO-3+offload

Consejos

• Siempre habilitar sample_packing: true — mayor única mejora de rendimiento (3–5× en datasets cortos)

• Usa flash_attention: true en GPUs Ampere+ para 20–40% de ahorro de VRAM

• Comienza con QLoRA para experimentos, cambia al ajuste fino completo solo cuando la calidad de LoRA se estanque

• Establecer val_set_size: 0.02 para monitorizar el sobreajuste durante el entrenamiento

• Preprocesa primero — ejecuta axolotl.cli.preprocess para validar el formato de los datos antes de comprometerte con una ejecución larga

• Usa la imagen Docker para entornos reproducibles — evita conflictos de dependencias

• lora_target_linear: true aplica LoRA a todas las capas lineales, generalmente mejor que apuntar solo a la atención

Solución de problemas

Problema	Solución
OutOfMemoryError	Reduce micro_batch_size a 1, habilita gradient_checkpointing
Errores de formato del dataset	Ejecuta python -m axolotl.cli.preprocess config.yml para depurar
sample_packing lento en la primera época	Normal — el cálculo inicial del empaquetado es de una sola vez
Entrenamiento Multi-GPU se cuelga	Verifica NCCL: export NCCL_DEBUG=INFO, asegúrate de que todas las GPUs sean visibles
flash_attention error de importación	Instala: pip install flash-attn --no-build-isolation
La pérdida no disminuye	Reduce la LR a 1e-4, aumenta el warmup, revisa la calidad del dataset
Error de conexión con WandB	Ejecuta wandb login o establece wandb_project: a cadena vacía

Recursos

• Axolotl GitHub

• Configs de ejemplo

• CLORE.AI Marketplace