Module 10 — Deployment & Optimization 🚀
The final step. A trained model that only runs in your notebook helps no one — this module is about getting it out into the world, fast.
Congratulations — by this point you can build, train, evaluate, and save real models. But there's a gap between a model that works in your training script and one that serves predictions in a product: a phone app, a web API, an embedded device, or a high-throughput server. Those environments often don't have Python, can't afford your training-time overhead, or demand millisecond latency. Deployment and optimization is the discipline of bridging that gap — packaging your model so it runs anywhere, and making it run fast enough to be useful. It's the least-taught but most career-relevant part of the deep learning workflow, because it's where models finally create value.
This module covers the two halves of that bridge. Exporting frees your model from the Python training loop: tools like TorchScript, torch.export, and ONNX turn your dynamic model into a portable, self-contained artifact that other runtimes and languages can execute. Optimization then makes it efficient: PyTorch 2.x's headline feature, torch.compile, can speed up both training and inference with essentially one line by fusing and compiling your model's operations, while techniques like quantization and half precision shrink models and accelerate inference further. We'll keep this at an overview level — deployment is a deep field — but you'll leave knowing the landscape and the first tools to reach for.
This module is split into three sub-modules — work through them in order.
📚 Sub-Modules
| # | Sub-Module | What you'll learn |
|---|---|---|
| 01 | Exporting Models | Freeing a model from Python with TorchScript, torch.export, and ONNX |
| 02 | torch.compile |
How PyTorch 2.x compiles models for speed, and how to use it with one line |
| 03 | Inference Optimization | Quantization, half precision, and practical considerations for serving |
| 04 | Serving & Next Steps | Serving a model behind an API, a deployment checklist, and where to go from here |
🎯 By the end of this module, you'll be able to...
- Export a trained model into a portable artifact that runs outside Python.
- Apply
torch.compileto speed up training and inference. - Reason about quantization and precision trade-offs for efficient deployment.
- Serve a model behind a simple API and know where to take your PyTorch journey next.
✅ Prerequisites
A trained, saved model (Module 06) and a clear grasp of inference mode — eval() + no_grad() — from Modules 02–03 and 06.
⬅️ Prev module: 09 · Ecosystem: Lightning · 🎓 You've reached the final module — the roadmap is in the root README.