Course Organization
How this course is put together, and how to read it
This page is the reading version of the opening organizational session. It covers the same ground as the deck, at the pace of a document rather than a lecture: how the course is structured, how sessions are named, what each unit does, and how you are assessed. Everything here is stable across the term — the one thing deliberately kept elsewhere is the dated schedule.
One course, two programmes
Flow-Based Generative Models: From Normalizing Flows to Flow Matching is a graduate-level course offered jointly to two programmes:
| Programme | Rhythm | What it includes |
|---|---|---|
| PGMAT | semester | deep-learning bootcamp (U0) + main course |
| PESC | trimester | main course, joining at the first joint unit |
There are two 90-minute sessions per week, alternating: a theory session (T), then a lab session (L). Theory sessions carry live proofs; labs are scaffolded PyTorch notebooks. Across the term you will also meet problem sets, a student seminar, and a final project.
If you are a PESC student, the bootcamp is not something you have missed. Its role is played for you by a self-study packet released at enrolment, and the course carries a standing promise described under U1 below: no joint session ever requires having attended U0.
Course motivation
Ten years of flow-based generative modelling converge on a single simulation-free framework — Flow Matching. Diffusion models are a family of special choices inside it.
The course walks that convergence rather than announcing it:
- Discrete flows (U1). Exact likelihood by change of variables; the price is architectural.
- Continuous time (U2). Neural ODEs lift the constraints — but training requires simulating the model.
- Flow Matching (U3). Train the vector field without simulating it. Diffusion enters as detours from this spine, not as a separate unit.
- Frontier (U6). Student seminars: manifolds, discrete data, graphs.
Reading the map
Every session has an ID
A session is named Unit.Kind# — unit, kind of session, number within the unit. Example: U3.T2 is the second theory session of unit U3.
| Kind | Meaning | Typical slot |
|---|---|---|
T |
theory | first slot of the week |
L |
lab | second slot of the week |
S |
seminar | (seminar phase) |
W |
workshop | (project phase) |
A |
async document | no live slot |
IDs are stable names. Everything in the course — these notes, the slides, the problem sets, the pre-planning documents — refers to a session by its ID, never by its date or its position in the week. Dates live in a separate calendar layer, which is what lets the same material be taught again on different days without a single cross-reference going stale.
The unit map
| Unit | Name | Sessions | Audience |
|---|---|---|---|
| U0 | Deep Learning Bootcamp | 5 T + 5 L | PGMAT only |
| UP | Probability for Generative Models | 1 A + 1 T | joint |
| U1 | Discrete Normalizing Flows | 2 T + 2 L | joint |
| U2 | Neural ODEs and CNFs | 2 T + 2 L | joint |
| U3 | Flow Matching (+ detours) | 4 T + 3 L | joint |
| U5 | Scaling and Ecosystem | 1 T | joint |
| U6 | Student Seminars | 4–5 S | joint |
| U7 | Project and Synthesis | 2 W | joint |
Small print worth reading once: there is no U4. The numbering jumps from U3 to U5. This is a deliberate ruling rather than an oversight — session IDs are permanent names, so units are never renumbered once they exist.
The units
U0 — Deep Learning Bootcamp (PGMAT only)
U0.T1–T5 and U0.L1–L5 cover supervised learning and autodiff; making training work; latent variables and the VAE; architectures for the road (U-Net, attention, time embeddings) and evaluation; and numerical ODE solvers.
The bootcamp exists to build the artifacts the whole course reuses: the training-loop template, the evaluation harness, the U-Net skeleton, and the solver notes. Later units treat these as given code with a contract-level description, which is precisely what makes the parity promise workable.
PS0 closes the bootcamp. It is implementation-only, graded on correctness and reproducibility.
PESC equivalent: a CPU-friendly self-study packet (ODE solver notes, a JAX primer, and pointers into UP.A), released at enrolment. PS1 draws on it.
UP — Probability for Generative Models
UP.A is an async, self-contained primer: densities and conditioning, Gaussian algebra, divergences, sampling. Its embedded exercises are graded — they are PS1.1.
UP.T1 is the first live joint session, and it proves the Lemma of the course: conditional expectation as an \(L^2\) projection, proved once in full. The Lemma returns three times in U3, and the session ends by announcing exactly where. Watch for that slide again.
U1 — Discrete Normalizing Flows
U1.T1 covers change of variables and coupling flows; U1.L1 puts coupling flows on 2D toy problems (the first joint lab); U1.T2 surveys the zoo and its limits; U1.L2 moves flows to images.
No joint session requires having attended U0. Bootcamp artifacts arrive as given code with a contract-level description.
Problem sets start carrying proof-completions here: results stated in lecture, finished by you.
U2 — Neural ODEs and CNFs
U2.T1 covers Neural ODEs and the adjoint method; U2.L1 puts solvers and adjoints into practice; U2.T2 covers continuous normalizing flows and FFJORD; U2.L2 is an at-home lab running FFJORD in 2D, where the cost becomes something you feel rather than something you are told about.
The unit ends on the course’s central cliffhanger: can we train the vector field without simulating the ODE?
U3 — Flow Matching, with diffusion detours
U3.T1–T4 build Flow Matching in full; U3.L1–L3 implement it — conditional flow matching from scratch, diffusion as a special case of your own code, then couplings and guidance.
Diffusion is never a separate unit. It enters through three mapped detours (D1–D3) attached to the Flow Matching spine.
The Rosetta Stone is a living two-column handout translating the Flow Matching dialect and the diffusion dialect. It grows with each U3 session and ships complete with the seminar kit — it is what lets you read the literature in either dialect.
U5 and U7 — Scaling; Project
U5.T1 is one session on scale: DiT, latent flow matching, few-step generation, and the surrounding ecosystem (Stable Diffusion 3, Flux, Meta’s flow-matching codebase). It feeds directly into project scoping.
U7.W1 is the project workshop: bring a one-page sketch, get structured peer feedback, and freeze the plan. Scope may shrink afterwards, never grow.
U7.W2 is synthesis: the course arc retold backwards, and the handoff to the frontier.
The final project either extends a course lab or applies Flow Matching to your own research data. It is graded on correctness, scoping, and honesty — never on how good the results look.
U6 — Student Seminars
Three tracks: A manifolds, B discrete data, C graphs, with two talks per session. Each talk is 30–35 minutes plus 10 minutes of discussion, opened by an assigned discussant with two prepared questions.
Two requirements are worth knowing in advance, because they shape how you prepare:
- Every talk’s second slide is a translation slide, mapping the paper’s notation onto course canon. Translating is the learning objective.
- Every talk ships a reproduction notebook at toy scale, with an honest “what is NOT reproduced” statement. A classmate should be able to run it end to end in under 30 minutes.
Logistics
Assessment (weights indicative)
| Item | Weight | Covers |
|---|---|---|
| PS0 (PGMAT only) | folded into PGMAT grade | bootcamp implementation |
| PS1 | ~12% | UP + U1 |
| PS2 | ~13% | U2 + early U3 |
| PS3 | ~13% | late U3 |
| Seminar + notebook | ~27% | U6: talk, discussant, notebook |
| Final project | ~35% | plan + report + code |
Implementation work is graded on correctness and reproducibility — seeded runs, logged configurations — never on sample quality or benchmark glory.
Materials and tools
Every session comes with lecture notes to read, slides to follow in class, and a printable PDF of the deck, all on the course site.
Labs use PyTorch as the primary framework, with JAX for illustrative moments; experiment logging goes through MLflow; everything is seeded and configured for exact reruns.
The house rule: every core object is implemented from scratch at least once. Libraries (Zuko, TorchCFM, torchdiffeq, and the rest) are cross-checks, never substitutes.
Standing references are Lipman et al., Flow Matching Guide and Code, and Bishop & Bishop, Deep Learning; the full library lives in the course bibliography.
Async weeks
A few weeks run async by design. This is a format, not an improvisation, and it comes with guarantees:
- a scaffolded notebook with “you should see” checkpoints, plus a checkpoint package (weights, configuration, seed) so nobody is blocked by compute;
- a shared Q&A thread, with blocking questions answered in under 24 hours;
- when a proof matters that week, a recorded proof clinic replaces the live derivation.
The rule behind it: absence weeks are converted, not lost.
Calendar
The course opens for PGMAT on Aug 18 with U0.T1.
For PESC, the trimester window opens Sep 21. That week is the async onboarding week: the self-study packet, UP.A, and PS1 are released, along with a recorded welcome lecture. The first live joint session is Sep 29 — UP.T1, the Lemma.
The last session is Dec 17 (U7.W2, synthesis), with the final project report due around Dec 19. No holiday this term falls on a class day, so no sessions are lost to holidays.
Planned absences
Three conference windows overlap the term. The schedule was designed around them rather than patched afterwards:
| Window | Dates | What happens instead |
|---|---|---|
| CBCTQ | Sep 21–25 | the async onboarding week above |
| CILAMCE | Oct 26–29 | async lab week + recorded proof clinic |
| Conference #3 | TBD | two slots held in reserve |
No content disappears in these windows. Labs go async, seminars run with a delegate chair, and theory moves only as a last resort — never out of order.