verl - Volcano Engine RL pour LLMs Cheatsheet

verl - Volcano Engine RL pour LLMs Cheatsheet

verl (Volcano Engine Reinforcement Learning) est un framework open-source haute performance pour l’apprentissage par renforcement lors de l’entraînement post-training de grands modèles de langage. C’est l’implémentation publique du paper HybridFlow, construit autour d’un modèle de programmation hybrid-controller qui te permet d’exprimer des flux de données RL complexes — PPO, GRPO, et autres — en quelques lignes en découplant le calcul des dépendances de données. Il s’intègre avec FSDP, Megatron-LM, vLLM et SGLang, et c’est l’un des frameworks RL les plus largement utilisés pour les LLMs.

L’entraînement RL post-training est exigeant en calcul et sensible à la configuration. Valide une récompense et une petite exécution avant de passer à la multi-nœud.

Installation

Method	Command
pip	pip install verl
From source	git clone https://github.com/volcengine/verl && cd verl && pip install -e .
Docker	use the official images referenced in the docs (CUDA + vLLM preinstalled)
Requirements	NVIDIA GPU(s), CUDA, PyTorch; vLLM or SGLang for rollout

Concepts Clés

Term	Meaning
HybridFlow	Le modèle de contrôleur : un seul contrôleur orchestre les workers distribués
Rollout	Phase de génération qui produit des échantillons (servie par vLLM/SGLang)
Actor / Critic	La politique en cours d’entraînement et (pour PPO) le modèle de valeur
Reward	Signal scalaire ; provenant d’un modèle de récompense ou d’une fonction personnalisée
Placement	Comment les modèles sont mappés sur des ensembles de GPU (colocalisés ou séparés)
Recipe	Configuration d’entraînement prête à l’emploi pour un algorithme

Algorithmes Supportés

Algorithm	Notes
PPO	Classic actor-critic RLHF
GRPO	Group-relative, no critic model required
ReMax / RLOO	Lightweight baselines
DAPO / Dr.GRPO	GRPO variants
DPO-style	Preference optimization recipes

Exécution d’un Travail d’Entraînement

verl est piloté par des remplacements de config en style Hydra sur la ligne de commande.

# GRPO example (conceptual): point at data, model, and rollout backend
python3 -m verl.trainer.main_ppo \
  algorithm.adv_estimator=grpo \
  data.train_files=$DATA/train.parquet \
  data.val_files=$DATA/val.parquet \
  actor_rollout_ref.model.path=Qwen/Qwen2.5-7B-Instruct \
  actor_rollout_ref.rollout.name=vllm \
  trainer.n_gpus_per_node=8 \
  trainer.nnodes=1

Config group	Controls
algorithm.*	Algorithm and advantage estimator (e.g. adv_estimator=grpo)
data.*	Train/val files, batch sizes, max lengths
actor_rollout_ref.model.*	Base model path and dtype
actor_rollout_ref.rollout.*	Rollout backend (vllm / sglang) and sampling
critic.*	Critic model settings (PPO)
trainer.*	GPUs per node, node count, logging, checkpoints

Backends & Scaling

Component	Options
Training engine	FSDP, FSDP2, Megatron-LM
Rollout engine	vLLM, SGLang
Distribution	Ray-based placement across GPUs/nodes
Device mapping	Colocate actor+rollout, or split across GPU sets

Récompense & Données

Task	How
Custom reward	Fournir une fonction de récompense module via config
Reward model	Pointer reward_model.* sur un modèle de scoring
Dataset format	Parquet avec prompt (et answer pour les récompenses vérifiables)
Verifiable rewards	Support intégré pour math/code-style exact-match rewards

Monitoring

Tool	Integration
Weights & Biases	trainer.logger=['console','wandb']
TensorBoard	Supported logger backend
Checkpoints	trainer.save_freq, resume from trainer.resume_mode

verl vs Autres Frameworks RL

Aspect	verl	OpenRLHF	ART
Core model	HybridFlow controller	Ray actor split	Client/server
Training engines	FSDP + Megatron	DeepSpeed/FSDP	Unsloth
Rollout	vLLM / SGLang	vLLM	vLLM
Best for	Débit + flexibilité	RLHF production à l’échelle	Agents dans ton propre code

Ressources

• GitHub Repository
• Official Documentation
• HybridFlow Paper