roatienza/Deep-Learning-Experiments: A Versioned Course in Notebook Form

What the repository is, and the problem it addresses

Most deep learning material forces a choice. A textbook explains the mathematics but leaves you without code. A tutorial repository gives you code but no derivation, so you copy a training loop without knowing why the loss is shaped that way. This repository tries to hold both ends: for each topic the README lists a PDF note and, where one exists, a notebook. The theory table runs from Overview and Supervised Learning through MLP, CNN, RNN and Transformer to Mamba, then Optimization, Regularization, Detection, Segmentation, Autoencoder, VAE, GAN, Normalizing Flows, Flow Matching and Diffusion, LLMs and Agents. The practice table covers Development Environment, Python, Numpy, Einsum, Einops, PyTorch, Gradio, Efficiency and PyTorch Lightning. The intended reader is someone who wants to read the derivation and then run the corresponding cell, whether in a course or alone. It is not a library and it is not a benchmark suite. It is a set of teaching artifacts with executable companions.

How the material is organised: PDFs, notebooks and year folders

The structure is flat and legible. The README is the index: two tables, one for theory and one for practice, each with columns for Topic, Note, Video and Code. The Note column points at Google Drive PDF links. The Code column points at notebooks inside the repository, and those paths carry the version. The MLP, CNN, RNN and Transformer notebooks live under versions/2023; the Mamba notebooks under versions/2024; the Normalizing Flow and Diffusion notebooks under versions/2025. The README also labels the whole set as the 2026 version, revised and expanded, while the code paths still reference 2023, 2024 and 2025. That mismatch is the repository's way of versioning: rather than tagging releases, it keeps old material in place and adds new work in a new folder. The single release listed, models (ver-0.01) from April 2022, predates most of what the README now indexes, so the release page is not a reliable map of the current content. The Video column is empty throughout, which means the videos named in the repository description are not linked from the README tables.

The notebooks themselves: small demos on MNIST and TinyStories

The code column shows a consistent pattern of small, self-contained demos. The vision notebooks are named for the dataset they use: mlp_mnist.ipynb, cnn_mnist.ipynb, rnn_mnist.ipynb, transformer_mnist.ipynb, vae_mnist.ipynb, cvae_mnist.ipynb, dcgan_mnist.ipynb, cgan_mnist.ipynb, mamba_simple_mnist.ipynb and mamba2_mnist.ipynb. The autoencoder folder offers two variants, a plain and denoising autoencoder in one notebook and a colorization autoencoder in another. The generative work extends to normalizing_flow_mnist.ipynb and, under versions/2025/diffusion/demo, diffusion.ipynb and flow_match.ipynb. The language modelling track is the exception to the MNIST pattern: it uses TinyStories, with a from-scratch training script (gpt2_tinystories_fr_scratch.py) and a validation notebook, plus a fine-tuning script (gpt2_tinystories.py) and its validation notebook. The segmentation entry points at a sam2_demo.ipynb under versions/2024/segmentation/python. The toolkit notebooks cover einsum, einops, Gradio (including a chat demo) and PyTorch Lightning. The design intent is visible in the filenames: each notebook is a minimal demonstration of one idea on a dataset small enough to run, not a reproduction of a paper's headline result.

Running it: there is no install step in the README

This is the part to be honest about. The README gives no installation command, no requirements file, no environment specification and no pinned dependency versions. What it does give is a Development Environment PDF in the practice table, which is presumably where the setup instructions live, and a PyTorch PDF. So the practical path is: clone the repository, open the notebook for the topic you want, and read the first cell before running anything. That first cell is where the real dependency list is, since a Jupyter notebook imports what it needs. Expect differences between folders. A versions/2023 notebook was written against whatever PyTorch was current then; the Mamba notebooks under versions/2024 and the diffusion notebooks under versions/2025 will pull in different packages again. The LLM scripts add a further step, because TinyStories is a dataset that has to be obtained before training, and the fine-tuning script implies a pretrained checkpoint that the README does not link. Treat each notebook as its own environment problem rather than assuming one environment covers the repository.

Where the format works against you

Three limitations stand out from the material alone. First, the year-folder scheme means duplicated concepts rather than a single maintained implementation. If you want the current CNN demo you have to know it is the one under versions/2023, and if a 2026 revision adds a new version, the old path stays valid but stale. Second, the notes are hosted on Google Drive as PDFs. That makes the repository dependent on an external service for half its content, and it means the notes cannot be diffed, searched or corrected through the same pull request flow as the notebooks. Third, the demo scale is deliberately small. MNIST and TinyStories are teaching datasets. Nothing in the README suggests these notebooks are meant to produce competitive results or to be adapted directly into production training runs. If you need a maintained implementation of, say, Mamba or flow matching, this repository gives you a readable reference to learn from, not a dependency to import. The absence of any test suite or CI configuration in the described layout reinforces that: there is nothing that would catch a notebook breaking after a library upgrade.

How it compares with a framework and with a single-paper repository

The natural alternative depends on what you actually want. If you want a maintained, installable implementation of these architectures, PyTorch Lightning is the closer comparison, and the repository acknowledges it by including a Lightning notebook in the toolkit table. The difference in approach is stark: Lightning is a package you install and version, with an API that is expected to keep working, whereas this repository is a set of files you read and run, with no compatibility promise across folders. If you want a paper implementation to reproduce, the alternative is the official repository for that paper, which typically ships a training script, a config and reported numbers. This repository instead gives you a lecture note plus a reduced demo, which is better for understanding and worse for reproducing. The SAM2 entry is a good illustration: the README links a demo notebook, not a training pipeline, so it teaches you how to call the model rather than how it was built. The repository's niche is the space between a course and a codebase, and it should be judged on that basis.

Maintenance, licence and what the MIT terms mean here

The licence is MIT, which is permissive and places few restrictions on reuse of the code. Two caveats belong with that. The notebooks depend on third-party packages, and the MIT licence on this repository does not extend to those dependencies or to any pretrained checkpoints the notebooks download; those carry their own terms, which the README does not enumerate. The PDF notes are hosted externally, so their availability is not governed by the repository's licence in any obvious way. On maintenance, the last push is dated 2026-08-15 and the README advertises a 2026 revision, so the project is active, but the single listed release is from 2022 and the code paths are year-stamped. That combination means upgrades arrive as new folders rather than as versioned releases, and there is no changelog in the supplied material to tell you what changed between them. Budget for reading each notebook's imports and for pinning your own environment, because the repository will not do it for you.

Editorial conclusion

Adopt it if you are teaching or self-studying deep learning and want a notebook to run beside each lecture PDF, and if you are willing to read the import cells because nothing tells you which PyTorch or Transformers version each notebook expects. Skip it if you need a pip-installable library, a stable API, or a maintained baseline to build a product on. Before relying on any notebook, open the first cell, note the imports and any download or checkpoint step, and check whether the file sits under versions/2023, versions/2024 or versions/2025, because that folder is the only version marker the repository provides.

Official sources

1. Issues
2. License: MIT
3. README
4. Releases
5. roatienza/Deep-Learning-Experiments on GitHub