fromthetensor: a 10-week paper-implementation syllabus built on notebooks

A syllabus, not a package

The README opens by naming its own model: the project is inspired by From the Transistor, geohot's hardware course. That reference explains the shape of everything that follows. There is no setup section, no installation command, no requirements file mentioned, and no API to call. What exists is a ten-week schedule divided into five sections, and each entry is a topic with a link to a notebook under examples/ plus a link to the paper the notebook is meant to reproduce. The repository topics list deep-learning, pytorch and transformers, which tells you the intended stack, and the notebook filenames confirm it: mnist_from_scratch.ipynb, cnn.ipynb, rnn.ipynb, lenet.ipynb, alexnet.ipynb, resnet.ipynb, dcgan.ipynb, gru_lstm.ipynb, cbow_skipgram.ipynb, transformer.ipynb, bert.ipynb, gpt2.ipynb, stable_diffusion.ipynb. Anyone arriving from a package index will be confused. Anyone arriving from a list of papers they have been meaning to implement will recognise the format immediately.

Who the ten-week sequence is actually for

The stated problem is that machine learning is hard and tutorials are hard to follow, and that software 2.0 is hard to understand from first principles. The README quotes George Hotz on the method: download a paper, implement it, repeat until you have skills. So the intended reader is someone who wants to build models rather than call them. The sequence assumes you can already read Python and that you are willing to run Jupyter notebooks. It does not assume prior deep learning, because section 2 starts at a neural network on MNIST written from scratch. It does assume tolerance for ambiguity, since the notebooks are the only specification of what a finished exercise looks like. If your goal is to fine-tune a model for a product deadline, this is the wrong artefact. If your goal is to be able to read a paper and produce a working implementation, the ordering is the product.

The progression from tensors to diffusion

Section 1 covers tensors, backpropagation and gradient descent in one week. Section 2 spends a week on three notebooks: a plain neural network, a CNN covering convolution and pooling, and an RNN covering the idea of stored state. Section 3 is three weeks of vision papers: LeNet, AlexNet, ResNet, then DCGAN for adversarial training. Section 4 is three weeks of language work: GRU and LSTM cells, CBOW and Skip-Gram for word2vec, the Transformer, fine-tuning BERT, and inference with GPT-2 including text generation strategies. Section 5 is a single week on Stable Diffusion. The weighting is the interesting editorial choice. Language models get as much time as vision models, and the generative image model that gives the course its title gets one week at the end. That is a defensible ordering if you treat diffusion as a synthesis exercise, but it means the headline topic is the thinnest part of the schedule.

How you actually run it

There is no install command in the README, so the practical path is to clone the repository and open a notebook. The links in the README point at github.com/jla524/fromthetensor/blob/main/examples/, and the README also references colab.research.google.com as a link target, which suggests the notebooks are meant to be opened in Colab as well as locally. A workable local flow is git clone of the repository, then jupyter notebook or jupyter lab from the repository root, then open examples/mnist_from_scratch.ipynb as the entry point because it is the first code link in the schedule. Beyond that the material does not specify a Python version, a PyTorch version, CUDA requirements, or a dependency list. You will be reading each notebook to discover its imports. Treat that as the first exercise, and treat any environment you build as yours rather than the project's, because nothing in the README pins one.

What the repository does not give you

The README is a table of contents with links. It contains no description of expected outputs, no test suite, no reference training curves, and no statement of how long any notebook takes to run. There are no releases retrieved for the repository, so there is no versioned artefact to depend on. The primary language field is listed as unknown, the licence is unknown, and there is no homepage. For a course that is fine, and arguably correct, since the point is that you write the code. For anyone who wants to cite it, vendor it, or build a training pipeline on top of it, the missing licence is a real blocker: without a licence file you have no stated permission to redistribute the notebooks, and you should check the repository directly rather than assume. The absence of an environment specification is the second practical constraint, because paper implementations from different years tend to assume different PyTorch APIs, and the schedule spans papers from LeNet through Stable Diffusion.

Where the schedule is thin

Section 4 compresses a lot. GRU and LSTM share one notebook and one paper link, the Chung et al. sequence-to-sequence comparison paper, even though the README describes them as separate cell types. Word2vec gets one notebook for both CBOW and Skip-Gram. The Transformer gets one notebook, and the attention mechanism it depends on is not given its own slot earlier in the schedule. BERT fine-tuning and GPT-2 inference are separate entries but both sit in the same week as the Transformer. That is four substantial architectures in three weeks, and the README does not say whether the notebooks are complete implementations or starting points with gaps to fill. The same ambiguity applies at the other end: section 5 asks you to build Stable Diffusion in one week, and the paper linked is the latent diffusion paper, arXiv 2112.10752. Whether that notebook is a from-scratch implementation or a walkthrough of an existing pipeline is not stated, and it changes the difficulty by an order of magnitude.

fromthetensor versus fast.ai and the official PyTorch tutorials

The obvious alternative is fast.ai, whose courses also run in notebooks and also target practitioners. The difference in approach is the direction of abstraction. fast.ai gives you a high-level library and teaches you to get results first, then peels back layers. fromthetensor does the opposite: it starts at the tensor and works upward through papers, with no framework layer between you and the architecture. The official PyTorch tutorials sit in a third position, task-oriented and maintained by the framework authors, but they are a catalogue rather than a sequence, so they will not tell you what to do in week three. If you learn best by shipping something working in the first hour, fast.ai is the better fit. If you learn best by reproducing a paper and debugging why your loss does not move, the fromthetensor ordering is more useful, and the cost is that you supply the environment and the patience.

Maintenance, licence and what to verify

The repository was last pushed in April 2026 and is not archived, so it is not abandoned, but there are no releases and no dependency metadata, which means there is nothing to upgrade in the conventional sense. Your maintenance cost is the cost of keeping your own environment working against notebooks that were written at different times. The licence is listed as unknown, so before you copy a notebook into a course, a company repo or a paid workshop, read the repository's licence file, or its absence, and decide accordingly. That is a factual check, not legal advice. The concrete next step is to open examples/transformer.ipynb and examples/stable_diffusion.ipynb and read their import cells, because those two notebooks sit at the end of the schedule and will tell you fastest whether the stack the course assumes is one you can assemble today.

Editorial conclusion

Adopt it if you already write Python and want a fixed sequence of papers to reimplement in PyTorch notebooks, and you accept that the repository supplies the order and the links rather than a supported package. Skip it if you need an installed library, a graded curriculum, or anything with a maintenance commitment behind it. Before starting, open examples/transformer.ipynb and examples/stable_diffusion.ipynb and check that the environment each one assumes still resolves on your machine, because the README does not state a Python version, a PyTorch version, or a dependency file.

Official sources

1. Issues
2. jla524/fromthetensor on GitHub
3. README