←News detail

Shao MengUpdated Oct 26 10:31

Sebastian Raschka releases an 11-hour video course on building a reasoning model, using…

AI summary

Sebastian Raschka's accompanying video course for "Build a Reasoning Model (From Scratch)" is now available: 11 hours across eight lectures, starting from the pretrained small Qwen3 0.6B and using Python/PyTorch to hand-code a verifier, inference-time scaling (sampling, self-consistency, scoring, self-refinement), a simplified GRPO version of RLVR, and distillation toward a stronger teacher. The course skips training the base model from scratch; the early generation and evaluation work can be done on a CPU, while the later training stages are recommended to use a GPU, with results evaluated on MATH-500. Shao Meng relayed the course design in a tweet and used an engine analogy to distinguish regular LLMs, reasoning models, and the Agent harness.

Why read this

AI score 67

The course starts from the pretrained Qwen3 0.6B and strings together a verifier, inference-time scaling, a GRPO version of RLVR, and distillation into a hands-on, reproducible path.

Topics

Tags

Quoted post

Sebastian Raschka

@rasbt

The complete reasoning-from-scratch video series is now up (and linked) here: https://t.co/5IOHLTCIGt (Taking a short break but will be back with LLM model and research updates in November!)

View original

The complete reasoning-from-scratch video series is now up (and linked) here: https://t.co/5IOHLTCIGt (Taking a short break but will be back with LLM model and research updates in November!)

View original post

Body · AI translation

Building a Reasoning Model from Scratch: An 11-Hour Video Course That Puts Evaluation, Inference-Time Scaling, RLVR, and Distillation into PyTorch

@rasbt's "Build a Reasoning Model (From Scratch)" series is absolutely the best tutorial—perhaps without equal—for systematically learning the principles and practice of model building. What's being released this time is the complete programming course that accompanies the new book: starting from a small, already-pretrained Qwen3, you hand-code in Python/PyTorch an evaluation verifier, inference-time scaling (sampling / self-consistency / scoring / self-refinement), a GRPO version of RLVR, and distillation toward a stronger teacher; the throughline is understanding the "reasoning model" itself. https://t.co/9HfdL9ePwo

Where reasoning models, ordinary LLMs, and Agents fit In the text, an engine analogy is used: a regular LLM is the engine; a reasoning model is that engine plus reinforcement learning post-training with more verifiable rewards (optionally plus inference-time scaling), making it better at hard problems such as math and code; the Agent harness is the outer layer of tools and context management that lets the engine take on larger tasks. An Agent can use an ordinary LLM or a reasoning model, but most contemporary mainstream ones are reasoning models with adjustable reasoning effort. The series resources correspond to three books/three blocks: LLM from Scratch → Reasoning Model from Scratch → Coding Agent component articles.

How the course is designed · Starting point: a small pretrained Qwen3 0.6B, skipping "training a base model from scratch" to focus on evaluation, inference-time scaling, RL, and distillation · Prerequisites: familiarity with Python and PyTorch; the previous LLM from Scratch course is recommended but not required · Compute: generation and evaluation in the early stages can run on CPU; for later training a GPU is strongly recommended; video 1 and the repository have environment suggestions · Suggested learning path: first read the corresponding chapter → code along with the video → do the exercises; there is also an approximately 90-minute LinkedIn Learning concept course that can serve as preparation

Eight lectures (by workflow) 1. Motivation and environment: the relationship between LLM / reasoning / Agent; installing dependencies with uv; CUDA / Apple Silicon / remote GPU 2. Loading the base model and generation: loading Qwen3 weights; streaming generation; KV cache + torch.compile 3. Verifier: extracting answers → normalization → mathematical equivalence; evaluating on MATH-500; and reusing it for the subsequent RLVR reward 4. Inference-time scaling I: temperature / multinomial / top-p; self-consistency (majority vote); accuracy vs. extra compute 5. Inference-time scaling II: token/sequence logprob scoring to break ties; self-refinement (critique → rewrite) and evaluating it 6. RL: simplified GRPO: RLHF vs RLVR; group-relative advantage; simplified GRPO loss; training loop and checkpoint 7. RL: stability and analysis: entropy / advantage, clip, KL, format reward; preventing reward hacking; re-evaluating on MATH-500 8. Distillation: soft/hard, on/off-policy; using teacher data such as DeepSeek R1; supervised training of a small model and comparison

Source

Shao Meng