From the Tensor: thirteen notebooks and three different course lengths

The description says 10 weeks, the manifest says 1, and the sections add to 9

The same course is three different lengths in three places.

The repository description calls it a rough outline for a 10 week course. The project manifest describes it as a rough outline for a 1 week course. And the section headings in the README carry their own durations: one week for the introduction, one week for deep learning, three weeks for the vision papers, three weeks for the language papers, and one week for vision-language models.

Those five headings sum to nine weeks, which matches neither number.

Nine against the description's ten is the difference you would notice while planning, and one against the manifest's is the difference you would notice while reading the manifest, which is the file a tool reads. The word rough is doing real work in the author's own phrasing, since a rough outline is a sketch of a curriculum rather than a syllabus with dates, and a sketch is exactly the kind of artefact where three numbers can drift apart without anyone noticing.

The honest reading is that the section durations are the most specific of the three, because they sit next to the content each week covers, and the other two are the loose ones.

Thirteen notebooks and thirteen papers, with one section that has no code at all

The correspondence between the index and the tree is exact, and it is the best thing about this repository.

The tree holds thirteen notebooks: one handwritten MNIST network, a CNN, an RNN, LeNet, AlexNet, ResNet, DCGAN, GRU and LSTM, CBOW and Skip-Gram, a Transformer, BERT, GPT-2 inference, and Stable Diffusion. Every one of those thirteen has a line in the README, and every one of the thirteen has a paper or video link beside it. Nothing in the tree is unlisted and nothing in the index is missing.

What breaks the symmetry is the first section. It has no notebook at all. The introduction, which is where tensors, backpropagation and gradient descent are supposed to be understood, is a single video link and a paragraph of prose. So the section that promises to show you how deep learning models are built from tensors is the one you watch rather than run.

The linking convention also changes twice. Sections three to five pair each item as code plus paper, with the papers hosted where they were originally published: a university page for LeNet, a conference proceedings page for AlexNet, and preprint servers for the rest. Section two pairs code with video instead, and section one has only video.

The weighting is the other thing worth noticing. The two three-week sections hold nine of the thirteen notebooks between them, and the final one-week vision-language section holds one.

The method is a quotation, and the repository is that quotation's output

The README opens with the premise it is built on, quoted from a talk rather than asserted by the author.

Asked how to get good at machine learning, the answer is three steps: download a paper, implement it, and keep doing that until you have skills. The surrounding paragraph makes the case for the format, arguing that machine learning is hard, that a lot of tutorials are hard to follow, and that it is hard to understand software written the way modern software is written from first principles.

The repository is a literal execution of those steps. Thirteen papers, thirteen implementations, and the reading list is not a bibliography at the end but the index itself, with each paper one click from the notebook that implements it. Two of the entries are not architecture implementations at all: running inference with GPT-2 is about text generation strategies, and fine-tuning BERT is about taking a pre-trained model rather than training one from random initialisation, which is a different exercise from the one the other eleven entries set.

The lineage is declared too. The title is an explicit riff on a well-known repository that goes from the transistor to the microprocessor, and the argument about first principles points at a specific essay on software written for machines rather than for people. Neither link is required reading to use the notebooks, and both tell you what kind of project this is trying to be.

One notebook closes the course, and the roadmap past it is a file you cannot see

The final entry is a Stable Diffusion notebook, and it is the only one in its section, which is allotted one week.

That is a large thing to attempt in a week next to two three-week sections that end with a Transformer and a BERT, and it is also the reason the course is called what it is called: the endpoint is a current generative image model rather than another classification network. Whether one week and one notebook gets you there is not something the repository claims, because it does not describe the contents of any notebook.

That is the second structural gap. Not one of the thirteen notebooks is described on the page. Each entry is one sentence naming the architecture and, in the two early sections, the concept the notebook is supposed to teach, such as convolution and pooling for the CNN or memory for the RNN. From the third section onwards the descriptions become uniform: learn about the architecture and its application. So the index tells you which paper each notebook implements and nothing about how hard the implementation is, how much of it is library calls, or how long it will take you.

Past the last section there is a heading called Beyond the Tensor, one quotation, and a pointer to a file called ideas.md for further ideas. That file is in the repository. Its contents are not on the page, so the forward roadmap of this course is a link to an unrendered document.

Twelve dependencies, a notebook stack in the runtime list, and one unexplained package

The manifest is short and modern, and it is the only machine-readable description of the environment.

The package is named after the course, at version 0.1.0, and requires Python 3.12 or newer. Twelve dependencies, every one of them a lower bound with no upper limit: a deep learning framework at 2.6 or newer, a transformer library at 4.56.1 or newer, a diffusion library at 0.35.1 or newer, a dataset library, an acceleration library, a plotting library at 3.10.3 or newer, an imaging library, a progress bar, two text-related packages, and three notebook packages.

Putting ipykernel, ipywidgets and jupyter in the runtime dependencies rather than in a development extra is the choice worth arguing about. These are thirteen notebooks whose output is the product, so the notebook stack is arguably not optional, and for a course that expects you to run everything, making the installation one command is the friendlier reading. It also means any script that imports this package to reuse a helper pulls a Jupyter installation with it.

The unexplained entry is the text transliteration library. Nothing on the page says what it is for, and given that the corpus for the word embedding and language model notebooks comes from the hub rather than from a local corpus, it is a reasonable thing for a data-loading helper to use and not a reasonable thing to leave unexplained in a course about model internals.

The tree also carries a custom dataset directory inside the examples, so there are two data paths available: a library and a local one. A lock file is committed, so the maintainers have a resolution even though the manifest does not constrain one.

No licence file, and a repository whose premise is implementing other people's work

The repository has no licence.

The licence field is empty, and the top level of the tree holds five entries: the README, the examples directory, the ideas file, the project manifest and the lock file. There is no licence file among them, and the manifest declares no licence field either.

That is a strange gap for a repository of this kind specifically. The entire method is to take a paper and implement it, and the papers are all attributed properly, linked to where they were published, written by their original authors. So the intellectual content being reimplemented is credited in detail. The code that reimplements it is not licensed at all, which means nobody has stated whether you may copy a notebook, adapt it for a tutorial, or publish a fork of it.

The README also carries no contributing guide, no code of conduct, no security policy and no pull request template, and the top level has no test directory. There is a lock file but no test configuration and no lint configuration in the manifest.

For a personal study repository that is a coherent choice. It is a notebook collection, not a library, and the version number is 0.1.0. But it is also the kind of repository that gets forked and used in bootcamps, and at that point the absence of a licence is the first thing somebody has to raise.

One reference in the link list is defined and never used

The README uses numbered references, and the list at the bottom has six entries. Five of them appear in the text: the repository the title riffs on, the essay about software written for machines, the talk the three-step method is quoted from, the account whose quotation closes the Beyond the Tensor section, and the ideas file.

The sixth, a link to a hosted notebook environment, is defined and never referenced anywhere in the visible page.

It is a small thing, and the most likely explanation is that the notebooks were once run in a hosted environment and the reference outlived the text that used it. Nothing on the page confirms that, and nothing contradicts it either.

The quotations are worth more attention than the dangling link, though. The three-step method is credited by name to a well-known figure in the field, and the closing section quotes somebody else saying that when people ask how to get better at machine learning, the honest answer is to stop learning about machine learning and start learning about systems. Both are marked with an author handle rather than presented as anonymous wisdom, which is a small courtesy that costs nothing.

And that last quotation is the interesting one for this particular repository. A collection of paper implementations is a machine learning artefact, and the closing note points at the argument that the durable skill is systems work. Both things are true here at once, and the repository does not pretend otherwise.

Editorial conclusion

Take From the Tensor if your plan is to implement papers rather than read about them, because that is what the repository is for and every entry pairs a paper with a notebook you can open. Leave it if you need a syllabus, a schedule or a maintained environment, since the three course lengths in the repository disagree with each other and the manifest has no test or lint configuration. Three things to check before you plan around it: which weeks you actually have, given that the section headings sum to nine while the description claims ten, whether the notebook you care about is a from-scratch implementation or a library call, since the depth differs across the sections, and what licence governs the code, because there is none stated and the repository is built from re-implementations of other people's papers.

Frequently asked questions

Official sources

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