Skip to main content Startseite Ersteller 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.
Zur Installation springen Skills Marktplatz Entdecken und erkunden Sie KI-Skills, die von der Community erstellt wurden.
Mit Codex oder Claude installieren Kopieren Sie diesen Prompt, fügen Sie ihn in Codex, Claude oder einen anderen Assistant ein und lassen Sie die Skill-Seite prüfen und installieren.
Prompt kopierenPrompt-Details anzeigen Ein direkter Befehl überspringt den Prüf-Prompt. Prüfen Sie die Quelle, bevor Sie ihn ausführen.
npx skills add https://github.com/synthetic-sciences/openscience --skill fine-tuning-with-trlDer Befehl bleibt in einer Zeile. Scrollen Sie horizontal, um ihn vor dem Kopieren vollständig zu prüfen.
Sie bevorzugen eine lokale Kopie? Laden Sie die Dateien herunter, die SkillsMP derzeit vorliegen.
ZIP herunterladen Herunterladen... Mehr aus diesem Repository Diffusion-based molecular docking. Predict protein-ligand binding poses from PDB/SMILES, confidence scores, virtual screening, for structure-based drug design. Not for affinity prediction.
Fast inference and fine-tuning platform with serverless and on-demand GPU deployments. OpenAI-compatible API for chat completions, embeddings, function calling, vision, and structured output. Supports SFT, DPO, and RL fine-tuning. SOC2 + HIPAA compliant.
Serverless inference, fine-tuning, embeddings, image generation, and batch processing on 200+ open-source models via an OpenAI-compatible API. Use when you need fast, cost-effective access to open-source LLMs without managing infrastructure.
Verwandte Berufe SOC
Basierend auf der SOC-Berufsklassifikation
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