Fine-tuning de LLMs: LoRA, QLoRA, DPO, GRPO y Modelos Abliterados

Prueba Prompting Primero

Iteración más barata y rápida. System prompts, ejemplos few-shot, salidas estructuradas y function calling. Si 5-10 ejemplos lo resuelven, no fine-tunees.

Usa RAG para Conocimiento

Si el gap es "el modelo no conoce nuestros docs", construye un pipeline RAG. Provee citaciones, se actualiza al instante, evita alucinaciones.RAG guide.

Fine-tune para Comportamiento

Fine-tune para formato consistente, persona, adherencia a JSON schema, patrones de tool-calls, o razonamiento de dominio. También para destilar teachers grandes en students pequeños.

Matriz de Decisión Rápida

Hechos frescos: RAG. Estilo/formato consistente: fine-tune. Skill nuevo: FT + RAG. Costo más bajo: destilar vía FT. Prototipo rápido: solo prompt.

Goal                       Tool
-------------------------  -----------
Up-to-date facts           RAG
Citations / sourcing       RAG
Consistent JSON output     Fine-tune
Brand voice / persona      Fine-tune
Tool-call reliability      Fine-tune
Domain reasoning           FT + RAG
Cost reduction             FT (distill)
One-off task               Prompt
Behavior on private data   Fine-tune

Comparación de Costos

Prompt: cero costo de entrenamiento. RAG: vector DB + recuperación. Fine-tune: $50-5000 entrenamiento, luego 30-70% menos costo por llamada. Punto de equilibrio: 1-10M tokens.

El Stack de Producción

IA en producción combina los tres: base fine-tuneado para formato/tono, RAG para hechos frescos, prompt engineering para comportamiento por request.

LoRA

PEFT base. Entrena adaptadores de bajo rango (W = W0 + BA). Rank 8-64. Adaptadores 50-200MB — portables, intercambiables, mergeables.

# LoRA hyperparameters that matter
r = 16              # rank: 8-64 typical
lora_alpha = 32     # scaling, usually 2*r
lora_dropout = 0.05
target_modules = [
  "q_proj","k_proj","v_proj","o_proj",
  "gate_proj","up_proj","down_proj"
]  # all linear layers (best quality)

QLoRA

LoRA + cuantización NF4 4-bit. Reduce VRAM ~4x. Default para entrenamiento hobbyista en tarjetas de 24-48GB.

# QLoRA config
bnb_4bit = BitsAndBytesConfig(
  load_in_4bit=True,
  bnb_4bit_quant_type="nf4",
  bnb_4bit_compute_dtype=torch.bfloat16,
  bnb_4bit_use_double_quant=True
)

DoRA

Descompone updates en magnitud y dirección. ~10% más lento que LoRA pero consistentemente mejor. use_dora=True en PEFT.

GaLore

Proyección de gradientes de bajo rango. Entrena todos los parámetros pero reduce optimizer memory ~65%. FT completo de 7B en 24GB.all parameters but projects gradients into a low-rank subspace, cutting optimizer memory ~65%. Enables full-parameter fine-tuning of 7B on a 24GB card. Slightly better quality ceiling than LoRA for deep adaptation.

NEFTune

Agrega ruido uniforme calibrado a embeddings. Cambio de una línea, ganancias gratis de calidad. neftune_noise_alpha=5 default.

ReFT

Stanford 2024. Aprende intervenciones sobre representaciones ocultas. 15-65x menos parámetros que LoRA con calidad comparable.

DPO

Reemplaza reward model + PPO con cross-entropy binario sobre pares chosen/rejected. 10x más simple, más estable. Default offline en 2026.

# DPO data format
{"prompt": "...", "chosen": "...", "rejected": "..."}

# beta controls KL constraint
# 0.1 = light alignment, 0.5 = heavy

GRPO (DeepSeek R1)

Detrás del breakthrough de razonamiento de R1. Muestrea G completions por prompt, calcula advantages relativos al grupo, elimina el value model. Disponible en TRL, Unsloth, Axolotl.

KTO

Entrena desde feedback binario no-pareado (thumbs-up / thumbs-down). Telemetría de producción se vuelve directamente data de entrenamiento.unpaired binary feedback (thumbs-up / thumbs-down) instead of paired preferences. Massively easier to collect data — production telemetry directly becomes training data. Often outperforms DPO at scale.

ORPO

Combina SFT y preferencias en un solo loss. Sin pipeline separado SFT-luego-DPO. Reduce a la mitad el tiempo de entrenamiento.

Variantes SimPO e IPO

SimPO elimina el modelo de referencia de DPO para más ahorro de memoria. IPO atiende el overfitting en pares confiados. Ambos en TRL.

RLHF Clásico (Legado)

Reward model + PPO. Aún usado en labs frontera. DPO/GRPO obtienen 90% del beneficio al 10% del costo de ingeniería.

Unsloth

2x más rápido, 70% menos VRAM que HF vanilla. Kernels Triton. Solo single-GPU (free tier). Soporta LoRA, QLoRA, DPO, GRPO, KTO, ORPO.

pip install unsloth
# Loads Llama 3.1 70B in 4-bit on 48GB
from unsloth import FastLanguageModel
model, tok = FastLanguageModel.from_pretrained(
  "unsloth/Meta-Llama-3.1-70B-bnb-4bit",
  max_seq_length=4096, load_in_4bit=True)

Axolotl

YAML declarativo, FSDP/DeepSpeed multi-GPU, todo método PEFT y de alineación. Grado producción. Default para flujos de equipo.

pip install axolotl
accelerate launch -m axolotl.cli.train \
  configs/llama3-lora.yml

Llama-Factory

200+ arquitecturas, todo PEFT y alineación, Gradio Web UI para no-coders. Fuerte cobertura de modelos chinos.

TRL (Hugging Face)

Librería de referencia: SFTTrainer, DPOTrainer, GRPOTrainer, KTOTrainer, ORPOTrainer. Usa directo para loops custom.SFTTrainer, DPOTrainer, GRPOTrainer, KTOTrainer, ORPOTrainer, RewardTrainer, PPOTrainer. Use directly when writing custom loops or building new methods. All other frameworks wrap TRL internally.

DeepSpeed y FSDP

Multi-GPU y multi-nodo. ZeRO-3 shard de optimizer/gradientes/parámetros. FSDP es el default moderno PyTorch native.

torchtune

Librería oficial nativa de PyTorch. Recetas limpias y testeadas para SFT, LoRA, QLoRA, DPO. Fácil de leer y modificar.

OpenAI Fine-tuning

Winding down (announced May 7, 2026): the self-serve fine-tuning platform is closed to new organizations; inactive organizations lose job creation July 2, 2026, and all customers lose the ability to create new fine-tuning jobs on January 6, 2027. Existing fine-tuned models (SFT, DPO, RFT on GPT-4.1/GPT-4o families and o-series) keep serving inference until their base models are deprecated.

Anthropic (Claude)

Disponible en AWS Bedrock para Claude Haiku. Sin fine-tuning de primera parte en api.anthropic.com. Customización via system prompts, prompt caching y Tool Use.

Together AI

Fine-tune cualquier modelo open: Llama 3.x, Qwen 2.5/3, Mistral, DeepSeek. SFT y DPO. ~$1-3/1M tokens. Mejor relación precio/features.

Fireworks AI

LoRA serverless: deploya adaptadores sin costo base por GPU. Multi-LoRA serving permite hostear 100+ adaptadores en un base.

OpenPipe

Destila llamadas de GPT-5.5 / Claude en modelos pequeños fine-tuneados. Logea tráfico, construye dataset, fine-tunea, deploya. Reduce costo 5-30x.distilling GPT-5.5 / Claude calls into small fine-tuned models. Logs production traffic, builds training set, fine-tunes, deploys. Drop-in OpenAI-compatible. Reduces inference cost 5-30x for high-volume specialized tasks.

Predibase

Plataforma enterprise alrededor de LoRAX (multi-LoRA inference) y Ludwig. SOC 2, deploy en VPC, ruteo automático de adaptadores.

RTX 4090 (24GB)

QLoRA 7B-13B en contexto 4-8K. LoRA 7B en FP16. FT completo 1-3B. Rig serio más barato (~$2K usado). Pareala con Unsloth.

# Comfort zones on 24GB
# QLoRA Llama 3.1 8B  : 8K ctx, batch 4
# QLoRA Llama 3.1 13B : 4K ctx, batch 2
# QLoRA Qwen 3 32B    : 2K ctx, batch 1 (tight)
# Full FT Llama 3.2 1B: 4K ctx, batch 8

RTX 5090 (32GB)

Blackwell, 32GB GDDR7, FP4/FP8 native. ~30-40% más rápida que 4090. Cabe QLoRA 30B y FT completo 7B con 8K contexto. Nuevo sweet spot.

H100 / H200 (80GB / 141GB)

Estándar datacenter. Hopper FP8 reduce memoria y acelera entrenamiento ~2x vs FP16. H100 maneja QLoRA 70B. H200 maneja QLoRA 100B+.

B200 / GB200

Datacenter Blackwell. 192GB HBM3e, FP4 native. Una B200 cabe 70B en BF16 para FT completo. Racks GB200 NVL72 para frontera.

AMD MI300X (192GB)

192GB HBM3 en ROCm 6. Cabe un 70B completo en FP16 para FT single-GPU. Axolotl y Unsloth soportan ROCm. Más barato por GB que H100.

Estimador Rápido de VRAM

QLoRA: ~param_B * 0.7 GB. LoRA: ~param_B * 2.5 GB. FT completo: ~param_B * 16-20 GB. Llama 3.1 8B QLoRA: ~6 GB.

QLoRA   : ~param_B * 0.7 GB
LoRA    : ~param_B * 2.5 GB
Full FT : ~param_B * 16-20 GB

# Examples (QLoRA)
Llama 3.1 8B  -> ~6 GB (fits 4090)
Llama 3.1 70B -> ~50 GB (fits H100)
Llama 3.1 405B-> ~280 GB (4x H100)

Abliteration (mlabonne)

Técnica 2024 de Maxime Labonne. Calcula la dirección de rechazo de diffs de activación, ortogonaliza cada matriz de pesos contra ella. Sin reentrenamiento, ~30 min en una GPU.

# Conceptual abliteration pipeline
# 1. Run harmful + harmless prompts
# 2. Take diff of mean residual streams
# 3. SVD -> refusal direction r
# 4. For each W: W = W - r r^T W
# 5. Save modified model

Dolphin (Eric Hartford)

Modelos SFT-fine-tuneados sobre dataset uncensored curado. Dolphin-3.0 cubre Llama 3.1, Qwen 2.5, Mistral. En cognitivecomputations en Hugging Face.cognitivecomputations. Widely used for agent frameworks needing unrestricted tool use.

Pliny the Liberator (L1B3RT4S)

Repo GitHub de prompts de jailbreak y técnicas de red-team para Claude, GPT, Gemini, Grok, DeepSeek, Llama. Actualizado en horas tras lanzamientos.

Casos de Uso Legítimos

Red-teaming, investigación de seguridad, ficción con temas adultos, clasificadores que reconocen contenido dañino, contenido jurisdiccionalmente apropiado, investigación.

Responsabilidad y Riesgo

Modelos liberados no absuelven al usuario de responsabilidad legal o ética por outputs. Envuelve con filtros de política, audit trails y restricciones de uso en producción.

Reaplicando Seguridad

Aplica una capa de seguridad separada: clasificadores de input/output (Llama Guard 3, ShieldGemma 2), policy prompts, allow-lists de tool-calls.

Unsloth: QLoRA SFT en Llama 3.1 8B

Script end-to-end: cargar Llama 3.1 8B en 4-bit, attach LoRA, fine-tune en dataset de chat, guardar adaptador. RTX 4090, ~30 min para 1K samples.

from unsloth import FastLanguageModel, is_bfloat16_supported
from trl import SFTTrainer
from transformers import TrainingArguments
from datasets import load_dataset

model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="unsloth/Meta-Llama-3.1-8B-Instruct-bnb-4bit",
    max_seq_length=4096,
    load_in_4bit=True,
)

model = FastLanguageModel.get_peft_model(
    model, r=16, lora_alpha=32, lora_dropout=0.05,
    target_modules=["q_proj","k_proj","v_proj","o_proj",
                    "gate_proj","up_proj","down_proj"],
    use_gradient_checkpointing="unsloth",
)

dataset = load_dataset("yahma/alpaca-cleaned", split="train")

trainer = SFTTrainer(
    model=model, tokenizer=tokenizer,
    train_dataset=dataset, dataset_text_field="text",
    max_seq_length=4096,
    args=TrainingArguments(
        per_device_train_batch_size=2,
        gradient_accumulation_steps=4,
        warmup_steps=10, num_train_epochs=1,
        learning_rate=2e-4,
        bf16=is_bfloat16_supported(),
        logging_steps=10, optim="adamw_8bit",
        seed=42, output_dir="outputs",
    ),
)
trainer.train()
model.save_pretrained("llama3-alpaca-lora")

Unsloth: Alineación DPO

Corre DPO sobre un checkpoint SFT con pares de preferencia. Mismo VRAM que SFT. Cambia SFTTrainer por DPOTrainer.SFTTrainer for DPOTrainer.

from trl import DPOTrainer, DPOConfig
# dataset has columns: prompt, chosen, rejected
dpo_trainer = DPOTrainer(
    model=model, ref_model=None,
    tokenizer=tokenizer,
    train_dataset=pref_dataset,
    args=DPOConfig(
        beta=0.1, learning_rate=5e-6,
        per_device_train_batch_size=2,
        gradient_accumulation_steps=4,
        num_train_epochs=1,
        bf16=True, output_dir="dpo-out",
    ),
)
dpo_trainer.train()

Axolotl: YAML LoRA Multi-GPU

Config declarativo para FSDP multi-GPU. accelerate launch -m axolotl.cli.train llama3-lora.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: 64
lora_dropout: 0.05
lora_target_linear: true

datasets:
  - path: tatsu-lab/alpaca
    type: alpaca
sequence_len: 4096
sample_packing: true
pad_to_sequence_len: true

gradient_checkpointing: true
gradient_accumulation_steps: 4
micro_batch_size: 2
num_epochs: 3
optimizer: adamw_torch
learning_rate: 2e-4
lr_scheduler: cosine
warmup_ratio: 0.05
bf16: auto
flash_attention: true

fsdp:
  - full_shard
  - auto_wrap
fsdp_config:
  fsdp_sync_module_states: true
  fsdp_offload_params: false
  fsdp_transformer_layer_cls_to_wrap: LlamaDecoderLayer

output_dir: ./outputs/llama3-lora
hub_model_id: yourname/llama3-lora-alpaca

GRPO: Razonamiento Estilo DeepSeek

Entrena razonamiento con rewards verificables (correctitud matemática). En TRL 0.12+ y Unsloth.

from trl import GRPOTrainer, GRPOConfig

def reward_fn(completions, **kw):
    # Verifiable reward: 1.0 if final answer matches
    return [1.0 if extract_answer(c)==truth else 0.0
            for c,truth in zip(completions, kw["truth"])]

trainer = GRPOTrainer(
    model=model, tokenizer=tokenizer,
    reward_funcs=[reward_fn],
    train_dataset=math_dataset,
    args=GRPOConfig(
        num_generations=8,           # G in GRPO
        max_completion_length=2048,
        learning_rate=1e-6,
        per_device_train_batch_size=1,
        gradient_accumulation_steps=8,
        output_dir="grpo-out",
    ),
)
trainer.train()

Deployando el Adaptador

Sirve via vLLM (producción), Ollama (local), o mergea en el base. Ver guías de Ollama y AI Inference.Ollama guide for local serving and the AI Inference guide for vLLM/TGI.

# Merge LoRA into base
from peft import PeftModel
merged = PeftModel.from_pretrained(base, "lora-out").merge_and_unload()
merged.save_pretrained("merged-model")

# Serve with vLLM
vllm serve merged-model --tensor-parallel-size 2

# Or convert to GGUF for Ollama
python llama.cpp/convert-hf-to-gguf.py merged-model
ollama create my-model -f Modelfile

Checklist de Evaluación

Eval en data hold-out con métricas de tarea (accuracy, BLEU, exec-pass) y regresiones de capacidad (MMLU, IFEval, HumanEval). lm-evaluation-harness es estándar.