Loading video...

Video Failed to Load

Go Home

New Course: Post-training of LLMs Learn to post-train and customize an LLM in this short course, taught by Banghua Zhu, Assistant Professor at the University of Washington University of Washington, and co-founder of @NexusflowX. Training an LLM to follow instructions or answer questions has two key stages: pre-training and...

125,146 views • 1 year ago •via X (Twitter)

10 Comments

Sudhir Gajre's profile picture
Sudhir Gajre1 year ago

@BanghuaZ @UW @NexusflowX Andrew, admittedly haven’t looked at the course materials yet. But I would suggest adding some discussion on the boundaries and limitations of context engineering. In my mind post-training should be considered only after you have exhausted CE.

Victor Ajayi's profile picture
Victor Ajayi1 year ago

@BanghuaZ @UW @NexusflowX I’ve been eager to deepen my understanding of post-training, and this course looks like the perfect opportunity. SFT, DPO, and RL are such powerful tools for shaping real-world AI behavior, can’t wait to explore how each one works in practice. Thanks for making this accessible!

Tony Sousan's profile picture
Tony Sousan1 year ago

@BanghuaZ @UW @NexusflowX @AndrewYNg, how do we effectively fine-tune LLMs for unique tasks? This course seems like a valuable opportunity. #AIlearning

TaskDrift™'s profile picture
TaskDrift™1 year ago

@BanghuaZ @UW @NexusflowX More people need to understand the power of post-training. SFT, DPO, and RL aren’t just for big labs, they unlock real use cases for smaller teams too. Love that this course makes it practical and hands-on.

casslin's profile picture
casslin1 year ago

@BanghuaZ @UW @NexusflowX This can be actually really helpful!

Dhiraj Khanna's profile picture
Dhiraj Khanna1 year ago

@BanghuaZ @UW @NexusflowX Wow, sounds really interesting! With insights from @BanghuaZ and the backing of @UW and @NexusflowX, it looks like a rare deep dive into post-training techniques that shape the future of AI. Looking forward to seeing how it transforms approaches to LLM instruction tuning.

CloudNERD's profile picture
CloudNERD1 year ago

@BanghuaZ @UW @NexusflowX This sounds like an incredible opportunity for anyone looking to deepen their understanding of LLMs.

Vincent Valentine (CEO of UnOpen.ai)'s profile picture
Vincent Valentine (CEO of UnOpen.ai)1 year ago

@BanghuaZ @UW @NexusflowX exciting to see more resources for mastering llms.

Mohammed Lubbad, PhD's profile picture
Mohammed Lubbad, PhD1 year ago

@BanghuaZ @UW @NexusflowX Customizing LLMs is crucial, but what about ethical considerations in deployment? This balance will shape future success. 🤔 #AITraining

Tsukuyomi's profile picture
Tsukuyomi1 year ago

@BanghuaZ @UW @NexusflowX post-training? Sounds like a great way to make your AI less of a wild child. Good luck, @BanghuaZ! Hope you don't accidentally unleash another rogue AI on us.

Related Videos

New Course: Reinforcement Fine-Tuning LLMs with GRPO! Learn to use reinforcement learning to improve your LLM performance in this short course, built in collaboration with Predibase by Rubrik, and taught by Travis Addair, its Co-Founder and CTO, and Arnav Garg, its Senior Engineer and Machine Learning Lead. Reasoning models have been one of the most important developments in LLMs. Reinforcement Fine-Tuning (RFT) uses rewards to encourage LLMs to find solutions to multi-step reasoning tasks such as solving math problems and debugging code - without needing pre-existing training examples like in traditional supervised fine-tuning. Group Relative Policy Optimization (GRPO) is a reinforcement fine-tuning algorithm gaining rapid adoption. Developed by the DeepSeek team and used to train the R1 reasoning model, GRPO uses reward functions that you can write in Python to assign rewards to model responses. It’s beneficial for tasks with verifiable outcomes and can work well even with fewer than 100 training examples. It can also significantly improve the reasoning ability of smaller LLMs, making applications faster and more cost effective. In this course, you’ll take a technical deep dive into RFT with GRPO. You’ll learn to build reward functions that you can use in the GRPO training process to guide an LLM toward better performance on multi-step reasoning tasks. In detail, you’ll: - Learn when reinforcement fine-tuning is a better fit than supervised fine-tuning, especially for tasks involving multi-step reasoning or limited labeled data. - Understand how GRPO uses programmable reward functions as a more scalable alternative to the human feedback required for other reinforcement learning algorithms, such as RLHF and DPO. - Frame the Wordle game as a reinforcement fine-tuning problem and see how an LLM can learn to plan, analyze feedback, and improve its strategy over time. - Design reward functions that power the reinforcement fine-tuning process. - Learn techniques for evaluating more subjective tasks, such as rating the quality of a text summary, using an LLM as a judge. - Understand why reward hacking happens and how to avoid it by adding penalty functions to discourage undesirable behaviors. - Learn the four key components of the loss calculation in the GRPO algorithm: token probability distribution ratios, advantages, clipping, and KL-divergence. - Launch reinforcement fine-tuning jobs using Predibase’s hosted training services. By the end of this course, you’ll be able to build and fine-tune LLMs using reinforcement learning to improve reasoning without relying on large labeled datasets or subjective human feedback. Please sign up here:

Andrew Ng

86,697 views • 1 year ago

OpenClaw meets RL! OpenClaw Agents adapt through memory files and skills, but the base model weights never actually change. OpenClaw-RL solves this! It wraps a self-hosted model as an OpenAI-compatible API, intercepts live conversations from OpenClaw, and trains the policy in the background using RL. The architecture is fully async. This means serving, reward scoring, and training all run in parallel. Once done, weights get hot-swapped after every batch while the agent keeps responding. Currently, it has two training modes: - Binary RL (GRPO): A process reward model scores each turn as good, bad, or neutral. That scalar reward drives policy updates via a PPO-style clipped objective. - On-Policy Distillation: When concrete corrections come in like "you should have checked that file first," it uses that feedback as a richer, directional training signal at the token level. When to use OpenClaw-RL? To be fair, a lot of agent behavior can already be improved through better memory and skill design. OpenClaw's existing skill ecosystem and community-built self-improvement skills handle a wide range of use cases without touching model weights at all. If the agent keeps forgetting preferences, that's a memory problem. And if it doesn't know how to handle a specific workflow, that's a skill problem. Both are solvable at the prompt and context layer. Where RL becomes interesting is when the failure pattern lives deeper in the model's reasoning itself. Things like consistently poor tool selection order, weak multi-step planning, or failing to interpret ambiguous instructions the way a specific user intends. Research on agentic RL (like ARTIST and Agent-R1) has shown that these behavioral patterns hit a ceiling with prompt-based approaches alone, especially in complex multi-turn tasks where the model needs to recover from tool failures or adapt its strategy mid-execution. That's the layer OpenClaw-RL targets, and it's a meaningful distinction from what OpenClaw offers. I have shared the repo in the replies!

Avi Chawla

138,769 views • 5 months ago