Skip to main content 首页 创作者 synthetic-sciences openscience fine-tuning-with-trl
fine-tuning-with-trl Fine-tune LLMs using reinforcement learning with TRL - SFT for instruction tuning, DPO for preference alignment, PPO/GRPO for reward optimization, and reward model training. Use when need RLHF, align model with preferences, or train from human feedback. Works with HuggingFace Transformers.
跳到安装 Skills Marketplace 发现并探索由社区构建的 Agent Skills
用 Codex 或 Claude 帮你安装 复制这段 Prompt,粘贴到 Codex、Claude 或其他助手里,让它检查 Skill 页面并帮你完成安装。
直接命令不会经过审查 Prompt;运行前请先检查来源。
npx skills add https://github.com/synthetic-sciences/openscience --skill fine-tuning-with-trl命令会保持在同一行。复制前请横向滚动并检查完整内容。
想先保存到本地?可下载 SkillsMP 当前能够提供的文件。
下载 Zip 下载中... name fine-tuning-with-trl description Fine-tune LLMs using reinforcement learning with TRL - SFT for instruction tuning, DPO for preference alignment, PPO/GRPO for reward optimization, and reward model training. Use when need RLHF, align model with preferences, or train from human feedback. Works with HuggingFace Transformers. category ml-training version 1.0.0 author Synthetic Sciences license MIT tags ["Post-Training","TRL","Reinforcement Learning","Fine-Tuning","SFT","DPO","PPO","GRPO","RLHF","Preference Alignment","HuggingFace"] dependencies ["trl","transformers","datasets","peft","accelerate","torch"]
TRL - Transformer Reinforcement Learning
Quick start
TRL provides post-training methods for aligning language models with human preferences.
Installation :
pip install trl transformers datasets peft accelerate
Supervised Fine-Tuning (instruction tuning):
from trl import SFTTrainer
trainer = SFTTrainer(
model="Qwen/Qwen2.5-0.5B" ,
train_dataset=dataset,
)
trainer.train()
DPO (align with preferences):
from trl import DPOTrainer, DPOConfig
config = DPOConfig(output_dir="model-dpo" , beta=0.1 )
trainer = DPOTrainer(
model=model,
args=config,
train_dataset=preference_dataset,
processing_class=tokenizer
)
trainer.train()
Common workflows
Workflow 1: Full RLHF pipeline (SFT → Reward Model → PPO)
Complete pipeline from base model to human-aligned model.
Copy this checklist:
RLHF Training:
- [ ] Step 1: Supervised fine-tuning (SFT)
- [ ] Step 2: Train reward model
- [ ] Step 3: PPO reinforcement learning
- [ ] Step 4: Evaluate aligned model
Step 1: Supervised fine-tuning
Train base model on instruction-following data:
from transformers import AutoModelForCausalLM, AutoTokenizer
from trl import SFTTrainer, SFTConfig
from datasets import load_dataset
model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen2.5-0.5B" )
tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen2.5-0.5B" )
dataset = load_dataset("trl-lib/Capybara" , split="train" )
training_args = SFTConfig(
output_dir= ,
per_device_train_batch_size= ,
num_train_epochs= ,
learning_rate= ,
logging_steps= ,
save_strategy=
)
trainer = SFTTrainer(
model=model,
args=training_args,
train_dataset=dataset,
tokenizer=tokenizer
)
trainer.train()
trainer.save_model()
"Qwen2.5-0.5B-SFT"
4
1
2e-5
10
"epoch"
Step 2: Train reward model
Train model to predict human preferences:
from transformers import AutoModelForSequenceClassification
from trl import RewardTrainer, RewardConfig
model = AutoModelForSequenceClassification.from_pretrained(
"Qwen2.5-0.5B-SFT" ,
num_labels=1
)
tokenizer = AutoTokenizer.from_pretrained("Qwen2.5-0.5B-SFT" )
dataset = load_dataset("trl-lib/ultrafeedback_binarized" , split="train" )
training_args = RewardConfig(
output_dir="Qwen2.5-0.5B-Reward" ,
per_device_train_batch_size=2 ,
num_train_epochs=1 ,
learning_rate=1e-5
)
trainer = RewardTrainer(
model=model,
args=training_args,
processing_class=tokenizer,
train_dataset=dataset
)
trainer.train()
trainer.save_model()
Step 3: PPO reinforcement learning
Optimize policy using reward model:
python -m trl.scripts.ppo \
--model_name_or_path Qwen2.5-0.5B-SFT \
--reward_model_path Qwen2.5-0.5B-Reward \
--dataset_name trl-internal-testing/descriptiveness-sentiment-trl-style \
--output_dir Qwen2.5-0.5B-PPO \
--learning_rate 3e-6 \
--per_device_train_batch_size 64 \
--total_episodes 10000
from transformers import pipeline
generator = pipeline("text-generation" , model="Qwen2.5-0.5B-PPO" )
prompt = "Explain quantum computing to a 10-year-old"
output = generator(prompt, max_length=200 )[0 ]["generated_text" ]
print (output)
Workflow 2: Simple preference alignment with DPO Align model with preferences without reward model.
DPO Training:
- [ ] Step 1: Prepare preference dataset
- [ ] Step 2: Configure DPO
- [ ] Step 3: Train with DPOTrainer
- [ ] Step 4: Evaluate alignment
Step 1: Prepare preference dataset
{
"prompt" : "What is the capital of France?" ,
"chosen" : "The capital of France is Paris." ,
"rejected" : "I don't know."
}
from datasets import load_dataset
dataset = load_dataset("trl-lib/ultrafeedback_binarized" , split="train" )
from trl import DPOConfig
config = DPOConfig(
output_dir="Qwen2.5-0.5B-DPO" ,
per_device_train_batch_size=4 ,
num_train_epochs=1 ,
learning_rate=5e-7 ,
beta=0.1 ,
max_prompt_length=512 ,
max_length=1024 ,
logging_steps=10
)
Step 3: Train with DPOTrainer
from transformers import AutoModelForCausalLM, AutoTokenizer
from trl import DPOTrainer
model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen2.5-0.5B-Instruct" )
tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen2.5-0.5B-Instruct" )
trainer = DPOTrainer(
model=model,
args=config,
train_dataset=dataset,
processing_class=tokenizer
)
trainer.train()
trainer.save_model()
trl dpo \
--model_name_or_path Qwen/Qwen2.5-0.5B-Instruct \
--dataset_name argilla/Capybara-Preferences \
--output_dir Qwen2.5-0.5B-DPO \
--per_device_train_batch_size 4 \
--learning_rate 5e-7 \
--beta 0.1
Workflow 3: Memory-efficient online RL with GRPO Train with reinforcement learning using minimal memory.
GRPO Training:
- [ ] Step 1: Define reward function
- [ ] Step 2: Configure GRPO
- [ ] Step 3: Train with GRPOTrainer
Step 1: Define reward function
def reward_function (completions, **kwargs ):
"""
Compute rewards for completions.
Args:
completions: List of generated texts
Returns:
List of reward scores (floats)
"""
rewards = []
for completion in completions:
score = len (completion.split())
score += len (set (completion.lower().split()))
rewards.append(score)
return rewards
from transformers import pipeline
reward_model = pipeline("text-classification" , model="reward-model-path" )
def reward_from_model (completions, prompts, **kwargs ):
full_texts = [p + c for p, c in zip (prompts, completions)]
results = reward_model(full_texts)
return [r["score" ] for r in results]
from trl import GRPOConfig
config = GRPOConfig(
output_dir="Qwen2-GRPO" ,
per_device_train_batch_size=4 ,
num_train_epochs=1 ,
learning_rate=1e-5 ,
num_generations=4 ,
max_new_tokens=128
)
Step 3: Train with GRPOTrainer
from datasets import load_dataset
from trl import GRPOTrainer
dataset = load_dataset("trl-lib/tldr" , split="train" )
trainer = GRPOTrainer(
model="Qwen/Qwen2-0.5B-Instruct" ,
reward_funcs=reward_function,
args=config,
train_dataset=dataset
)
trainer.train()
trl grpo \
--model_name_or_path Qwen/Qwen2-0.5B-Instruct \
--dataset_name trl-lib/tldr \
--output_dir Qwen2-GRPO \
--num_generations 4
When to use vs alternatives
Need to align model with human preferences
Have preference data (chosen/rejected pairs)
Want to use reinforcement learning (PPO, GRPO)
Need reward model training
Doing RLHF (full pipeline)
SFT : Have prompt-completion pairs, want basic instruction following
DPO : Have preferences, want simple alignment (no reward model needed)
PPO : Have reward model, need maximum control over RL
GRPO : Memory-constrained, want online RL
Reward Model : Building RLHF pipeline, need to score generations
Use alternatives instead:
HuggingFace Trainer : Basic fine-tuning without RL
Axolotl : YAML-based training configuration
LitGPT : Educational, minimal fine-tuning
Unsloth : Fast LoRA training
Common issues Issue: OOM during DPO training
Reduce batch size and sequence length:
config = DPOConfig(
per_device_train_batch_size=1 ,
max_length=512 ,
gradient_accumulation_steps=8
)
Or use gradient checkpointing:
model.gradient_checkpointing_enable()
Issue: Poor alignment quality
config = DPOConfig(beta=0.5 )
config = DPOConfig(beta=0.01 )
Issue: Reward model not learning
Check loss type and learning rate:
config = RewardConfig(
learning_rate=1e-5 ,
num_train_epochs=3
)
Ensure preference dataset has clear winners:
Issue: PPO training unstable
config = PPOConfig(
kl_coef=0.1 ,
cliprange=0.1
)
Advanced topics SFT training guide : See references/sft-training.md for dataset formats, chat templates, packing strategies, and multi-GPU training.
Hardware requirements
GPU : NVIDIA (CUDA required)
VRAM : Depends on model and method
SFT 7B: 16GB (with LoRA)
DPO 7B: 24GB (stores reference model)
PPO 7B: 40GB (policy + reward model)
GRPO 7B: 24GB (more memory efficient)
Multi-GPU : Supported via accelerate
Mixed precision : BF16 recommended (A100/H100)
Use LoRA/QLoRA for all methods
Enable gradient checkpointing
Use smaller batch sizes with gradient accumulation
Resources