Course Syllabi

"People ask how I cover so much material in a single pass. Simple: I slide over everything one local window at a time, keep my stride small, and trust the hierarchy to assemble the big picture by week thirteen."

A Methodically Scheduled Sliding Window

1. How to Use These Syllabi

All three tracks assume the same semester shape: thirteen teaching weeks, with roughly three contact hours per week split between class meetings and a supervised lab session. The pacing heuristic that makes the schedules work is one chapter of reading per week as the default, two chapters in weeks where one of them is light or serves as a refresher, and the part-closing "Tools of the Trade" chapters (Chapter 8, Chapter 17, Chapter 29, Chapter 38) assigned as reference reading rather than examinable content. Students consistently report that the chapters read fastest when paired with an open interpreter, so every week's lab reuses the code from that week's reading rather than introducing a parallel codebase.

Each weekly row in the tables below lists three things: the chapters to read before the week's meetings, the lab (always derived from the exercises and worked examples inside those chapters), and the deliverable that gets graded. Labs are designed for two to three hours of supervised work plus a comparable amount of homework polish. Deliverables alternate between short notebook submissions and report-style writeups so that students practice both forms of communication.

Hardware expectations differ by track. Track 1 runs entirely on student laptops: NumPy, OpenCV, and scikit-image need no GPU. Track 2 needs modest GPU access (a free hosted notebook tier is sufficient for every lab through week 9; weeks 10 and 11 benefit from a dedicated GPU). Track 3 assumes reliable GPU access from week 4 onward, since training even small VAEs, GANs, and diffusion models on CPU turns afternoon labs into overnight jobs. All three tracks end in a final project, and Section 6 explains how the capstone scales across them.

2. Track 1: Image Processing and Classical Computer Vision Undergraduate

This track covers Parts I and II (Chapter 0 through Chapter 17) in one semester. It is the gateway course: the only prerequisites are basic Python and first-year linear algebra, matching the book's own entry bar. The arc moves from pixels and arrays through filtering, frequency, and geometry into the classical vision canon of features, multi-view geometry, motion, and pre-deep-learning recognition. The closing week on Chapter 16 is deliberate: students leave understanding not just how classical pipelines work but why they plateaued, which sets up a sequel course built on Track 2. Table C.1 gives the full schedule.

3. Track 2: Deep Learning for Computer Vision Upper-Level

This track covers Part III (Chapter 18 through Chapter 29) with targeted refreshers from Parts I and II in week 1. It suits students who have either taken Track 1 or absorbed equivalent material elsewhere; the only hard prerequisites are comfort with NumPy arrays (Chapter 0) and the convolution vocabulary of Chapter 3, both of which the first week refreshes explicitly. The semester builds one competence per week: training loops, CNNs, architectures, recipes, transformers, detection, segmentation, self-supervision, video, 3D, and deployment, in that order, so each lab strictly reuses the machinery of the previous ones. Table C.2 gives the schedule.

Two design choices in Table C.2 deserve a note. First, the midterm lands in week 8 rather than week 7 so that segmentation, the most technically dense chapter of the first half, is examined while detection is still fresh. Second, week 12 deliberately assigns no new examinable reading: in every trial run of this track, the projects that received a dedicated studio week before presentations were the ones that shipped working evaluations instead of half-finished training scripts.

4. Track 3: Generative Vision Models Graduate

This track covers Part IV (Chapter 30 through Chapter 38) for graduate students who may arrive from heterogeneous backgrounds: some from a vision course, some from NLP, some from outside machine learning entirely. The first two weeks are therefore a compressed prerequisite sprint through the parts of Part III that Part IV leans on: training mechanics (Chapter 18, Chapter 19), recipes (Chapter 21), transformers (Chapter 22), and CLIP-style representation learning (Chapter 25), since text conditioning in Chapter 34 is unintelligible without it. Diffusion gets two full weeks; it is the center of gravity of the modern generative stack and the chapter students most need to internalize rather than skim. As befits a graduate course, three paper-reading responses tie the book's material to the primary literature. Table C.3 gives the schedule.

5. Track 4: Generative AI, From Variational Autoencoders to World Models Graduate

This track is the syllabus for "Generative AI: From Variational Autoencoders to World Models", a thirteen-week graduate course taught by Dr. Alexander Apartsin at the Holon Institute of Technology (HIT). Where Track 3 surveys the breadth of Part IV, this track takes a probability-first spine: it builds the field from the latent-variable view forward, deriving the evidence lower bound, score matching, the diffusion variational bound, and flow-matching objectives in sequence, then carries those tools all the way into world models, the generative simulators that learn to roll out an environment's dynamics. It draws on the chapters that were recently expanded with self-contained derivations, PyTorch labs, and graduate-level exercises, so the book can serve as the course's primary text. Table C.5 maps the thirteen weeks to the exact sections that support them.

The course has historically been taught against two excellent external references: Simon Prince's Understanding Deep Learning and Kevin Murphy's Probabilistic Machine Learning: Advanced Topics. With the expanded derivations now in place, this book provides each result from first principles, so it can stand as the primary text with Prince and Murphy as supplementary reading rather than required ones: Prince for additional geometric intuition on the diffusion and flow material, Murphy for the broader probabilistic-modeling context around variational inference and energy-based models.

Each section listed in Table C.5 now contains from-scratch derivations, runnable PyTorch labs, and end-of-section exercises pitched at the level of graduate assignments, so an instructor can build problem sets and lab sheets directly from the assigned reading without authoring parallel material.

The course is organized around seven learning outcomes. Table C.6 maps each outcome to the sections where the book develops it, so the assessment plan can be tied directly to the reading rather than asserted independently of it.

6. Track 5: Building Vision AI with Foundation and Generative Models Undergraduate Graduate

This track is a thirteen-week, code-first survey of modern vision AI that runs across engineering, digital-health, and computer-science cohorts and can be taught to undergraduate or graduate students alike. Where the earlier tracks march through one part of the book in order, this one cuts a fast diagonal: it opens with the image-processing fundamentals every practitioner needs, climbs straight into CNNs, detection, and segmentation, then spends its second half on the foundation and generative models (ViT and DINOv2, CLIP and BLIP-2, GANs, Stable Diffusion, ControlNet) that define the current toolset. It is built around production libraries (PyTorch, OpenCV, Hugging Face Diffusers and Transformers, Stable Diffusion, YOLO, SAM, and CLIP) and a project that runs the length of the course. Because the book is self-contained, every topic first develops the concept from scratch and then shows the library one-liner that does it in practice, so this book can be the course's sole textbook with no external reference required. Table C.7 maps the thirteen weeks to the exact sections that support them.

7. Grading Schemes That Match the Material

A grading scheme is a statement about what the course values, and the three tracks value different things. Track 1 is skills-dense and lab-driven, so labs dominate. Track 2 balances labs against a substantial project, because training and evaluating a real model is the competence the course exists to certify. Track 3 is project-heavy with a literature component, as graduate courses should be. Track 4 follows the same graduate grading philosophy as Track 3, with a project and presentations carrying most of the weight. Table C.4 summarizes the recommended weights for the three lab-driven tracks; each row sums to 100 percent.

Three policies have proven worth adopting alongside the weights in Table C.4. First, drop each student's single lowest lab score ("best n minus 1"); it removes the bad-week incentive to submit plagiarized work. Second, split the project grade explicitly across milestones (Section 7) rather than awarding it all at the end, so that procrastination is priced in early and cheaply. Third, publish the weights as executable code on day one. The snippet below is the entire policy for Track 2, and handing it to students as code removes a whole category of end-of-semester disputes.

WEIGHTS = {"labs": 0.35, "quizzes": 0.10, "midterm": 0.15, "project": 0.40}
scores  = {"labs": 90.0, "quizzes": 80.0, "midterm": 80.0, "project": 88.0}

assert abs(sum(WEIGHTS.values()) - 1.0) < 1e-9  # weights must sum to one
final = sum(WEIGHTS[k] * scores[k] for k in WEIGHTS)
print(f"Final grade: {final:.1f}")              # Final grade: 86.7

8. Project Milestones and the Capstone as Final Project

All three tracks share the same four-milestone project arc, visible in the deliverable columns of Tables C.1 to C.3: a one-page proposal around week 5 or 6, a checkpoint with data and a baseline around week 7 to 9, a working-prototype checkpoint around week 10 to 12, and a final demonstration with a written report in week 13. The milestone weights within the project grade are roughly 10 percent proposal, 20 percent per checkpoint, and 50 percent final deliverable. The grading question at every checkpoint is deliberately narrow: not "is this impressive?" but "does the pipeline run end to end on real data today?" A project that runs badly at checkpoint 1 nearly always finishes; a project that promises to run brilliantly later often does not.

The natural final project for any of these tracks is the book's capstone: an end-to-end vision system spanning classical preprocessing and geometry, a fine-tuned detector or segmenter, a generative synthetic-data engine, and honest evaluation with deployment. The full capstone is intentionally larger than one semester's project slot, so each track adopts the slice that matches its material:

• Track 1 assigns the classical slice: the acquisition, preprocessing, calibration, and geometric stages of the capstone, ending in a measured, reproducible classical pipeline (for example a measurement or inspection system built entirely from Parts I and II machinery).
• Track 2 assigns the learned-perception slice: fine-tune the capstone's detector or segmenter on a custom dataset, evaluate it honestly with the metrics of Chapter 23 and Chapter 24, and ship it through the export and benchmarking workflow of Chapter 28.
• Track 3 assigns the generative slice: build the synthetic-data engine of Chapter 37 around a controllable generator from Chapter 35, then demonstrate with a rigorous evaluation harness whether the synthetic data improves a downstream perception model.

For a two-semester sequence (Track 1 followed by Track 2, or Track 2 followed by Track 3), the full capstone works as a year-long project: the first semester's final deliverable becomes the second semester's checkpoint 1, and students experience the rare pedagogical pleasure of building on their own prior work instead of starting over.

9. Adapting the Tracks

The thirteen-week grid compresses or stretches without redesign. For a ten-week quarter, remove the quiz weeks' second meetings, fold the two Tools-of-the-Trade reference readings into adjacent weeks, and cut one chapter per track: Track 1 drops Chapter 14 to survey depth, Track 2 drops Chapter 26, and Track 3 compresses the prerequisite sprint into a single week with a mandatory pre-quarter reading assignment. For a fifteen-week semester, give the recovered weeks to Chapter 13 and project studio time in Track 1, to Chapter 25 and deployment in Track 2, and to a second week of Chapter 34 in Track 3.

Self-study learners can run any track solo by treating the lab column as the weekly contract and the deliverable column as a public commitment (a blog post, a repository tag, a short demo video). The reading-path guides in Appendix D complement these schedules for readers who want a goal-directed path through the book without the semester structure, and the dataset catalog in Appendix B supplies drop-in replacements for any lab dataset that does not fit a reader's domain or license constraints.