前阵子有个做后端开发的朋友说要转AI问我能不能跳过“多层感知机”直接学Transformer。我说你这是在盖楼不打地基。虽然现在的注意力都被大模型、扩散模型这些词吸走了但你随便拆开一张现代神经网络的实现代码最底层的计算单元依然是同一件事线性变换加非线性激活函数交替堆叠。这个东西的学名就是多层感知机也就是MLP。这篇文章把多层感知机的原理和代码一次讲透。从单个神经元怎么工作到前向传播和反向传播每一步的数学账本再到用NumPy从零手写一个能跑手写数字分类的网络最后用主流深度学习框架重写一遍看看框架替你扛了多少活。无论你是刚入门的学生还是想把基础补扎实的工程师这篇都值得花一两个小时认真看完。1. 为什么说多层感知机是所有深度学习骨架1.1 一个神经元加权求和再加一道“开关”先看最简单的情况。一个神经元接收若干输入每个输入乘一个权重加上一个偏置然后过一个激活函数输出一个数。用公式写就是[ a g(\sum_{i} w_i x_i b) ]这跟你去菜市场买菜算账的逻辑一样单价就是权重买多少就是输入总价就是加权和而激活函数是一道“开关”决定这个结果要不要“放行”到下一层。单看这一步没什么神奇的但把它堆成几百层就能拟合出能写诗、能画图的函数这个跨度本身就是深度学习最反直觉的地方。1.2 单层感知机的软肋画不出一条线搞不定的事早期感知机就是一层这样的神经元它只能学出线性决策边界。你给它二维平面上两类点如果这两类点能被一条直线分开它很快就能收敛但如果数据是“异或”那种分布——对角的两块属于一类另外两块属于另一类——单层感知机就彻底抓瞎因为这种分割在平面上需要两条直线也就是一个非线性的边界。这个“线性不可分”的问题在1969年那本著名的专著里被拿出来反复讨论直接导致神经网络进入了一段漫长的低谷期。现在回头看问题其实不在神经元本身而是层数不够、也没有好用的非线性激活函数做帮手。1.3 多层加非线性逼近任何连续函数的底气多层感知机的核心改动就两条一是堆了至少一个隐藏层二是隐藏层用非线性激活函数。这两件事合在一起赋予了网络一个非常硬核的性质只要隐藏层神经元数量足够多多层感知机可以任意精度逼近任何一个连续函数。这就是常说的万能逼近定理。道理可以这么理解每个隐藏层神经元相当于在输入空间里划出一块“区域”多个神经元组合起来就能拼出任意形状的边界。第一层学的是边缘和局部特征第二层把局部特征组合成更大的模式往后层层抽象。所以你不需要手动设计特征直接让网络自己学这就是“表示学习”的起点。2. 前向传播用一张3层网络把矩阵运算彻底算明白2.1 符号约定先别让维度把你绕晕后面代码里我用的是行向量约定输入 (x) 的形状是 ((N, d_{in}))其中 (N) 是样本数(d_{in}) 是输入维度。第 (i) 个权重矩阵 (W_i) 的形状是 ((d_{in}^{(i)}, d_{out}^{(i)}))偏置 (b_i) 的形状是 ((d_{out}^{(i)},))。矩阵乘法的顺序是 (x W_i b_i)。这里容易混的一点是为什么 (W) 不是反过来排成 ((d_{out}, d_{in}))两种写法都有人用本质只是转置关系。我推荐先记住“前一个维度是上一层的输出维度”这个规则心里时刻能说出每个矩阵的形状后面写代码、调bug都会从容很多。2.2 手算一遍从输入到概率输出我拿一个 2→4→2 的小网络完整算一遍让你看清楚每一步数字是怎么流过去的。输入 (x [0.5, -1.0])第一层权重[ W_1 \begin{bmatrix} 0.2 -0.3 0.4 0.1 \ 0.6 0.2 -0.1 0.5 \end{bmatrix} \quad b_1 [0.1, 0.0, -0.2, 0.3] ]先算第一层的加权输入 (z_1 x W_1 b_1)第1个神经元(0.5 \times 0.2 (-1.0) \times 0.6 0.1 -0.4)第2个神经元(0.5 \times (-0.3) (-1.0) \times 0.2 0.0 -0.35)第3个神经元(0.5 \times 0.4 (-1.0) \times (-0.1) (-0.2) 0.1)第4个神经元(0.5 \times 0.1 (-1.0) \times 0.5 0.3 -0.15)过 sigmoid 激活 (a_1 \sigma(z_1))得到大约 ([0.401, 0.413, 0.525, 0.463])。第二层权重[ W_2 \begin{bmatrix} 0.5 -0.2 \ 0.3 0.4 \ -0.1 0.6 \ 0.2 0.1 \end{bmatrix} \quad b_2 [0.05, -0.05] ]继续算 (z_2 a_1 W_2 b_2)第1个输出(0.401 \times 0.5 0.413 \times 0.3 0.525 \times (-0.1) 0.463 \times 0.2 0.05 \approx 0.415)第2个输出(0.401 \times (-0.2) 0.413 \times 0.4 0.525 \times 0.6 0.463 \times 0.1 - 0.05 \approx 0.396)最后过 softmax把这两个数变成概率。算出来大约是 ([0.505, 0.495])非常接近但已经分出了高下。这就是一次完整的前向传播输入经过一层层矩阵乘法和激活函数最终输出每个类别的概率。2.3 为什么权重这样排向量的“形状感”比公式重要很多新手卡在“为什么梯度公式里要转置”这种问题上根源是手里没有一张维度的地图。我的建议是你自己推导的时候永远把每一步的输入、输出形状写在旁边(x): ((N, 2))(W_1): ((2, 4)) → (z_1): ((N, 4))(a_1): ((N, 4))(W_2): ((4, 2)) → (z_2): ((N, 2))(a_2): ((N, 2))任何矩阵乘法只要参与运算的两个矩阵内部维度能对上结果形状就绝对不会错。这个习惯能让你少掉一半头发。3. 反向传播误差如何“精准甩锅”到每一个权重3.1 核心直觉梯度就是一张责任分摊表前向传播算完一轮之后网络到底错在哪儿反向传播要回答的就是这个问题。你可以把它理解成一个团队项目搞砸了现在要开复盘会最终损失对某一个权重的影响有多大就是那个权重的梯度。梯度大说明这个权重“责任大”调整它效果最明显梯度接近0说明这个权重对当前损失几乎没影响改了也没用。链式法则在这里的作用是把最终损失的责任通过一层一层的关系准确地回传给每个参数。这不是什么玄学就是复合函数求导的逐层展开。3.2 链式法则逐层拆解从损失到第一层参数假设输出层用 softmax损失用交叉熵[ L -\frac{1}{N}\sum_n \sum_k y_{nk} \log \hat{y}_{nk} ]这里 (\hat{y}) 是网络输出的概率。有一个非常经典的化简softmax 配上交叉熵之后输出层的误差信号就是[ \delta_{out} \hat{y} - y ]就是预测概率减去 one-hot 真实标签这个结果在代码里直接用不需要再手动算 log 的导数。然后误差信号往上一层传[ \delta_h (\delta_{out} \cdot W_2^T) \odot g(a_1) ]这里 (\odot) 是逐元素相乘(g(a_1)) 是激活函数的导数对于 sigmoid 就是 (a(1-a))。每个隐藏层神经元的“责任”由两部分组成它把多少误差传给下一层通过 (W_2^T)以及它自己的激活函数当时“放行了多少信号”通过 (g(a_1))。得到每一层的误差信号之后权重梯度就是上一层的激活输出和当前层误差信号的外积[ \frac{\partial L}{\partial W_1} x^T \cdot \delta_h ]这步不用硬背拿维度反推就能写出来(x^T) 是 ((d_{in}, N))(\delta_h) 是 ((N, d_{hidden}))乘在一起正好是 ((d_{in}, d_{hidden}))和 (W_1) 的形状一致。所有梯度公式你都可以用“形状必须和参数形状一致”这个原则去验证对不对。3.3 参数更新梯度下降与学习率的“旋钮”属性拿到梯度之后参数更新就一句话[ W W - \eta \cdot \frac{\partial L}{\partial W} ](\eta) 就是学习率。注意我强调它是“旋钮”而不是“开关”调大一点收敛快但调太大会在损失函数曲面上左右横跳甚至发散调小一点稳定但太小会用大量时间换几次无效的微调。实践中通常先从 (0.1) 这个量级开始观察损失曲线再微调而不是凭感觉直接给定值。4. 从Zero到一NumPy手写一个可训练的多层感知机4.1 网络骨架与初始化为什么不能把权重设成0理论说清楚了现在动手。用NumPy从零写一个支持任意层数的MLP代码大概一百来行完整可运行。第一件要注意的事是初始化。如果你把所有权重初始化为0那么同一层所有神经元会学到完全相同的梯度也就是“对称性”问题——网络变成一堆复制品永远学不出有区分度的特征。正确做法是用小随机数初始化。这里我用的是He初始化标准差按输入维度缩放目的是让信号在层层传播时既不会被放大到爆炸也不会缩小到消失。import numpy as np def sigmoid(x): return 1.0 / (1.0 np.exp(-x)) def sigmoid_deriv(a): return a * (1.0 - a) def softmax(z): # 减去最大值是为了数值稳定不影响概率结果 z z - np.max(z, axis1, keepdimsTrue) e np.exp(z) return e / np.sum(e, axis1, keepdimsTrue) class MLP: def __init__(self, sizes, seed42): np.random.seed(seed) self.sizes sizes self.W [] self.b [] for i in range(len(sizes) - 1): std np.sqrt(2.0 / sizes[i]) # He初始化 self.W.append(np.random.randn(sizes[i], sizes[i 1]) * std) self.b.append(np.zeros(sizes[i 1])) def forward(self, x): self.zs [] self.acts [x] a x for i, (W, b) in enumerate(zip(self.W, self.b)): z a W b self.zs.append(z) a softmax(z) if i len(self.W) - 1 else sigmoid(z) self.acts.append(a) return a def backward(self, x, y): m x.shape[0] grad_W [] grad_b [] delta (self.acts[-1] - y) / m # softmax 交叉熵的梯度 for i in reversed(range(len(self.W))): a_prev self.acts[i] grad_W.append(a_prev.T delta) grad_b.append(np.sum(delta, axis0)) if i 0: delta (delta self.W[i].T) * sigmoid_deriv(self.acts[i]) grad_W.reverse() grad_b.reverse() return grad_W, grad_b def train(self, x, y, lr0.2, epochs100): for epoch in range(epochs): out self.forward(x) grad_W, grad_b self.backward(x, y) for i in range(len(self.W)): self.W[i] - lr * grad_W[i] self.b[i] - lr * grad_b[i] if epoch % 10 0: loss -np.mean(np.sum(y * np.log(out 1e-9), axis1)) acc np.mean(np.argmax(out, axis1) np.argmax(y, axis1)) print(fepoch {epoch:3d} loss {loss:.4f} acc {acc:.4f})4.2 前向与反向的实现细节为什么梯度方向要反转这个实现里有几个值得注意的细节。第一forward里我用self.zs和self.acts把每一层的中间结果都存了下来这是反向传播的“账本”——没有这些中间值后面根本没法算梯度。第二backward里我是从输出层往输入层反向遍历的所以算出的grad_W顺序是反的最后要reverse()回来才能和self.W的顺序对齐。这种顺序问题非常容易出bug如果你自己写建议在每次更新前用断言把梯度和参数的形状对一遍。第三个细节是输出层的梯度写法。很多人以为要手动对交叉熵求导其实不用softmax 输出的概率与 one-hot 标签相减就已经是对交叉熵损失的梯度了。这是深度学习里最经典的公式之一能手动推一遍最好推不出来就先记住结论。4.3 在真实数据上跑起来数据预处理决定成败理论网络要落到真实数据上有一件事比模型本身更影响结果那就是数据预处理。以经典的手写数字数据集为例每张图是28×28的灰度图一共10个类别。你要做的预处理很简单把28×28的图片拉平成784维的向量把像素值从0到255缩放到0到1之间把整数标签转成one-hot向量X_train X_train.reshape(-1, 784) / 255.0 X_test X_test.reshape(-1, 784) / 255.0 y_train_onehot np.eye(10)[y_train] y_test_onehot np.eye(10)[y_test] model MLP([784, 64, 64, 10], seed42) model.train(X_train, y_train_onehot, lr0.2, epochs100) pred np.argmax(model.forward(X_test), axis1) print(test acc:, np.mean(pred np.argmax(y_test_onehot, axis1)))第一次跑通你会看到损失从开始时逼近2.3因为10个类别随机猜的理论损失就是 (-\ln(0.1) \approx 2.3026)一路降到0.2以下测试集准确率能到92%左右。这个结果在“深度学习”里不算惊艳但它是你亲手写出来的每一行梯度下降日拱一卒换来的这个手感比任何调包都值钱。5. 训练多层感知机的实战调参与避坑5.1 激活函数等于号sigmoid在深层网络里会“窒息”手写版里隐藏层用的是sigmoid跑这种两三层的小网络没问题但层数一加深就会碰到一个经典问题梯度消失。sigmoid的导数最大只有0.25而隐藏层每往上传一层误差信号就要多乘一个小于1的数。假设网络有5层最坏情况下梯度衰减到原来的 (0.25^5 \approx 0.001)最靠近输入的层几乎学不到东西。更推荐的做法是隐藏层用ReLU(g(z) \max(0, z))它在正半区导数恒为1不会指数级压缩梯度。ReLU也有自己的脾气比如神经元一旦在反向传播中收到较大梯度权重被推到负数区这一路就可能永远失活这就是“dead ReLU”问题。实践中常见做法是用LeakyReLU或者加一个很小的初始偏置来缓解。选激活函数没有绝对的对错但你必须知道它给你带来的代价是什么。5.2 输入归一化与初始化两个被低估的细节很多人第一版代码跑不出理想精度问题往往不在梯度公式而在输入没归一化。如果某个特征的数值范围是0到255另一个是-1到1那么权重更新时前者对应的梯度天然就更大模型会被“大数值特征”带偏训练过程就容易震荡。把输入缩放到0到1或者标准化成均值为0方差为1能让所有特征处在同一量级损失曲面更接近“碗形”梯度下降走得更顺。初始化同理。刚才代码里用的He初始化是配合ReLU类激活函数设计的如果用sigmoid/tanh更经典的是Xavier初始化标准差按 (\sqrt{1/d_{in}}) 缩放。选错初始化不会立刻报错但你会发现网络要么学得极慢要么先冲上高损失然后一路崩溃。这几个“不起眼”的细节往往是训练稳定性和最终精度的分水岭。5.3 看损失曲线诊断几种典型“心电图”训练经验积累到一定程度你会发现自己越来越依赖损失曲线来诊断问题就像医生看心电图。下面这几种曲线形态基本可以立刻定位问题方向损失曲线表现最可能的原因优先尝试的手段损失一直不降稳在2.3附近学习率太小或初始化不合适或特征没归一化调大学习率到0.5试试重查预处理损失先降后突然变NaN或爆涨学习率太大梯度爆炸调小学习率检查是否用了数值不稳定的softmax训练损失下降但验证集损失很快反弹过拟合增加数据、加正则、加Dropout、早停损失曲线剧烈震荡不下去学习率偏大或批大小太小调小学习率增大批大小注意把学习率从0.1改成0.5属于“试新的量级”改成0.15则基本是心理安慰。调参要按数量级走一次只动一个变量记录结果否则你永远不知道是哪一步起了作用。5.4 过拟合信号训练集满分测试集不及格我见过太多新手看着训练集准确率逼近99%就认为模型成了一测测试集只有85%当场傻眼。这是过拟合的典型信号模型把训练数据的细节和噪声背了下来却没有学到可以泛化的规律。对策按优先级来第一收集更多数据第二加正则化L2正则的直观效果是约束权重不长得太“极端”第三加Dropout随机让一部分神经元在训练时失活强迫网络学冗余特征第四早停验证集损失连续好几个epoch不降就停止训练。这些在小MLP上已经够用到了大模型时代思路也依然是这一套只是实现工具变得更复杂了而已。6. 用主流框架重写同一模型框架替你扛了多少活6.1 自动求导与计算图反向传播公式从此不用手推手写一遍之后再用PyTorch这类框架写同一个MLP你会立刻体会到“框架到底帮你做了什么”。最核心的一件事是自动求导你只要把前向计算写好框架会在后台构建一张计算图记录数据流向然后调用loss.backward()自动完成所有反向传播梯度计算。你不需要管理self.zs和self.acts这些中间变量也不需要操心梯度顺序反没反、delta该往哪一层传。这极大提升了效率但前提是你得先知道框架在替你做什么。前面手写的经验在这里就是“地图”遇到梯度异常你能大概猜到是计算图哪里出了问题而不是完全黑盒。6.2 框架版完整代码同样结构的现代写法PyTorch版本同样是一个两层隐藏层的MLP但代码风格完全不一样import torch import torch.nn as nn from torch.utils.data import DataLoader, TensorDataset class MLP(nn.Module): def __init__(self, input_dim784, hidden_dims(64, 64), num_classes10): super().__init__() layers [] dims (input_dim,) hidden_dims (num_classes,) for i in range(len(dims) - 1): layers.append(nn.Linear(dims[i], dims[i 1])) if i len(dims) - 2: layers.append(nn.ReLU()) # 隐藏层用ReLU self.net nn.Sequential(*layers) def forward(self, x): return self.net(x) model MLP() criterion nn.CrossEntropyLoss() # 内部自带 softmax optimizer torch.optim.SGD(model.parameters(), lr0.2) train_loader DataLoader( TensorDataset(torch.tensor(X_train, dtypetorch.float32), torch.tensor(y_train, dtypetorch.long)), batch_size128, shuffleTrue, ) for epoch in range(20): model.train() total_loss 0.0 for xb, yb in train_loader: optimizer.zero_grad() out model(xb) loss criterion(out, yb) loss.backward() optimizer.step() total_loss loss.item() print(fepoch {epoch 1:2d} loss {total_loss / len(train_loader):.4f}) model.eval() with torch.no_grad(): test_out model(torch.tensor(X_test, dtypetorch.float32)) pred test_out.argmax(dim1).numpy() print(test acc:, np.mean(pred y_test))有几点注意这里的标签不需要转成one-hotCrossEntropyLoss内部直接接收整数索引nn.Linear不会帮你加激活函数ReLU要自己挂在层与层之间这也是我之前说权重形状容易混的地方PyTorch线性层的权重形状是 ((out, in))源码层面和手写版正好是转置关系。6.3 DataLoader、device与eval模式新手最容易翻的三个车框架版比手写版多出的这些东西每一个都是实现细节里的“坑”。第一个是model.train()和model.eval()的区别。train()模式下Dropout和BatchNorm处于工作状态eval()模式下它们会被关闭或改用统计值。如果你在测试时不切到eval()带Dropout的模型会输出一个“随机版本”的预测结果忽高忽低。第二个坑是device。数据在CPU上传到模型模型在GPU上一调用就会报维度错误或者device不匹配。统一的习惯是把模型和批量数据都显式to(device)不要靠自动搬运。第三个坑是torch.no_grad()。评估阶段不需要计算梯度包一层这个上下文管理器既能省内存又能加速。很多人忘了这一句测试时显存莫名其妙就爆了其实就是在给不需要梯度的前向传播傻算计算图。最后说点个人体会。我在带新人调模型时发现一个规律凡是框架用得溜但没手写过反向传播的人遇到loss变成NaN或者是梯度爆炸这类问题基本只能靠删掉重试而手写过一次的人看到NaN会条件反射去查梯度流经的每一层到底是哪一步出现了无穷大。这个能力没法速成手写一次就有了。如果你看完这篇决定动手写一遍我的建议是先别改结构把代码原样跑通再去调隐藏层宽度、学习率、激活函数这三样。等你看到自己写的网络从瞎猜变成一条稳定的下降曲线那种手感和单纯调包是完全不一样的。 前阵子有个做后端开发的朋友说要转AI问我能不能跳过“多层感知机”直接学Transformer。我说你这是在盖楼不打地基。虽然现在的注意力都被大模型、扩散模型这些词吸走了但你随便拆开一张现代神经网络的实现代码最底层的计算单元依然是同一件事线性变换加非线性激活函数交替堆叠。这个东西的学名就是多层感知机也就是MLP。这篇文章把多层感知机的原理和代码一次讲透。从单个神经元怎么工作到前向传播和反向传播每一步的数学账本再到用NumPy从零手写一个能跑手写数字分类的网络最后用主流深度学习框架重写一遍看看框架替你扛了多少活。无论你是刚入门的学生还是想把基础补扎实的工程师这篇都值得花一两个小时认真看完。1. 为什么说多层感知机是所有深度学习骨架1.1 一个神经元加权求和再加一道“开关”先看最简单的情况。一个神经元接收若干输入每个输入乘一个权重加上一个偏置然后过一个激活函数输出一个数。用公式写就是[ a g(\sum_{i} w_i x_i b) ]这跟你去菜市场买菜算账的逻辑一样单价就是权重买多少就是输入总价就是加权和而激活函数是一道“开关”决定这个结果要不要“放行”到下一层。单看这一步没什么神奇的但把它堆成几百层就能拟合出能写诗、能画图的函数这个跨度本身就是深度学习最反直觉的地方。1.2 单层感知机的软肋画不出一条线搞不定的事早期感知机就是一层这样的神经元它只能学出线性决策边界。你给它二维平面上两类点如果这两类点能被一条直线分开它很快就能收敛但如果数据是“异或”那种分布——对角的两块属于一类另外两块属于另一类——单层感知机就彻底抓瞎因为这种分割在平面上需要两条直线也就是一个非线性的边界。这个“线性不可分”的问题在1969年那本著名的专著里被拿出来反复讨论直接导致神经网络进入了一段漫长的低谷期。现在回头看问题其实不在神经元本身而是层数不够、也没有好用的非线性激活函数做帮手。1.3 多层加非线性逼近任何连续函数的底气多层感知机的核心改动就两条一是堆了至少一个隐藏层二是隐藏层用非线性激活函数。这两件事合在一起赋予了网络一个非常硬核的性质只要隐藏层神经元数量足够多多层感知机可以任意精度逼近任何一个连续函数。这就是常说的万能逼近定理。道理可以这么理解每个隐藏层神经元相当于在输入空间里划出一块“区域”多个神经元组合起来就能拼出任意形状的边界。第一层学的是边缘和局部特征第二层把局部特征组合成更大的模式往后层层抽象。所以你不需要手动设计特征直接让网络自己学这就是“表示学习”的起点。2. 前向传播用一张3层网络把矩阵运算彻底算明白2.1 符号约定先别让维度把你绕晕后面代码里我用的是行向量约定输入 (x) 的形状是 ((N, d_{in}))其中 (N) 是样本数(d_{in}) 是输入维度。第 (i) 个权重矩阵 (W_i) 的形状是 ((d_{in}^{(i)}, d_{out}^{(i)}))偏置 (b_i) 的形状是 ((d_{out}^{(i)},))。矩阵乘法的顺序是 (x W_i b_i)。这里容易混的一点是为什么 (W) 不是反过来排成 ((d_{out}, d_{in}))两种写法都有人用本质只是转置关系。我推荐先记住“前一个维度是上一层的输出维度”这个规则心里时刻能说出每个矩阵的形状后面写代码、调bug都会从容很多。2.2 手算一遍从输入到概率输出我拿一个 2→4→2 的小网络完整算一遍让你看清楚每一步数字是怎么流过去的。输入 (x [0.5, -1.0])第一层权重[ W_1 \begin{bmatrix} 0.2 -0.3 0.4 0.1 \ 0.6 0.2 -0.1 0.5 \end{bmatrix} \quad b_1 [0.1, 0.0, -0.2, 0.3] ]先算第一层的加权输入 (z_1 x W_1 b_1)第1个神经元(0.5 \times 0.2 (-1.0) \times 0.6 0.1 -0.4)第2个神经元(0.5 \times (-0.3) (-1.0) \times 0.2 0.0 -0.35)第3个神经元(0.5 \times 0.4 (-1.0) \times (-0.1) (-0.2) 0.1)第4个神经元(0.5 \times 0.1 (-1.0) \times 0.5 0.3 -0.15)过 sigmoid 激活 (a_1 \sigma(z_1))得到大约 ([0.401, 0.413, 0.525, 0.463])。第二层权重[ W_2 \begin{bmatrix} 0.5 -0.2 \ 0.3 0.4 \ -0.1 0.6 \ 0.2 0.1 \end{bmatrix} \quad b_2 [0.05, -0.05] ]继续算 (z_2 a_1 W_2 b_2)第1个输出(0.401 \times 0.5 0.413 \times 0.3 0.525 \times (-0.1) 0.463 \times 0.2 0.05 \approx 0.415)第2个输出(0.401 \times (-0.2) 0.413 \times 0.4 0.525 \times 0.6 0.463 \times 0.1 - 0.05 \approx 0.396)最后过 softmax把这两个数变成概率。算出来大约是 ([0.505, 0.495])非常接近但已经分出了高下。这就是一次完整的前向传播输入经过一层层矩阵乘法和激活函数最终输出每个类别的概率。2.3 为什么权重这样排向量的“形状感”比公式重要很多新手卡在“为什么梯度公式里要转置”这种问题上根源是手里没有一张维度的地图。我的建议是你自己推导的时候永远把每一步的输入、输出形状写在旁边(x): ((N, 2))(W_1): ((2, 4)) → (z_1): ((N, 4))(a_1): ((N, 4))(W_2): ((4, 2)) → (z_2): ((N, 2))(a_2): ((N, 2))任何矩阵乘法只要参与运算的两个矩阵内部维度能对上结果形状就绝对不会错。这个习惯能让你少掉一半头发。3. 反向传播误差如何“精准甩锅”到每一个权重3.1 核心直觉梯度就是一张责任分摊表前向传播算完一轮之后网络到底错在哪儿反向传播要回答的就是这个问题。你可以把它理解成一个团队项目搞砸了现在要开复盘会最终损失对某一个权重的影响有多大就是那个权重的梯度。梯度大说明这个权重“责任大”调整它效果最明显梯度接近0说明这个权重对当前损失几乎没影响改了也没用。链式法则在这里的作用是把最终损失的责任通过一层一层的关系准确地回传给每个参数。这不是什么玄学就是复合函数求导的逐层展开。3.2 链式法则逐层拆解从损失到第一层参数假设输出层用 softmax损失用交叉熵[ L -\frac{1}{N}\sum_n \sum_k y_{nk} \log \hat{y}_{nk} ]这里 (\hat{y}) 是网络输出的概率。有一个非常经典的化简softmax 配上交叉熵之后输出层的误差信号就是[ \delta_{out} \hat{y} - y ]就是预测概率减去 one-hot 真实标签这个结果在代码里直接用不需要再手动算 log 的导数。然后误差信号往上一层传[ \delta_h (\delta_{out} \cdot W_2^T) \odot g(a_1) ]这里 (\odot) 是逐元素相乘(g(a_1)) 是激活函数的导数对于 sigmoid 就是 (a(1-a))。每个隐藏层神经元的“责任”由两部分组成它把多少误差传给下一层通过 (W_2^T)以及它自己的激活函数当时“放行了多少信号”通过 (g(a_1))。得到每一层的误差信号之后权重梯度就是上一层的激活输出和当前层误差信号的外积[ \frac{\partial L}{\partial W_1} x^T \cdot \delta_h ]这步不用硬背拿维度反推就能写出来(x^T) 是 ((d_{in}, N))(\delta_h) 是 ((N, d_{hidden}))乘在一起正好是 ((d_{in}, d_{hidden}))和 (W_1) 的形状一致。所有梯度公式你都可以用“形状必须和参数形状一致”这个原则去验证对不对。3.3 参数更新梯度下降与学习率的“旋钮”属性拿到梯度之后参数更新就一句话[ W W - \eta \cdot \frac{\partial L}{\partial W} ](\eta) 就是学习率。注意我强调它是“旋钮”而不是“开关”调大一点收敛快但调太大会在损失函数曲面上左右横跳甚至发散调小一点稳定但太小会用大量时间换几次无效的微调。实践中通常先从 (0.1) 这个量级开始观察损失曲线再微调而不是凭感觉直接给定值。4. 从Zero到一NumPy手写一个可训练的多层感知机4.1 网络骨架与初始化为什么不能把权重设成0理论说清楚了现在动手。用NumPy从零写一个支持任意层数的MLP代码大概一百来行完整可运行。第一件要注意的事是初始化。如果你把所有权重初始化为0那么同一层所有神经元会学到完全相同的梯度也就是“对称性”问题——网络变成一堆复制品永远学不出有区分度的特征。正确做法是用小随机数初始化。这里我用的是He初始化标准差按输入维度缩放目的是让信号在层层传播时既不会被放大到爆炸也不会缩小到消失。import numpy as np def sigmoid(x): return 1.0 / (1.0 np.exp(-x)) def sigmoid_deriv(a): return a * (1.0 - a) def softmax(z): # 减去最大值是为了数值稳定不影响概率结果 z z - np.max(z, axis1, keepdimsTrue) e np.exp(z) return e / np.sum(e, axis1, keepdimsTrue) class MLP: def __init__(self, sizes, seed42): np.random.seed(seed) self.sizes sizes self.W [] self.b [] for i in range(len(sizes) - 1): std np.sqrt(2.0 / sizes[i]) # He初始化 self.W.append(np.random.randn(sizes[i], sizes[i 1]) * std) self.b.append(np.zeros(sizes[i 1])) def forward(self, x): self.zs [] self.acts [x] a x for i, (W, b) in enumerate(zip(self.W, self.b)): z a W b self.zs.append(z) a softmax(z) if i len(self.W) - 1 else sigmoid(z) self.acts.append(a) return a def backward(self, x, y): m x.shape[0] grad_W [] grad_b [] delta (self.acts[-1] - y) / m # softmax 交叉熵的梯度 for i in reversed(range(len(self.W))): a_prev self.acts[i] grad_W.append(a_prev.T delta) grad_b.append(np.sum(delta, axis0)) if i 0: delta (delta self.W[i].T) * sigmoid_deriv(self.acts[i]) grad_W.reverse() grad_b.reverse() return grad_W, grad_b def train(self, x, y, lr0.2, epochs100): for epoch in range(epochs): out self.forward(x) grad_W, grad_b self.backward(x, y) for i in range(len(self.W)): self.W[i] - lr * grad_W[i] self.b[i] - lr * grad_b[i] if epoch % 10 0: loss -np.mean(np.sum(y * np.log(out 1e-9), axis1)) acc np.mean(np.argmax(out, axis1) np.argmax(y, axis1)) print(fepoch {epoch:3d} loss {loss:.4f} acc {acc:.4f})4.2 前向与反向的实现细节为什么梯度方向要反转这个实现里有几个值得注意的细节。第一forward里我用self.zs和self.acts把每一层的中间结果都存了下来这是反向传播的“账本”——没有这些中间值后面根本没法算梯度。第二backward里我是从输出层往输入层反向遍历的所以算出的grad_W顺序是反的最后要reverse()回来才能和self.W的顺序对齐。这种顺序问题非常容易出bug如果你自己写建议在每次更新前用断言把梯度和参数的形状对一遍。第三个细节是输出层的梯度写法。很多人以为要手动对交叉熵求导其实不用softmax 输出的概率与 one-hot 标签相减就已经是对交叉熵损失的梯度了。这是深度学习里最经典的公式之一能手动推一遍最好推不出来就先记住结论。4.3 在真实数据上跑起来数据预处理决定成败理论网络要落到真实数据上有一件事比模型本身更影响结果那就是数据预处理。以经典的手写数字数据集为例每张图是28×28的灰度图一共10个类别。你要做的预处理很简单把28×28的图片拉平成784维的向量把像素值从0到255缩放到0到1之间把整数标签转成one-hot向量X_train X_train.reshape(-1, 784) / 255.0 X_test X_test.reshape(-1, 784) / 255.0 y_train_onehot np.eye(10)[y_train] y_test_onehot np.eye(10)[y_test] model MLP([784, 64, 64, 10], seed42) model.train(X_train, y_train_onehot, lr0.2, epochs100) pred np.argmax(model.forward(X_test), axis1) print(test acc:, np.mean(pred np.argmax(y_test_onehot, axis1)))第一次跑通你会看到损失从开始时逼近2.3因为10个类别随机猜的理论损失就是 (-\ln(0.1) \approx 2.3026)一路降到0.2以下测试集准确率能到92%左右。这个结果在“深度学习”里不算惊艳但它是你亲手写出来的每一行梯度下降日拱一卒换来的这个手感比任何调包都值钱。5. 训练多层感知机的实战调参与避坑5.1 激活函数等于号sigmoid在深层网络里会“窒息”手写版里隐藏层用的是sigmoid跑这种两三层的小网络没问题但层数一加深就会碰到一个经典问题梯度消失。sigmoid的导数最大只有0.25而隐藏层每往上传一层误差信号就要多乘一个小于1的数。假设网络有5层最坏情况下梯度衰减到原来的 (0.25^5 \approx 0.001)最靠近输入的层几乎学不到东西。更推荐的做法是隐藏层用ReLU(g(z) \max(0, z))它在正半区导数恒为1不会指数级压缩梯度。ReLU也有自己的脾气比如神经元一旦在反向传播中收到较大梯度权重被推到负数区这一路就可能永远失活这就是“dead ReLU”问题。实践中常见做法是用LeakyReLU或者加一个很小的初始偏置来缓解。选激活函数没有绝对的对错但你必须知道它给你带来的代价是什么。5.2 输入归一化与初始化两个被低估的细节很多人第一版代码跑不出理想精度问题往往不在梯度公式而在输入没归一化。如果某个特征的数值范围是0到255另一个是-1到1那么权重更新时前者对应的梯度天然就更大模型会被“大数值特征”带偏训练过程就容易震荡。把输入缩放到0到1或者标准化成均值为0方差为1能让所有特征处在同一量级损失曲面更接近“碗形”梯度下降走得更顺。初始化同理。刚才代码里用的He初始化是配合ReLU类激活函数设计的如果用sigmoid/tanh更经典的是Xavier初始化标准差按 (\sqrt{1/d_{in}}) 缩放。选错初始化不会立刻报错但你会发现网络要么学得极慢要么先冲上高损失然后一路崩溃。这几个“不起眼”的细节往往是训练稳定性和最终精度的分水岭。5.3 看损失曲线诊断几种典型“心电图”训练经验积累到一定程度你会发现自己越来越依赖损失曲线来诊断问题就像医生看心电图。下面这几种曲线形态基本可以立刻定位问题方向损失曲线表现最可能的原因优先尝试的手段损失一直不降稳在2.3附近学习率太小或初始化不合适或特征没归一化调大学习率到0.5试试重查预处理损失先降后突然变NaN或爆涨学习率太大梯度爆炸调小学习率检查是否用了数值不稳定的softmax训练损失下降但验证集损失很快反弹过拟合增加数据、加正则、加Dropout、早停损失曲线剧烈震荡不下去学习率偏大或批大小太小调小学习率增大批大小注意把学习率从0.1改成0.5属于“试新的量级”改成0.15则基本是心理安慰。调参要按数量级走一次只动一个变量记录结果否则你永远不知道是哪一步起了作用。5.4 过拟合信号训练集满分测试集不及格我见过太多新手看着训练集准确率逼近99%就认为模型成了一测测试集只有85%当场傻眼。这是过拟合的典型信号模型把训练数据的细节和噪声背了下来却没有学到可以泛化的规律。对策按优先级来第一收集更多数据第二加正则化L2正则的直观效果是约束权重不长得太“极端”第三加Dropout随机让一部分神经元在训练时失活强迫网络学冗余特征第四早停验证集损失连续好几个epoch不降就停止训练。这些在小MLP上已经够用到了大模型时代思路也依然是这一套只是实现工具变得更复杂了而已。6. 用主流框架重写同一模型框架替你扛了多少活6.1 自动求导与计算图反向传播公式从此不用手推手写一遍之后再用PyTorch这类框架写同一个MLP你会立刻体会到“框架到底帮你做了什么”。最核心的一件事是自动求导你只要把前向计算写好框架会在后台构建一张计算图记录数据流向然后调用loss.backward()自动完成所有反向传播梯度计算。你不需要管理self.zs和self.acts这些中间变量也不需要操心梯度顺序反没反、delta该往哪一层传。这极大提升了效率但前提是你得先知道框架在替你做什么。前面手写的经验在这里就是“地图”遇到梯度异常你能大概猜到是计算图哪里出了问题而不是完全黑盒。6.2 框架版完整代码同样结构的现代写法PyTorch版本同样是一个两层隐藏层的MLP但代码风格完全不一样import torch import torch.nn as nn from torch.utils.data import DataLoader, TensorDataset class MLP(nn.Module): def __init__(self, input_dim784, hidden_dims(64, 64), num_classes10): super().__init__() layers [] dims (input_dim,) hidden_dims (num_classes,) for i in range(len(dims) - 1): layers.append(nn.Linear(dims[i], dims[i 1])) if i len(dims) - 2: layers.append(nn.ReLU()) # 隐藏层用ReLU self.net nn.Sequential(*layers) def forward(self, x): return self.net(x) model MLP() criterion nn.CrossEntropyLoss() # 内部自带 softmax optimizer torch.optim.SGD(model.parameters(), lr0.2) train_loader DataLoader( TensorDataset(torch.tensor(X_train, dtypetorch.float32), torch.tensor(y_train, dtypetorch.long)), batch_size128, shuffleTrue, ) for epoch in range(20): model.train() total_loss 0.0 for xb, yb in train_loader: optimizer.zero_grad() out model(xb) loss criterion(out, yb) loss.backward() optimizer.step() total_loss loss.item() print(fepoch {epoch 1:2d} loss {total_loss / len(train_loader):.4f}) model.eval() with torch.no_grad(): test_out model(torch.tensor(X_test, dtypetorch.float32)) pred test_out.argmax(dim1).numpy() print(test acc:, np.mean(pred y_test))有几点注意这里的标签不需要转成one-hotCrossEntropyLoss内部直接接收整数索引nn.Linear不会帮你加激活函数ReLU要自己挂在层与层之间这也是我之前说权重形状容易混的地方PyTorch线性层的权重形状是 ((out, in))源码层面和手写版正好是转置关系。6.3 DataLoader、device与eval模式新手最容易翻的三个车框架版比手写版多出的这些东西每一个都是实现细节里的“坑”。第一个是model.train()和model.eval()的区别。train()模式下Dropout和BatchNorm处于工作状态eval()模式下它们会被关闭或改用统计值。如果你在测试时不切到eval()带Dropout的模型会输出一个“随机版本”的预测结果忽高忽低。第二个坑是device。数据在CPU上传到模型模型在GPU上一调用就会报维度错误或者device不匹配。统一的习惯是把模型和批量数据都显式to(device)不要靠自动搬运。第三个坑是torch.no_grad()。评估阶段不需要计算梯度包一层这个上下文管理器既能省内存又能加速。很多人忘了这一句测试时显存莫名其妙就爆了其实就是在给不需要梯度的前向传播傻算计算图。最后说点个人体会。我在带新人调模型时发现一个规律凡是框架用得溜但没手写过反向传播的人遇到loss变成NaN或者是梯度爆炸这类问题基本只能靠删掉重试而手写过一次的人看到NaN会条件反射去查梯度流经的每一层到底是哪一步出现了无穷大。这个能力没法速成手写一次就有了。如果你看完这篇决定动手写一遍我的建议是先别改结构把代码原样跑通再去调隐藏层宽度、学习率、激活函数这三样。等你看到自己写的网络从瞎猜变成一条稳定的下降曲线那种手感和单纯调包是完全不一样的。