1. 为什么全连接网络搞不定图片？​

所谓全连接网络 (Fully Connected Network)，就是每一层的每个神经元，都要去死记硬背上一层的所有输入。

假设你要处理一张用手机拍的照片（1200 万像素）。如果用全连接网络，把每个像素点都当成一个输入：

$1200\text{万像素} \times 3 (\text{RGB颜色}) \times 1000 (\text{随便一层隐藏层}) \approx 360 \text{亿个参数}$

这还只是第一层！你电脑的显卡内存当场就会爆炸。

更要命的是，它没有"视觉常识"：

当你找照片里的猫时，你是死盯着左上角那个像素点的 RGB 变动吗？ 当然不是，你看的是特征：这儿有个尖尖的耳朵，那儿有个带胡须的鼻子。 而且，不管这只猫是在左边还是右边（平移），它都还是一只猫。全连接网络根本不懂这个道理，左边的猫和右边的猫对它来说完全是两幅毫不相干的输入。

2. 卷积的直觉：拿着滤镜的手电筒​

CNN 改变了游戏规则。它的核心操作叫 卷积 (Convolution)。

别怕这个词，在图像处理里，卷积就是拿着一个带图案滤镜的手电筒去扫图片。

1. 滤镜 (Filter / Kernel)：这是一个很小的矩阵（比如 3x3 像素）。
   • 滤镜 A 专门用来找横线。
   • 滤镜 B 专门用来找竖线。
   • 滤镜 C 专门用来找对角尖角。
2. 滑动扫描 (Sliding)：拿着滤镜从图片左上角一点点滑动到右下角，就像在做全身扫描。
3. 激活匹配：如果底下的图块刚好和滤镜的图案长得很像，结果数值就会"爆表"（高亮显示出来）。

这样一扫，我们不用去记几千万个单独的像素，而是直接把图片变成了几张特征图（Feature Maps）——一张标记了所有横线在哪，一张标记了所有竖线在哪。

3. 层层建构：Pooling (池化) 的抽象艺术​

找到了横线竖线又怎样呢？这依然不是猫。

这就是为什么我们需要很多个卷积层叠在一起，中间还要加一个核心操作——Pooling（池化）。

池化的逻辑简单但有效：生成缩略图，顺便抓大放小。 比如 2x2 的格子里，取最大那个数值，抛弃掉三个不重要的细节。图片瞬间缩小 4 倍，但关键特征的相对位置被强行保留并放大了。

经过一系列的 卷积 → 激活 → 池化 堆叠，神奇的事情发生了：网络学会了像搭积木一样层层抽象。

• Layer 1：看到很多基础的边缘和线条（横线、竖线）。
• Layer 2：线条组成了部件（角落、圆弧这种基础形状）。
• Layer 3：部件拼凑成了器官（猫耳朵、猫眼睛、胡须）。
• Layer 4：将各个器官的概念整合，得出高维结论——（这是一只完整的猫）。

这就是深度学习为什么带个"深"字。没有深度，就无法在一团杂乱的像素泥潭里，捏造出拥有高级语义的抽象概念。

4. 为什么在大模型时代，CNN 退居二线了？​

统治了计算机视觉差不多 10 年（2012 AlexNet 到 2020 年初）后，CNN 的地位受到了挑战。 现在大火的多模态大模型（比如 GPT-4o 的视觉能力、Sora），底层的视觉架构正全面转向基于 Transformer 的架构（如 ViT，Vision Transformer）。

主要原因有两个：

1. 视野限制：只见树木，不见森林​

CNN 天生是看局部的（比如只能看 3x3 的格子）。虽然堆叠很多层之后最终能覆盖整张图，但它骨子里很难在一开始就建立起跨越整张图两端的全局联系。

而 Transformer 的注意力机制（Attention）截然不同——它第一眼就会让图片的每个切块，互相之间打个招呼建立联系。

2. 追求秦始皇式的"书同文、车同轨"​

文本是序列，音频是序列。如果把图片也切成一个个小方块当成序列……那我们干脆全用同一套 Transformer 引擎处理算了！ 这就是现在多模态统一模型（Omni-model）的工程美学，用同一套内核理解文字、声音和图像。

5. 总结​

下一阶段预告： CNN 解决了空间上的局部关系——但如果是时间上漫游的关系呢？比如怎样理解一整本书、甚至理解跨越半个小时对话中的上下文？

这便是改变人类科技进程架构的诞生。准备好，我们将跨入第2阶段：Transformer与语言模型的璀璨星河。

下一章: Transformer基础

1. 教练的进化：优化器 (Optimizer)​

既然“反向传播”算出了方向（梯度），也知道了错在哪（Loss），怎么改才能让 Loss 稳健缩小？ 这就需要优化器控制下山的步伐，其中最具决定性的参数就是学习率（Learning Rate）。

1.1 开山鼻祖：SGD（随机梯度下降）​

最朴素的逻辑，看见坡就下，朝最陡的方向走固定的一定步子。

• 致命弱点：如果遇到一个狭长的山谷，由于坡度陡但其实谷底在沿长轴方向，SGD 会在山谷两壁上疯狂反复横跳（震荡），迟迟不敢走向真正的谷底。

1.2 加上惯性：Momentum​

物理学给了工程师灵感：给下山的小球加上动量（惯性）。

• 原理：如果连续几次都在朝东边走，那下次跨步时就把往东的步伐加大；如果一会儿往南一会儿往北，南北的幅度就会被惯性抵消。
• 效果：它极大地缓解了 SGD 的无脑震荡，像一辆安装了悬挂系统的越野车。

1.3 现代标配与 LLM 御用：Adam 与 AdamW​

既然方向可以加惯性，那不同维度的学习步长能不能因人而异？ 如果在某一个参数维度上地形非常平坦，那就步子迈大点；如果某一个维度崎岖，就自动把学习率降低。

这就是 Adam (Adaptive Moment Estimation)：目前绝大部分深度学习模型的默认优化器。

• AdamW：由于 Adam 在最后对抗“过拟合”的数值衰减上存在一个隐秘的代数 bug。研究人员修复了这个 bug 提出了 AdamW，它同时拥有自适应步长极速收敛的优势，又能让模型泛化能力更强。目前所有的大语言模型（LLM，包括 LLaMA、GPT等）一开场，优化器必填 AdamW。

1.4 P2 前沿：Lion 优化器​

寻找最优解的算力成本越来越高，Google 近年提出了极简的 Lion。 如果不算精确梯度的具体数值，**只看梯度的“符号（正负号）”**呢？只要知道向左还是向右，闭着眼睛猛冲就行了。不仅霸道，更是被证明比 Adam 还能节省显存。

2. 驯服过拟合：正则化与 Dropout​

AI 也喜欢“死记硬背历年模拟卷（训练集）”，到了“真正的考场（测试集）”就翻车，这叫过拟合。 参数越多，模型背答案的能力越强。

Dropout（随机失活）​

这是深度学习史上最简单、也最天才的发明之一： 在训练时，随机拔掉一部分神经元的网线（比如 30%）。

• 为什么会有用？ 如果一个公司里总有 30% 的人随时会旷工，为了保证项目正常交付，大家就不能搞单点依赖，每个人都得学点真本事，独立承担任务。 这逼迫神经网络里的每一个节点，不能依靠前面特定的几张面孔来投机取巧，必须各自去提取真正通用、抗干扰的特征。

# PyTorch 中一行代码搞定
import torch.nn as nn
self.dropout = nn.Dropout(p=0.3)  # 30% 的概率摸鱼

黄金法则：千万记住！Dropout 只在训练时开启。等真正上线考试（推理预测）时，要恢复所有的神经元全量出击。

3. 把网络推向深渊再捞起来：残差连接 (ResNet)​

在 2015 年前，哪怕再有钱、算力再高，没人敢把神经网络叠到 20 层以上。 因为存在死穴：梯度消失。 根据链式法则，小于 1 的导数连乘 20 次，到最前面的浅层时梯度已经接近无限小。浅层网络根本收不到指令，形同瘫痪。

2015年何凯明提出的 残差网络（ResNet），打破了深度学习的天花板，一举将网络推上了 150+ 层。

黄金跳跃（Skip Connection）​

做法粗暴：如果你在后面几层可能什么都学不到，那我就在这个模块旁边直接修一条**“高速公路”**，把原始的输入原封不动地“跨层相加”到后面。

$\text{Out} = \text{Network}(x) + x$

• 容错率极高：哪怕中间那一坨 Network(x) 彻底训烂了输出为 0，最坏也就是把输入原样透传。
• 梯度高速公路：在反向传播时，如果通过神经元那条路梯度消失了，损失信号可以沿着这条 "+" 号的直连通路，光速、毫无折损地直达网络的前线！

Transformer 为什么能叠 96 层甚至更多？它的骨架深处，依然铭刻着残差连接的烙印。

4. 数据也要排队洗澡：归一化 (Normalization)​

除了把梯度传回去，数据在往前输送的过程中也会出事。

试想一条流水线，第一层神经元把输出放大到了 1000，第二层神经元却习惯处理 -1 到 1 的数字，第二层当场罢工（这就叫内部协变量偏移）。 所以我们要强制在两层之间设一道海关：把过来的数字，强行捏回均值为 0，方差为 1 的标准正态分布。

4.1 BatchNorm (批归一化，图像时代的王)​

• 原理：一次抓一堆数据（一个 Batch），计算这堆数据里某一个特征列的均值和方差，强行抹平他们的尺度。
• 结局：它是 CNN 训练极速起飞的核心功臣。但由于它太依赖“同一批抓到的数据”（如果每一批长短不一，它就懵了），因此在自然语言处理里遭到了淘汰。

4.2 LayerNorm (层归一化，语言时代的基石)​

在自然语言领域，一句话可能有 5 个词，另一段话有 50 个词。“跨句子横着算”完全行不通。

• 原理：LayerNorm 改成了**“竖着对单句话”**内部所有维度的特征自己求均值和方差。
• 地位：它是 Transformer 的命脉。没有 LayerNorm，注意力机制的数字会瞬间爆炸成 NaN。

4.3 极限精简：RMSNorm​

既然只是想要平滑尺度，我们有必要严格计算“均值”吗？ RMSNorm (均方根归一化) 一脚踢开了大模型减均值的计算步骤，仅保留方差。 牺牲了可以忽略不计的一丁点表现，换来了肉眼可见的提速——今天你叫得上名号的开源多模态与语言模型（如 LLaMA、Qwen全系），用的全部都是 RMSNorm。

5. 总结与路线串联​

现在，无论它是深陷欠拟合的泥潭，还是濒临过拟合的悬崖，无论是横跨 100 层的深渊还是面对不平滑曲面，你都已经给这个叫“多层感知器”的裸体机甲，挂载了全套的生存装备。

但这套骨架还缺一样东西： 它没有专门的定制器官。 当它被投入名为“像素”与“图像识别”的绞肉机里时，由于没有专门的结构（全连接的参数实在太多了），它将彻底被显存压垮。

我们需要为它换上特殊的机械臂。 下一章，我们将介绍一种专门利用“探照灯与局部手电筒”席卷视觉时代的网络器官——CNN 卷积层。

下一章: 1.3 CNN卷积网络

1. 为什么需要"深度"学习？​

在第0阶段的猫狗分类例子里，如果所有猫都长得标准，一个简单的线性公式（画一条直线把猫和非猫分开）可能就够了。

但现实世界太复杂了：

但现实世界太复杂了：那些被拍下的猫可能正蜷缩成抽象的毛团而导致形状彻底畸变，也可能潜伏在暗灰色的草丛和阴影里被直接抹去了原有的辨识色。更别提由于设备老旧，有些照片直接褪色成了纯黑白。

简单的线性分类器遇到这些情况直接歇菜。 这好比你想用一把直尺去测量海岸线的长度——工具太简单，无法描述复杂的现实。

为了处理这种**非线性（Non-linear）**的复杂问题，我们需要一个更复杂的脑子——神经网络（Neural Networks）。

2. 神经网络：模仿人脑的积木​

2.1 神经元（Neuron）​

生物神经元的工作方式很简单：

在生物学意义上，一根神经元依靠树突从四面八方接收其他相连同伴传来的电信号。接收完毕后，细胞体负责将所有杂乱的电流强度进行汇总累加，若累加的刺激强度越过了那条临界阈值并变得足够“兴奋”，它便会毫不犹豫地通过长长的轴突将这一股强大的电流脉冲直接发射到下一个神经元上去。

我们在电脑里造的人工神经元逻辑完全一样：

$\text{输出} = \text{激活函数}\left(\sum_i \text{输入}_i \times \text{权重}_i + \text{偏置}\right)$

拆解开来，这里- 输入 ($x$)：从外界接收的信号（比如图片的像素点、前一层传来的特征）。

• 权重 ($w$)：表示这个输入有多重要。如果 $w$ 很大，说明神经元对这个输入非常敏感。
• 偏置 ($b$)：神经元自己的"触底门槛"，决定了它天生有多容易被激活。
• 求和与扭曲：先把前面三样东西算一算（$w \cdot x + b$），然后交给激活函数 (Activation Function) 进行扭曲。

2.2 多层感知机（MLP）​

把很多神经元堆成多层，就是多层感知机（Multi-Layer Perceptron，MLP），也叫全连接网络：

这就是将神经元大规模堆叠并排布成好几个密集团队后的结构——全连接网络（Multi-Layer Perceptron，MLP）。它通常拥有三个严阵以待的区域：负责吞吐海量图片原始像素点的输入层，负责在黑暗黑盒里进行逐级特征抽取的庞大隐藏层，以及负责最终宣判概率结论（比如“这是个猫的概率是99%”）的输出层。

输入层  →  隐藏层1  →  隐藏层2  →  输出层
像素值     线条/边缘    形状/部件    是猫/不是猫

"深度"就是"层数多"。层数越多，模型能理解的概念就越抽象、越高级。

3. 激活函数：它到底是干嘛的？​

问题：为什么神经元算完乘法和加法后，非要多此一举，加上一个"激活函数"？

答案：为了能画出弯曲的线，而不是只会画直线。

3.1 为什么我们需要"弯曲"？​

假设你在做一个预测房价的简单 AI：直接抛出面积去预测房子的总价。如果你仅仅在网络里用死板的加减乘除计算，就算往中间堆叠了一万层也没有意义——因为一万根直线的叠加，依然是一条直线。这就意味着它会粗暴笃定任何事物都在恒定无限增长，往往会推演出 10 万平米的房子竟然价值 2 万亿的荒诞反常识结论。

真实世界的数据往往是**非线性（弯曲或折断）**的。

• 假如没有激活函数，不管你叠多少层神经元，哪怕你叠了 1000 层，它本质上还是在做无聊的乘法和加法（线性变换）。
• 线性变换永远只能画出"直线"或"平面的纸"。如果你的任务是把混在一起的一堆红球和蓝球分开，而它们本就弯弯曲曲地缠绕在一起，你是不可能用一条直线切开的。
• 激活函数就像一双手，把这张"平面的纸"进行揉捏、折叠、扭曲，最终让网络拥有了拟合世界万物的能力。这就叫非线性表达能力。

3.2 常见激活函数对比​

3.2.1 ReLU（最主流的经典方案：水闸）​

$\text{ReLU}(x) = \max(0, x)$

3.2.2 Sigmoid / Tanh（历史遗物，了解即可）​

$\text{Sigmoid}(x) = \frac{1}{1 + e^{-x}}, \quad \text{Tanh}(x) = \frac{e^x - e^{-x}}{e^x + e^{-x}}$

早期神经网络用的激活函数，会把信号压缩到一个固定范围（比如 0 到 1 之间）。

缺点：信号太强或太弱时，梯度几乎变成 0，导致反向传播时"消息传不回去"（梯度消失）。现在的隐藏层基本不用了，偶尔在输出层用用。

3.2.3 GELU / SiLU（现代 LLM 用的）​

$\text{GELU}(x) \approx x \cdot \sigma(1.702x)$

可以把它们理解成"更聪明的水闸"——不是像 ReLU 那样非黑即白（要么完全关掉，要么原样放行），而是根据信号强度平滑过渡。

现代大语言模型如 GPT 家族与 LLaMA 已经开始抛弃这套非黑即白的一刀切理论，而是将其逐步换成了“可以带着一点人情味的平滑水闸”。以 GELU（或是十分相近的 SiLU）为例，当它们遭遇强烈的负面信号时它照旧会彻底锁死通道；但在应对那些微微有些摇摆、轻微偏负的黯淡信号时，它不再残忍断交，而是会稍微留下一条极细的门缝让那么丁点负面残留也溜过去试探传导余温。而当它转向纯粹的正向信号高歌猛进时它便又恢复了无碍放行。

正是这种细微且带着导数连续切角的顺滑曲线过渡，使得当前被推上千万张并行显卡的极深网络系统里，能比那些棱角分明的 ReLU 跑出更加稳定强劲且毫无阻滞的健康梯度潜流流动。

为什么 LLM 要换成这个：更平滑的过渡让梯度在大规模训练时流动得更稳定，效果更好。GPT 系列用 GELU，LLaMA / Mistral / Qwen 用 SiLU $\text{SiLU}(x) = x \cdot \sigma(x)$。

你只需要记住：ReLU → 经典场景（CNN）；GELU/SiLU → 现代 LLM 标配。选哪个，框架会帮你决定。

4. 反向传播：训练的引擎​

还记得第0阶段的训练循环吗？

猜答案 → 算 Loss → 找方向（梯度）→ 优化器改参数

"找方向"这一步，具体是**反向传播（Backpropagation）**在做：

• 前向传播（Forward Pass）： 数据从左到右流过网络，得到一个预测结果，然后算出 Loss。

• 反向传播（Backward Pass）： Loss 从右向左"反向"流动，利用链式法则（Chain Rule），精准计算每一个权重参数对这次错误"负多大责任"（这就是梯度）。

输出层 → 告诉隐藏层3："是你算错了！"
隐藏层3 → 告诉隐藏层2："我被你坑了！"
...一直传到第一层

责任大的参数狠狠改，责任小的略微调整。这就是神经网络能够学习的根本原因。

5. 训练循环的重要拼图：损失函数与优化器​

知道了反向传播怎么找方向，我们还需要两把尺子和一个教练。

5.1 损失函数（Loss Function）——衡量"错误"的尺子​

Loss Function 的作用只有一个：告诉模型，你现在错得有多离谱。

[!TIP] 类比：射击比赛 🎯

试想你在参加一把严苛的射击定级赛。如果你脱靶了仅仅 1 米，虽然偏离了靶心，但有些严苛程度似乎还能忍受。可如果你干脆利落地脱靶了整整 10 米远，MSE（均方误差） 这种暴戾的损失函数就会当场翻脸。因为它计算出来的并不是误差恶化了原先的 10 倍，而是无比的 100 倍暴击惩罚！也就是平方级别的灾难性放大痛击。 这种对大范围跑偏深恶痛绝的极致惩戒设定，逼迫着每一次神经网络的反向传播必须首先全力剿灭那些最夸张严重的长尾失误地带。这也导致一贯被称为回归问题“老大哥”的 MSE 彻底化身为预估温度、气压与大宗商品连续浮动数值无可匹敌的头号终极判官。 与其对应的赛道相反，当我们站在那些并不是衡量距离感而是需要铁血裁决“它是猫还是狗”的这类的非黑即白分类场上时，Cross Entropy (交叉熵) 便举起了独裁制霸的权杖。它根本不关心你物理距离上跑偏了多少厘米远，它全盘盯死的是你在上报错误答案时究竟有着怎样嚣张狂妄的确信度。如果你仅仅只有一丁点模棱两可的微弱信心说这是一条狗，它大发慈悲只对你记下微末寥寥的损失教训；然而假如你蛮横狂傲地抱着 100% 盲目的坚决态度把一头雄狮强行按头认成了猫，它那隐藏着极限对数函数惩罚的重手铁锤将会当场引爆出势将冲破无穷大阻力的惊天报错警报狂飙！

一句话记住：Loss 越低 = 模型越好。训练的目标就是 Minimize Loss。

5.2 Loss函数的硬核解剖​

为了衡量预测和真相隔了多远，除了我们提到的 MSE 外，AI 处理分类问题时几乎一律采用交叉熵 (Cross Entropy)，它的数学思想更为深邃：

• 如果预测对了（比如 99% 的概率猜是猫，实际也是猫），惩罚极小。
• 但如果错得很离谱还很自信（比如 99% 概率猜是猫，实际却是狗），交叉熵会给出一个爆炸级的无穷大惩罚。
• 这个无穷大的惩罚在反向传播时，会产生猛烈的梯度，瞬间把那些“自信且愚蠢”的参数拉回正轨。如果是 MSE 面对这种“信心满满的错误”，由于导数函数的特性，很多时候会引发可悲的“梯度消失”（惩罚传不回去，模型原地摆烂）。

一句话记住：回归数值用 MSE；算概率分类必用 Cross Entropy。

6. 总结​

但这就是神经网络的最强体态了吗？不是的。 仅仅通过 MLP 的死记硬背，参数在下山的过程中很容易引发剧烈的维度震荡、由于步子太大掉下悬崖（梯度爆炸），甚至背完答案后无法理解新题（严重过拟合）。

如何控制住这头暴躁的猛兽？

下一章预告： 我们将为 MLP 披上真正的铠甲。从下山的神兵利器（AdamW 优化器），到封锁过拟合的 Dropout，直至后来拯救千层网络于水火之中的划时代基石——BatchNorm 与局部跳跃（残差连接）。

下一章: 1.2 核心优化技术（优化器、BN与残差）

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 助手能够处理跨越多步骤的任务。

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