Welcome to the first page!
We’re going to start our journey into the exciting world of Reinforcement Learning (RL) and discover how it’s revolutionizing the way we train Language Models like the ones you might use every day.
This page will give you a friendly and clear introduction to RL, even if you’ve never encountered it before. We’ll break down the core ideas and see why RL is becoming so important in the field of Large Language Models (LLMs).
Imagine you’re training a dog. You want to teach it to sit. You might say “Sit!” and then, if the dog sits, you give it a treat and praise. If it doesn’t sit, you might gently guide it or just try again. Over time, the dog learns to associate sitting with the positive reward (treat and praise) and is more likely to sit when you say “Sit!” again.
That, in a nutshell, is the basic idea behind Reinforcement Learning! Instead of a dog, we have a language model (in reinforcement learning, we call it an agent), and instead of you, we have the environment that gives feedback.
![https://huggingface.co/nlp-course/images/resolve/main/grpo/2.jpg][image1]
Let’s break down the key pieces of RL:
This is our learner. In the dog example, the dog is the agent. In the context of LLMs, the LLM itself becomes the agent we want to train. The agent is the one making decisions and learning from the environment and its rewards.
This is the world the agent lives in and interacts with. For the dog, the environment is your house and you. For an LLM, the environment is a bit more abstract – it could be the users it interacts with, or a simulated scenario we set up for it. The environment provides feedback to the agent.
These are the choices the agent can make in the environment. The dog’s actions are things like “sit”, “stand”, “bark”, etc. For an LLM, actions could be generating words in a sentence, choosing which answer to give to a question, or deciding how to respond in a conversation.
This is the feedback the environment gives to the agent after it takes an action. Rewards are usually numbers.
Positive rewards are like treats and praise – they tell the agent “good job, you did something right!“.
Negative rewards (or penalties) are like a gentle “no” – they tell the agent “that wasn’t quite right, try something else”. For the dog, the treat is the reward.
For an LLM, rewards are designed to reflect how well the LLM is doing at a specific task – maybe it’s how helpful, truthful, or harmless its response is.
This is the agent’s strategy for choosing actions. It’s like the dog’s understanding of what it should do when you say “Sit!“. In RL, the policy is what we’re really trying to learn and improve. It’s a set of rules or a function that tells the agent what action to take in different situations. Initially, the policy might be random, but as the agent learns, the policy becomes better at choosing actions that lead to higher rewards.
![https://huggingface.co/nlp-course/images/resolve/main/grpo/1.jpg][image2]
Reinforcement Learning happens through a process of trial and error:
| Step | Process | Description |
|---|---|---|
| 1. Observation | The agent observes the environment | The agent takes in information about its current state and surroundings |
| 2. Action | The agent takes an action based on its current policy | Using its learned strategy (policy), the agent decides what to do next |
| 3. Feedback | The environment gives the agent a reward (or penalty) | The agent receives feedback on how good or bad its action was |
| 4. Learning | The agent updates its policy based on the reward | The agent adjusts its strategy - reinforcing actions that led to good rewards and avoiding those that led to penalties |
| 5. Iteration | Repeat the process | This cycle continues, allowing the agent to continuously improve its decision-making |
Think about learning to ride a bike. You might wobble and fall at first (negative reward!). But when you manage to balance and pedal smoothly, you feel good (positive reward!). You adjust your actions based on this feedback – leaning slightly, pedaling faster, etc. – until you learn to ride well. RL is similar – it’s about learning through interaction and feedback.
Now, why is RL so important for Large Language Models?
Well, training really good LLMs is tricky. We can train them on massive amounts of text from the internet, and they become very good at predicting the next word in a sentence. This is how they learn to generate fluent and grammatically correct text, as we learned in chapter 2.
However, just being fluent isn’t enough. We want our LLMs to be more than just good at stringing words together. We want them to be:
Pre-training LLM methods, which mostly rely on predicting the next word from text data, sometimes fall short on these aspects.
Whilst supervised training is excellent at producing structured outputs, it can be less effective at producing helpful, harmless, and aligned responses. We explore supervised training in chapter 11.
Fine-tuned models might generate fluent and structured text that is still factually incorrect, biased, or doesn’t really answer the user’s question in a helpful way.
Enter Reinforcement Learning! RL gives us a way to fine-tune these pre-trained LLMs to better achieve these desired qualities. It’s like giving our LLM dog extra training to become a well-behaved and helpful companion, not just a dog that knows how to bark fluently!
A very popular technique for aligning language models is Reinforcement Learning from Human Feedback (RLHF). In RLHF, we use human feedback as a proxy for the “reward” signal in RL. Here’s how it works:
![https://huggingface.co/nlp-course/images/resolve/main/grpo/3.jpg][image3]
Get Human Preferences: We might ask humans to compare different responses generated by the LLM for the same input prompt and tell us which response they prefer. For example, we might show a human two different answers to the question “What is the capital of France?” and ask them “Which answer is better?“.
Train a Reward Model: We use this human preference data to train a separate model called a reward model. This reward model learns to predict what kind of responses humans will prefer. It learns to score responses based on helpfulness, harmlessness, and alignment with human preferences.
Fine-tune the LLM with RL: Now we use the reward model as the environment for our LLM agent. The LLM generates responses (actions), and the reward model scores these responses (provides rewards). In essence, we’re training the LLM to produce text that our reward model (which learned from human preferences) thinks is good.
From a general perspective, let’s look at the benefits of using RL in LLMs:
| Benefit | Description |
|---|---|
| Improved Control | RL allows us to have more control over the kind of text LLMs generate. We can guide them to produce text that is more aligned with specific goals, like being helpful, creative, or concise. |
| Enhanced Alignment with Human Values | RLHF, in particular, helps us align LLMs with complex and often subjective human preferences. It’s hard to write down rules for “what makes a good answer,” but humans can easily judge and compare responses. RLHF lets the model learn from these human judgments. |
| Mitigating Undesirable Behaviors | RL can be used to reduce negative behaviors in LLMs, such as generating toxic language, spreading misinformation, or exhibiting biases. By designing rewards that penalize these behaviors, we can nudge the model to avoid them. |
Reinforcement Learning from Human Feedback has been used to train many of the most popular LLMs today, such as OpenAI’s GPT-4, Google’s Gemini, and DeepSeek’s R1. There are a wide range of techniques for RLHF, with varying degrees of complexity and sophistication. In this chapter, we will focus on Generalized Policy Rectification Optimization (GRPO), which is a technique for RLHF that has been shown to be effective at training LLMs that are helpful, harmless, and aligned with human preferences.
GRPO (Generalized Policy Rectification Optimization) represents a significant advancement in reinforcement learning for language models. It was developed by DeepSeek and played a crucial role in training their DeepSeek-R1 model, which has achieved state-of-the-art performance on various reasoning benchmarks.
This course is focused on GRPO and its implementation in the DeepSeek-R1 model. But before we dive into the technical details of GRPO, let’s look at the benefits of using GRPO over other RLHF techniques.
| Aspect | Description | Technical Significance |
|---|---|---|
| Direct Preference Learning | GRPO directly learns from preference data without requiring explicit reward modeling | Eliminates the need for a separate reward model, reducing complexity and potential error sources in the training pipeline |
| Enhanced Stability | Uses a novel group-based optimization approach that considers multiple responses simultaneously | The group-based approach provides more stable gradients and better convergence properties compared to traditional pairwise comparisons |
| Computational Efficiency | Achieves better sample efficiency through its group-based training mechanism | Reduces the computational resources needed for training, making it more practical for large-scale language models |
| Scalable Architecture | Designed specifically for large language models with distributed training in mind | Enables effective training of models with billions of parameters while maintaining stability |
| Improved Reasoning | Particularly effective at enhancing multi-step reasoning capabilities | The group optimization approach helps the model learn better reasoning patterns by considering multiple solution paths simultaneously |
| Training Pipeline Integration | Seamlessly integrates with existing pre-training and fine-tuning workflows | Can be applied as a post-training step without requiring changes to the base model architecture |
GRPO addresses several key limitations of previous approaches like PPO (Proximal Policy Optimization):
The success of GRPO in DeepSeek-R1 demonstrates its effectiveness as a training method for large language models, particularly in improving their reasoning and problem-solving capabilities. We’ll explore the technical details of how GRPO works in Module 3.
Congratulations on completing Module 1! You’ve now got a solid introduction to Reinforcement Learning and its crucial role in shaping the future of Large Language Models. You understand the basic concepts of RL, why it’s used for LLMs, and you’ve been introduced to GRPO, a key algorithm in this field.
In the next module, we’ll get our hands dirty and dive into the DeepSeek R1 paper to see these concepts in action!