uvadlc_notebooks: A Teaching Repository That Runs on a Laptop CPU
Repository of Jupyter notebook tutorials for teaching the Deep Learning Course at the University of Amsterdam (MSc AI), Fall 2023
At a glance
- What is it?
- The University of Amsterdam's deep learning tutorials pair lecture theory with executable PyTorch and JAX+Flax notebooks, pretrained checkpoints under 1GB, and a conda environment split by CPU and GPU. The design choice that matters is that every notebook is written to run without a GPU, which is also the constraint that limits what the repository can teach you.
- Who is it for?
- Adopt this if you are learning deep learning implementation from lectures, teaching a course, or comparing a PyTorch model against its JAX+Flax translation line by line. Skip it if you need production training recipes at scale, since the notebooks are built to execute on common laptops without a GPU and the README directs large training to the Snellius cluster as a separate manual step.
- Can I use it commercially?
- Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
- Is it still maintained?
- Yes. The repository last received commits 107 days ago.
- What is it written in?
- Mainly Jupyter Notebook, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on September 15, 2026, and from our analysis. They are not legal advice.
DEEP OPEN-SOURCE ANALYSIS
The gap between a lecture slide and a working implementation
A deep learning lecture can explain multi-head attention on a whiteboard in twenty minutes. Turning that into code that runs, with the tensor shapes correct and the loss converging, is a separate skill that courses often leave to the student. This repository exists to close that gap. The README describes the notebooks as designed to help you understand the theory from the lectures by seeing corresponding implementations, and the topics list runs from optimization and initialization through transformers, graph neural networks, deep energy models, autoencoders, adversarial attacks, normalizing flows, autoregressive image modeling, vision transformers, meta learning and SimCLR. The audience is narrow and stated: MSc AI students at the University of Amsterdam, plus anyone else working through the same material. The notebooks are not graded assignments, but the README says the content is relevant for the graded assignment and exam, which tells you the intended depth. This is teaching material with a defined syllabus, not a general-purpose model zoo.
Two framework tracks over the same tutorial content
The structural decision that distinguishes this repository is that the tutorials exist twice. The primary track teaches PyTorch and PyTorch Lightning, and the README states that the notebooks are also provided as one-to-one translations to JAX+Flax as an alternative framework. One-to-one is the operative phrase. The same tutorial, the same model, expressed in two ecosystems, which makes the repository usable as a comparison artifact rather than a single-framework course. The tutorials have additionally been integrated as official tutorials of PyTorch Lightning, and the README points to the PyTorch Lightning documentation as another place to view them. For a reader deciding whether to adopt this, the dual track is the strongest argument: you can read the attention implementation in PyTorch Lightning and then read the Flax version of the same computation, and the differences you notice are framework differences rather than pedagogical ones. The cost is maintenance surface. Two implementations of every notebook have to track upstream API changes in two fast-moving libraries.
Pretrained checkpoints and a sub-1GB disk budget
The README makes a concrete resource claim: the notebooks are designed so that you can execute them on common laptops without the necessity of a GPU, and the required disk space for the pretrained models and datasets is less than 1GB. The mechanism is that pretrained models are downloaded automatically when a notebook runs, or can be fetched manually from a linked Google Drive folder. That is the detail that makes local execution plausible. Training a vision transformer from scratch on a laptop is not, but loading a checkpoint and running the analysis cells is. The README's own guidance reinforces this split: it suggests the Snellius cluster only if you really want to train a new model, and says to use the local or Colab options to go through the discussion and analysis of the models. So the repository is honest about which parts are interactive and which parts are demonstrations of someone else's training run. If your goal is to reproduce training curves rather than inspect a trained model, the default path will not get you there.
Getting a notebook to execute: conda, Colab, or nbconvert
Three execution paths are documented. Locally, the notebooks live under docs/tutorial_notebooks in the repository, and the README says a conda environment is provided in the same repository with CPU and GPU versions, chosen depending on your system. Colab is the second path: each notebook on the documentation site carries a badge linking to Colab, and the README instructs you to enable GPU support via Runtime -> Change runtime type. The README notes that each notebook runs independently and does not require connecting Google Drive, but warns that changes may be lost when the session closes unless you save locally or copy the notebook to Drive first. The third path is the Snellius cluster, and it comes with two specific pieces of configuration advice worth quoting because they are the kind of thing you only learn after a failed job. Disable tqdm output, otherwise your slurm output file might overflow and be several MB large; in PyTorch Lightning this is done by setting progress_bar_refresh_rate=0 in the trainer. And comment out matplotlib plotting statements, or change plt.show() to plt.savefig(...). The README also notes that Snellius may not allow a student account to run Jupyter notebooks directly on the gpu_shared partition, so the workflow is to convert first with jupyter nbconvert --to script ...ipynb and then submit the script as a job.
The CPU-first promise is also the ceiling
Designing for laptop execution shapes what the notebooks can demonstrate. If a tutorial must finish on a CPU with under 1GB of assets, the models are necessarily small and the datasets are necessarily toy or subsetted. That is a reasonable trade for teaching the mechanics of an architecture, and a poor fit for anyone trying to learn about the engineering problems that appear at scale: distributed training, gradient accumulation across many devices, mixed precision, dataloader throughput on large corpora. The README's cluster section is a pointer, not a tutorial on those topics, and it explicitly frames Snellius as the place to go only when you want to train a new model. A second limitation is version drift. The repository is described as being kept up to date for the Fall 2024 course edition, and the notebooks depend on PyTorch, PyTorch Lightning, JAX, Flax and Optax. All five move. A notebook that ran cleanly in one semester can break on a later library release, and the conda environment files are the mechanism meant to prevent that, which means the environment file is the artifact to trust rather than your globally installed packages. There are no releases in the repository, so there is no tagged version to pin against; the default branch is master.
Compared with a maintained library tutorial set
The obvious alternative is the official tutorial collections from the frameworks themselves, such as the PyTorch tutorials or the Flax documentation examples. The difference in approach is one of coherence versus coverage. Framework tutorials are written per feature, maintained by the library team, and updated as the API changes, but they are not sequenced as a course. They assume you arrived looking for a specific capability. This repository is sequenced: the README lists tutorials in an order that maps onto lectures, and the material is written to be presented in the first hour of a group tutorial session, with recorded sessions on a linked YouTube playlist. The trade is that the framework collections will usually be more current on any single API, while this repository offers a path through the material. If you want to understand why a residual connection helps, follow the sequence here. If you want the current recommended way to write a custom training loop in the latest Lightning release, the framework's own documentation is the better source, because it moves with the release and this repository moves with the course calendar.
Licence, feedback channels and what upkeep actually involves
The repository is MIT licensed, which permits reuse, modification and redistribution with the licence and copyright notice retained. That is permissive enough for teaching material you want to adapt into your own course, though the citation the README requests is a bibtex entry for Lippe 2024 rather than a licence term, so attribution is a courtesy here and not an obligation under MIT. If you build on these notebooks, cite them anyway; it costs one entry. On maintenance, the README is candid that this is the first time the tutorials were presented in this form and that small bugs and issues are expected, with feedback routed through a Google Form or by email. There is no release process, so upgrades mean pulling from master and hoping the conda environment still resolves. The practical implication for an adopter is that you should vendor the environment file alongside the notebooks rather than relying on the live repository, because the only versioning signal available is the commit you cloned and the course edition named in the README.
Editorial conclusion
Adopt this if you are learning deep learning implementation from lectures, teaching a course, or comparing a PyTorch model against its JAX+Flax translation line by line. Skip it if you need production training recipes at scale, since the notebooks are built to execute on common laptops without a GPU and the README directs large training to the Snellius cluster as a separate manual step. Before committing, open the conda environment file for your platform, confirm the CPU or GPU variant matches your machine, and check that the notebook you care about appears in the tutorial list, because the numbering runs to Tutorial 17 with gaps and the README states that seven of the tutorials are discussed in the course.
Community notes