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.
- LoRA está listo para producción y cuenta con amplio soporte en motores de inferencia.
El fine-tuning con LoRA adapta un modelo preentrenado a tu dominio entrenando pequeñas capas adaptadoras (alrededor del 0,4% del total de pesos) en lugar de reentrenar todo el modelo, permitiendo que un fine-tune de Llama 3.1 8B se ejecute en solo 8 GB de VRAM en 1-2 horas usando Unsloth.
El fine-tuning normalmente significa reentrenar un modelo enorme desde cero, lo que requiere hardware serio. LoRA es un atajo: en lugar de tocar todos los pesos del modelo, entrena un pequeño conjunto de capas adicionales que orientan al modelo hacia tu dominio o estilo de escritura específico. Por eso cabe en GPUs de consumo y se completa en un par de horas en lugar de días.
¿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:
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 (hasta 2× de velocidad respecto al entrenamiento estándar, según unsloth.ai):
# 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.
¿Es un modelo con fine-tuning mejor que RAG para el conocimiento del dominio?
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.
¿Qué es LoRA y cómo funciona?
LoRA (Low-Rank Adaptation) agrega capas adaptadoras entrenables pequeñas a un modelo base congelado. En lugar de actualizar los 7 mil millones de parámetros, LoRA entrena solo los pesos del adaptador (típicamente entre 1 y 10 millones de parámetros). Esto reduce los requisitos de VRAM en 10–20× y el tiempo de entrenamiento de días a horas.
¿Qué herramienta es mejor para el fine-tuning con LoRA?
Unsloth es la opción más rápida para hardware de consumo — 2× más rápido que el entrenamiento estándar con un 70 % menos de VRAM. HuggingFace TRL con PEFT es la opción más usada. Axolotl es mejor para usuarios avanzados que necesitan flexibilidad de configuración.
¿Qué formato de archivo usan los pesos del adaptador LoRA?
Los adaptadores LoRA se guardan como archivos safetensors (por ejemplo, adapter_model.safetensors) junto con un adapter_config.json. El tamaño total del adaptador suele ser de 50–500 MB según el rank (lora_r) y el número de capas adaptadas.
Fuentes
- Hu, E. et al. (2021). "LoRA: Low-Rank Adaptation of Large Language Models." 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." 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). "Train LLMs up to 2× faster with 70% less VRAM (Unsloth)." github.com/unslothai/unsloth — Framework LoRA más rápido, compatible con Llama 3.x, Qwen3, Mistral con hasta 2× de aceleración del entrenamiento.
- Hugging Face. (2025). "TRL: Transformer Reinforcement Learning." 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.