An AI Learning Map — Orientation: The Whole Picture Before the Details

1. Why learn this

Since ChatGPT appeared in late 2022, AI has no longer been a research-lab story. It has become a tool people use every day. In companies, conversations such as “let’s add AI to our service” or “let’s build an internal document Q&A bot” now happen routinely.

But these conversations often contain confusion.

• “If we use RAG, does hallucination disappear?” — half right, half wrong.
• “GPT-5 has more parameters, so it must be better, right?” — if you do not know what a parameter is, you cannot judge.
• “Please train the model on our company policy.” — the word “train” can mean three different things here.

The goal of this curriculum is simple. Even someone who has forgotten math up to middle school should be able to read only this set of documents and reach undergraduate-level conceptual understanding of AI. The goal is not deriving formulas. It is building the ability to judge for yourself what is right and wrong in conversations like the ones above.

Module 00 is the time to unfold the map before the trip. Even if you do not know the detailed geography, you first see where the cities are and what roads connect them.

One-line summary: This curriculum aims for conceptual understanding that lets you judge AI conversations yourself, not formula derivation; module 00 shows the full map.

---

2. First, an analogy — traveling to a large city for the first time

Studying AI is like traveling through a huge city for the first time.

• Bad trip: as soon as you land at the airport, you get lost in alleys, meaning formulas. Because you do not know where you are in the city, you quickly get tired.
• Good trip: first you go up to an observation deck and look over the whole city. “The river splits the city, the north is the old town, and the south is the new town.” Then you walk through one district at a time.

This module is that observation deck. We look at three things.

1. Terrain — how the terms AI, machine learning, deep learning, and LLM overlap
2. Logistics flow — how modern AI products start from data and pass through processes before reaching your hands
3. City history — how this city collapsed twice and then flourished as it does now

From the observation deck, you do not need to read every sign. The things you only roughly understand in this module will be zoomed in one by one in modules 01-36.

One-line summary: Before entering the alleys, meaning detailed theory, start from the observation deck, meaning the whole picture. That is this module’s role.

---

3. Terminology map: AI ⊃ machine learning ⊃ deep learning ⊃ LLM

In the news, AI, machine learning, deep learning, and LLM are often used as if they mean almost the same thing. In reality, they are nested like Russian dolls.

Meaning of each layer

Term	One-line definition	Representative examples	Main modules
Artificial Intelligence (AI)	Any technology that imitates human intellectual activity	Rule-based chess program, navigation route search	This module
Machine Learning	A method where the computer finds rules from data instead of humans writing rules	Spam filter, product recommendation	Module 02
Deep Learning	Machine learning that stacks artificial neural networks deeply	Face recognition, speech recognition	Module 03
Large Language Model (LLM)	A very large deep learning model pretrained on massive text	ChatGPT, Claude	Modules 04-10
Diffusion model	A deep learning model that restores images from noise	Stable Diffusion, Midjourney	Module 16

The key points are these.

• Not all AI is machine learning. Expert systems in the 1980s were bundles of thousands of hand-written if-then rules. They are AI even without learning.
• Not all machine learning is deep learning. Classical methods such as decision trees and linear regression learn from data without neural networks (→ module 02).
• ChatGPT is inside the innermost doll. To understand ChatGPT, you need to understand the outer dolls first, meaning machine learning and deep learning. That is why this curriculum is ordered module 02 → 03 → …

Traditional programming vs machine learning — the one most important difference

If there is one conceptual shift running through this entire curriculum, it is this.

	Traditional programming	Machine learning
What humans provide	Rules + input	Input + correct examples (data)
What the computer produces	Output	Rules (model)
Example: spam filter	Developer directly writes a rule such as “if the word free appears, mark as spam”	Show 100,000 spam/normal emails and the system finds the decision rule itself
If rules change	Developer edits code	Train again with new data

Let’s build intuition with a mini example. There are three emails.

Email	Contains “free”?	Number of exclamation marks	Correct answer
A	Yes	3	Spam
B	Yes	0	Spam
C	No	0	Normal

In the traditional approach, a developer writes code saying “if it contains free, it is spam.” In the machine learning approach, we give only this table, the data, and say “you find the rule.” The computer discovers the pattern that whether “free” appears matches the answer. With only three rows it looks trivial, but scaling this to 100,000 examples and thousands of features gives a real spam filter; scaling it to trillions of words gives an LLM. Exactly how the system “discovers” this is the topic of module 02.

One-line summary: The relationship is AI ⊃ machine learning ⊃ deep learning ⊃ LLM, and the essence of machine learning is “data, not humans, creates the rules.”

---

4. The big picture of modern AI: data → pretraining → alignment → product

Products like ChatGPT are not made overnight. They pass through roughly four stages, and later modules in this curriculum cover each stage.

Using cooking as an analogy:

1. Data collection = grocery shopping. Collect trillions of words from web documents, books, code, and more. Bad ingredients make bad food.
2. Pretraining = basic skill training. Using the collected text, the model solves the simple problem of “predict the next word” hundreds of billions of times. This repetition alone stores grammar, common sense, and ingredients of reasoning in the model (→ module 07). After this stage, the model is like a kitchen assistant with lots of cooking knowledge but no customer-service manners.
3. Alignment = customer-service training. Teach attitudes such as “answer questions” and “refuse dangerous requests.” Techniques such as RLHF, which reflects human preferences, belong here (→ module 08).
4. Product layer = store operation. Wrap the finished model to make a real service. RAG, which finds company documents and answers with evidence (→ module 13), Tool Calling, which lets the model call calculators or APIs (→ module 14), and Agents, which plan and execute multiple steps (→ module 15), all belong to this layer.

The curriculum flow for these processes looks like this.

flowchart LR
    A[Data collection] --> B["Pretraining (module 07)"]
    B --> C["Alignment (module 08)"]
    C --> D[Finished model]
    D --> E["Efficiency and serving (module 10)"]
    E --> F["Product layer (modules 11-15)"]
    F --> G[User]

There is one more process between the finished model and the product layer: efficiency and inference. If you run a model with hundreds of billions of dials as-is, it is too slow and too expensive. So techniques such as slimming it down with quantization and reusing computation with caching are used (→ module 10). API price and response speed are determined here.

One practical insight: if your company wants to build an “internal document Q&A bot,” you almost always work on stage 4, the product layer. Stages 1-3 cost enormous amounts of money, so companies such as OpenAI, Anthropic, and Google handle them. Most companies rent a finished model and design the product layer. That is why this curriculum covers both principles (modules 01-10) and product construction (modules 11-15).

One-line summary: Modern AI is made through the four-stage process “data → pretraining → alignment → product,” and most practical work happens in the final product layer.

---

5. The journey of one question: what happens inside ChatGPT

Now let’s ask a finished product one question. Internally, something like this happens. For now, just become familiar with the stage names. Detailed principles are handled in the indicated modules.

sequenceDiagram
    participant U as User
    participant T as Tokenizer
    participant M as Model body
    participant D as Decoding
    U->>T: Input "Where does the cat sleep?"
    T->>M: Convert text to token IDs (module 04)
    M->>M: Understand context with attention (modules 05-06)
    M->>D: Output probability distribution for the next token
    D->>D: Select one token from probabilities (module 09)
    D->>U: Display selected token
    Note over T,D: Repeat this process for every token

Step by step:

1. Tokenization. A model cannot read letters directly. It splits a sentence into pieces called tokens and turns each piece into an ID. For example, “the cat sleeps on the sofa” may be split into pieces like [the, cat, sleeps, on, the, sofa] (→ module 04).
2. Embedding. Each token ID becomes a list of numbers, a vector. These numbers act like “meaning coordinates” for words (→ module 04).
3. Passing through the Transformer body. The text passes through dozens of layers. In each layer, a mechanism called attention calculates “which words in the sentence should I refer to in order to understand this word” (→ modules 05-06).
4. Probability distribution output. The model’s final output is not a sentence. It is a probability table for what the next token might be.
5. Decoding. Select one token from that probability table. You may choose only the most likely one, or you may mix in some randomness (→ module 09).
6. Repeat. Attach the selected token to the end of the input and repeat steps 1-5. The reason answers appear to flow out one character or piece at a time is exactly this: they are generated token by token.

Mini example: if the input has reached “the cat sleeps on the”, the model’s output might be this probability table.

Next token candidate	Probability
sofa	0.62
bed	0.15
floor	0.08
roof	0.05
Tens of thousands of others	0.10

If “sofa” is selected, the sentence becomes “the cat sleeps on the sofa,” and the model again outputs the probability table for the next token, such as a period. ChatGPT is ultimately a repeated loop of “next-token probability calculator + selection machine.” The mystery solved across modules 04-09 is how such a simple identity produces such plausible abilities.

One-line summary: One question is processed through repeated “tokenization → embedding → attention → probability table → token selection,” and later modules handle each stage.

---

6. 70 years of AI history: two winters and one explosion

AI did not suddenly appear. It is a 70-year drama that began around 1950. Knowing which season we are in changes how you read the news.

Period	Event	Why it matters
1950	Turing’s “Can machines think?” paper	Proposed the Turing Test, judging intelligence through conversation. The beginning of the AI question
1956	Dartmouth workshop	The name “Artificial Intelligence” was born
1958	Perceptron	The first artificial neuron, ancestor of today’s neural networks (→ module 03)
1970s-80s	Two AI winters	Overhyped expectations → poor results → investment disappeared. Proof of perceptron limitations was one trigger
2012	AlexNet	Deep learning won an image-recognition competition by a large margin. Signal of the deep learning revival
2017	Transformer paper	The shared blueprint for modern LLMs appeared (→ module 06)
2020	GPT-3	Demonstrated that scaling models can reveal new abilities (→ module 07)
2022	ChatGPT	A model tamed with RLHF (→ module 08) reached the public. 100 million users in two months
Present	Multimodal and agents	AI handles images and speech beyond text (→ module 16), and acts with tools (→ module 15)

The story of two winters

Let’s look a little deeper at the “AI winters” in the timeline. It helps us stay sober about today’s heat.

The first winter, in the 1970s. When the perceptron appeared in 1958, media and military funders poured in money, saying “thinking machines are near.” But in 1969, leading scholars mathematically proved that a single-layer perceptron could not solve even a very simple problem: XOR, which is true only when two conditions differ. Stacking multiple layers would solve it, but at the time we had neither training methods nor computing power for multiple layers. Funding dried up, and researchers left the field.

The second winter, late 1980s-1990s. This time, expert systems, where people hand-wrote rules, became popular. Early results were good, but as rules grew into tens of thousands, maintenance became impossible and exceptions broke the systems. The lesson was “humans cannot write every rule.” This is the background that made machine learning, “let the data find the rules,” become mainstream (→ module 02).

What melted the winters was AlexNet in 2012. In the ImageNet competition, where others fought over 1-2 percentage points in error rate, a deep learning team lowered error by nearly 10 percentage points at once. Academia and industry changed direction.

There are two historical lessons to remember.

First, AI winters came not because the technology was wrong, but because expectations ran too far ahead. When the perceptron appeared in 1958, newspapers wrote that walking and talking machines would soon arrive. That took about 60 more years. The idea, neural networks, was right, but computing power and data were nowhere near enough.

Second, the explosion after 2012 happened because three ingredients arrived at once. 1. massive data accumulated by the internet, 2. cheap large-scale computation from GPUs originally used for games, and 3. algorithms refined over decades. Without any one of the three, today’s AI would not exist.

One-line summary: AI spent 70 years moving between hype and winter, exploded after 2012 when data, GPUs, and algorithms aligned, and the 2017 Transformer set the current board.

---

7. Learning map: the path connecting 37 modules

This curriculum has two layers.

• Core track (00-18): a single story of how LLMs are built, aligned, assembled into products, and operated.
• Breadth supplement track (19-36): classical AI, traditional ML, vision, speech, robotics, MLOps, security, governance, and domain AI, which are easy to miss from an LLM-only view.

First, the principle flow of the core track.

flowchart TD
    M00[00 Orientation] --> M01[01 Minimal math]
    M01 --> M02[02 Machine learning basics]
    M02 --> M03[03 Neural networks]
    M03 --> M04[04 Tokens and embeddings]
    M04 --> M05[05 Sequence models and attention]
    M05 --> M06[06 Transformer deep dive]
    M06 --> M07[07 Building an LLM]
    M07 --> M08["08 Taming models with RLHF"]
    M08 --> M09[09 How generation works]
    M09 --> M10[10 Efficiency and inference]

The principle track proceeds like stacking bricks. You need the minimal math of vectors (01) to see machine learning (02), machine learning to see neural networks (03), and then layer by layer you reach the summit called the Transformer in module 06. Modules 07-10 show how to scale, align, and run it as an LLM.

Next is the product track.

flowchart TD
    M10[10 Efficiency and inference] --> M11[11 AI product architecture]
    M11 --> M12[12 Vector search]
    M12 --> M13[13 RAG]
    M13 --> M14[14 Tool calling]
    M14 --> M15[15 Agent]
    M11 --> M16[16 Diffusion and multimodal]
    M15 --> M17[17 Evaluation and operations]
    M16 --> M17
    M17 --> M18[18 Coding Agent Harness]

The product track is the story of “what do we build with a finished model?” We examine product architecture (11), lay search infrastructure (12), expand capabilities through RAG (13) → Tool calling (14) → Agent (15), add image generation and multimodal AI (16), and then learn “how do we know what we built works?” (17). Module 18 is the finale practice: designing a coding agent harness.

Finally, the breadth supplement track.

flowchart TD
    M19[19 Classical AI Problem Solving] --> M20[20 Knowledge Representation]
    M20 --> M21[21 Probabilistic Reasoning and Causality]
    M21 --> M22[22 Planning and Reinforcement Learning]
    M22 --> M23[23 Classical Machine Learning Zoo]
    M23 --> M24[24 Data-Centric AI]
    M24 --> M25[25 NLP Beyond LLMs]
    M25 --> M26[26 Computer Vision]
    M26 --> M27[27 Speech and Audio AI]
    M27 --> M28[28 Recommender Search Ranking]
    M28 --> M29[29 Robotics and Embodied AI]
    M29 --> M30[30 ML Systems and MLOps]
    M30 --> M31[31 Scalable AI Infrastructure]
    M31 --> M32[32 AI Security Privacy Safety]
    M32 --> M33[33 Responsible AI Governance]
    M33 --> M34[34 Human-Centered AI]
    M34 --> M35[35 AI by Domain]
    M35 --> M36[36 Research Literacy]

The important point is that the numbering is not the only possible academic prerequisite order. Modules 00-18 are the default route for quickly understanding LLM systems. Modules 19-36 are the route for broadening the map of AI afterward. If you want academic breadth first, you can read 19-24 after 00-03, then return to 04-18 and 25-36.

Expected study time

Section	Modules	Expected time per module	Note
Warm-up	00	2-2.5 hours	This module
Principle track	01-10	4-6 hours	Do not rush 01, because minimal math supports everything afterward
Product track	11-18	3-6 hours	Directly practical. 18 is the coding agent harness finale
Breadth supplement	19-36	2-4 hours	Compressed modules for broadening the field map

At a pace of two modules per week, 00-18 takes about 2-3 months. Including 19-36, 4-5 months is more realistic. You may be tempted to skip ahead, for example “I just want RAG quickly,” but if you read only the product track without the principle track, you can imitate operation without knowing why it works. If you are in a hurry, at least pass through 01-04 first.

Recommended paths by situation

Course	Path	For whom
Core standard course	00 → all of 18 in order	People who want a solid grasp of LLM systems and product structure
Full breadth course	00 → all of 36 in order	People who want to broaden the whole AI field map beyond LLMs
Academic breadth first	00 → 01 → 02 → 03 → 19 → 20 → 21 → 23 → 24 → 22 → 04-18 → 25-36	People who want to first understand the place of classical AI and traditional ML
Practical fast course	00 → 01 → 02 → 04 → 11 → 12 → 13 → 14 → 15 → 17 → 18	People who must design an internal document Q&A bot or coding-agent product now
Principle focused course	00 → 01-10	People asking “what exactly is a Transformer?”

Even if you choose the fast course, return to skipped modules, especially 03, 05, and 06, when you have time. Building RAG without understanding attention is different from building it with a sense of context design.

One-line summary: Modules 01-10 stack the bricks of principle, 11-18 build LLM products, and 19-36 broaden the map of AI as a whole.

---

8. How to study: run each module this way

Each module is one complete Markdown body. The recommended study loop is:

flowchart LR
    A[Check the key question in README] --> B[Read the body carefully]
    B --> C[Explain the key summary in your own words]
    C --> D{Are there few blocked concepts?}
    D -->|Yes| E[Next module]
    D -->|No| F[Reread only blocked sections]
    F --> C

Concrete tips:

• Read the README’s key question first. The goal of a module is to answer that question. If you get lost in the body, return to the key question.
• Restate the key summary in your own words. You can practice retrieval without a workbook. Look at each line of the summary table and explain aloud what it means.
• Follow mini hand-calculation examples yourself. Small examples with 2-3 numbers appear throughout the body. If you only read them with your eyes, they disappear after five minutes; if you write them once on paper, they stay.
• Analogies are starting points, not destinations. Every analogy becomes inaccurate somewhere. When the body says “where this analogy breaks,” pay special attention.
• If stuck, moving forward is acceptable. Later modules often make earlier concepts click. If you are blocked on one section for more than 30 minutes, mark it and continue.

One-line summary: Use the loop “check key question → read body → explain key summary in your own words → reread blocked sections.”

---

9. Fixing term confusion: “learns,” “knows,” and “parameters”

Three expressions cause the most confusion in AI conversations. We preview them here; precise understanding is completed in modules 02-03.

”AI learns” — not studying, but dial adjustment

Do not imagine human learning. Machine “training” is the repetition of this loop.

flowchart TD
    A[Give a problem - what is the next word?] --> B[The model guesses]
    B --> C[Compare with the correct answer and measure error]
    C --> D[Adjust parameters a tiny bit in the direction that reduces error]
    D --> A

It is like turning a radio frequency dial to find the direction where noise decreases. The only difference is that there are not 2-3 dials, but hundreds of billions, and the adjustment repeats hundreds of billions of times. “Measuring how wrong it is” appears in module 02 as the loss function, and “adjusting in the direction that reduces it” appears as gradient descent.

Another important fact: when you talk with ChatGPT, the model is not learning. The dials were fixed during training, and during conversation the model only computes in read-only mode. That is why it cannot remember what you told it yesterday in a new conversation. Your conversations may be used as material for later training, but that is a separate process.

”The model knows” — not a database, but a bundle of patterns

The model does not store sentences or documents inside. It is not a database that retrieves facts. It is a bundle of statistical patterns distilled from training text. It answers “Paris” to “the capital of France is” not because that sentence is stored somewhere, but because the dials are tuned so that “Paris” has overwhelmingly high probability after that phrase.

Two practical conclusions follow.

• In weak-pattern areas such as rare facts or events after training, it calmly produces plausible but wrong sentences. This is hallucination. It is not just a bug; it is a natural side effect of being a probabilistic sentence generator.
• Therefore, when you need current or internal information, you need product-layer designs such as RAG (→ module 13), which finds documents outside the model and passes them in. This is why an internal document Q&A bot cannot be just the model.

”175 billion parameters” — the number of dials

A parameter is one of the adjustable dials above. Its physical form is a single number such as 0.0231. Saying “GPT-3 has 175 billion parameters” means there are 175 billion such numbers. A tiny two-neuron network might have roughly four parameters: two numbers multiplied by inputs plus two base values. Module 03 introduces that structure through hand calculation.

More parameters generally allow more patterns and often improve capability, but performance does not increase in direct proportion. Amount and quality of data and training method must also match (→ module 07). Today, smaller models often beat larger models with better data and techniques. Drop the habit of reading “parameter count = performance grade.”

Bonus: three meanings of “please train it on our company policy”

Now we can break down the sentence previewed in section 1. In practice, this request usually means one of three things, with wildly different cost and difficulty.

Interpretation	Actual work	Analogy	Modules
Put it in the prompt	Include the full policy in the conversation input	Open-book exam	Module 11
RAG	Retrieve only policy chunks related to the question and insert them	Librarian who finds the needed pages	Modules 12-13
Fine-tuning	Actually adjust dials using company data	Send the employee back to training camp	Module 08

Most “please train it” requests are handled by the first or second option, and true training, the third option, is rarer than people think. This distinction alone can cut meeting time in half.

Common expression	Misleading association	Actual meaning
”AI learns”	It studies and understands like a person	It repeatedly adjusts hundreds of billions of dials to reduce error
”The model knows”	Facts are stored like a database	They are compressed as next-token probability patterns, which is why hallucination happens
”N parameters”	Bigger means automatically smarter	It means N adjustable numbers. Data and method also matter

One-line summary: Learning is dial adjustment, knowledge is probability patterns, and parameters are dial counts. All three refer to mechanical realities different from human cognition.

---

10. Common misunderstandings

Misunderstanding 1: “ChatGPT searches the internet in real time to answer.” Usually no. Answers are generated from patterns formed from data up to the training time. Products that look like they search the web have an external search tool attached (→ module 14 Tool calling). That is product-layer design, not the model’s inherent ability.

Misunderstanding 2: “AI is improving itself.” The current deployed model does not change by itself. If performance improved, the company trained and replaced it with a new version. If answers feel better than yesterday, it may be a version change, prompt difference, or randomness from probabilistic generation.

Misunderstanding 3: “Hallucination is a bug and will soon be completely fixed.” Hallucination is not a code bug; it is the shadow of the operating principle “select the next token by probability.” RAG (→ module 13) or evaluation systems (→ module 17) can greatly reduce it, but as long as the principle remains, it is hard to make it exactly zero. Designing to reduce it is a core practical skill.

Misunderstanding 4: “If AI says ‘sorry,’ it feels sorry.” That sentence is also just a high-probability next token for the situation. Outputting emotional vocabulary and having emotions are different. The model is polite because the alignment stage (→ module 08) tuned it to prefer such responses.

Misunderstanding 5: “Old machine learning became useless after deep learning appeared.” No. For tabular data such as loan screening or churn prediction, decision-tree families still often beat deep learning; they are fast, cheap, and easy to explain (→ module 02). Learning to choose the right tool for the problem is one goal of this curriculum.

One-line summary: There is no default real-time search, self-improvement, or emotion; hallucination is a shadow of the principle; classical machine learning is still active.

---

11. Position of this module in the full map

• Previous module: none. This is the starting point.
• This module: from the observation deck, we saw the terrain (term relationships), process (pipeline), history (timeline), and travel plan (learning map).
• Next module (→ module 01 minimal math): now we go down into the first alley. Vectors, matrices, probability, functions: we will equip the minimal math tools used in all later modules, with concepts only and no calculation drills. Concepts previewed here, such as embeddings as lists of numbers, probability tables, and dial adjustment, all reappear in the language of module 01.

Preview of concepts that only appeared by name here:

Concept touched in this module	Main module
Tokens, embeddings	Module 04
attention	Modules 05-06
Next-word prediction training	Module 07
RLHF, alignment	Module 08
Selecting tokens from probability tables	Module 09
RAG, Tool calling, Agent	Modules 13-15

One-line summary: Module 00 was the observation deck for the whole trip, and the next stop is minimal math (module 01), the common language of all modules.

---

12. Key summary

1. Goal of this curriculum: help even people who have forgotten math reach undergraduate AI-major-level conceptual understanding.
2. Term relationship: AI ⊃ machine learning ⊃ deep learning ⊃ (LLM, Diffusion). ChatGPT is inside the innermost layer.
3. Essence of machine learning: the computer finds rules from data instead of humans writing them.
4. Modern AI process: data → pretraining → alignment → product (RAG/Tool/Agent). Most practical work happens in the product layer.
5. Identity of ChatGPT: a machine that repeats “next-token probability calculation + selection” token by token.
6. History: after two AI winters, AI revived in 2012 through data, GPUs, and algorithms; the 2017 Transformer set the current board.
7. Training = repeated adjustment of dials, parameters, in the direction that reduces error. The model does not train during conversation.
8. Model knowledge = probability patterns, not stored documents. Hallucination is a side effect of this nature.
9. Study method: check key question → read body → explain key summary in your own words → reread blocked sections. 2-6 hours per module.
10. Path: build bricks with the principle track (01-10), build products with the product track (11-18), and broaden the AI map with the supplement track (19-36).

---

13. To go deeper (optional)

You do not need to read the following materials to continue the curriculum. The body is written to be self-contained.

• Alan Turing, “Computing Machinery and Intelligence” (1950) — the original source of the Turing Test. It reads more like a philosophical essay and contains no formulas.
• Vaswani et al., “Attention Is All You Need” (2017) — the original Transformer paper. Rather than reading it now, read it after module 06 as a way to confirm what you already know.
• Andrej Karpathy’s “Intro to Large Language Models” lecture — an introductory lecture that feels like a one-hour expansion of section 5 of this module, the journey of one question.