Qwen3
Module FTDD-08 · Course 3 — LLM Fine-Tuning Masterclass
45 minutes · 4 sub-sections: Why Hybrid · The Pipeline · Thinking Budget · The Workhorse
The hybrid thinking/non-thinking reference. One model, two modes, adaptive compute.
Deep-Dives
The production problem
Dedicated reasoner (R1)
Always deliberates.
Best on hard problems.
Latency tax on simple queries.
Fast assistant
Always answers directly.
Chatbot speed.
Cannot deliberate on hard problems.
The naive fix: two models + a router. 2x weights, 2x serving, router misroutes. Production teams hate this.
Qwen3's answer: fusion
One set of weights. Both modes coexist. Switched by a thinking budget.
The same model produces a long deliberate chain or a fast direct answer, selected at inference time.
- No router. No second model. One deployment serves both workloads.
- A thinking budget — a single parameter — decides how much to deliberate.
This is why Qwen3 is the deployed workhorse where R1 is the research touchstone. Production needs the hybrid property.
The four-stage pipeline
STAGE 1 · Long-CoT cold start · seed reasoning format (echoes R1)
↓
STAGE 2 · Reasoning RL (GRPO-style) · verifiable rewards; scales reasoning (echoes R1)
↓
STAGE 3 · THINKING-MODE FUSION · merge thinking + non-thinking into one (the novel stage)
↓
STAGE 4 · General RL · full distribution; keeps non-thinking strong
Stages 1 and 2 mirror R1. Stage 3 is what makes Qwen3 a hybrid rather than a dedicated reasoner.
Stage 3 — the fusion (the novel contribution)
The stage that separates Qwen3 from R1. Take the thinking model from Stage 2 and fuse it with a non-thinking (fast, direct) model.
Key insight: thinking pathways and direct-response pathways are not mutually exclusive in the weights. They can coexist, and a control token or budget selects which the model expresses.
After fusion, the model has both capabilities in one set of parameters.
This is what R1 does NOT do — R1 ships a pure reasoner. Qwen3 ships a model that can be either.
The thinking budget
One parameter. Adaptive compute.
| Budget | Behavior | Use case |
|---|
| Low | Short/empty <think>, direct answer | Chatbot, simple Q&A |
| Mid | Brief deliberation, then answer | Balanced default |
| High | Long self-correcting chain, verified answer | Math, code, proof |
Same weights. The budget collapses routing into a single continuous parameter.
Why the budget matters operationally
Without a budget
A hybrid model still needs a per-query router to decide thinking vs non-thinking. The router is itself a failure mode.
With the budget
Set a default appropriate to your workload. The model spends within it. No classifier needed.
Chatbot: low default. Math-solver: high default.
The trade-off: the budget is a latency-quality dial, not "more is always better." Running every query through a long chain wastes tokens. Using it well is an engineering judgment.
Why Qwen3 is the workhorse
36T+ pretraining tokens. Family from 0.6B dense to 235B-A22B MoE.
The scale matters for the hybrid thesis:
- The base is strong — broad world knowledge, multilingual, from pretraining alone.
- The non-thinking mode inherits this strength. A fused model is only a good hybrid if non-thinking is genuinely capable, not a degraded reasoner.
Family: 0.6B / 1.7B / 4B / 8B / 14B / 32B dense · 235B-A22B MoE flagship. Covers what teams actually deploy.
R1 vs Qwen3 — complementary references
R1 — distillation reference
Proved reasoning emerges from RL and transfers via SFT.
Study when: building a student by distilling from a teacher.
Qwen3 — hybrid reference
Proved you can fuse modes and control with a budget.
Study when: deploying one model that serves chatbot + reasoner.
Know both. Qwen3's distillation drew on R1's recipe. The field's budget conventions borrow from Qwen3. The strongest teams borrow from both.
Anti-patterns
Defaulting to max budget everywhere. The budget is a latency-quality dial. Running trivial queries through long chains wastes tokens with no gain. Set the default to your workload; raise per query only when warranted.
Treating fusion as "two models glued together." Fusion is one set of weights with two modes. Building a router re-creates the problem fusion solved. Trust the single model; use the budget.
Ignoring non-thinking mode in eval. Evaluate both modes against their respective benchmarks. Stage 4 exists to keep non-thinking strong — test that it did its job.
What you can now do
- Explain why thinking-mode fusion (Stage 3) is the key innovation over a dedicated reasoner.
- Draw the four-stage pipeline and what each stage contributes.
- Predict how a low vs high thinking budget changes latency, tokens, and quality.
- Distinguish Qwen3 from R1: hybrid for production, R1 for distillation.
Next: FTDD-09 — llama.cpp + vLLM (serving the model you just built)