dataflowr/notebooks: A Course Repository, Not a Library

What the dataflowr repository actually contains

This is course material, not a software project. The README describes it as code and notebooks for the deep learning course dataflowr, and the schedule it lists is the one followed at ecole polytechnique in 2023. The repository is written almost entirely in Jupyter Notebook, with at least one Julia notebook referenced (Module2/AD_with_dual_numbers_Julia.ipynb). Each session in the README maps to one or more website modules, and each module maps to notebooks under directories such as Module5, Module8, Module11, Module16 and Module17.

The audience is someone learning deep learning with PyTorch who wants to type the code rather than read it. The README's own framing supports that: one of the things to remember from the first session is that you do not need to understand everything to run a deep learning model, with the stated goal of the course being to come back to each step and understand it. That is a pedagogical sequence, and the repository is the exercise half of it. If you want a maintained library that hides these steps, this is the opposite of what you want.

The module structure and what each session covers

The README lays out seven sessions. Session one is finetuning VGG on dogs and cats. Session two covers PyTorch tensors and automatic differentiation, plus the start of Homework 1, an MLP from scratch. Session three bundles loss functions for classification, optimization, stacking layers, convolutional networks and dropout, with a CIFAR10 overfitting notebook at Module5/Stacking_layers_MLP_CIFAR10.ipynb. Session four covers dataloading, embedding layers, collaborative filtering, word2vec, batchnorm and resnets, plus the start of Homework 2 on class activation maps and adversarial examples. Session five covers autoencoders, GANs and siamese networks, with Homework 3 on VAEs. Session six is recurrent networks. Session seven is attention and transformers, including a correction to the PyTorch tutorial on attention in seq2seq.

The density is uneven. Session three lists five modules, session seven lists one. That is a scheduling artifact rather than a design flaw, but it means you cannot assume equal weight per session when planning study time. The naming is also inconsistent: most notebook paths use a numeric prefix matching the module, but the dropout material lives under Module 15 and batchnorm under Module 16 even though both are listed in session three or four. Follow the links in the README rather than guessing directory names.

Empty notebooks and the fill-in-the-blank design

Several notebooks are explicitly empty scaffolds. The README names 08_collaborative_filtering_empty.ipynb, 08_Word2vec_pytorch_empty.ipynb, 16_simple_batchnorm_eval.ipynb, ODIN_mobilenet_empty.ipynb, 09_AE_NoisyAE.ipynb, 10_GAN_double_moon.ipynb and 11_predictions_RNN_empty.ipynb. The suffix is the signal: you are expected to write the missing parts, and the accompanying website module carries the explanation.

This is the central design decision of the repository and it cuts both ways. It makes the material good for deliberate practice, because you cannot run a completed solution and mistake reading for learning. It also means the repository is only half usable on its own. A reader who clones it without the website gets a set of notebooks with gaps and no statement of what belongs in them. The README does not describe a solutions branch or a solutions directory, and the material provided does not show one. Treat the empty notebooks as exercises that require the module page open in a second window, and check before starting whether the specific notebook you want has a filled counterpart in the same directory.

Running the notebooks: there is no install step

There is no package to install. You clone the repository and open the notebooks in a Jupyter environment, which the README does not spell out because the course presumably supplies one. The commands below are the standard ones for a repository of .ipynb files; the repository itself documents none of them, and you should not read them as project-specific instructions.

git clone https://github.com/dataflowr/notebooks.git cd notebooks jupyter lab

The real configuration work is the Python environment, and this is where the material is thin. The README does not list a requirements.txt, an environment.yml, a pyproject.toml or a stated PyTorch version. The notebooks import torch and torchvision, and the material references torch.nn.module, dataloaders and pretrained models such as VGG and MobileNet, so you will need a PyTorch install with torchvision and a Jupyter kernel. Because no version is pinned, the failure mode is a notebook written against an older torch API that no longer matches your installed version. If you hit an error inside a cell, check the notebook's own import and call signatures before assuming your environment is broken.

Where this format breaks down

The repository is not a reusable component. There is no importable module, no stable interface, and no release history in the material provided, so you cannot pin a version and expect the same behaviour six months later. If your goal is to add collaborative filtering or a word2vec embedding to a production pipeline, copying cells out of a teaching notebook will give you code with no tests, no input validation and no error handling. The notebooks are written to demonstrate a mechanism on a dataset small enough to run in a session.

A second limitation is the coupling to the website. The README's module links point to dataflowr.github.io, and the explanations live there. The notebooks assume that context. A third is dataset availability: the material references dogs and cats, CIFAR10, MNIST, a larger collaborative filtering dataset and an engine failure prediction task. The README does not describe how each dataset is fetched or where it is hosted, so expect to spend time on data plumbing before you reach the interesting part of a notebook. None of these are defects in a course, but all of them matter if you were hoping for a drop-in reference implementation.

Compared with a maintained tutorial library

The obvious alternative for someone who wants runnable PyTorch examples with pinned dependencies is the official PyTorch tutorials repository, which ships examples as versioned code with a build and test setup. The difference in approach is the point. PyTorch tutorials aim to be correct and current; dataflowr aims to be teachable and sequenced. The dataflowr README even points at a PyTorch tutorial in session seven, where it offers a correction to the attention in seq2seq example. That is a course treating another project's tutorial as a text to critique, which tells you the two repositories are doing different jobs.

If you want to understand why backpropagation is not just the chain rule, as the session two notes put it, or why a loss function and an accuracy metric answer different questions, the dataflowr sequence is built for that. If you want a working seq2seq attention model with a maintained dependency list, take the PyTorch tutorial and read dataflowr's correction alongside it. Neither choice is wrong; picking the wrong one for your goal wastes a week.

Licence and the cost of keeping up

The repository is Apache-2.0. That permits commercial use, modification and redistribution provided you keep the licence and notice files and state significant changes. It also includes an explicit patent grant, which matters if you lift code into a product. It does not mean the notebooks are correct or maintained, and it does not cover the datasets the notebooks download, which carry their own terms. This is a description of the licence text, not legal advice; if you plan to redistribute adapted notebooks, read the full Apache-2.0 terms.

Upgrade cost is the more practical concern. There are no releases in the material provided, so there is no version boundary to upgrade across. The last push recorded is 2026-05-29, which indicates the repository is still being touched, but a push is not a compatibility guarantee. The maintenance model is a course being taught: material gets revised when the course runs, not on a schedule you can plan around. If you fork it for your own teaching, budget for re-checking every notebook against your PyTorch version each term, because nothing in the repository will tell you which cells broke.

Editorial conclusion

Adopt this if you are working through PyTorch fundamentals and want the exercise notebooks that accompany a specific taught course schedule, or if you are an instructor looking for empty notebooks such as 08_collaborative_filtering_empty.ipynb to build a session around. Do not adopt it if you need an installable library, a pinned dependency set, or an API with a support commitment; there are no releases in the material provided and the notebooks are the deliverable. Before committing time, open the notebooks for the modules you actually need and check whether the empty variants have solutions elsewhere in the repository, and confirm which PyTorch version each notebook was written against, since nothing in the README states it.

Official sources

1. dataflowr/notebooks on GitHub
2. Issues
3. License: Apache-2.0
4. Project website
5. README