# Ramakm/ai-hands-on: a notebook-first path from math to RAG

> The repository walks a learner through math, PyTorch, neural networks, transformers, RAG and OCR as Jupyter notebooks. It is a curriculum to run yourself, not a library to install.

**Ramakm/ai-hands-on** — A group of notebooks  and other files which can help you learn AI from scratch.

- Repository: https://github.com/Ramakm/ai-hands-on
- Website: https://growtechie.substack.com/
- Stars: 1,449 · Forks: 306
- Language: Jupyter Notebook
- License: MIT
- Published: 2026-09-10 · Updated: 2026-09-10 · Language: en
- Canonical page: https://hysenlabs.com/projects/ramakm-ai-hands-on

## Who the notebook curriculum is built for

The README describes the repository as "a complete, hands-on guide to becoming an AI Engineer" and says it is designed for learning from first principles, building neural networks, and understanding modern LLM systems end to end. That framing sets the audience: someone who can read Python and wants the mechanics, not someone shopping for a model to call. The directory names are the syllabus, and they run in a deliberate order. 1.Math covers derivatives, vectors, gradients, matrix operations, linear algebra, probability and statistics. 2.Pytorch handles tensors, matrix multiplication, transposing, reshaping, indexing, slicing, concatenating. 3.Neural-Network(NN) builds neurons, layers and networks from scratch, then covers RMSNorm, activation functions, and optimizers named as Adam and Muon with learning rate decay. 4.Transformer goes to attention, self-attention, multi-head attention and a decoder-only architecture. 5.RAG and 6.OCR sit at the end as applied pipelines. The repository also carries Basic ML Model Implementation with linear regression, logistic regression, a decision tree model and naive Bayes classification, plus folders for Fine-Tuning, LLM, DL and ANN_&_CNN.ipynb. If you already know why a gradient flows backward, the first two folders are review. If you have only called an API and never written a training loop, the sequence is the point.

## How the repository is organised and how the notebooks flow

There is no runtime, no package and no service here. The mechanism is a folder tree of Jupyter notebooks plus markdown, with a learning path file that the README points to at Start_here/learning_path.md. The README states a recommended workflow: open Jupyter in the project root, then work through notebooks in the order 1.Math/, 2.PyTorch/, 3.Neural-Network(NN)/, 4.Transformer/. Two folders are called out as exceptions: 5.RAG/ and 6.OCR/ are described as folders "to run separately", and the README notes that some subfolders, naming 5.RAG/ and 6.OCR/ as examples, include their own requirements.txt with additional dependencies. That split is the architecture. The first four folders share the root dependency set, and the last two are isolated because retrieval and OCR pull in libraries the math and tensor notebooks do not need. The RAG section is where the repository stops being self-contained: the README lists integrations with embedding models and vector stores, and cloud LLM support through Atlas Cloud (with deepseek-ai/DeepSeek-V3-0324 named as the default), MiniMax (M3), OpenAI, or any OpenAI-compatible API. So the RAG notebooks expect credentials and a network call, unlike everything before them.

## Installing the dependencies and running your first notebook

The README gives one install command for the root set. Run it from the project root after cloning, and expect numpy and matplotlib plus whatever else the file pins.

```bash
pip install -r requirements.txt
```

The root requirements.txt is short. It pins numpy>=1.20.0 and matplotlib>=3.3.0, and the torch line is present but commented out:

```
# torch>=2.0.0
```

That matters. The PyTorch, neural network and transformer folders cannot run on the root install as written, so you install torch yourself before opening 2.Pytorch/. The README does not say which torch build to pick, so choose the wheel for your platform from the PyTorch install selector rather than copying a command from here. Once torch is in place, start Jupyter from the project root:

```bash
jupyter lab
```

The README lists jupyter notebook as the alternative. From the file browser, open 1.Math/ and work forward. When you reach 5.RAG/ or 6.OCR/, leave the root environment and install that folder's own requirements.txt inside it, because the README states those subfolders carry additional dependencies. For the RAG notebooks, the README names Atlas Cloud, MiniMax, OpenAI or any OpenAI-compatible API as the generation backend, so you will need a key and an endpoint before those cells return anything.

## Where the repository stops being enough

The gaps are structural, not accidental. First, the root requirements.txt ships with torch commented out, so the install command in the README does not by itself produce a working environment for the deep learning folders. A learner who follows the README literally will hit an import error in 2.Pytorch/ and have to diagnose it. Second, the RAG path depends on external services. The README names several providers and a default model, but it does not document what happens when a key is missing, when a provider changes a model name, or how to run retrieval without a cloud call. There is no release list to consult, so there is no versioned artifact to pin against. Third, this is a curriculum, not a dependency. There is no importable package, so nothing here belongs in a production pipeline; copying a notebook cell into a service means owning that code yourself. Fourth, the OCR folder is described only as "OCR pipeline and utilities" with preprocessing and text extraction, which is thin enough that you should open the notebooks before assuming they cover your document types. Finally, the last push was on 2026-09-01, so the material is recent, but the README does not describe a contribution process for notebook corrections beyond the presence of a .github/ directory.

## How it compares with a structured course or a framework tutorial

The obvious alternative is a video or cohort course with the same arc, such as the Microsoft Generative AI for Beginners material that this README links under GEN AI References, or the Coursera "Generative AI for Everyone" course it also lists. The difference in approach is control. A course delivers a fixed sequence with someone else's environment and pacing; this repository hands you notebooks and expects you to install numpy, matplotlib and torch, pick an LLM provider, and decide when a concept has landed. The second alternative is framework documentation, for example the PyTorch tutorials or the scikit-learn user guide that the README links in its Machine Learning Frameworks table alongside XGBoost, LightGBM and CatBoost. Those are reference material organised by API, not by learning order, and they do not build a transformer from scratch before showing you attention. A third comparison is the reading list the README recommends but does not include: Chip Huyen's AI Engineering, Géron's Hands-On Machine Learning, Goodfellow, Bengio and Courville's Deep Learning, Hastie, Tibshirani and Friedman's The Elements of Statistical Learning, and Michael Nielsen's Neural Networks and Deep Learning. Books give depth and editing that notebooks rarely match. This repository gives you cells you can change and rerun, which is a different kind of learning.

## Maintenance, licence and the cost of keeping up

The repository is not archived and the last push was on 2026-09-01, so it is current rather than dormant. There are no retrieved releases, which means there is no changelog to read before pulling changes; you track the main branch or you pin a commit yourself. The practical upgrade cost sits in two places. The root requirements.txt uses lower bounds (numpy>=1.20.0, matplotlib>=3.3.0) rather than exact pins, so a fresh install months from now can resolve to different versions than the notebooks were written against, and the torch line is commented out entirely. The RAG notebooks carry the heavier cost because they name specific cloud models: the README lists deepseek-ai/DeepSeek-V3-0324 as the Atlas Cloud default and MiniMax M3, and model identifiers on hosted providers change on the provider's schedule, not yours. The licence is MIT, which the README surfaces through a badge and the repository carries as a LICENSE file. MIT permits reuse and modification with the copyright notice and permission notice retained; it offers no warranty. That is a permissive starting point if you want to lift a cell into your own work, and it says nothing about the licences of the third-party books, courses and frameworks the README links to, which you would check separately.

## Conclusion

Adopt it if you want a sequenced set of notebooks that starts at derivatives and ends at a RAG pipeline, and you are willing to install PyTorch yourself because the root requirements.txt leaves torch commented out. Skip it if you need a supported library, a packaged course with exercises and grading, or anything with a release cadence. Before committing time, open Start_here/learning_path.md, check that 5.RAG/ and 6.OCR/ each carry their own requirements.txt, and decide which LLM provider you will point the RAG notebooks at.

## FAQ

### How do I learn AI hands-on with Ramakm/ai-hands-on?

Follow the order the README gives: install the root requirements, start Jupyter from the project root, and work through 1.Math/, 2.PyTorch/, 3.Neural-Network(NN)/ and 4.Transformer/. Run 5.RAG/ and 6.OCR/ separately, since the README states those subfolders include their own requirements.txt with additional dependencies. A recommended progression is also documented at Start_here/learning_path.md.

### Is Ramakm/ai-hands-on free to use?

Yes. The repository is licensed under MIT, which the README shows as a badge and the repository carries as a LICENSE file. That covers the notebooks and files in the repository, not the cloud LLM providers the RAG section can call, which have their own terms.

### Does Ramakm/ai-hands-on install PyTorch for me?

No. The root requirements.txt pins numpy>=1.20.0 and matplotlib>=3.3.0, and the torch>=2.0.0 line is present but commented out. You install PyTorch yourself before running the notebooks in 2.Pytorch/, 3.Neural-Network(NN)/ and 4.Transformer/.

### Which LLM providers does the RAG section of Ramakm/ai-hands-on support?

The README lists Atlas Cloud, with deepseek-ai/DeepSeek-V3-0324 named as the default, MiniMax (M3), OpenAI, or any OpenAI-compatible API. That means the RAG notebooks need credentials and network access, unlike the earlier folders.

## Sources

- [Issues](https://github.com/Ramakm/ai-hands-on/issues)
- [License: MIT](https://github.com/Ramakm/ai-hands-on/blob/main/LICENSE)
- [Project website](https://growtechie.substack.com/)
- [Ramakm/ai-hands-on on GitHub](https://github.com/Ramakm/ai-hands-on)
- [README](https://github.com/Ramakm/ai-hands-on/blob/main/README.md)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/ramakm-ai-hands-on