中文版: AI 学习路线图 00 · 路线图总览

00 · Read This First: The Map of the Road

The AI Learning Roadmap · Stage 0 of 9

---

Why This Stage Matters

You are about to start one of the most rewarding learning journeys available today. Artificial intelligence has moved from research labs into every corner of software, and the skills you will build over the next ten to twelve months are exactly the ones the industry is hiring for right now: understanding how models learn, knowing how to build applications on top of them, and being able to make agents that do real work.

But the field is also noisy. There are hundreds of courses, thousands of papers, and a new "must-learn" framework every week. Without a map, it is easy to spend months studying the wrong things — memorizing APIs that will change, or reading papers before you have the foundations to understand them.

This roadmap is that map. It is a deliberately sequenced path that takes you from zero — no programming, no machine learning background — to building production-grade LLM applications and AI agents. Read this article once, keep it as your reference, and let it tell you where you are at every step.

The Big Picture: One Mental Model

Before the stages, you need one clear mental model of how the field fits together. Every stage in this roadmap walks up the following diagram.

Artificial Intelligence
│  making machines do things that require intelligence
│
└─ Machine Learning
   │  systems that learn from data instead of being programmed
   │
   ├─ Classical ML          → trees, regressions, clustering
   └─ Deep Learning         → neural networks with many layers
      │
      ├─ Computer Vision    → images (CNNs)
      ├─ Speech & Audio
      └─ Natural Language Processing → text
         │
         └─ Large Language Models    → neural networks scaled to
            │                          billions of parameters
            └─ Agents                 → LLMs + tools + memory + loop

Here is the same idea in one sentence per layer:

• Artificial intelligence (AI) is the broad goal: building machines that can perceive, reason, and act.
• Machine learning (ML) is the dominant method: instead of hand-writing rules, we show a program examples and let it find the patterns.
• Deep learning (DL) is ML using neural networks — models with many layers that learn increasingly abstract representations (edges → shapes → objects; letters → words → meaning).
• Large language models (LLMs) are deep networks scaled up and trained on enormous amounts of text. Their core trick is surprisingly simple: predict the next word, over and over. Out of that simple goal, general abilities in writing, reasoning, and coding emerge.
• Agents are LLMs placed inside a loop: they can call tools (search, code, databases), remember what they have done, plan a sequence of actions, and keep going until a task is finished.

Each of the nine stages in this series teaches you exactly one layer of that stack. By Stage 8 you will be building agents; Stage 9 shows you where the frontier is.

How This Roadmap Works: Rhythm and Structure

The series is organized into five phases. The rhythm matters as much as the content: each phase alternates between absorption (learning foundations and theory) and creation (building real things). This alternation is what keeps you motivated and prevents the two classic failure modes — endless theory without building, and building without understanding.

Phase	Stages	Theme	Time
I · Foundations	0–2	Ground: tools and math	Months 1–2
II · Core ML	3–4	Understand: how machines learn	Months 3–5
III · The LLM Era	5–6	Enter: transformers and LLMs	Months 6–7
IV · Build & Deploy	7–8	Create: applications and agents	Months 8–10
V · Beyond	9	Extend: frontier and career	Month 11+

Every article follows the same eight-part template, so you always know what to expect:

1. Why This Stage Matters — motivation, and where it fits on the map
2. Core Concepts — the ideas, explained intuition-first
3. Tools & Skills — what you will actually use
4. Hands-On Tasks — concrete exercises
5. Milestone Checkpoint — a self-test that proves you are ready to move on
6. Curated Resources — a short, carefully chosen list (3–5 items)
7. Time Estimate & Pace — hours and a suggested weekly split
8. Bridge to the Next Stage — one paragraph connecting forward

The milestone checkpoints are not suggestions; they are the actual gate between stages. If you cannot pass the self-test, spend another week on that stage before moving on. If you pass it easily, accelerate.

Five Learning Principles

These principles are baked into every article. Read them once; they will save you hundreds of hours.

1. Learn by building. You do not learn gradient descent by watching videos; you learn it by implementing it and watching your loss curve fall. Every stage ends with a hands-on project, and the projects are the point of the series.

2. Follow the 80/20 rule. Each article deliberately covers the 20% of a topic that gives you 80% of the practical capability. Exotic algorithms and academic depth are marked as "go deeper" options — optional, not required.

3. Learn math just in time. Math is introduced the moment it becomes necessary, intuition first and formulas second. You will never see an abstract topic without a note explaining exactly where it is used.

4. Let knowledge compound. Each stage explicitly reuses the previous one. When you meet an old concept from a new angle — and you will — that is not repetition; it is the same idea becoming part of you.

5. Make progress visible. You track progress through milestones, and you write things down. Explaining what you learned is how you discover what you have not understood yet. (This series exists because writing is the best test of understanding.)

The Tools You Will Meet

Here is the toolkit you will accumulate, stage by stage. Do not try to learn them all now — just know the names so nothing surprises you later.

Stage	Tools
1	Python, Git & GitHub, VS Code, Jupyter
2	NumPy, Matplotlib
3	pandas, scikit-learn
4	PyTorch
5	Hugging Face Transformers
6	vLLM / Ollama, eval harnesses, model APIs
7	LangChain / LangGraph, vector databases, eval frameworks
8	LangGraph (or equivalent), agent frameworks
9	Whatever your capstone project needs

Every one of these is free, well-documented, and has an enormous community. You never need to pay for software in this roadmap.

Mindset: What Actually Determines Success

Four things predict success in this journey more than raw intelligence:

1. Consistency beats intensity. Ten hours a week for ten months beats forty hours a week for two months — because the second schedule ends in burnout. Protect your weekly rhythm like a job.

2. Debugging is the real skill. Most of your time as an AI practitioner will be spent asking "why is this not working?" — a loss that will not drop, a model that repeats itself, an agent stuck in a loop. The good news: debugging is a learnable skill, and every stage trains it. When something fails, read the error, change one thing, test again. This loop is the job.

3. Getting stuck is the process, not a problem. The uncomfortable hour before a concept clicks is where the learning happens. Do not reach for the answer the moment you are confused; give yourself a time-box (say, 30 minutes) of genuine struggle first. Then use your resources.

4. Use AI as your tutor. You are learning about AI while AI is at its most capable. Use a chatbot to explain concepts, review your code, quiz you, and unstick you — but never let it do the learning for you. A good rule: if you could not explain the AI's answer back, you did not learn it.

Milestone Checkpoint

Before moving to Stage 1, complete this checklist:

• Write your personal plan: how many hours per week you can commit, and which day(s) you will study. Write it somewhere you will see it.
• Set up your environment: install Python 3, VS Code, and Git; create a GitHub account. (Stage 1 explains each step.)
• Self-test: explain to a friend (or to yourself, out loud) the difference between AI, ML, deep learning, an LLM, and an agent — using the diagram above.

If you can pass that self-test, you are officially on the road.

Curated Resources

• This roadmap — your primary source; return to this article whenever you lose your bearings.
• Andrej Karpathy — "Intro to Large Language Models" (YouTube, ~1 hour) — the single best one-hour overview of what LLMs are; watch it now, rewatch it at Stage 6.
• 3Blue1Brown — Neural Networks (YouTube series) — the best visual intuition for how networks learn; useful from Stage 2 onward.
• Lilian Weng — "What Are LLMs?" — a deep technical blog archive that grows with you.

That is deliberately short. At every stage we give you 3–5 resources maximum; more choice is not more learning.

Time Estimate & Pace

• Total: ~1 week (10–15 hours total).
• This week: read this article once fully; watch the Karpathy talk; write your plan; set up your environment. The rest of the week is yours — start Stage 1 early if you finish.

Bridge to the Next Stage

You now have the map. Stage 1 gives you the vehicle: Python, Git, and a solid understanding of how the computer underneath actually works. Nothing in the rest of this series is hard once those foundations are truly yours — so let's build them properly.