从MLP到LeNet：输出层为何总用sigmoid和softmax？

1. 从MLP到LeNet：先搞清楚模型在做什么

1.1 全连接层与卷积层的共性：输出层永远是那一层"考卷"

很多人学神经网络时，会把MLP（多层感知机）和LeNet当成两个独立的东西——一个用来入门理解原理，一个用来做正经的图像识别。这种割裂感很容易让人忽略一件关键的事：无论网络中间层是nn.Linear还是nn.Conv2d，无论前面是64维的特征还是2048维的feature map，最后一层永远是一个"打分器"。

以经典的手写数字识别任务为例。一个MLP的最后一层可能是nn.Linear(128, 10)，把128维特征压缩成10个实数；LeNet的最后一层可能是nn.Linear(120, 10)，把120维特征压缩成10个实数。这10个实数本质上就是模型对"这张图属于数字0到9"的原始打分——在英文文献里这串数字叫logits，直译过来就是"逻辑值"，我更喜欢叫它"粗评分"。

为什么用"粗"这个字？因为这个时候的评分完全不能直接当结论用。假设模型输出[3.5, -1.2, 0.8, ...]，你不能说"数字0的分数是3.5，所以这张图有3.5的概率是0"。分数可以是任意实数，可以是负的，可以超过100。正常的概率必须满足两个条件：落在[0, 1]区间，所有类别的概率加起来等于1。把粗评分变成符合条件约束的概率值，这就是输出层需要用sigmoid或softmax的本职工作。

我自己带过不少入门的朋友，他们最常见的困惑就是：既然分类就是选分数最高的那个类别，为什么不直接argmax一下完事？这个问题的答案是：训练阶段和推理阶段的需求不一样。推理阶段你确实只需要一个"最大分数的下标"，但在训练阶段，如果只有分数而没有概率，损失函数就无法计算——因为梯度下降要求我们回答"模型错得多离谱"，而"差距"这个概念需要在一个有边界、可比较的空间里定义。

1.2 输出层的历史使命：从原始打分到可信概率

再从历史角度梳理一下。早期神经网络（比如感知机）的输出层就是一个简单的线性变换，不接任何非线性函数。它的行为就像一台打分机器：输入特征，输出一个实数，然后拿这个实数和阈值比较，大于阈值就判为正类，小于阈值就判为负类。

这种设计的最大问题是：打分没有可解释性。同样是正类，分数是100和分数是0.1，模型对这两个样本的"信心"显然完全不同，但阈值逻辑只能告诉你"都是正类"。更重要的是，当我们需要用梯度下降训练网络时，线性打分和真实的期望输出（比如0/1标签）之间的误差曲面非常不友好，收敛缓慢且容易震荡。

引入sigmoid之后，输出被限制到(0, 1)区间，可以视作"正类的概率估计"。这带来两个直接好处：第一，误差的反馈变得平滑——模型是"有点确定"还是"非常确定"都有了数值区分；第二，结合交叉熵损失之后，梯度大小与模型犯错的严重程度成正比，训练稳定性大幅提升。

后来多分类任务变多，sigmoid作为单输出二分类的利器就不够用了，因为多分类需要同时输出多个类别的概率，且这些概率要竞争性地加起来等于1。这时候softmax登场。LeNet诞生于1998年前后，它的输出层用的就是softmax思路。可以说，从MLP到LeNet，网络结构朝着"更深、更复杂"演变，但输出层做概率化这件事，从几十年前到现在都没有变过。

2. sigmoid与softmax的数学直觉与本质差异

2.1 sigmoid：那个把实数域压缩到(0,1)的"S"形闸门

sigmoid函数的表达式是：

[ \sigma(x) = \frac{1}{1 + e^{-x}} ]

如果你画一下它的图像，会得到一条经典的S形曲线。x趋近负无穷时，输出趋近0；x趋近正无穷时，输出趋近1；x=0时输出恰好是0.5。这个函数最大的价值在于把实数轴上无边无际的输入，映射到一个有边界的概率区间，相当于给模型的粗评分装了一道闸门。

什么时候用sigmoid？当你的任务本质上是"二选一"的时候。比如判断一封邮件是不是垃圾邮件：标签只有两个，是或者不是；模型只需要输出一个概率p，表示"是垃圾邮件的概率"，那么"不是"的概率自然就是1-p。

但这里有个关键细节，很多人入门时常踩坑：sigmoid输出的是单侧概率，它自己并不负责"两个类别的比较"。也就是说，你的模型最后一层只需要输出一个实数（logit），喂给sigmoid得到p，然后配合二分类交叉熵损失（BCE）进行训练。这个流程天然假设了"类别一"的概率是p，"类别二"的概率是1-p，两个类别的概率是互补关系。

我见过不少新手在写二分类模型时，输出层搞两个节点，套两次sigmoid，然后手动把两个输出归一化。这种操作不是完全不能工作，但梯度性质和概率解释都变得别扭。正确且省心的做法是：输出一个logit，接一次sigmoid。

2.2 softmax：一群概率的分配器

softmax的公式是：

[ \text{softmax}(z_i) = \frac{e^{z_i}}{\sum_{j=1}^{K} e^{z_j}} ]

它做的事情可以理解成三步：先对所有输入分数取指数（把负分数变成正的小数，把正分数放大），然后把所有指数值加起来作为分母，最后用每个指数除以这个总和。结果是所有输出都是正数，且加起来恒等于1——这正是一个合法的概率分布。

什么时候用softmax？当任务是"多选一"的分类时。比如MNIST手写数字识别，10个类别，一张图必然只属于其中一个数字。模型最后一层输出10个粗评分，经过softmax得到10个概率，哪个概率大就倾向判哪一类。

softmax还有一个特性值得单独拿出来说：它是"竞争性"的分配器。某一个类别的概率大了，其他类别的概率必定变小，因为总和固定为1。这个特性非常契合分类问题的本质——样本只能属于一个类别，所有类别的概率必须互相挤压、互相竞争。相比之下，如果10个节点各自过sigmoid，得到的10个概率互不干扰、和也不为1，那只适合"多标签分类"场景（比如一张图里同时有猫和狗、且可以都没有）。

2.3 为什么隐藏层不选它们：梯度消失的真实原因

既然sigmoid和softmax这么好用，为什么我们不在隐藏层也用它们？这个问题几乎每个初学者都会问。核心原因是梯度消失，而梯度消失的根源在于导数太小。

sigmoid的导数是：

[ \sigma'(x) = \sigma(x)(1 - \sigma(x)) ]

当输入x=0附近时，导数值约为0.25，看起来还可以。但一旦输入跑到两端，比如x=5时σ(x)=0.993，导数就只有0.993×0.007≈0.007，几乎为零。神经网络深层的梯度需要逐层反向传播，一层乘0.007，两层乘0.000049，十层之后梯度直接归零。这就是为什么早期浅层网络用sigmoid还凑合，一旦堆到十几层，训练就完全跑不动——梯度传到前面几层的时候早就消失了。

ReLU（以及它的各种变体）之所以后来成为隐藏层的主流选择，核心原因就是它在正半轴的导数恒为1，梯度传递不会衰减。当然ReLU也有自己的问题（比如负半轴梯度恒为0，导致某些神经元"死亡"），但相比sigmoid在深层网络中的梯度消失，ReLU瑕不掩瑜。

softmax虽然输出是向量，但和sigmoid有类似的问题：它在输入极端时饱和，梯度趋近于零。所以softmax几乎只在最后一层出现，隐藏层基本不会用它。结论可以总结成一句话：激活函数分两派——隐藏层用"不饱和"的ReLU家族，输出层用"概率化"的sigmoid或softmax，各司其职。

3. 输出层为什么必须用它们：概率化的不可替代性

3.1 从神经网络的"轻信"到概率化表达

假设你的模型输出层不接任何非线性变换，直接输出一个实数向量。这个时候，模型的"预测"只是一个无约束的实数，你没法回答"你对这个预测有多大把握"这个问题。模型可能给出分数3.2，也可能给分数-0.7，但3.2比-0.7"确定"多少？3.2是"79%置信度"还是"98%置信度"？完全说不清。

引入sigmoid或softmax的本质，是把模型的输出从"单点估计"升级为"概率分布"。这里面蕴含了一个重要的工程思想：深度学习模型不应该只给出答案，还应该给出"对答案的置信程度"。很多实际业务场景都依赖这个置信度——比如在自动驾驶中，模型对某个障碍物识别置信度低于阈值时，系统会切换策略请求人工接管；在医疗影像筛查中，置信度低的样本会被标记给医生重点复核。如果没有概率化输出，这些下游策略就无从谈起。

你可以把输出层之前的网络理解成一个特征提取器，它把输入"翻译"成一套内部特征；输出层则负责把这套特征"翻译"成人能看懂的决策语言。概率就是这个决策语言的标准语法。没有概率化的输出层，就像一份没有单位的报告——数字再精确，使用的人也无法解读。

3.2 与损失函数的"黄金搭档"：交叉熵的推导逻辑

输出层加sigmoid或softmax，表面上看是为了得到概率，更深层的原因是为了配合交叉熵损失做训练。这一点值得掰开揉碎讲，因为它是理解深度学习训练过程的钥匙。

先看二分类交叉熵：

[ L = -[y \log(p) + (1-y)\log(1-p)] ]

其中y是真实标签（0或1），p是模型预测的"正类概率"。这个函数在p越接近y时越小，越偏离时越大。

为什么这个形式和sigmoid是绝配？因为二者组合之后，梯度计算会变得非常干净。如果你自己手推过sigmoid + 均方误差的组合，会发现梯度里包含一个σ'(z)因子，当预测饱和时梯度趋近于零，学习极其缓慢。而sigmoid + 交叉熵组合，梯度化简后恰等于p - y——预测概率和真实标签的差值。这个差值天然包含了误差信号：差得多梯度大，差得少梯度小，完美符合直觉。

多分类交叉熵也类似：

[ L = -\sum_{i=1}^{K} y_i \log(p_i) ]

搭配softmax之后，梯度同样化简为p_i - y_i。这一性质让训练变得高效而稳定。所以你现在应该明白，为什么几乎所有分类模型的最后一层都是"线性层 + softmax + 交叉熵"的套餐——不是因为他们喜欢这么写，而是因为这三者的搭配在数学上是优化的、在工程上是高效的。

反过来说，如果你在输出层用了ReLU，结果会怎样？ReLU的输出永远是非负数，没有上界，概率化无从谈起；如果再用交叉熵，log(p)当p可能大于1时就没意义。所以输出层选激活函数，其实是被"你想用什么损失函数"倒推出来的。你要是非用均方误差训分类，那也不是完全不行，但收敛速度和最终效果通常会差一大截。

3.3 LeNet输出层的经典配置

LeNet-5作为卷积神经网络的鼻祖之一，它的输出层设计在今天看来依然是教科书级别的示范。网络末端的结构大致是：卷积+池化提取特征之后，特征图被展平为一维向量，然后依次经过两个全连接层，最后到达一个10维输出的全连接层。

在原始论文里，最后一层的10个输出节点对应数字0到9。训练阶段，这10个logits会经过softmax变成概率，和真实标签计算交叉熵损失；推理阶段，取softmax输出中概率最大的下标作为预测类别。这个"训练用softmax计算损失，推断用argmax取结果"的范式，已经成为现代分类网络的通用模板。

我在实操中经常提醒自己一件事：nn.CrossEntropyLoss在PyTorch里自带softmax逻辑，也就是说你喂给它的应该是未经softmax的logits，而不是概率。这一点初看反直觉，原因在于PyTorch为了提高数值稳定性和计算效率，把softmax的指数运算和交叉熵的对数运算做了融合，内部一起算。如果你先手动softmax，再喂给CrossEntropyLoss，模型依然能跑，但数值上多了一步中间转换，极端情况下还可能因为log(0)出现NaN。

配套LeNet这类模型，一个标准的输出层写法是：

import torch.nn as nn class LeNet(nn.Module): def __init__(self, num_classes=10): super().__init__() self.features = nn.Sequential( nn.Conv2d(1, 6, kernel_size=5, padding=2), nn.ReLU(), nn.MaxPool2d(2), nn.Conv2d(6, 16, kernel_size=5), nn.ReLU(), nn.MaxPool2d(2), ) self.classifier = nn.Sequential( nn.Linear(16 * 5 * 5, 120), nn.ReLU(), nn.Linear(120, 84), nn.ReLU(), nn.Linear(84, num_classes) # 输出10个logits ) def forward(self, x): x = self.features(x) x = torch.flatten(x, 1) x = self.classifier(x) return x # 直接返回logits

这里有个细节值得注意：定义模型时完全不写softmax。softmax只在训练时通过损失函数隐式地完成，在推理时则显式调用torch.softmax(model(x), dim=1)。这么做的好处是让训练和推理都能保持数值稳定，也避免了在forward里多一层不必要的计算。

4. 实操：从MLP到LeNet的输出层复现与踩坑记录

4.1 环境准备与数据切分

动手之前，先把环境准备好。我用的是PyTorch 2.x版本，搭配CUDA 11.8，Python 3.10。不需要高级显卡，CPU也能跑通下面这个MNIST小实验，只是慢一些。数据方面直接使用torchvision.datasets.MNIST，0到9共10类，训练集6万张、测试集1万张，每张图是28×28的灰度图。

老规矩，数据要做标准化。MNIST的像素值在0到255之间，直接喂给网络倒也能跑，但收敛速度和稳定性都会差一些。标准做法是归一化到[0,1]或标准正态分布。我用的是transforms.ToTensor()配合transforms.Normalize((0.1307,), (0.3081,))，这两个数值是MNIST官方提供的均值和标准差。很多人会忽略这一步，结果发现训练loss总是在高位震荡——不是网络结构有问题，就是数据没有标准化。

切分数据时我习惯固定随机种子（比如random.seed(42)），然后划分训练集和验证集。简单任务可以只留测试集做最终评估，但考虑到我要反复调试输出层结构，还是从训练集里单独划出一部分作为验证集，避免过拟合导致判断失误。

4.2 手写MLP输出层：两种激活函数的对比实验

先写一个三层的MLP作为基线。输入层784个神经元（28×28），隐藏层128+64个ReLU，输出层10个logits。关键代码如下：

import torch import torch.nn as nn import torch.nn.functional as F class SimpleMLP(nn.Module): def __init__(self, output_mode="softmax"): super().__init__() self.fc1 = nn.Linear(28 * 28, 128) self.fc2 = nn.Linear(128, 64) self.fc3 = nn.Linear(64, 10) self.output_mode = output_mode def forward(self, x): x = torch.flatten(x, 1) x = F.relu(self.fc1(x)) x = F.relu(self.fc2(x)) logits = self.fc3(x) if self.output_mode == "softmax_manual": return F.softmax(logits, dim=1) # 手动softmax return logits # logits模式

训练时我对比了三种配置：

配置A：模型输出logits，配合nn.CrossEntropyLoss()。效果最稳，验证集准确率约98%。

配置B：模型输出softmax后的概率，喂给nn.CrossEntropyLoss()。准确率同样约98%，但训练中我发现loss的初始值比配置A略大。原因很简单：CrossEntropyLoss内部默认做了一次log_softmax，你喂给它概率，相当于在已经归一化的数值上又跑一次对数运算，导致数值范围出现细微偏移，虽然最终不影响结果，但纯粹是白算一道。

配置C：模型输出softmax后的概率，喂给nn.MSELoss()。训练速度明显变慢，验证准确率掉到94%以下。这个现象完全符合预期：sigmoid/softmax在饱和区的梯度太小，配合均方误差时梯度里多了一个p(1-p)因子，导致误差大时梯度反而小，训练被"卡住"。

这三个实验放在一起，结论非常清晰：输出层的激活函数不是随便选的，必须和损失函数配套使用。logits + CrossEntropyLoss是默认首选，手动softmax + CrossEntropyLoss属于多此一举，softmax + MSELoss则是在给自己挖坑。

4.3 LeNet输出层复现：从MLP到CNN的核心变化

接下来把MLP升级成LeNet。和MLP相比，结构上最大的变化是把全连接层换成了卷积层+池化层，但输出层依然是那个10维logits层。这里我不再赘述卷积的细节，重点看输出层的衔接部分。

LeNet的卷积部分输出的是一个(batch_size, 16, 5, 5)的特征图。要接全连接层，需要先把它展平成16 * 5 * 5 = 400维的向量。这里有一个常见的尺寸计算问题，我建议你动手跑之前先用形状打印确认一下：

def print_shape_hook(module, input, output): print(f"{module.__class__.__name__}: input={input[0].shape}, output={output.shape}") # 在forward中临时插入hook观察形状 for name, layer in model.named_modules(): layer.register_forward_hook(print_shape_hook)

我一开始写LeNet的时候，就是没仔细算卷积输出的尺寸，直接照搬论文的120维全连接输入，结果跑前向传播直接报维度不匹配错误。后来老老实实打印每一层的输出形状，才发现经过两次5×5卷积和2×2最大池化之后，特征图是16×5×5而不是我以为的16×10×10。这个失误值得分享，因为维度核对是手写CNN时最常见的低级错误。

输出层的训练代码和MLP完全一样：

model = LeNet(num_classes=10) criterion = nn.CrossEntropyLoss() optimizer = torch.optim.Adam(model.parameters(), lr=0.001) for epoch in range(5): for images, labels in train_loader: optimizer.zero_grad() logits = model(images) loss = criterion(logits, labels) loss.backward() optimizer.step()

在MNIST上，这个LeNet大约训练3个epoch就能到98%以上的准确率，明显快过MLP。这里的差异来自卷积层对图像局部结构的利用效率，但也说明了一个事实：无论特征提取层多复杂，输出层的训练逻辑完全不受影响。

推理时如果要输出概率，记得要先过softmax：

model.eval() with torch.no_grad(): logits = model(images) probs = torch.softmax(logits, dim=1) # 每行概率之和为1 preds = probs.argmax(dim=1)

4.4 训练中的隐藏层激活函数选择：为什么LeNet也用ReLU

有一个细节你可能会注意到：上面写的LeNet代码里，隐藏层激活函数用的是ReLU，而不是LeNet论文原版的tanh或sigmoid。这是我在实际实验时改动的。

LeNet-5原始论文发表于1998年，那时候ReLU还没有普及，作者用的是tanh作为隐藏层激活函数。我在复现时尝试过原版的tanh配置，在MNIST上也能达到不错的准确率，但训练速度明显慢于ReLU版本。原因就在于tanh在两端饱和区域的梯度非常小，反向传播时信息衰减明显。换用ReLU之后，训练收敛速度加快，精度还略有提升。这说明什么？说明复现经典网络结构时，不用拘泥于"原版"的一切细节，隐藏层的激活函数完全可以根据现代实践替换，但输出层的sigmoid/softmax这个设计，至今仍在沿用，因为它是不可替代的。

如果你偷懒把隐藏层的ReLU也换成sigmoid，你会立刻看到深度网络训练困难的全过程——浅层还好，到了第三层、第四层，loss下降得极其缓慢，训练到后面基本停滞。这就是梯度消失的真实体验。

5. 常见问题与调参心得实录

5.1 问题速查表

5.2 logits、概率与预测结果的混用陷阱

这是我在实际项目中频繁遇到的坑，专门拿出来说一说。训练完之后，你的模型可能输出三类东西：

• logits：原始粗评分，范围不限，适合喂给交叉熵损失；
• 概率（probs）：logits经过softmax之后的结果，范围[0,1]且各维度之和为1；
• 预测类别（preds）：概率最大的那个下标，只有一个整数。

很多初学者会弄混这三者的用途。比如有的代码在模型forward里直接返回softmax后的概率，训练时手动写loss = -torch.log(probs[range(batch), labels])，这样也能跑，但如果不小心传入了logits，就会出现log(负数)直接NaN。再比如，有的推理代码用logits.argmax(dim=1)取预测，这其实数学上和probs.argmax(dim=1)完全等价，因为softmax是单调递增变换，最大概率的位置就是最大logits的位置。所以推理时可以不用算softmax，直接取argmax，省一次计算量。

我的建议是：在代码注释里明确标注清楚当前变量是logits还是probs还是preds，不要混用。这种问题在写Demo时无伤大雅，一旦代码进入生产环境，一个"喂错数据类型"的bug可能潜伏很久才被发现，排查成本远高于写注释的成本。

5.3 关于数值稳定的实战优化

softmax在计算指数时，如果输入分数很大（比如某个logit是1000），e^1000直接溢出成无穷大，softmax结果变成NaN。这个问题在正常的MNIST训练中几乎不会出现，但在自然语言处理或者某些回归模型中，logits的尺度可能非常大。标准的缓解做法是softmax前先减去输入的最大值，即softmax(z) = softmax(z - max(z))。因为减最大值不改变指数函数的相对比例，但能把所有指数项限制在[0,1]，彻底避免溢出。

PyTorch的CrossEntropyLoss内部已经做了这个稳定化处理，所以直接使用它不会遇到这类问题。但如果你自己写损失函数或者自定义前向逻辑，务必加上这一层保护。

5.4 类别不平衡场景下的输出层调优

现实任务中经常遇到类别极不平衡的情况，比如某类样本占99.9%、另一类占0.1%。这种场景下，输出层依然是sigmoid或softmax，但训练时会面临两个额外问题。

第一，模型很容易陷入"全预测为多数类"的局部最优，因为这样loss就已经很小了。对策是调整损失函数的类别权重，比如在PyTorch的CrossEntropyLoss里传入weight参数，给少数类更大的梯度权重。第二，经过softmax得到的概率，是有校准问题的——模型的0.99置信度并不真的等于99%的准确率。如果你在做决策时需要准确的概率，建议画一下可靠性图，必要时做温度缩放（temperature scaling）来校准概率。

这里的核心思路是：输出层的激活函数不是训练结束就完事，它产出的概率值还能继续被下游流程二次加工。温度缩放的具体做法是在softmax里除一个可学习的温度参数T：

[ \text{softmax}(z_i / T) ]

T大于1时概率分布更平缓，T小于1时概率分布更尖锐。调温度不会改变预测类别，但会改变置信度值。这个技巧在模型集成、不确定性估计等场景中非常实用。

6. 写在最后：一点个人心得

从MLP到LeNet，网络结构发生了天翻地覆的变化——全连接变成了卷积，二维输入变成了四维张量，池化、归一化、残差连接一个接一个地冒出来。但如果你盯着输出层看，会发现它几乎没怎么变过：永远是一层线性变换，后面跟着sigmoid或softmax，配合交叉熵损失完成训练。这个"不变"本身就是一种很强烈的信号——概率化输出是神经网络分类任务的底层需求，无论前面的特征提取器多么强大，最后都需要一个合法概率来收尾。

我在实际做项目时，看到出问题的模型，第一反应不是去调前面的卷积层结构，而是先检查输出层和损失函数是否匹配。排查清单很简单：分类任务用的是不是交叉熵？模型输出的是logits还是概率？输出层节点的数量是不是类别数？这套检查十分钟能跑完，但解决过我无数次的问题。希望你也能养成这个习惯，少走一些弯路。

如果你正在入门深度学习，可以按照这篇博文的思路，在MNIST上跑一遍MLP和LeNet的对比实验，亲眼看一看不同输出层配置下的训练曲线差异——这比背十遍公式都管用。