Glonce

Sebastian Raschka releases 11-hour video course on building reasoning models

miscThe Glonce editorsSebastian Raschka🔥50Glonce rating50Impact35Novelty30Relevance100Surprise15Players30Credibility85
Sebastian Raschka releases 11-hour video course on building reasoning models

Sebastian Raschka, author of the Ahead of AI newsletter, has published a video course to go with his book Build a Reasoning Model (From Scratch). It is eight coding lectures totalling 11 hours, recorded over the last few months. He describes it as essentially the sequel to his Coding LLMs from the Ground Up course from last year, though it can be watched without that course.

The premise is that reasoning models remain central: in his words, almost all current-generation LLMs are reasoning models or offer a reasoning mode. The series starts with a pre-trained model rather than training one from scratch, which lets it concentrate on evaluation, inference-time scaling, reinforcement learning and distillation, all implemented in Python and PyTorch.

Before the videos, Raschka explains how LLMs, reasoning models and agents fit together. A reasoning model is a conventional LLM upgraded with more post-training via reinforcement learning with verifiable rewards, optionally combined with inference scaling techniques. It then acts as the engine inside an agent harness, a software framework whose task is context management and giving the LLM access to tools. An agent can use either kind of model, but reasoning models are the more typical choice because they are more capable.

Scope and prerequisites: the videos use a small pre-trained Qwen3 model. Raschka recommends being comfortable with Python and PyTorch. The earlier Build a Large Language Model (From Scratch) material is recommended but not strictly required. The early text-generation and evaluation examples can be worked through on a CPU; for later experiments, especially training, a GPU makes the work much more practical.

The lectures that are described in detail run as follows. Video 1 covers motivation and setup: the relationship between LLMs, reasoning models and agents, installing Python and PyTorch dependencies with uv, choosing hardware, checking CUDA or Apple Silicon support, and using a remote GPU with VS Code. Video 2 loads the pre-trained Qwen3 0.6B weights, implements a streaming text generator, and adds KV caching and model compilation to speed up generation; it also covers greedy decoding, tokens, logits and measuring generation speed. Video 3 builds a math-answer verifier step by step (answer extraction, normalization, checking mathematical equivalence) and uses it to evaluate the base model on the MATH-500 dataset. The same verifier later supplies the reward signal for reinforcement learning with verifiable rewards (RLVR).

Video 4 turns to inference-time scaling, where the model weights stay fixed. It implements temperature scaling, multinomial sampling and top-p filtering to generate diverse answers, then combines them through self-consistency, which is majority voting over final answers. It also looks at the tradeoff between accuracy and the extra compute for more candidates. Video 5 adds scoring functions to compare answers and break ties in self-consistency, including token and sequence log probabilities, and implements a self-refinement loop in which the model critiques an answer and attempts a revision; it then checks on MATH-500 how useful those steps are. Video 6 implements a simplified version of Group Relative Policy Optimization (GRPO) for RLVR: generating groups of responses, scoring them with the verifier, and using their relative rewards for weight updates. It also compares RLHF with RLVR and covers the training loop, logging, checkpoints, stability and memory needs. The listing for the remaining two videos is not part of the text covered here.

Raschka recommends reading a book chapter, working through its code alongside the matching video, and then trying the exercises. The book is available from Manning and Amazon, and the print edition is in color. For a shorter, more conceptual overview he also points to his AI Reasoning Models course on LinkedIn Learning: about 90 minutes, covering inference-time scaling, reinforcement learning and distillation, and it should be free for 24 hours when accessed via the link in his article. He adds that he is taking a short break and expects to be back with LLM research roundups next month.

Key facts

  • Eight coding videos totalling 11 hours accompany Sebastian Raschka's book Build a Reasoning Model (From Scratch), with Python and PyTorch implementations.
  • The series starts from a pre-trained Qwen3 0.6B model and evaluates it on MATH-500 using a verifier built in video 3.
  • Videos 4 and 5 cover inference-time scaling (sampling, self-consistency, scoring, self-refinement); video 6 implements a simplified GRPO for RLVR.
  • Early examples run on a CPU; a GPU makes the later experiments, especially training, much more practical.
  • A separate, shorter AI Reasoning Models course of about 90 minutes is on LinkedIn Learning and should be free for 24 hours via the author's link.

Why it matters

Raschka argues that reasoning models are as relevant as ever, since almost all current-generation LLMs are reasoning models or offer a reasoning mode. The course walks through the machinery behind them (evaluation, inference-time scaling, reinforcement learning with verifiable rewards, distillation) in code rather than theory alone. He also frames reasoning models as the engine inside agent harnesses, so understanding them helps with understanding modern LLM agents. This is teaching material, not a new research result.

Who it affects

Readers who want to learn how reasoning models work by implementing them: people comfortable with Python and PyTorch, and viewers of his earlier Coding LLMs from the Ground Up course, of which this is essentially the sequel. Readers of the book get matching video lectures for its chapters. People who only want the main ideas can use the shorter LinkedIn Learning course instead.

How to use it

Raschka suggests reading a chapter, working through its code alongside the corresponding video, and then trying the exercises. Video 1 covers environment setup with uv and hardware choices, and the repository also has hardware and environment recommendations. The early text-generation and evaluation work runs on a CPU; a GPU is much more practical for the later training experiments. The book is sold by Manning and Amazon. The LinkedIn Learning course should be free for 24 hours through the link in the article, which shouldn't then require a LinkedIn Premium subscription.

How solid is it

The material comes straight from its author, who wrote the book and recorded the lectures, and the article gives detailed topic lists for each video. It is a description of a course, so there are no benchmark results to check; no MATH-500 accuracy figures for the base model, inference scaling or GRPO training are given. Detailed descriptions are available for videos 1 to 6 only.

Risks and caveats

The course uses a small model, Qwen3 0.6B, and a simplified version of GRPO, so it is built for learning rather than for reproducing production-scale training. Training experiments are much more practical on a GPU. The author describes the earlier Build a Large Language Model (From Scratch) content as recommended but not strictly required, and expects comfort with Python and PyTorch. The LinkedIn Learning access is described only as something that should be free for 24 hours.

“The task of the harness is sophisticated context management and giving the LLM access to tools.”

— Sebastian Raschka, Ahead of AI