The Right Way for Beginners to Learn AI: Don't Get the Four-Stage Learning Path Wrong

Many people start learning AI by diving straight into papers and tuning large models, only to find themselves still stuck at the door six months later. The problem is often not the level of effort, but the order of stages. A Bilibili creator breaks AI learning into four stages and points out where most people get stuck—this roadmap is worth checking against for every beginner.

Stage 1: Foundations—Only Three Things

The goal at this level is simple: pave the way for deep learning later. Specifically, just three things—Python, the PyTorch framework, and math.

You don't need deep Python knowledge—being able to write loops, call libraries, and read error messages is enough. The creator particularly emphasizes the "can read error messages" standard: error messages are the first-hand feedback for self-learners, and if you can't read them, all subsequent debugging becomes blind guessing.

For the PyTorch framework, the advice is to jump right in and avoid obscure frameworks—it's the most widely used in industry. As for math—linear algebra, calculus, and probability/statistics—just knowing what the formulas do is enough; no manual computation required.

The most typical pitfall at this level is skipping the basics and going straight to deep learning. The creator's observation is blunt: if you can't understand formulas or get code running, you'll have to come back and fill the gaps, which ends up being slower.

Why PyTorch and not TensorFlow?

PyTorch is maintained by Meta's (formerly Facebook) AI research team and rose to popularity in academia around 2019 thanks to its dynamic computation graph (define-by-run) design. It has now become the default framework for paper reproduction and open-source models (such as the vast majority of models on Hugging Face). In contrast, early TensorFlow featured static graphs and a more mature deployment pipeline, but had a poorer debugging experience and higher onboarding cost. For enterprises, PyTorch appears far more frequently in job postings than other frameworks—this is the practical basis for the creator's advice to "avoid obscure frameworks": learn a framework with an active ecosystem and rich documentation and community resources, so you can more easily find answers when problems arise.

Behind "can read error messages": How to read Python exception stacks

Python error messages are usually read from the bottom up: the last line is the exception type and description (e.g., KeyError, Shape mismatch), and the lines above are the call stack (Traceback), indicating which file, which line, and which level of function call the error occurred in. A large number of errors in deep learning actually come from mismatched tensor shapes, inconsistent data types, and inconsistent devices (CPU/GPU). As long as you develop the habit of first checking the last line's exception type and then tracing the stack to locate your own code, most problems can be diagnosed on your own. This is also the creator's intent in making it a passing standard for the foundation stage: debugging ability determines how self-consistent your subsequent learning will be.

Stage 2: Enter Deep Learning—Get a Model Running Hands-On

After building the foundation, you formally enter deep learning. At this stage, first learn classic network architectures: CNN, RNN, LSTM, GRU—get familiar with what the most basic models look like, then start building.

The passing standard is clear: be able to independently take a model from data loading through training to producing results. Note the keywords here are "independently" and "complete"—not following a tutorial and typing along, but being able to walk the entire pipeline yourself.

This standard may not seem high, but it filters out a large number of learners who "can only import but can't tune parameters." Once you can run through a complete training process, you'll have an intuitive feel for the relationships among data, models, loss functions, and optimizers.

Stage 3: Choose a Direction—Build a Project Worth Putting on Your Resume

At the advanced stage, you can no longer learn broadly; you must choose a direction. The creator lists three mainstream industry directions:

• Structured data direction: e.g., time-series neural networks
• NLP text direction: must understand Transformer and Hugging Face
• Vision direction: object detection, image segmentation, object tracking, behavior recognition

The core at this level is not "getting a demo running" but building a complete project worth putting on your resume. The gap between a demo and a project lies in engineering steps like data cleaning, evaluation, and iteration—and that's exactly what recruiters look at.

What is the relationship between Transformer and Hugging Face?

Transformer is a sequence modeling architecture proposed in the 2017 paper "Attention Is All You Need." Its core is the self-attention mechanism, which replaces the recurrent structure of RNNs, supports parallel computation, and is the foundation of models like BERT and GPT. Hugging Face is an open-source community and tool library built around the Transformer ecosystem; its transformers library wraps thousands of pretrained models, allowing loading, fine-tuning, and inference in just a few lines of code. The NLP direction's requirement to "understand Transformer and use Hugging Face" essentially demands both an understanding of the attention mechanism's principles and proficiency in using ecosystem tools to accomplish practical tasks—both are indispensable.

Stage 4: Read Papers and Write Code—No Shortcuts

Once the direction is chosen, if you want to go further, there's only one path: read papers and write code.

Start reading papers with classic ones, focusing on understanding why models are designed the way they are, not just memorizing conclusions. For coding, try to reproduce models yourself, or even modify model architectures, rather than staying forever at the level of calling libraries. The creator's exact words: "There are no shortcuts—it's just repeatedly grinding with papers and code."

The real watershed at this level is whether you can continue building on top of large models: RAG, Agent, fine-tuning, post-training, inference acceleration, deployment, etc. Being able to connect these pieces and land them is what it truly takes to reach the threshold of large models.

What do RAG, Agent, fine-tuning, and post-training each mean?

RAG (Retrieval-Augmented Generation) retrieves relevant documents from an external knowledge base before the large model generates, splicing the retrieval results into the prompt, thereby alleviating the model's outdated knowledge and hallucination problems. Agent (intelligent agent) refers to a paradigm where a large model calls tools, plans multi-step tasks, and iterates actions based on feedback. Fine-tuning is continuing to train a pretrained model with domain data to adapt it to a specific task; post-training is a broader term covering alignment methods such as supervised fine-tuning (SFT) and RLHF/DPO. Inference acceleration and deployment focus on engineering optimizations like quantization, distillation, KV Cache, and vLLM. Together, these form a complete capability chain from "knowing how to use models" to "being able to ship products."

Lessons from the Four-Stage Roadmap

The value of this breakdown is that it turns the vague goal of "learning AI" into verifiable checkpoints: each level has clear passing standards rather than judging by feel whether you've learned it. Comparing yourself against it, most people get stuck either because they skip levels (tuning large models before building foundations) or because they stop at the demo level (unable to complete a full project loop).

The original article's ending mentions that the author has prepared a learning roadmap and materials, available in the homepage group—not elaborated here. For self-learners, more important than materials is first confirming which level you're currently at—get the order right, and your effort won't be wasted.

One-line Summary

AI learning has four stages; skipping levels and stopping at demos are the main reasons most people get stuck.

Paragraph Summary

The article breaks AI learning into four verifiable stages: the first level builds foundations—Python that can read error messages, PyTorch proficiency, and just knowing what math formulas do; the second level enters deep learning, learning classic architectures like CNN, RNN, LSTM, GRU, with the passing standard being independently running the complete pipeline from data loading to training results; the third level requires choosing one direction—structured data, NLP, or vision—and building a complete project worth putting on a resume rather than a demo; the fourth level relies on repeatedly grinding through papers and code, with the real watershed being whether you can complete landing work like RAG, Agent, fine-tuning, and deployment on top of large models. The author points out that most people get stuck either by skipping levels or by stopping at the demo level—get the order right, and your effort won't be wasted.