"不是工作让人绝望，是上班让人绝望。" "上班"是沦为资本机器中的零件，受外部指令支配；而"工作"是拥有绝对自主权，是"自己那点事"，基于天职与才干，伴随着创造的快乐。 ——陈丹青

如果用一个词来形容我的2025，那一定是重塑自我。 回想上一年的这个时候，我还在为未来感到迷茫。谁能想到，那台曾经被我认为是"过度投入"的台式机，现在竟然成了我最强的生产力工具，跑模型、做渲染，撑起了我的技术底座。这一年，我从迷茫中杀出了一条血路，虽然跌跌撞撞，但也算是在这波涛汹涌的浪潮中站稳了脚跟。

1. 编程范式的转变：从 1.0 到 2.0​

我们要学的不是一种新的编程语言，而是一种全新的思考方式。

传统编程（Software 1.0）​

如果你是写业务代码的工程师，你每天做的事情大概是这样的：你告诉计算机每一条具体的规则。

如果你是写业务代码的工程师，你每天做的事情大概是这样的：你告诉计算机每一条具体的规则。

• 场景：判断一张照片里是不是猫。
• 做法：写 if (有耳朵) and (有胡须) and (毛茸茸)...
• 问题：根本写不完！老虎也有耳朵胡须，玩具猫怎么算？规则稍微变一点，代码就得重写。

$规则 + 数据 = 答案$

机器学习（Software 2.0）​

既然规则太复杂写不出来，那能不能让机器自己把规则找出来？

我们不写规则了，给机器看一万张猫的照片和一万张不是猫的照片，然后告诉它："你自己找规律，反正左边这些必须叫'猫'，右边这些不行。"

机器经过一通计算，最后归纳出了一套超级复杂的数学公式（可能有一亿个参数）。这套公式，就是我们炼出来的模型（Model）。

$答案 + 数据 = 规则$

这就是机器学习的核心：用数据换取规则。

2. 三大学习范式​

和人类学习方式一样，机器学习也有三种范式。

2.1 监督学习（Supervised Learning）​

2.2 无监督学习（Unsupervised Learning）​

2.3 强化学习（Reinforcement Learning）​

3. 绕不开的数学直觉​

虽然我们承诺不堆砌吓人的公式，但知识图谱里的这几个数学名词，是你学 AI 必须建立的核心直觉。它们构成了机器能"学"懂一切的数理基石。

3.1 概率统计：模型眼里的世界是不确定的​

• 概率分布：现代AI输出的往往不是绝对的答案（"这是猫"），而是概率分布（"90%是猫，10%是狗"）。理解这一点，就能理解为什么语言模型每次生成的回答都不一样。
• 最大似然估计（MLE）：听起来很高深，其实就是"事后诸葛亮"。训练模型的过程，其实就是在寻找一组参数，使得这组参数**最有可能（似然最大化）**推导出我们手头正确的训练数据。
• 贝叶斯定理：不仅是推荐系统的底层逻辑，也是人类学习的逻辑。它告诉模型如何根据"新收集的证据（后验）"来修正原本的"固有印象（先验）"。
• 信息论（熵与交叉熵）："熵"在物理学里代表混乱，在信息论里代表不确定性。衡量"模型的预测概率"和"真实答案"之间有多大差异的尺子，就是我们要学的交叉熵。

3.2 微积分与凸优化：如何找到最优解​

• 导数与链式法则：导数就是斜率（下山的坡度）。而在有很多步骤的复杂计算中，如何把最终的误差"一层层向前传导回去"？这就靠高数里最重要的链式法则。它就是下一章我们要学的反向传播的灵魂。
• 凸优化与拉格朗日乘子法：早期的机器学习（比如传统的支持向量机 SVM）非常追求数学完美，利用这些方法能在理论上证明找到了"全局最优的唯一解"；但现在的深层神经网络面对的地形太复杂了（非凸优化），我们大多只能靠"梯度下降"这种摸石头过河的方法找可行解。

3.3 线性代数：AI 世界的"乐高积木"​

• 标量、向量、矩阵与张量（Tensor）：AI 里的数据到底长什么样？一个孤立的数字叫标量；一排数字叫向量；一张由数字组成的二维表格叫矩阵；三维及以上的数字魔方统称张量。大名鼎鼎的 PyTorch，本质上就是一个超级强大的"张量计算器"（类似于自带 GPU 加速的高级 NumPy）。
• 矩阵乘法与点积（Dot Product）：神经网络前向传播的本质，就是把你的输入数据矩阵和无穷无尽的权重矩阵相乘。到了第2阶段你会发现，让 Transformer 一战封神的注意力机制，核心动作不过是精妙地计算了几次点积（算出两个向量在某个维度上有多少"相似度"）。
• 广播机制（Broadcasting）：写 AI 代码最常碰到的概念。当你把一个"小矩阵"（比如偏置常量）加到"大矩阵"上时，底层框架会自动把小矩阵复制并拉伸到和大矩阵一样的形状再计算。理解了这个，你的网络模型才不会一上线就疯狂报"维度不匹配"的错。

4. 工程师黑话对照表​

以后看论文、看文档，你会反复看到这几个词，先把它们映射到人话：

5. 机器"学习"的本质：训练循环​

这是本章最重要的部分。所谓"训练模型"，其实就是在跑一个死循环。

想象一个蒙着眼睛的人摸着下山：

第一步：猜（Forward Pass / 前向传播） 模型拿到一道题，先根据当前参数瞎猜一个答案。

模型：我觉得这是猫！

第二步：对答案（Loss Function / 损失函数） 用损失函数来衡量猜得有多离谱。Loss 越高表示错得越离谱。

裁判：错！这是狗。你的答案离正确答案差了十万八千里（Loss = 1000）。

第三步：找方向（Gradient / 梯度） 计算出要往哪个方向调参数，才能让 Loss 变小。就把梯度理解成"坡度"——指出下山的方向。

模型：那我该往哪个方向改？是把参数调大点还是调小点？

第四步：改错（Optimizer / 优化器） 用优化器按照梯度方向，微调模型里的参数。

优化器：刚才那个参数调小一点点，下次应该能对。

这个循环跑几百万次，直到 Loss 几乎变成 0，我们就说：训练完成了。

6. 一个必须知道的陷阱：过拟合​

Loss 越低 = 模型越好？不对。

过拟合（Overfitting）：模型在训练集上 Loss 极低，但在新数据上一塌糊涂。 就像一个学生把历年真题答案全背下来了，但换一道新题就不会了。

这也是为什么我们要把数据分成三份：

• 训练集（Training Set）：用来训练，调整参数。
• 验证集（Validation Set）：训练过程中监控"有没有过拟合"，不用于更新参数。
• 测试集（Test Set）：训练完成后，最终考试用一次，评估真实水平。

7. 总结​

1. 机器学习 = 用数据换规则，让机器自己找规律。
2. 监督学习 是最主流的范式，本质就是带答案的刷题。而强化学习则是 DeepSeek-R1 等终极推理模型的秘密基石。
3. 训练循环 = 猜答案 → 算 Loss误差 → 找下山梯度 → 优化器改参数，循环往复。
4. 过拟合 是永恒的陷阱，训练集/验证集/测试集的划分是基本功。

有了这个“黑箱循环框架”，这就足够了。 关于具体的 损失函数（交叉熵/MSE） 和 优化器（SGD/AdamW等） 有哪些分类，这属于构建具体模型时的底层黑科技，我们将在下一阶段详细解答。

下一章预告： 现在我们知道了机器是怎么"学"的——但如果问题复杂到了“识别图片是一只猫”、或者“理解一段长语言”？仅仅靠简单的线性数学公式绝对搞不定。

这就需要一个层级庞大、能画出任意弯曲边界的超级"脑子"——欢迎进入第1阶段：深度学习核心。 我们将在这个阶段，把神经网络这个黑箱扒开，看看人工神经元和链式法则的真面目。

下一章: 1.1 神经网络骨架（MLP与反向传播）

📍 开篇：怎么用这份图谱​

这是什么​

一张 AI 工程学习路线图，按学习顺序排列。你可以把它理解为"课程大纲"——在开始每个阶段之前，先来这里扫一眼该阶段的关键词，学完之后再回来，看看掌握了多少。

优先级说明​

每个技术点都有优先级标注，含义如下：

默认前置条件​

本图谱默认你已经具备：

• 基本编程能力（Python/JavaScript）
• HTTP/API 调用基础
• JSON/数据结构理解
• Git/命令行操作

如果这些还不会，先去补，本图谱不展开。

📊 全局路线图​

第0阶段  →  第1阶段  →  第2阶段  →  第3阶段  →  第4阶段  →  第5阶段
数学基础     深度学习     Transformer   提示工程     RAG         Agent

                                                              ↓
                                                         第6阶段  第7阶段
                                              ←  ←  ←  微调    部署优化

第8阶段  第9阶段  第10阶段
多模态   评估安全  商业生态  ← 可与第3-5阶段并行学习

建议路径：0 → 1 → 2 → 3 → 4 → 5，这是核心主线。
第6-7阶段（微调/部署）和第8-10阶段可以按需跳入。

第0阶段：数学与编程基础​

🎯 目标：建立直觉，不是变成数学家。够用就行。

Python 基础​

• 🔥 P0 Python 语法与数据结构（列表、字典、函数、类）
• 🔥 P0 NumPy / PyTorch 张量操作（矩阵运算是日后看代码的基础）
• ⭐ P1 虚拟环境管理（conda / venv）

线性代数​

• 🔥 P0 向量与矩阵（AI 里的数据全是矩阵）
• 🔥 P0 点积（Dot Product）（注意力机制的核心运算）
• ⭐ P1 特征值/特征向量（理解 PCA 降维时用到）

概率统计​

• 🔥 P0 概率分布（模型输出的是概率，不是答案）
• 🔥 P0 最大似然估计（理解"模型在优化什么"）
• ⭐ P1 贝叶斯定理（理解先验/后验）
• ⭐ P1 信息论基础（熵、交叉熵——损失函数的来源）

微积分​

• 🔥 P0 导数与链式法则（反向传播的数学基础）
• ⭐ P1 梯度下降的直观理解

机器学习基础​

• 🔥 P0 监督学习 / 无监督学习（两种学习范式）
• 🔥 P0 训练集 / 验证集 / 测试集（为什么要分，怎么分）
• 🔥 P0 过拟合（Overfitting）（模型在考试题上刷满分，但真题翻车）
• ⭐ P1 凸优化、拉格朗日乘子法

第1阶段：深度学习核心​

🎯 目标：理解神经网络是怎么"学"的，知道每个组件在干什么。

神经网络基础​

• 🔥 P0 神经元与多层感知机（MLP）（AI 的基本单元）
• 🔥 P0 激活函数：ReLU / Sigmoid / Tanh（为什么不能全是线性？）
• 🔥 P0 前向传播（Forward Pass）（数据从左到右流动，得到预测）
• 🔥 P0 反向传播（Backward Pass / Backpropagation）（误差从右到左流动，分摊责任）
• 🔥 P0 损失函数：交叉熵（分类）/ MSE（回归）

训练技巧​

• 🔥 P0 优化器：SGD → Adam → AdamW（怎么用梯度更新参数）
• 🔥 P0 Dropout（训练时随机"关掉"一些神经元，防过拟合）
• 🔥 P0 Batch Normalization（让每层的输入保持稳定分布）
• ⭐ P1 残差连接（ResNet / Skip Connection）（解决深层网络梯度消失问题）
• ⭐ P1 Layer Normalization / RMSNorm（Transformer 用的归一化，不是 BN）
• ⭐ P1 激活函数进阶：GELU / SiLU / Swish（现代 LLM 用的激活函数）
• 📚 P2 梯度裁剪（Gradient Clipping）
• 📚 P2 二阶优化方法、Lion 优化器

CNN卷积网络​

• 🔥 P0 卷积（Convolution）与局部特征提取（利用带着特征滤镜的手电筒扫描）
• 🔥 P0 池化（Pooling）（抓大放小，层层抽象与平移不变性）
• ⭐ P1 归纳偏置（和 Transformer 定制的全局相关性比较）

第2阶段：Transformer 与语言模型​

🎯 目标：理解现代 AI 的"发动机"——Transformer，以及 GPT/BERT 是怎么建在它上面的。

注意力机制​

• 🔥 P0 Self-Attention（自注意力）（每个词同时"看"整个句子）
• 🔥 P0 Q / K / V 矩阵（Query-Key-Value：图书馆检索类比）
• 🔥 P0 Multi-Head Attention（多头注意力）（8个人同时从不同角度看）
• 🔥 P0 Masked 自注意力（GPT 生成时只看"已写的"，不能偷看后面）
• ⭐ P1 Cross-Attention（Encoder-Decoder 之间的信息交流）

Transformer 架构​

• 🔥 P0 Encoder-Decoder 架构（BERT 用 Encoder，GPT 用 Decoder）
• 🔥 P0 MoE（混合专家模型，Mixture of Experts）（GPT-4、DeepSeek、Mixtral 背后的省算力杀器，稀疏激活机制）
• 🔥 P0 位置编码（Positional Encoding）：Sinusoidal（原版）/ 可学习位置编码
• ⭐ P1 RoPE（旋转位置编码）（现代 LLM 的位置编码标准，支持长上下文）
• ⭐ P1 Mamba / SSM（状态空间模型）（被誉为 Transformer 最大挑战者的非注意力架构流派）
• 📚 P2 Transformer 变体（Transformer-XL、XLNet）

预训练模型​

• 🔥 P0 BERT：MLM（完形填空）+ NSP（句子关系预测）→ 理解型模型
• 🔥 P0 GPT：自回归语言建模（预测下一个词）→ 生成型模型
• 📚 P2 ALBERT、ELECTRA、T5 架构

分词（Tokenization）​

• 🔥 P0 BPE（Byte Pair Encoding）（主流分词算法，GPT系列用）
• 🔥 P0 WordPiece（BERT 用）
• ⭐ P1 SentencePiece（语言无关的分词框架）
• ⭐ P1 Unigram 语言模型、Byte-level BPE

第3阶段：提示工程（Prompt Engineering）​

🎯 目标：用好 API——不写一行训练代码，只靠 Prompt 就能解决 80% 的问题。

核心技术​

• 🔥 P0 Zero-shot（直接问，测试模型底线）
• 🔥 P0 Few-shot / In-Context Learning（给例子让模型学）
• 🔥 P0 System Prompt / Role Prompting（设定全局身份和规则）
• 🔥 P0 Chain-of-Thought（CoT）（让模型"一步步想"，而不是直接猜答案）
• 🔥 P0 结构化输出（JSON 模式）（让 AI 输出能被代码解析的格式）
• 🔥 P0 Prompt Injection 防御（防止用户输入"忽略之前的指令"）
• ⭐ P1 ReAct 模式（Reason + Act：让模型思考然后行动，Agent 的前身）
• ⭐ P1 Self-Consistency（生成多次取多数答案）
• ⭐ P1 Meta-Prompting / Negative Prompting
• ⭐ P1 Prompt Chaining / Self-Refine
• ⭐ P1 Output Parsing（正则解析 AI 输出）
• 📚 P2 Tree of Thoughts（ToT）/ Graph of Thoughts（GoT）
• 📚 P2 DSPy（自动优化 Prompt）
• 📚 P2 Prompt Tuning / Prefix Tuning / P-Tuning v2
• 📚 P2 Prompt Compression（压缩长 Prompt）

第4阶段：检索增强生成（RAG）​

🎯 目标：解决"AI 不知道你公司的事"——把私有知识库接入 LLM。

Embedding 与向量检索​

• 🔥 P0 Embedding 模型（从 Word2Vec → BERT Embedding → 专用模型）
• 🔥 P0 余弦相似度（Cosine Similarity）（衡量两段文字的"语义距离"）
• 🔥 P0 向量数据库：Chroma（本地轻量）/ Pinecone（云托管）/ Milvus（大规模）
• ⭐ P1 Sentence-BERT / BGE / E5 / Instructor Embeddings（嵌入模型对比）
• 📚 P2 HNSW / IVF / FAISS（向量索引算法，数据库内部实现）
• 📚 P2 Product Quantization / Matryoshka Embeddings

文档处理​

• 🔥 P0 Chunking（文档切分）：固定大小 / 语义切分 / 递归切分
• ⭐ P1 Parent-Child Retrieval（小块检索，大块返回）
• ⭐ P1 Contextual Compression（压缩检索结果）

检索策略​

• 🔥 P0 稠密检索（Dense Retrieval）（用 Embedding 做语义搜索）
• 🔥 P0 稀疏检索（BM25）（关键词搜索，不懂语义但不怕专有名词）
• 🔥 P0 混合搜索（Hybrid Search）（两者结合，取长补短）
• 🔥 P0 重排序（Cross-Encoder Reranker）（粗排 50 个 → 精排 5 个）
• ⭐ P1 HyDE（Hypothetical Document Embeddings）（先生成"假答案"再检索）
• ⭐ P1 Multi-Query Retrieval / Query Expansion（多维度检索）
• ⭐ P1 GraphRAG（知识图谱增强 RAG）
• ⭐ P1 Long Context vs RAG（什么时候用长上下文替代 RAG？）
• 📚 P2 Self-RAG / CRAG（自适应检索）
• 📚 P2 RAPTOR / FLARE / IRCoT / ColBERT / SPLADE

RAG 的专职评估体系​

• 🔥 P0 RAG 评估三元组：上下文相关性 / 答案忠实度 / 答案相关性
• ⭐ P1 Ragas / TruLens（专门针对 RAG 系统的离线评估开源框架）

第5阶段：智能体（Agent）与工具使用​

🎯 目标：从"聊天机器人"升级到"能干活的 AI"——让模型自主规划和执行任务。

Agent 核心​

• 🔥 P0 ReAct 循环（思考 → 行动 → 观察，循环直到任务完成）
• 🔥 P0 Function Calling / Tool Calling（让模型调用外部 API）
• 🔥 P0 JSON Schema 定义工具（告诉模型"这个工具叫什么、有什么参数"）
• 🔥 P0 记忆管理：
  • 短期记忆：对话历史（Context Window）
  • 长期记忆：向量数据库存储（接 RAG）
  • 记忆总结：摘要压缩历史（节省 Token）
• 🔥 P0 Plan-and-Solve（先让模型写计划，再逐步执行）
• ⭐ P1 Human-in-the-Loop（敏感操作前让人类确认）
• ⭐ P1 Reflection / Self-Correction（让 Agent 检查自己的输出）
• ⭐ P1 Tool Retrieval（工具太多时，先检索合适的工具）
• ⭐ P1 LangChain / LangGraph 基础

GUI Agent 与物理化​

• 🔥 P0 Computer Use（计算机控制操作）（让 AI 直连鼠标键盘，像人一样看屏幕点击 UI，Claude引领）
• ⭐ P1 OmniParser / UI-TARS（跨越系统鸿沟的 GUI 识别和动作执行模型）
• 📚 P2 WebVoyager / Android in the Wild

多 Agent 协作​

• 🔥 P0 串行 / 并行 / 层次化 Agent（单打独斗 vs 分工合作）
• 🔥 P0 状态机与图（LangGraph）（用有向图描述 Agent 的工作流）
• 📚 P2 AutoGPT / BabyAGI（早期框架，了解即可）
• 📚 P2 CrewAI / Autogen / CAMEL / Voyager
• 📚 P2 AgentBench（Agent 评测基准）

MCP（Model Context Protocol）​

• 🔥 P0 为什么需要 MCP（Agent 的"USB 协议"，统一数据接入）
• 🔥 P0 Server / Client 架构（数据源 vs AI 应用端）
• 🔥 P0 三类能力：Resources（数据）/ Tools（功能）/ Prompts（预定义交互）
• ⭐ P1 MCP vs Function Calling（区别在哪？）
• ⭐ P1 常见 MCP Server：文件系统 / Google Drive / Notion / GitHub / 数据库
• ⭐ P1 如何编写 MCP Server（Python / TypeScript）
• ⭐ P1 Transport Layer：stdio / HTTP / WebSocket
• 📚 P2 MCP 协议细节（JSON-RPC 2.0）/ Schema 定义 / Sampling 流程

第6阶段：模型微调与优化​

🎯 目标：当 Prompt + RAG 都不够用时，直接改变模型本身的能力。

微调决策​

• 🔥 P0 微调 vs 提示工程（何时该微调，何时该 Prompt）
• 🔥 P0 指令微调（Instruction Tuning / SFT）（让基座模型学会"对话"）

高效微调​

• 🔥 P0 LoRA（低秩适应）（只训练 1% 的参数，效果达到全量的 95%）
• 🔥 P0 QLoRA（量化 + LoRA）（消费级显卡也能微调 70B 模型）
• ⭐ P1 AdaLoRA / DoRA（LoRA 的改进版）
• ⭐ P1 Adapter Layers / Prefix Tuning

对齐技术​

• 🔥 P0 RLHF（人类反馈强化学习）：奖励模型 + PPO（概念理解即可）
• 🔥 P0 DPO（直接偏好优化）（比 RLHF 稳定，现在更常用）
• 🔥 P0 GRPO（群组相对策略优化）（DeepSeek-R1 的致胜法宝，彻底丢弃 Critic 模型的极简强化学习架构）
• ⭐ P1 KTO / IPO / ORPO（DPO 的各种变体）
• ⭐ P1 Constitutional AI（宪法AI，Anthropic 的对齐方法）
• 📚 P2 PPO 细节 / Reward Modeling 深入

数据与合并​

• ⭐ P1 Synthetic Data（合成数据）：Self-Instruct / Evol-Instruct（用 GPT-4 生成训练数据）
• ⭐ P1 模型合并（Model Merging）：SLERP / Task Arithmetic / MergeKit（不训练，直接"拼"）
• ⭐ P1 DARE / TIES-Merging / Model Soups / LoRA Merging
• 📚 P2 蒸馏（Distillation）/ Alpaca / Vicuna 案例

第7阶段：推理优化与部署​

🎯 目标：让模型跑得更快、更便宜、更稳——从本地到生产环境。

推理引擎​

• 🔥 P0 vLLM（生产首选，连续批处理 + PagedAttention，比 HuggingFace 快 10x）
• 🔥 P0 llama.cpp（CPU / Mac 上跑大模型）
• 🔥 P0 Ollama（本地运行最简单的工具）
• ⭐ P1 TensorRT-LLM（NVIDIA 推理优化）/ TGI / LM Studio
• 📚 P2 ONNX Runtime / OpenVINO / CTranslate2

量化（模型瘦身）​

• 🔥 P0 INT8 / INT4 量化（模型体积缩小 4-8 倍，质量损失可接受）
• 🔥 P0 GGUF 格式（llama.cpp 的通用量化格式）
• ⭐ P1 GPTQ / AWQ（量化算法对比）

推理加速​

• 🔥 P0 KV Cache（解码阶段缓存计算结果，避免重复算）
• 🔥 P0 Prompt Caching（提示词缓存）（长上下文降本增效的神器，Claude/DeepSeek API与vLLM全靠它省钱）
• ⭐ P1 Continuous Batching（连续批处理）（动态处理请求，vLLM 的核心）
• ⭐ P1 Speculative Decoding（推测解码）（小模型先猜，大模型验证）
• ⭐ P1 Flash Attention / Flash Decoding（注意力机制的高效实现）
• ⭐ P1 Streaming LLM / Context Length Extension（PI / YaRN / NTK）
• 📚 P2 Medusa / Lookahead Decoding（Speculative Decoding 变体）

服务化​

• 🔥 P0 模型路由（Model Routing）（简单问题小模型，复杂问题大模型）
• 🔥 P0 语义缓存（Semantic Caching）（相似问题复用答案，节省 30-50% 成本）

🔗 对应文章：模型优化与部署

第8阶段：多模态与前沿模型​

🎯 目标：了解 AI 能力的边界——图像、语音、推理，以及现在最热的进展。

视觉语言模型（VLM）​

• 🔥 P0 CLIP（图文联合 Embedding，图和文放在同一个向量空间）
• 🔥 P0 GPT-4V / Claude Vision / Gemini（商业 VLM 能力）
• ⭐ P1 LLaVA（开源视觉语言模型）
• ⭐ P1 Qwen-VL / CogVLM / ImageBind
• 📚 P2 BLIP / BLIP-2 / InstructBLIP / Flamingo / KOSMOS

图像生成​

• 🔥 P0 Flux（当前最强的开源文生图模型，颠覆了 SDXL 的地位，支持原生极速生成）
• 🔥 P0 Stable Diffusion（最主流稳定的传统扩撒模型路线及开源生态）
• 🔥 P0 ControlNet（精确控制生成结果：姿势 / 边缘 / 深度图）
• ⭐ P1 LoRA for Diffusion（低成本画风定制）
• ⭐ P1 SDXL / SD3 / IP-Adapter / DreamBooth / Textual Inversion
• 📚 P2 Diffusion 原理（DDPM / DDIM）/ Consistency Models / LCM

视频与 3D 生成（新前沿）​

• 🔥 P0 Sora / HunyuanVideo（Sora开创了DiT架构物理世界模拟器，混元证明了开源路线的可用性）
• ⭐ P1 Gen-3 / Pika / Kling（快手可灵）
• ⭐ P1 AnimateDiff / ComfyUI 视频流工作流
• 📚 P2 Gaussian Splatting（3D高斯渲染，取代 NeRF 的三维革命）

语音​

• 🔥 P0 传统 Pipeline：Whisper（ASR 语音识别）+ VALL-E / Bark（TTS 语音合成）
• 🔥 P0 端到端语音模型：GPT-4o Realtime / Gemini Live / MiniMax（直接音频to音频）
• ⭐ P1 AudioCraft / MusicGen

推理模型（Reasoning Models）​

• 🔥 P0 Test-time Compute Scaling（推理时花更多算力 = 更好的答案）
• 🔥 P0 Process Reward Model (PRM)（奖励每一步推理过程，不只看最终结果）
• 🔥 P0 DeepSeek-R1（开源推理模型里程碑）
• 🔥 P0 RLAIF（AI 自我反馈替代人类反馈，DeepSeek-R1 的关键）
• ⭐ P1 o1 / o3 / QwQ / Gemini Thinking
• ⭐ P1 Best-of-N Sampling / Process vs Outcome Supervision
• ⭐ P1 Verifier Models / STaR（Self-Taught Reasoner）
• 📚 P2 MCTS（蒙特卡洛树搜索）/ Beam Search
• 📚 P2 Quiet-STaR / ReST / V-STaR

长上下文​

• ⭐ P1 Long Context vs RAG（200K+ tokens，什么时候不用 RAG？）
• ⭐ P1 RoPE 位置插值（PI / YaRN）/ 1M tokens 应用

第9阶段：评估、安全与监控​

🎯 目标：AI 项目最容易翻车的地方——上线前后都要考虑。

评估方法​

• 🔥 P0 LLM-as-a-Judge（用 GPT-4 自动评测输出质量）
• 🔥 P0 公开基准：MMLU / HumanEval / MT-Bench / Chatbot Arena
• ⭐ P1 TruthfulQA / GSM8K / MATH / AlpacaEval
• 📚 P2 ARC / HellaSwag / PIQA / DROP / BoolQ / WinoGrande
• 📚 P2 HELM / ToxiGen / BOLD / BBQ
• 📚 P2 专业基准：MedQA / LegalBench / FinQA / C-Eval / CMMLU
• 📚 P2 视觉基准：VQA / COCO / TextVQA

安全​

• 🔥 P0 Jailbreak 防御（防止用户绕过安全限制）
• 🔥 P0 Prompt Injection 防御（用户输入被当成指令执行的风险）
• 🔥 P0 PII 检测脱敏（隐私信息不能流入 API）
• 🔥 P0 内容过滤（Content Filtering）
• 🔥 P0 Red Teaming（主动攻击自己找漏洞）
• ⭐ P1 Guardrails / NeMo Guardrails（规则+模型双重校验）
• 📚 P0 幻觉检测（Hallucination Detection）

生产监控​

• 🔥 P0 链路追踪：LangSmith / Arize Phoenix（记录每一步的耗时、成本、输入输出）
• 🔥 P0 成本分析（Token 使用统计，按功能 / 用户分摊）
• 🔥 P0 A/B 测试（Prompt 改了，结果到底变好了吗？）
• ⭐ P1 延迟监控（P50 / P95 / P99）

第10阶段：商业与生态​

🎯 目标：了解市场上有什么，做选型决策时不瞎选。

商业模型 API​

• 🔥 P0 OpenAI：GPT-4o / o1 / o3（综合最强，价格较高）
• 🔥 P0 Anthropic Claude：Claude 3.5 Sonnet（编码最强，上下文最长）
• 🔥 P0 Google Gemini：Gemini 2.0（多模态强，价格有优势）
• 🔥 P0 国内：文心一言 / 通义千问 / 讯飞星火（合规要求下的选择）
• ⭐ P1 Claude 3 Opus / Haiku / Gemini Pro / Ultra
• ⭐ P1 Command R / R+（RAG 优化）/ Mistral Large
• 📚 P2 AI21 Jurassic / Inflection Pi / 腾讯混元 / 商汤日日新

开源模型生态​

• 🔥 P0 LLaMA 3（Meta 开源，最主流的基座）
• 🔥 P0 Mistral / Mixtral（欧洲开源，MoE 架构高效）
• 🔥 P0 Qwen 2.5（阿里，中文最强开源）
• 🔥 P0 DeepSeek（推理能力开源里程碑）
• 🔥 P0 Phi-3（微软，小模型性价比王）
• ⭐ P1 Yi / ChatGLM / InternLM / Baichuan（国内开源模型）
• ⭐ P1 Vicuna / Alpaca / WizardLM / Orca / Zephyr / Starling（SFT 社区模型）
• 📚 P2 Falcon / MPT / StableLM / Bloom / OPT / Pythia / GPT-NeoX

工具生态​

• 🔥 P0 LangChain / LlamaIndex（AI 应用框架，RAG + Agent 首选）
• 🔥 P0 Axolotl / Unsloth（微调工具，QLoRA 首选）
• 🔥 P0 vLLM / Ollama / TGI（部署工具）
• ⭐ P1 Instructor / Marvin（结构化输出工具）
• ⭐ P1 Guidance / LMQL（受控生成）
• 📚 P2 HuggingFace Accelerate / PEFT / DeepSpeed / Megatron-LM
• 📚 P2 FastChat / OpenLLM / Weights & Biases / MLflow / lm-evaluation-harness

企业应用场景​

• 🔥 P0 Coding Agent：Cursor / GitHub Copilot / Claude Code（改变编程方式）
• 🔥 P0 文档问答（RAG 最典型落地场景）
• 🔥 P0 客服系统（Agent + 情感分析 + 升级转人工）
• 🔥 P0 数据分析助手（Code Interpreter + Agent）
• ⭐ P1 GitHub Copilot vs Cursor / Aider 对比
• ⭐ P1 Devin / OpenHands / Code Interpreter / Sandbox
• ⭐ P1 CodeLlama / StarCoder / DeepSeek-Coder（开源编程模型）
• 📚 P2 AlphaCode / WizardCoder / Phind-CodeLlama / SWE-bench

🗺️ 章节依赖关系图​

颜色说明：

• 灰色 = 理论基础（按需查询）
• 粉色 = 应用核心（先学这里）
• 蓝色 = 工程深化（有需求再学）
• 绿色 = 生态认知（随时了解）

✅ 最后的话​

学 AI 最大的坑是贪多求全。

这份图谱不是让你从第 0 阶段到第 10 阶段全部学完，而是：

1. 第3阶段（Prompt）+ 第4阶段（RAG）+ 第5阶段（Agent）是核心主线，优先打通
2. P0 的内容是现在的任务，P1 是遇到再查，P2 是知道有这东西就行
3. 第0-2阶段的理论部分，按需回头查，不必现在

开始行动：直接从第3阶段 Prompt Engineering 开始，做一个能用的 Demo，再往后走。

[!NOTE] Q: 为什么要设置虚拟环境 A: 首先，它防止版本冲突。它将每个代理的依赖项隔离开来，确保一个代理的更新不会意外地破坏另一个工具或系统。

cd path\to\your\project
python -m venv agent-env
agent-env\scriptslactivate
pip install dependencies
pip freeze > requirements.txt

理解 ReAct 推理循环

在自主 AI 开发中，ReAct 循环扮演着同样的角色。它为 AI 系统提供了一种结构化的方式来思考任务、选择合适的工具并智能地行动。ReAct 将模型转变为一个由迭代思考和行动驱动的解决问题代理，而不是简单地用文本回应的聊天机器人。

ReAct 概述和目的​

ReAct，全称 Reasoning + Acting，是现代自主系统的核心。它将逻辑推理与工具执行相结合，使 AI 能够像人类助手一样处理任务。其核心优势包括：

• 支持多步骤、结构化的工作流。
• 启用工具使用，如 API、记忆检索或计算。
• 允许代理根据中间结果进行适应。
• 为有目标导向的行动提供可预测的周期

ReAct Loop​

这个过程始于代理接收到输入，类似于实验室助理接到任务。代

1. 输入接收：

   • 代理的旅程始于接收到某种输入。这可以是用户提出的问题、从记忆中检索的信息，或者是工具输出的结果。

2. 观察信息：

   • 代理在接收到输入后，会首先观察和分析这些信息。这一步骤类似于实验室助理在接到任务后，先查看所有相关的笔记和资料，以确保理解上下文。

3. 设定上下文：

   • 观察信息的过程为后续的决策打下基础。通过理解输入的内容，代理能够更好地决定下一步的行动。

推理：代理在行动前思考​

在采取任何行动之前，代理会进行内部推理。它可能会将任务分解为步骤，考虑哪个工具最合适，或分析它已经掌握的信息。推理是代理的"计划时刻"，确保行动是有意而非冲动的。这就像助理决定是查找数据、运行实验还是请求澄清后再继续进行。

• 内部推理：代理在行动前会思考，确保其行动是经过深思熟虑的，而不是随意的。
• 任务分解：代理可能会将复杂任务拆分为更小的步骤，便于处理。
• 工具选择：代理会考虑使用哪些工具来完成任务。
• 信息分析：代理会回顾已有的信息，以便更好地制定计划。

行动：触发工具以推进​

一旦代理有了计划，它通常通过调用函数或外部工具来采取行动。这可能是一个搜索查询、API 调用、计算或内存查找。在代理框架中，这些行动通常表示为结构化的 JSON 命令，告诉系统使用哪个工具以及传递什么参数。就像实验室助理根据他们的推理执行特定任务一样，代理精确地执行函数，并且是确定性的。

• 采取行动：代理在制定计划后，会执行相应的操作。
• 工具调用：行动可能涉及调用外部工具，如API或进行计算。
• JSON命令：代理的操作通常以JSON格式描述，明确指定使用的工具和参数。
• 精确执行：代理的操作是基于推理的结果，确保每一步都是有目的的。

反思：从每一步中学习​

行动之后，代理评估结果。工具是否返回了所需信息？问题是否解决，还是需要其他步骤？这种反思反映了人类助手在继续之前检查实验是否成功或查询是否提供了正确数据的过程。反思可以防止无限循环，并帮助助手与目标保持一致。

• 结果评估：代理在行动后会检查结果是否符合预期。
• 问题解决：代理需要判断问题是否已经解决，或者是否需要进一步的步骤。
• 防止循环：通过反思，代理可以避免陷入无尽的循环，并确保行动与目标一致。

完成循环：多步问题解决​

代理会持续循环观察 → 推理 → 行动 → 反思，直到得出最终答案。在实践中，这可能涉及多次工具调用、多轮推理，或记忆查询与计算的组合。就像研究人员不断迭代直到找到解决方案一样，ReAct 循环使 AI 助手能够处理跨越多步骤的任务。

• 循环过程：代理不断重复观察、推理、行动和反思的过程，直到解决问题。
• 多步任务：在复杂任务中，代理可能需要多次调用工具和进行推理。
• 迭代解决：代理的工作方式类似于研究人员，通过反复尝试寻找解决方案。