TRL documentation
LoRA sin arrepentimientos
LoRA sin arrepentimientos
Investigaciones recientes del equipo de Thinking Machines Lab (Schulman et al., 2025) demuestran que LoRA puede igualar el rendimiento del fine-tuning completo cuando se configura correctamente, mientras que utiliza solo el ~67% de la potencia de cálculo. Estos hallazgos son emocionantes para los usuarios de TRL porque son fáciles de implementar y pueden mejorar el rendimiento del modelo con presupuestos más pequeños.
Esta guía proporciona instrucciones simples para reproducir los resultados del artículo de blog en TRL.
Se recomienda leer la publicación del blog antes de seguir esta guía, o consultar ambos recursos en paralelo para obtener los mejores resultados.
Ventajas de LoRA frente al ajuste fino completo
En primer lugar, recordemos las ventajas de LoRA frente al ajuste fino completo.
LoRA añade capas de adaptador sobre el modelo base, que contienen significativamente menos parámetros que el propio modelo base. Este diseño reduce los requisitos de memoria de GPU y permite un entrenamiento más eficiente. Como se describe en el blog, se pensaba originalmente que este enfoque implicaba un compromiso en el rendimiento, aunque una configuración cuidadosa puede superar este compromiso e igualar el rendimiento del ajuste fino completo.
Ejemplos con TRL
Implementemos y entrenemos adaptadores LoRA en los scripts de TRL basándonos en los hallazgos principales del artículo de blog. Después, revisaremos cada hallazgo a la luz de los resultados de TRL.
Ajuste fino supervisado (SFT)
La publicación del blog realiza SFT en una variedad de modelos y conjuntos de datos del Hub, que podemos reproducir en TRL.
Podemos integrar estos hallazgos con la API de Python de TRL de la siguiente manera:
from datasets import load_dataset
from peft import LoraConfig
from trl import SFTTrainer, SFTConfig
dataset = load_dataset("open-thoughts/OpenThoughts-114k", split="train")
peft_config = LoraConfig(r=256, lora_alpha=16, target_modules="all-linear")
training_args = SFTConfig(
learning_rate=2e-4,
per_device_train_batch_size=1,
gradient_accumulation_steps=4,
num_train_epochs=1,
report_to=["trackio"],
)
trainer = SFTTrainer(
model="Qwen/Qwen2.5-3B-Instruct",
train_dataset=dataset,
peft_config=peft_config,
args=training_args,
)
trainer.train()
hf jobs uv run \
--flavor a100-large \
--timeout 8h \
--secrets HF_TOKEN \
"https://raw.githubusercontent.com/huggingface/trl/main/trl/scripts/sft.py" \
--model_name_or_path Qwen/Qwen2.5-3B-Instruct \
--dataset_name open-thoughts/OpenThoughts-114k \
--learning_rate 2.0e-5 \
--num_train_epochs 1 \
--packing \
--per_device_train_batch_size 2 \
--gradient_accumulation_steps 16 \
--use_peft \
--lora_r 256 \
--lora_alpha 16 \
--lora_target_modules all-linear \
--output_dir Qwen2.5-3B-OpenThoughts-LoRA \
--report_to trackio \
--push_to_hub
Para usar Hugging Face Jobs, inicia sesión en el Hub (hf auth login) y ten un saldo de créditos positivo. Consulta la documentación de Jobs para más detalles.
uv run "https://raw.githubusercontent.com/huggingface/trl/main/trl/scripts/sft.py" \
--model_name_or_path Qwen/Qwen2.5-3B-Instruct \
--dataset_name open-thoughts/OpenThoughts-114k \
--learning_rate 2.0e-5 \
--num_train_epochs 1 \
--packing \
--per_device_train_batch_size 2 \
--gradient_accumulation_steps 16 \
--eval_strategy no \
--use_peft \
--lora_r 256 \
--lora_alpha 16 \
--lora_target_modules all-linear \
--output_dir Qwen2.5-3B-OpenThoughts-LoRA \
--report_to trackio \
--push_to_hub
Para ejecutar el script localmente, es necesario tener uv instalado. Consulta la documentación de uv para más detalles.
Una vez que comienza el entrenamiento, puedes monitorear el progreso en Trackio, que registrará la URL.
Aprendizaje por refuerzo (GRPO)
La publicación del blog realiza GRPO en una variedad de modelos y conjuntos de datos del Hub, y una vez más podemos reproducir los resultados en TRL.
| Modelo | Dataset |
|---|---|
| Llama-3.1-8B-Base | GSM8k |
| Llama-3.1-8B-Base | DeepMath-103K |
| Qwen3-8b-base | DeepMath-103K |
Para el aprendizaje por refuerzo, el blog utiliza una tarea de razonamiento matemático que podemos reproducir como una función de Python.
Podemos implementar estas recomendaciones con la API de Python de TRL de la siguiente manera:
from datasets import load_dataset
from peft import LoraConfig
from trl import GRPOConfig, GRPOTrainer
from trl.rewards import reasoning_accuracy_reward
dataset = load_dataset("HuggingFaceH4/OpenR1-Math-220k-default-verified", split="train")
peft_config = LoraConfig(
r=1,
lora_alpha=32,
target_modules="all-linear"
)
training_args = GRPOConfig(
learning_rate=5e-5,
per_device_train_batch_size=1,
gradient_accumulation_steps=4,
num_train_epochs=1,
num_generations=8,
generation_batch_size=8,
report_to=["trackio"],
)
trainer = GRPOTrainer(
model="Qwen/Qwen3-0.6B",
reward_funcs=reasoning_accuracy_reward,
args=training_args,
train_dataset=dataset,
peft_config=peft_config,
)
trainer.train()
Este fragmento omite la función de recompensa, definida anteriormente, para mantener el ejemplo conciso.
hf jobs uv run \
--flavor a100-large \
--timeout 4h \
--secrets HF_TOKEN \
--env PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True \
"https://huggingface.co/datasets/burtenshaw/lora-without-regrets/resolve/main/grpo.py" \
--model_name_or_path Qwen/Qwen3-0.6B \
--dataset_name HuggingFaceH4/OpenR1-Math-220k-default-verified \
--output_dir grpo-full-qwen3-0.6b \
--learning_rate 1.0e-6 \
--lr_scheduler_type cosine \
--warmup_steps 0.0 \
--max_grad_norm 1.0 \
--beta 0.0 \
--max_completion_length 4096 \
--num_generations 16 \
--generation_batch_size 16 \
--gradient_accumulation_steps 8 \
--per_device_train_batch_size 1 \
--num_train_epochs 1 \
--lora_r 1 \
--lora_alpha 32 \
--lora_dropout 0.0 \
--lora_target_modules all-linear \
--vllm_mode colocate \
--save_strategy steps \
--save_steps 50 \
--save_total_limit 1 \
--logging_steps 1 \
--max_steps 200 \
--report_to trackioPara usar Hugging Face Jobs, inicia sesión en el Hub (hf auth login) y ten un saldo de créditos positivo. Consulta la documentación de Jobs para más detalles.
uv run "https://huggingface.co/datasets/burtenshaw/lora-without-regrets/resolve/main/grpo.py" \
--model_name_or_path Qwen/Qwen3-0.6B \
--dataset_name HuggingFaceH4/OpenR1-Math-220k-default-verified \
--output_dir grpo-full-qwen3-0.6b \
--learning_rate 1.0e-6 \
--lr_scheduler_type cosine \
--warmup_steps 0.0 \
--max_grad_norm 1.0 \
--beta 0.0 \
--max_completion_length 4096 \
--num_generations 16 \
--generation_batch_size 16 \
--gradient_accumulation_steps 8 \
--per_device_train_batch_size 1 \
--num_train_epochs 1 \
--lora_r 1 \
--lora_alpha 32 \
--lora_dropout 0.0 \
--lora_target_modules all-linear \
--vllm_mode colocate \
--save_strategy steps \
--save_steps 50 \
--save_total_limit 1 \
--logging_steps 1 \
--max_steps 200 \
--report_to trackioPara ejecutar el script localmente, es necesario tener uv instalado. Consulta la documentación de uv para más detalles.
El script de aprendizaje por refuerzo con GRPO se implementa como un script personalizado en TRL, que utiliza la función de recompensa mostrada anteriormente. Puedes revisarlo en grpo.py - Buenas prácticas para el aprendizaje por refuerzo con LoRA
Hallazgos clave en la optimización de LoRA
Los autores recomiendan aplicar LoRA a todas las matrices de pesos en lugar de limitarlo a las capas de atención, ya que aumentar el rango no compensa esta restricción. En TRL, esto se puede configurar usando --lora_target_modules all-linear para aplicar LoRA a todas las matrices de pesos.
Logramos reproducir los resultados del artículo de blog utilizando TRL y el modelo SmolLM3. Entrenamos el modelo durante 500 pasos en el conjunto de datos Math 220k con la función de recompensa y la configuración anteriores. Como se puede ver en la figura siguiente, la curva de recompensa media de entrenamiento del modelo LoRA coincide con la curva de ajuste fino completo.

Y lo más importante, el modelo LoRA utiliza significativamente menos memoria que el modelo de ajuste fino completo, como podemos ver en la figura siguiente.

Estos son los parámetros que usamos para entrenar los modelos anteriores
| Parámetro | LoRA | FT completo |
|---|---|---|
--model_name_or_path | HuggingFaceTB/SmolLM3-3B | HuggingFaceTB/SmolLM3-3B |
--dataset_name | HuggingFaceH4/OpenR1-Math-220k-default-verified | HuggingFaceH4/OpenR1-Math-220k-default-verified |
--learning_rate | 1.0e-5 | 1.0e-6 |
--max_completion_length | 4096 | 4096 |
--lora_r | 1 | - |
--lora_alpha | 32 | - |
--lora_dropout | 0.0 | - |
--lora_target_modules | all-linear | - |
Desglosemos los hallazgos clave del artículo de blog y cómo pudimos reproducirlos.
1. LoRA rinde mejor cuando se aplica a todas las matrices de pesos
Los autores recomiendan aplicar LoRA a todas las matrices de pesos en lugar de limitarlo a las capas de atención, ya que aumentar el rango no compensa esta restricción.

LoRA solo de atención rinde peor incluso cuando se utiliza un rango más alto para igualar la cantidad de parámetros. En TRL, esto se puede configurar usando --lora_target_modules all-linear para aplicar LoRA a todas las matrices de pesos. En Python, podemos hacerlo de la siguiente manera:
from peft import LoraConfig
peft_config = LoraConfig(target_modules="all-linear") 2. El adaptador necesita una capacidad suficiente para aprender del conjunto de datos
La publicación del blog recomienda utilizar un rango de LoRA suficiente para aprender del conjunto de datos. El rango determina el número de parámetros entrenables en el adaptador de LoRA. Por lo tanto, “Para conjuntos de datos que superan la capacidad de LoRA, LoRA rinde peor que FullFT”.

En el script de TRL, podemos usar --lora_r para establecer el rango y adaptarlo según la tarea y el conjunto de datos en los que estamos entrenando. El artículo de blog recomienda los siguientes rangos según la tarea y el tamaño del conjunto de datos:
Las tareas de aprendizaje por refuerzo suelen requerir menor capacidad, por lo que se pueden usar rangos de LoRA más pequeños. Esto se debe a que los algoritmos de gradiente de política extraen aproximadamente ~1 bit de información por episodio, lo que exige una capacidad de parámetros mínima.
La entrada del blog define el tamaño ideal del conjunto de datos para que LoRA iguale el ajuste completo como “Escala de posentrenamiento”. Lo que podemos usar para determinar el rango recomendado para los LoRAs de SFT y RL como:
| Tipo de tarea | Tamaño del conjunto de datos | Rango recomendado |
|---|---|---|
| SFT | Escala de posentrenamiento | 256 |
| RL | Cualquier tamaño | 1-32 |
3. “FullFT y los LoRAs de alto rango tienen curvas de aprendizaje similares”
Contrario a lo que se podría esperar, el artículo de blog recomienda usar una tasa de aprendizaje más alta que la utilizada para el ajuste fino completo. En la tabla anterior, usamos 1.0e-5 para LoRA y 1.0e-6 para el ajuste fino completo. En el script de TRL, podríamos usar --learning_rate para establecer la tasa de aprendizaje. La escalado en LoRA hace que la tasa de aprendizaje óptima sea aproximadamente independiente del rango.

4. “En algunos escenarios, LoRA es menos tolerante con tamaños de lote grandes que el ajuste fino completo.”
La publicación del blog recomienda usar un tamaño de lote efectivo < 32 porque los autores encontraron que LoRA es menos tolerante con tamaños de lote grandes. Esto no se pudo mitigar aumentando el rango de LoRA. En el script de TRL, podríamos usar --per_device_train_batch_size y --gradient_accumulation_steps para establecer el tamaño de lote.

Conclusiones
Con TRL, puede implementar de manera eficiente adaptadores LoRA para igualar el rendimiento del ajuste fino completo, aplicando los conceptos clave (dirigirse a todas las matrices de pesos, elegir el rango adecuado y gestionar el tamaño del lote y la tasa de aprendizaje) sin el alto costo de cómputo de FullFT.
Cita
@article{schulman2025lora,
title = {{LoRA Without Regret}},
author = {John Schulman and Thinking Machines Lab},
year = 2025,
journal = {Thinking Machines Lab: Connectionism},
doi = {10.64434/tml.20250929},
note = {https://thinkingmachines.ai/blog/lora/}
}