Key Takeaways
- LoRA = agregar capas entrenables pequeñas a un modelo preentrenado. Solo el 1–5 % de los pesos del modelo son entrenables, lo que reduce drásticamente el VRAM y el tiempo.
- Requisitos del fine-tuning: 500–1000 ejemplos de alta calidad, 8–16 GB de VRAM, 1–4 horas de entrenamiento.
- Mejores herramientas: unsloth (la más rápida), Hugging Face TRL, Axolotl (la más flexible).
- Rank de LoRA (r): Más bajo (r=8) es más pequeño y rápido; más alto (r=64) es más expresivo. Por defecto: r=16–32.
- En abril de 2026, LoRA está listo para producción y cuenta con amplio soporte en motores de inferencia.
¿Cómo funciona LoRA?
LoRA agrega pequeñas matrices "adaptadoras" junto a los pesos originales del modelo. Durante el entrenamiento, solo se actualizan los adaptadores. Los pesos originales permanecen congelados.
Ejemplo: un modelo de 13B tiene 13 mil millones de pesos. LoRA agrega solo 50 millones de parámetros entrenables (~0,4 % del original). El entrenamiento es 100× más rápido.
En la inferencia, la salida del adaptador se combina con la salida del modelo principal mediante multiplicación de matrices. La penalización de velocidad es mínima (~5 %).
Resultado: un modelo específico del dominio que rinde mejor en tus tareas usando solo 8 GB de VRAM en lugar de 26 GB.
¿Qué es QLoRA (LoRA cuantizado en 4 bits)?
QLoRA combina LoRA con cuantización de 4 bits — el modelo base se carga en 4 bits (QLoRA) mientras que solo el adaptador se entrena en 16 bits. Esto reduce a la mitad los requisitos de VRAM:
En abril de 2026, QLoRA es el estándar para hardware de consumo. El flag `load_in_4bit=True` de Unsloth en el ejemplo de código anterior activa QLoRA automáticamente. La diferencia de calidad del 2 % respecto a LoRA completo es insignificante para la mayoría de las tareas de adaptación de dominio.
Cuándo usar LoRA (16 bits) en lugar de QLoRA (4 bits):
• Tareas que requieren máxima precisión (análisis médico, análisis de contratos legales)
• Tienes 16+ GB de VRAM disponibles
• Fine-tuning de modelos de 3B o más pequeños (los ahorros de QLoRA son mínimos en tamaños pequeños)
| Método | VRAM Modelo 7B | VRAM Modelo 13B | Calidad vs Completo |
|---|---|---|---|
| Fine-tuning completo | 28 GB | 52 GB | 100 % (referencia) |
| LoRA (base 16 bits) | 16 GB | 30 GB | ~97 % |
| QLoRA (base 4 bits) | 8 GB | 14 GB | ~95 % |
¿Deberías hacer fine-tuning o usar RAG?
Matriz de decisión:
Antes de invertir en fine-tuning con LoRA, verifica que un mejor prompting no pueda resolver el problema primero — la ingeniería de prompts es más rápida, reversible e independiente del modelo. Para el marco de decisión completo, consulta ingeniería de prompts vs fine-tuning: cómo decidir.
El fine-tuning es una forma de mantener un flujo de trabajo de codificación productivo sin conexión. Para la configuración offline más completa — modelo, IDE, caché de paquetes, espejo de documentación — consulta LLM de codificación local sin Internet.
| Criterio | Fine-Tuning | RAG |
|---|---|---|
| Frecuencia de cambio de documentos | Anual o menos | Semanal o más |
| Requisitos de conocimiento | El modelo necesita comprensión profunda | La recuperación es suficiente |
| Datos de entrenamiento disponibles | Se necesitan 500+ ejemplos de calidad | Cualquier documento funciona |
| Costo (largo plazo) | Único ($50–200) | Embeddings continuos |
| Latencia | Más rápido (sin recuperación) | Más lento (recuperación + LLM) |
| Ideal para | Código, escritura creativa, estilo del dominio | Bases de conocimiento, preguntas y respuestas |
¿Cómo preparas los datos de entrenamiento?
La calidad de los datos de entrenamiento determina el éxito del fine-tuning. Datos malos = modelo malo.
Mínimo: 500 ejemplos. Cada ejemplo = entrada + salida esperada.
Óptimo: 1000–5000 ejemplos. Más datos = mayor precisión.
Formato: JSON o JSONL. Cada línea = un ejemplo de entrenamiento.
[
{"instruction": "Translate to French", "input": "Hello world", "output": "Bonjour le monde"},
{"instruction": "Summarize", "input": "Long text...", "output": "Summary..."},
{"instruction": "Code review", "input": "Python code...", "output": "Review comments..."}
]
# OR instruction-only format:
[
{"text": "<|user|>Translate to French\nHello<|assistant|>Bonjour"},
{"text": "<|user|>Summarize\nText<|assistant|>Summary"}
]
Configuración de fine-tuning con Unsloth
Unsloth es el framework LoRA más rápido (4× de velocidad respecto al entrenamiento estándar):
# Install unsloth
pip install unsloth[colab-new] xformers bitsandbytes
from unsloth import FastLanguageModel
from datasets import load_dataset
# Load base model with LoRA
model, tokenizer = FastLanguageModel.from_pretrained(
model_name="unsloth/llama-3.1-8b-bnb-4bit",
max_seq_length=2048,
load_in_4bit=True,
lora_r=16, lora_alpha=32,
lora_dropout=0.05
)
# Load training data
dataset = load_dataset("json", data_files="training.jsonl")
# Configure trainer
from trl import SFTTrainer
trainer = SFTTrainer(
model=model,
tokenizer=tokenizer,
train_dataset=dataset["train"],
dataset_text_field="text",
max_seq_length=2048,
args=TrainingArguments(
per_device_train_batch_size=4,
num_train_epochs=3,
learning_rate=2e-4,
output_dir="output"
)
)
# Train
trainer.train()Hiperparámetros clave para el fine-tuning con LoRA
| Hiperparámetro | Valor recomendado | Rango típico | Efecto |
|---|---|---|---|
| learning_rate | 2e-4 | 1e-5 a 1e-3 | Más bajo = estable, convergencia más lenta |
| lora_r (rank) | 16 | 4 a 64 | Más alto = más expresivo, más lento |
| lora_alpha | 32 | 8 a 256 | Más alto = efecto LoRA más fuerte |
| num_train_epochs | 3 | 1 a 10 | Más épocas = riesgo de sobreajuste |
| batch_size | 4 | 1 a 32 | Mayor = entrenamiento más rápido, más VRAM |
| warmup_steps | 100 | 0 a 1000 | Aumento gradual del LR, estabiliza el entrenamiento |
¿Cómo evalúas los modelos con fine-tuning?
Pérdida de entrenamiento: debe disminuir a lo largo de las épocas. Si se mantiene plana, la tasa de aprendizaje puede ser demasiado baja.
Pérdida de validación: debe disminuir pero mantenerse por encima de la pérdida de entrenamiento (normal). Si aumenta, hay sobreajuste.
Pruebas manuales: ejecuta el modelo con fine-tuning en ejemplos de prueba y compara las salidas con los resultados esperados.
Tareas de benchmark: usa benchmarks estándar (MMLU, HumanEval) para medir la mejora.
¿Cuáles son los errores más comunes en el fine-tuning?
- Demasiado pocos ejemplos de entrenamiento. Menos de 200 ejemplos suele provocar sobreajuste. Recopila al menos 500.
- Entrenar durante demasiadas épocas. El modelo memoriza datos en lugar de aprender patrones generalizables. Máximo 3–5 épocas.
- No validar con datos no vistos. Siempre divide los datos en entrenamiento/validación (80/20). Valida con frecuencia para detectar sobreajuste.
- Usar los mismos datos para fine-tuning y evaluación. La precisión reportada no tiene sentido si se evalúa sobre datos de entrenamiento.
- No guardar checkpoints. El entrenamiento puede durar horas. Guarda cada época para poder recuperarte de fallos.
Preguntas frecuentes sobre el fine-tuning con LoRA
¿Cuántos datos de entrenamiento se necesitan?
Mínimo 500 ejemplos, óptimo 1000–5000. La calidad importa más que la cantidad. 100 ejemplos de alta calidad > 1000 de baja calidad.
¿Puedo hacer fine-tuning en una laptop?
Sí. Usa cuantización de 4 bits y LoRA. Un modelo de 7B requiere 8 GB de VRAM; el entrenamiento tarda 1–2 horas en CPU (lento) o 10–15 min en GPU.
¿Cómo fusiono los adaptadores LoRA en el modelo base?
Usa unsloth o HF transformers: `model.merge_and_unload()`. Crea un único archivo de modelo (~3–4 GB para 7B), listo para inferencia.
¿Puedo combinar múltiples adaptadores LoRA?
Sí, con restricciones. Apila adaptadores para aplicación secuencial, o usa técnicas de composición de adaptadores (por ejemplo, DoRA).
¿La calidad del modelo con fine-tuning es mejor que RAG?
Para la mayoría de las tareas, sí. Los modelos con fine-tuning comprenden los conceptos del dominio en profundidad. RAG es mejor cuando los documentos son voluminosos y cambian con frecuencia.
¿Cuál es la diferencia entre LoRA y QLoRA?
LoRA carga el modelo base en 16 bits y entrena capas adaptadoras pequeñas. QLoRA carga el modelo base en 4 bits y entrena los adaptadores en 16 bits. QLoRA usa aproximadamente la mitad del VRAM: 8 GB para 7B vs 16 GB para LoRA. La diferencia de calidad es ~2 % — insignificante para la mayoría de las tareas. Unsloth activa QLoRA con `load_in_4bit=True`.
¿Cómo uso un modelo LoRA con fine-tuning en Ollama?
Después del entrenamiento, fusiona el adaptador en el modelo base: `model.merge_and_unload()`. Convierte a GGUF usando el script `convert.py` de llama.cpp. Crea un Modelfile de Ollama apuntando al archivo GGUF: `FROM ./my-finetuned-model.gguf` Luego: `ollama create my-model -f Modelfile` y `ollama run my-model`. El modelo con fine-tuning funciona de forma idéntica a cualquier modelo de Ollama.
¿Puedo hacer fine-tuning de Llama 3.3 70B con LoRA en hardware de consumo?
Sí, con QLoRA. Llama 3.3 70B en 4 bits requiere ~40 GB de VRAM — cabe en dual RTX 4090 (2×24 GB) o una A100 80GB individual. Tiempo de entrenamiento: 4–8 horas en 1000 ejemplos. Para la mayoría de los usuarios, hacer fine-tuning de modelos de 7B o 13B es más práctico y genera el 90 %+ de la ganancia de calidad del 70B para tareas de dominio.
Fuentes
- Hu, E. et al. (2021). "LoRA: Low-Rank Adaptation of Large Language Models." https://arxiv.org/abs/2106.09685 — Artículo original de LoRA que demuestra que el 0,4 % de parámetros entrenables iguala la calidad del fine-tuning completo.
- Dettmers, T. et al. (2023). "QLoRA: Efficient Finetuning of Quantized LLMs." https://arxiv.org/abs/2305.14314 — Artículo de QLoRA: modelo base cuantizado en 4 bits + adaptadores LoRA en 16 bits reducen los requisitos de VRAM a la mitad.
- Unsloth. (2026). "Unsloth: 4× Faster LoRA Training." https://github.com/unslothai/unsloth — Framework LoRA más rápido, compatible con Llama 3.x, Qwen2.5, Mistral con 4× de aceleración del entrenamiento.
- Hugging Face. (2025). "TRL: Transformer Reinforcement Learning." https://github.com/huggingface/trl — SFTTrainer para fine-tuning supervisado con soporte de adaptadores LoRA.
- Test PE link content
- El fine-tuning funciona mejor cuando los fundamentos son sólidos. Antes de invertir tiempo en LoRA, asegúrate de que tus prompts base estén optimizados: la guía de ingeniería de prompts cubre 80 técnicas que mejoran la calidad de las salidas en modelos sin ajustar.