AI-Practices: A Notebook-First Curriculum That Runs From Linear Regression to Autonomous Agents

The Problem It Solves Is Curriculum Fragmentation, Not Missing Algorithms

Most people learning machine learning do not lack tutorials. They lack a sequence. Scikit-learn's user guide covers classical models well, a PyTorch tutorial covers tensors and autograd, a Keras guide covers layers, and a Hugging Face course covers transformers. Each is competent in isolation. Nothing tells you what to open after you finish the previous one, and nothing keeps the vocabulary consistent across the boundary.

AI-Practices attacks that specific gap. Its README describes a directory tree split into six named stages, from 01-foundations through 14-agents-reasoning, with a separate 08-theory-notes folder for reference material and a 09-practical-projects folder for end-to-end work. The stated audience is someone who wants both the derivation and the code: the README claims that every concept has a mathematical derivation and a code implementation. That claim is the whole pitch, and it is also the thing you should test first.

The repository is primarily Jupyter Notebook, with Python as the secondary language. That choice matters more than it looks. A notebook is a document you read and a program you run in the same artifact, which is exactly right for a curriculum and exactly wrong for a dependency. There is no package to install, no importable namespace, no semantic version. You clone it and you work inside it.

How the 14 Modules Are Layered, and Where the Seams Are

The README's tree groups modules into stages. Stage one is 01-foundations, which the detailed tables break into eight submodules: training models, classification, support vector machines, decision trees, ensemble learning, dimensionality reduction, unsupervised learning, and an end-to-end project using California housing prices. Stage two covers 02-neural-networks, 03-computer-vision and 04-sequence-models. Stage three is 05-advanced-topics, 06-generative-models and 07-reinforcement-learning. Stage four jumps to 10-large-language-models and 11-multimodal-learning. Stage five is 12-deployment-optimization and 13-distributed-training. Stage six is 14-agents-reasoning.

The numbering is not contiguous. Modules 08 and 09 sit outside the stage list as theory notes and practical projects, which is a reasonable structural decision but means the folder order in a file browser does not match the learning order in the README. If you navigate by directory listing rather than by the documented path, you will hit 08-theory-notes before you have seen a Transformer, and the notes will be less useful than they are after module 04.

The framework split is the other seam. The badges state PyTorch 2.0+ and TensorFlow 2.13+, and the submodule tables confirm the split: 02-neural-networks is written around Keras and the Sequential and Functional APIs, while 10-large-language-models lists GPT and LLaMA implemented from scratch, which in practice means PyTorch. A learner moving from module 03 to module 10 changes framework mid-curriculum. That is realistic, since production teams do run both, but it doubles the environment surface and it means a single virtualenv has to satisfy two large dependency trees.

The Mechanism Is Notebooks Plus Tests, and the Tests Are the Interesting Part

There is no runtime architecture here in the server sense. The mechanism is a repository of notebooks backed by Python files, with a stated 500+ Python files and 280+ notebooks, and a test suite the README counts at 100+ unit tests. Several module tables carry a test-coverage column with a check mark: all eight reinforcement learning submodules, all seven LLM submodules, all three multimodal submodules, all four deployment submodules, all four distributed training submodules, and all six agent submodules. The 09-practical-projects entry for integrated systems is annotated with 109 tests on its own.

That column is the most useful thing in the README, because it tells you where the author invested in executable verification and where the material is closer to prose. The foundations and neural network modules do not carry the same markers in the tables shown. If you are choosing where to start, the coverage column is a better signal than the module number.

The practical projects folder is where the pieces are meant to converge. It lists Titanic survival prediction, Otto classification, SVM text classification and XGBoost work under 01-ml-basics; MNIST CNN classification under computer vision; sentiment analysis with LSTM, Transformer text classification, NER and machine translation under NLP; temperature and stock prediction under time series; Flappy Bird DQN, Dino Run and stock trading RL; and multimodal retrieval, a visual question answering agent and a code assistant under integrated systems. A curriculum that ends with a VQA agent and a code assistant is aiming at current practice rather than at textbook exercises, which is a deliberate and defensible choice.

Getting It Running: Clone, Then Satisfy Two Framework Stacks

The README does not include a quickstart command block in the material available here, so the concrete steps are the ones implied by the structure. Clone the repository, create an environment, and install dependencies. The badges state Python 3.10+, PyTorch 2.0+ and TensorFlow 2.13+, and the homepage points to a GitHub Pages site at zimingttkx.github.io/AI-Practices that serves as the rendered front end.

The environment is the first real decision. Because module 02 is Keras-based and module 10 is PyTorch-based, a single environment needs both. If you only care about the LLM, agent or distributed training material, you can skip TensorFlow entirely and install PyTorch alone; the README's own module tables show that TensorFlow appears in the neural network and computer vision stages, not in the LLM, multimodal, deployment, distributed or agent stages. That split is worth exploiting rather than fighting.

There is no requirements file, lockfile or package manifest described in the supplied material, and no releases have been retrieved. That means dependency resolution is on you. Notebook-based curricula age in a specific way: the code may be correct while the pinned-by-nobody versions drift. A notebook that calls a Keras API which was renamed in a later TensorFlow minor release will fail on import, and nothing in the repository will tell you that until you run it. Budget an afternoon for environment work before you budget an hour for the first module.

The Real Limitations: No Releases, No Lockfile, and an Unverifiable Track Record

The most concrete limitation is packaging. The repository has no retrieved releases. There is no version to pin, no changelog to read, and no way to say which commit you learned from when you come back in six months. For a tutorial that is tolerable. For anything you intend to build on, it means you are vendoring code rather than depending on it.

The second limitation is the evidence base for the claims. The README states 500+ Python files, 280+ notebooks, 100+ unit tests, and two Kaggle gold medals from the Feedback Prize ELL and RSNA Abdominal Trauma competitions, plus a silver in American Express Default and a bronze in RSNA Lumbar Spine. Those are self-reported counts and competition placements. The competition results are the kind of claim that can be checked against public leaderboards, and you should check them if the Kaggle material is why you are here. File counts tell you about volume, not about whether a given notebook is finished or correct.

The third limitation is scope as a warning sign rather than a virtue. Fourteen modules spanning PCA to DeepSpeed to multi-agent debate is an enormous surface for any single repository. The test-coverage column suggests the author knows this and concentrated verification in the newer modules, which is the right instinct. But a learner who wants depth on, say, tensor parallelism should expect the 13-distributed-training material to be an orientation rather than a substitute for reading the DeepSpeed and Megatron-LM documentation directly. The README names both tools; it does not claim to replace them.

Finally, the repository is archived: no. It was pushed on 2026-09-10. That is recent enough that the material is likely to reflect current practice in the LLM and agent modules, and it also means the content is still moving, which is a mild argument against treating any single commit as a stable reference.

Alternatives: Where a Book, a Course or a Framework Repo Fits Better

The closest structural alternative is a single-framework course rather than a multi-framework repository. Fast.ai's course and the Hugging Face NLP course both commit to one stack and go deep on it. Fast.ai builds everything on PyTorch and its own fastai library, so the learner never context-switches frameworks; the trade-off is that Keras and TensorFlow, which appear throughout AI-Practices modules 02 and 03, are simply absent. If your target job uses TensorFlow Serving or Keras, AI-Practices covers ground that a PyTorch-only course does not.

A second alternative is a framework's own examples repository, such as the PyTorch examples or TensorFlow tutorials trees. Those are maintained by the framework vendors, so they track API changes closely and carry version tags. The difference in approach is that vendor examples are organised by feature, not by learning progression. There is no path from a linear regression example to a distributed training example, because the repository has no opinion about what you should learn first. AI-Practices has exactly that opinion, expressed as numbered stages, and that opinion is the product.

A third alternative is a textbook with a companion repository, which trades interactive notebooks for a coherent argument. Notebooks encourage running cells out of order and skipping the prose between them, and a curriculum that claims both derivation and implementation is vulnerable to readers who only consume the second half. If you already know the mathematics, that is fine. If you do not, the 08-theory-notes folder is a reference, not a substitute for a text.

The honest comparison is this: AI-Practices wins on breadth and on having a stated sequence. It loses on versioning, on dependency pinning, and on the depth any single module can reach given how many modules there are.

Licence and the Cost of Keeping Up With It

The licence is MIT, per the repository metadata and the LICENSE badge in the README. MIT is permissive: it allows reuse, modification and redistribution, including in commercial work, provided the copyright notice and permission notice are retained. That matters here because the code in the notebooks is meant to be copied into your own projects, and MIT is about as unobstructed as a licence gets for that use. It also means the repository comes with no warranty, which for tutorial code is worth taking literally. This is not legal advice; read the LICENSE file and, for anything commercially sensitive, talk to someone qualified.

Maintenance cost is the part the README does not address, and it is the cost you will actually pay. There are no releases, so there is nothing to upgrade from or to. Upgrading means pulling the default branch and re-running your notebooks against whatever the current commit contains, then fixing whatever broke. Because the stated baseline is Python 3.10+, PyTorch 2.0+ and TensorFlow 2.13+ with open-ended upper bounds, a fresh environment today will resolve to much newer versions than the author used, and notebook failures from API drift are the expected failure mode rather than an edge case.

The practical mitigation is to freeze your own environment the moment a module works, and to record the commit hash you cloned. That gives you a stable point to return to, which the repository itself does not provide. The cost is not in reading the material; it is in the environment archaeology required to make the older modules run on a current stack.

Who Should Clone It, and What to Check Before You Do

This repository fits a specific reader: someone who has finished an introductory machine learning course, knows Python, and wants a single directory tree that walks from gradient descent to a multi-agent system without changing resources every three weeks. It also fits an engineer who already works in one of the two frameworks and wants a structured way to pick up the other, since the module split makes it easy to see which half uses which.

It does not fit someone who needs a library. If you want to import a tested implementation of PPO or LoRA into a service, this is the wrong shape of artifact: no releases, no package, no pinned dependencies, and code that lives inside notebooks. It also does not fit anyone who cannot run two deep learning frameworks in one environment, or who needs a documented support policy before depending on something.

The verification order is short. First, clone the repository and run two notebooks from different stages, one Keras-based from module 03 and one PyTorch-based from module 10, to confirm your environment can hold both. Second, run the test suite for whichever module you plan to lean on hardest, using the coverage column in the README to pick a module the author claims is tested rather than one that is not. Third, if the Kaggle competitions are your reason for being here, open the 05-kaggle-competitions folder and confirm the code matches the placements the README lists. Do those three things and you will know within an afternoon whether this curriculum is worth the months it takes to work through.

Editorial conclusion

Adopt AI-Practices if you want a single repository whose directory tree doubles as a syllabus, and you are willing to run the notebooks yourself against Python 3.10+, PyTorch 2.0+ or TensorFlow 2.13+. Do not adopt it if you need a versioned, installable package with pinned dependencies, or if your environment cannot support two deep learning frameworks side by side. Before committing, verify three things: that the notebooks you care about actually execute on your hardware, that the 100+ unit tests cover the modules you intend to rely on, and that the two Kaggle gold medals described in the README correspond to code you can reproduce from the competition folders rather than to result summaries alone.

Official sources

1. Issues
2. License: MIT
3. Project website
4. README
5. zimingttkx/AI-Practices on GitHub