Welcome — start here
Before we begin
If you are completely new to AI, you are in the right place. Many courses assume you already know linear algebra, calculus, and Python machine learning libraries. This one does not.
This page answers questions beginners actually have before Lesson 1:
- What do words like model, training, and inference actually mean?
- What will I actually learn, in plain language?
- How long does Module 1 take, and what do I need installed?
- How should I read each lesson so it sticks?
- What comes later in the full course?
There is no assumed background in machine learning or calculus. Module 1 builds intuition first, then one small Python project so you feel training happen — not just read about it.
Key concepts (plain English)
Articles and videos throw around the same words. Here is a mini glossary so nothing sounds like magic when Lesson 1 starts.
Model — A recipe that turns input into output. Under the hood it is mostly numbers (called weights or parameters) plus simple math. A spam filter, a face detector, and ChatGPT are all models — different size, same idea.
Training — The process of finding good weights using many labeled examples. The model makes a guess, compares it to the correct answer, measures how wrong it was (loss or error), and nudges the weights to do better next time. Repeat thousands or millions of times. Training is learning.
Inference — Using a finished model on new data. You send input in; you get a prediction out. Weights stay fixed — nothing is learned during inference. When you ask ChatGPT a question, that is inference. People also say prediction or running the model.
Dataset — The collection of examples used for training (and often a separate set for testing). “We trained on 10,000 photos” means the model saw those photos many times while adjusting weights.
Label / ground truth — The correct answer paired with an example: “this email is spam,” “this pixel brightness is 180,” “this image is a cat.” Training needs something to compare guesses against.
Features — The measurable parts of input the model reads. For a photo patch, features might be pixel brightness values in a list. For tabular data, features might be age, price, or temperature.
Loss (error) — One number that says “how bad was the batch of guesses?” Training tries to push loss down over time. Module 1 spends a full lesson on gradient descent — the standard way to take those downhill steps.
Epoch — One full pass through the training dataset. Often you train for many epochs so the model sees every example more than once.
Overfitting — Memorizing training examples instead of learning a general pattern. Good on old data, bad on new data. Later phases cover how to detect and reduce it.
Underfitting — The model is too simple to capture the pattern — high error even on training data.
The split that confuses most beginners:
| Phase | What happens | Weights change? | When you see it |
|---|---|---|---|
| Training | Learn from examples with known answers | Yes | Building the model (hours to weeks) |
| Inference | Predict on new input | No | Using the app or API (milliseconds) |
Figure
Training vs inference
You do not need to memorize every row yet. If model, training, and inference feel clear, you are ready for the rest of this page and Lesson 1.
Figure
Module 1 at a glance
What is this course?
This learning path is called AI: From Basics to GenAI. It is standalone — you do not need any other course on this site, and nothing else is required before you begin.
The big picture
Modern AI tools (ChatGPT, image generators, recommendation systems) look different on the surface, but most of them share one skeleton:
- Data comes in (text, image, audio, numbers).
- A model transforms that data using learned numbers (weights).
- An output comes out (a label, a sentence, a prediction).
Module 1 explains how those learned numbers get found — starting with the smallest possible example, not a billion-parameter black box.
When all phases are published, the path runs from this foundation through classical machine learning, neural networks, PyTorch, transformers, and generative AI. You will build projects along the way so each idea has something concrete attached to it.
Module 1 uses plain Python and NumPy for one short project. Later phases introduce PyTorch, which automates much of the calculus — but you will already know what it is automating because you did it by hand first.
Figure
The same pattern everywhere
Who is this for?
Good fit if you:
- Hear “train a model” or “neural network” and want to know what that means, not just how to click buttons.
- Can use a computer and are willing to try basic Python for one project (we walk through it line by line).
- Did not study heavy math — we explain in full sentences with examples before any jargon.
- Prefer slow, descriptive lessons over fast bullet lists.
You do not need:
- Prior ML or deep learning courses
- Advanced calculus (we use slope intuition, not proofs)
- A GPU or paid cloud account for Module 1
What Module 1 teaches (in plain English)
Module 1 is titled “Math & intuition.” That name scares people — so here is what it actually means in practice:
| Topic | What you will understand (not just memorize) |
|---|---|
| Vectors & matrices | How a photo becomes a grid of numbers, and how a grid becomes a list a model can read |
| Dot products | How to score “how similar are these two patterns?” — used in matching and classification |
| Probability & noise | Why single pixel readings lie a little, and why training uses many examples averaged together |
| Gradient descent | How a model improves itself by small downhill steps on an error graph |
At the end you build a real project: fit a simple brightness model to part of an image, plot error going down over time, and compare your result to a built-in solver. That loop — predict, measure error, update weights — is the same loop behind large models, with three weights instead of three billion.
How to use each lesson (read this — it matters)
Every lesson is written to be read slowly, not skimmed. Recommended approach:
- Read the “Before we begin” section — it tells you why the lesson exists.
- Work through examples with paper or a calculator — do not skip the numbers.
- Answer checkpoints before revealing the answer sketch — guessing first builds memory.
- Re-read confusing sections — Module 1 is designed to be revisited; clarity beats speed.
- Use “What’s next” only when the current lesson feels solid, not merely finished.
Your progress saves in this browser when you open a lesson. You can leave and resume from the curriculum page.
If a lesson feels superficial: that usually means a section was skipped. Go back to the worked examples — the understanding lives there.
What to install before the project
Lessons 1–6 are reading and thinking. Lesson 7 (project) is the only one that requires code.
Before the project:
- Python 3.10+ — python.org/downloads
- NumPy & Matplotlib —
pip install numpy matplotlib - Pillow (optional, for loading photos) —
pip install pillow - Any editor (VS Code, Cursor, etc.)
If Python is new, spend an hour on variables, lists, and for loops — enough to follow the project skeleton.
Full course roadmap (future phases)
Module 1 is complete. Module 2 (core machine learning) is live — start at Welcome to Module 2. Later phases (added over time):
- Math & intuition — complete
- Core machine learning — live now
- Neural networks
- PyTorch fundamentals
- Deep learning architectures
- Transformers & GenAI
- Agents & tool use
- Production & deployment
Focus only on Module 1 for now.
Ready?
When this page makes sense, open the first technical lesson:
Lesson 1 — Vectors, matrices, and image data
Take your time. There is no deadline — only the goal of actually understanding each idea before moving on.