Recap and final exam

Ten modules to go from an anonymous 7 to 8 billion parameter model on Hugging Face to a customer-support assistant running at under a millisecond of cost per request. Here is the course condensed, then the threads running through it, then the exam.

The course at a glance

Module	What to retain
1. What scaling changes	In-context learning is a real phenomenon but not learning; emergent abilities are partly a metric artifact; the open-proprietary split is stable, choose on data control and cost
2. Pretraining and scaling laws	Filtering budget rivals training budget; deduplication protects generalisation; Chinchilla $C \approx 6\,N\,D$, but inference cost pushes past the ratio; check language share
3. Instruction tuning	Chat template is silent when wrong; quality trumps quantity (LIMA); LoRA fits 7B fine-tuning on one consumer GPU
4. Alignment: RLHF and DPO	Preference pairs beat gold answers per hour of review; DPO replaces PPO for most projects; alignment does not fix hallucinations
5. Decoding	Top-p 0.9 as default; repetition penalty breaks structured output; $T=0$ removes one source of randomness, not all
6. Context and memory	Attention is quadratic in prefill; lost-in-the-middle is real; RAG replaces "bigger window" with targeted retrieval
7. Hallucinations	Grounding plus abstention licence is the only structural fix; citations turn unsupported claims into detectable objects; fine-tuning does not repair pretraining compression
8. Quantization and serving	AWQ or GPTQ 4-bit for GPU, GGUF for CPU; vLLM with continuous batching; re-evaluate quantized models on your own set
9. Evaluation	MMLU is contaminated; Arena has style bias; LLM-as-a-judge has position bias; your 300 real questions are the real benchmark
10. Costs and architecture	API predictable, self-hosting cheaper at load; router with a small model saves 20 to 40 %; prompt cache on shared prefix is the biggest quick win

The threads running through the course

Alignment aligns style, not knowledge. A well-aligned model states a made-up policy in the same polite voice it uses for a correct one. Instruction tuning (module 3) and preference training (module 4) teach the model how to answer. What it knows was decided in pretraining (module 2) and cannot be repaired downstream. This is why grounding (module 7), retrieval (module 6, and course 18) and evaluation (module 9) are not optional add-ons: they are what compensates for the fact that the training pipeline gives you a fluent generator, not a fact source.

Public benchmarks are noisy at the top and contaminated everywhere. A one-point gap on MMLU or a fifty-Elo gap on Arena is not a decision. Modules 8, 9 and 10 all converge on the same rule: build a 200 to 500 question evaluation set from your own users, categorise by intent, freeze it, and use it as the ground truth for every model swap. Public scores are for shortlisting, not choosing.

Cost is decided by the boring things. The quantization format (module 8), the routing between small and large models (module 10), the prompt cache on the shared system prefix (module 10) each move the bill more than any headline model improvement. A 4-bit AWQ model on vLLM with a router and a warm cache runs at a third of the cost of a naive full-precision deployment, with quality drops that most business users do not notice.

The pipeline is now standard, the judgement is not. Every serious LLM project in 2026 uses the same pieces: open base, LoRA SFT, DPO, RAG, vLLM. The pieces are not the differentiator. The differentiator is knowing what to fine-tune on (module 3), which preferences to collect (module 4), what to retrieve (module 6), how to catch hallucinations (module 7), and how to measure (module 9). Building the pipeline is a week. Building the judgement is the rest of the project.

The final exam

The exam has 40 questions covering all ten modules: the shape of in-context learning and the emergence debate, the Chinchilla law and its inference-cost twist, the base-versus-instruct distinction and the chat template trap, the RLHF-versus-DPO comparison, decoding parameter effects, context-window costs and lost-in-the-middle, hallucination causes and remedies, quantization formats and vLLM serving, benchmark contamination and LLM-as-a-judge biases, cost-per-request arithmetic and router architectures.

Several questions present situations to diagnose: a support assistant that invents a refund policy in the same tone as a correct one, quality that drops with no error after a model swap, a repetition penalty that breaks JSON output, a 128k-context prompt that costs 50x more than a 8k one, an MMLU score two points above yours from a model that just memorised the test set, a self-hosted deployment where cost is dominated by the four hours of idle time between traffic peaks. Judgement is what gets assessed, not memorised API signatures.

On success, your certificate of completion is issued immediately; its number can be verified by any third party on the platform.

Before you start

Re-read the table above and, for each row, ask yourself "what symptom would I see if I got this wrong?". If you can explain why fine-tuning does not fix hallucinations, why $T=0$ does not guarantee reproducibility, why a router saves money without hurting quality on the routed subset, and why your own 300 questions matter more than any public leaderboard, you are ready. Good luck!

Final exam

Ready to validate this course?

40 questions drawn at random from the course bank · passing score 70% · verifiable PDF certificate issued immediately on success.

Start the exam

You need to be signed in to your InSkillML account with an active subscription. You can also start the exam from My courses.