企业官网建设流程全解析

神经网络叠层越多，不代表能力越强。很多人堆了一个几十层的网络，结果训练 loss 不降，验证集指标甚至比浅层还差。问题往往不在网络结构，而在激活函数选错了。激活函数决定了每一层输出的分布、梯度的传递方式，以及网络在反向传播时能不能把误差“送”回浅层。这次我们用一篇文章讲清楚 10 种主流激活函数，从公式到 PyTorch 实现，再到 CNN、RNN、Transformer 里的实际选择思路，最后给出排查激活函数问题的通用方法。文章里所有代码都是可以直接运行的，重点看梯度变化和输出分布，你会明白“神经网络越叠越蠢”很多时候是激活函数在拖后腿。

激活函数是神经网络里最不起眼、却最影响训练上限的模块。它位于每个神经元之后，决定这个神经元是否被“激活”，以及激活的程度。如果网络中完全没有激活函数，那么无论堆多少层，都只是在做线性变换的复合，最终仍然等价于一个线性模型，连异或问题都解不了。激活函数引入非线性，才让网络有逼近任意函数的能力。但同时，激活函数的选择也直接决定了梯度是否稳定、是否容易出现神经死亡、是否适合深层网络、是否适合注意力机制。所以这篇文章不会只列公式，而是会把 10 种激活函数的特性、公式、代码、适用场景和坑全部整理出来，方便你在实际项目里快速对照选择。

1. 激活函数的作用：为什么非线性是神经网络的上限

激活函数的核心作用可以拆成四件事。

第一，引入非线性。多层的线性变换叠加后仍然是线性变换，这意味着无论网络多深，表达能力都停留在二维平面或超平面上。只有加入非线性激活函数，神经网络才能拟合曲线、分段函数、复杂决策边界。这也是“神经网络为什么需要激活函数”的标准答案。

第二，控制输出范围。Sigmoid 输出被压缩到 (0,1)，Tanh 输出到 (-1,1)，这种有界输出适合作为概率或归一化特征。ReLU 输出范围是 [0,+∞)，不加限制，适合深层特征提取。输出范围影响后续层的数值稳定性，也影响梯度大小。

第三，决定梯度流动。反向传播时，损失对参数的导数会乘以激活函数的导数。如果激活函数的导数很小，比如 Sigmoid 最大导数只有 0.25，那么多层相乘后梯度会指数级衰减，出现梯度消失。如果激活函数导数恒为 0，比如 ReLU 在负区间，梯度直接被截断，可能出现神经元死亡。所以激活函数本质上是在“控制梯度的高速公路”。

第四，影响信息稀疏性。ReLU 会把负输入直接置零，产生稀疏激活。稀疏性可以减少参数间的耦合，但过度稀疏会导致大量神经元死亡。GELU、Swish 这类平滑激活函数则通过对负值进行小幅保留来维持信息流动。

理解了这四点，就能明白为什么不同网络结构会用不同激活函数。CNN 追求计算效率和稀疏特征，所以常用 ReLU；RNN 需要长期记忆传递，所以用 Tanh 作为候选记忆，用 Sigmoid 作为门控；Transformer 在 FFN 中使用 GELU 或 Swish，因为它们在负区间的平滑性更好，训练更稳定。

下面我们就进入 10 种激活函数的详细对比。这里先给一张速览表，表格里的公式使用常见的数学记号，实际代码会在后文给出。

2. 10 种激活函数能力速览

从表里可以看到，激活函数并没有绝对的好坏，只有是否匹配网络结构。后面我们会逐一拆解每个函数的实现和调试重点。

3. 从梯度消失到自归一化：激活函数的演进逻辑

激活函数的发展，本质上是在对付两个问题：梯度消失和神经元死亡。

早期神经网络多用 Sigmoid 和 Tanh。Sigmoid 能把任意输入映射到 0 到 1 之间，非常符合“激活概率”的直觉。但它的导数在输入绝对值较大时接近 0，一旦网络层数变多，梯度连乘后迅速趋近于 0，浅层参数几乎无法更新。Tanh 解决了输出零中心化的问题，梯度范围比 Sigmoid 好一些，但仍然存在饱和区。

ReLU 的出现是转折点。它在正区间导数恒为 1，梯度可以无损地向前传播，而且计算极快，只需要一行代码max(0, x)。因此从 AlexNet 开始，ReLU 成了 CNN 的默认选择。但 ReLU 在负区间的导数恒为 0，输入一旦落在负区间，这个神经元的梯度就是 0，并且可能永远不会恢复，这就是“死亡 ReLU”。实际表现是网络训练一段时间后，部分特征图变成全零，模型表达能力下降。

Leaky ReLU 和 PReLU 给了负区间一个很小的斜率，让梯度即使在负输入时也能流通。ELU 则更进一步，在负区间使用指数函数，输出均值更接近 0，收敛更快。但 ELU 的计算量比 ReLU 大。SELU 通过引入两个缩放参数，让网络在某种条件下自动保持均值和方差，实现“自归一化”，从而允许堆叠非常深的网络，不过它对初始化有严格要求。

近几年的趋势是“平滑”和“自适应”。Swish/SiLU 和 GELU 都是 x 乘以一个门控函数。GELU 用标准正态分布的累积分布函数作为门控，可以理解为按输入大小进行概率加权；Swish 用 Sigmoid 作为门控。这类函数在负区间不是完全置零，而是保留了微小的负响应，梯度更平滑，训练更稳定。Transformer 的 FFN 层大量使用 GELU 和 Swish，这也是它们成为当前主流的原因之一。

理解了这条演进路线，你就能根据网络深度和结构去匹配激活函数，而不是每次都无脑选 ReLU。

4. 10 种激活函数的公式与 PyTorch 实现

下面给出这 10 种激活函数的数学公式和直接可用的 PyTorch 代码。代码里包括两种形式：一种是直接使用torch.nn官方模块，一种是用torch运算自定义实现，方便你理解内部逻辑。

4.1 Sigmoid

公式：

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

PyTorch 实现：

import torch import torch.nn as nn import torch.nn.functional as F # 官方模块 sigmoid = nn.Sigmoid() x = torch.randn(4, 8) # 自定义实现 def sigmoid_custom(x): return 1 / (1 + torch.exp(-x)) print(sigmoid(x).shape) print(sigmoid_custom(x).shape)

Sigmoid 的输出不是零中心化的，这会导致后一层接收的输入总是正数，给优化带来困难。在深层网络中，Sigmoid 只建议用于最后的二分类输出或门控单元。

4.2 Tanh

公式：

[ \text{Tanh}(x) = \frac{e^x - e^{-x}}{e^x + e^{-x}} ]

PyTorch 实现：

tanh = nn.Tanh() def tanh_custom(x): return (torch.exp(x) - torch.exp(-x)) / (torch.exp(x) + torch.exp(-x)) print(tanh(x).shape)

Tanh 的输出范围是 (-1, 1)，零中心化，梯度比 Sigmoid 更强。在 RNN 的候选记忆和 LSTM 的更新门中，它经常作为核心激活函数。但 Tanh 在两端仍然饱和，深度网络中依然可能梯度消失。

4.3 ReLU

公式：

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

PyTorch 实现：

relu = nn.ReLU() def relu_custom(x): return torch.maximum(torch.zeros_like(x), x) print(relu(x).shape)

ReLU 的优点是计算快、正区间梯度恒为 1，不会梯度消失。缺点是负区间导数恒为 0，如果学习率设置不当，大量神经元可能死亡。使用时要注意初始化，可以用kaiming初始化。

4.4 Leaky ReLU

公式：

[ \text{LeakyReLU}(x) = \begin{cases} x & x > 0\ \alpha x & x \le 0 \end{cases} ]

其中 (\alpha) 通常取 0.01。

PyTorch 实现：

leaky_relu = nn.LeakyReLU(negative_slope=0.01) def leaky_relu_custom(x, alpha=0.01): return torch.where(x > 0, x, alpha * x) print(leaky_relu(x).shape)

Leaky ReLU 给负区间分配了很小的斜率，让负输入也能产生梯度。它不会完全杀死神经元，但负区间的学习可能会不稳定。实际使用中可以把 (\alpha) 设置为可学习参数，就变成了 PReLU。

4.5 PReLU

公式：

[ \text{PReLU}(x) = \begin{cases} x & x > 0\ \alpha x & x \le 0 \end{cases} ]

(\alpha) 是模型可学习参数，并且可以每个通道单独一个斜率。

PyTorch 实现：

prelu = nn.PReLU(num_parameters=1, init=0.25) # 查看可学习参数 print(prelu.weight)

PReLU 的斜率在训练中会自适应更新。如果初始化偏大，网络早期会偏向线性；如果偏小，则接近 Leaky ReLU。超分辨率任务常用 PReLU，因为它能保留更多负区间信息。

4.6 ELU

公式：

[ \text{ELU}(x) = \begin{cases} x & x > 0\ \alpha (e^x - 1) & x \le 0 \end{cases} ]

其中 (\alpha) 通常取 1。

PyTorch 实现：

elu = nn.ELU(alpha=1.0) def elu_custom(x, alpha=1.0): return torch.where(x > 0, x, alpha * (torch.exp(x) - 1)) print(elu(x).shape)

ELU 在负区间是平滑饱和的，输出均值更接近 0，对噪声有更好的鲁棒性。但 exp 运算比 ReLU 慢，且当 x 很小的时候梯度也会接近 0。适合在需要稳定收敛的深层网络中使用，但不是所有场景都能体现优势。

4.7 SELU

公式：

[ \text{SELU}(x) = \lambda \begin{cases} x & x > 0\ \alpha (e^x - 1) & x \le 0 \end{cases} ]

其中 (\lambda \approx 1.0507)，(\alpha \approx 1.67326)。

PyTorch 实现：

selu = nn.SELU() def selu_custom(x, alpha=1.67326, scale=1.0507): return scale * torch.where(x > 0, x, alpha * (torch.exp(x) - 1)) print(selu(x).shape)

SELU 是 ELU 的缩放版本。当网络使用全连接层且按 LeCun 初始化时，SELU 可以让每一层的输出自动保持零均值和固定方差，实现自归一化。但它在卷积网络和 Transformer 上不保证有效，使用时要严格遵循对应的初始化规则。

4.8 Swish / SiLU

公式：

[ \text{Swish}(x) = x \cdot \sigma(x) ]

其中 (\sigma(x) = \frac{1}{1 + e^{-x}})。PyTorch 里对应nn.SiLU。

PyTorch 实现：

silu = nn.SiLU() def swish_custom(x): return x * torch.sigmoid(x) print(silu(x).shape)

Swish 是无上界、有下界的平滑函数，负区间不是完全置零，而是先减小后趋于 0，形成一种“软门控”。Google 的研究表明，在深层模型上 Swish 往往优于 ReLU。它已经成为 EfficientNet、Transformer 等结构中的常见选择。

4.9 Mish

公式：

[ \text{Mish}(x) = x \cdot \tanh(\ln(1 + e^x)) ]

PyTorch 实现：

def mish_custom(x): return x * torch.tanh(torch.nn.functional.softplus(x)) # PyTorch 1.9+ 也提供了官方 nn.Mish mish = nn.Mish() print(mish(x).shape)

Mish 和 Swish 类似，也是平滑非单调函数，但在负区间的保留值更平滑，梯度变化更连续。在 YOLOv4 等目标检测网络里，Mish 被用作主干特征提取的激活函数。它的计算开销稍高，但训练稳定性通常更好。

4.10 GELU

公式：

[ \text{GELU}(x) = x \cdot \Phi(x) ]

其中 (\Phi(x)) 是标准正态分布的累积分布函数。实际计算中常用近似形式：

[ \text{GELU}(x) \approx 0.5x \left(1 + \tanh\left(\sqrt{2/\pi}(x + 0.044715x^3)\right)\right) ]

PyTorch 实现：

def gelu_custom(x): return 0.5 * x * (1 + torch.tanh(torch.sqrt(torch.tensor(2.0 / torch.pi)) * (x + 0.044715 * x**3))) gelu = nn.GELU() print(gelu(x).shape)

GELU 是 Transformer 中最常用的激活函数之一。它在负区间保留随机门控效果，让网络更像一个概率加权激活。BERT、GPT 系列的 FFN 层都使用 GELU。由于涉及 tanh 或 erf 运算，计算量比 ReLU 大，但在现在 GPU 上开销相对可控。

5. 激活函数的实际选择：CNN、RNN、Transformer 怎么配

理解了公式和实现，下面来谈实际选择。没有一种激活函数可以在所有任务上碾压其他，但我们可以按网络结构给出优先建议。

5.1 CNN 网络

CNN 的主流选择依然是 ReLU 或其变体。卷积层特征图的计算量很大，ReLU 的简单截断可以快速产生稀疏特征，且几乎不增加计算成本。对于普通图像分类、目标检测，ReLU 在大多数情况下已经足够。如果深度的确很深，或者你发现训练时大量特征图变成全零，可以考虑 Leaky ReLU 或 PReLU。

如果模型使用了大量 BatchNorm，那么 ReLU 通常没问题，因为 BatchNorm 会把输入重新归一化，减少负区间输入导致神经元死亡的概率。如果模型采用 GroupNorm，特别是在小 batch 训练时，Leaky ReLU 或 Swish 会更稳。

5.2 RNN / LSTM 网络

RNN 和 LSTM 内部激活函数的搭配是固定的：候选记忆一般用 Tanh，门控用 Sigmoid。Tanh 将候选值压缩到(-1,1)，保证长期记忆的数值稳定；Sigmoid 输出 0 到 1，模拟门的开闭。如果换成 ReLU，循环网络容易出现输出爆炸，因为正梯度连续相乘会快速增大。

在近几年的一些改进 RNN 中，人们尝试在循环连接处使用 ReLU 并配合梯度裁剪，但工程上不推荐随意替换。除非做研究实验，否则 LSTM 里保持 Tanh + Sigmoid 组合是最稳妥的。

5.3 Transformer 网络

Transformer 的 FFN 层通常使用 ReLU、GELU 或 Swish。从使用比例上看，BERT 系列用 GELU，GPT 系列用 GELU，最近的一些模型也偏好 Swish/SiLU。这些平滑激活函数的共同优势是负区间有微小梯度，不会让神经元完全冻结，同时非饱和区域能让深层模型稳定收敛。

当你在自定义 Transformer 时，默认选 GELU，如果追求低延迟推理，可以换回 ReLU，因为 ReLU 不需要计算 exp 或 tanh，算子融合更简单。需要注意的是，不是所有推理框架都实现了 GELU 或 Swish 的高性能算子，跨平台部署前要在目标硬件上做基准测试。

5.4 输出层激活函数

输出层的选择取决于任务类型。二分类用 Sigmoid，多分类用 Softmax，回归任务用线性激活（也可以理解为没有激活函数），多标签分类用多个 Sigmoid。如果做目标检测的边界框回归，则保持线性输出。

这里要强调的是，Softmax 也可以看作一种激活函数，但它更像一个归一化层，用来把 logits 转换成概率分布。很多人会把输出层激活函数和隐藏层激活函数混为一谈，实际它们的作用完全不同。

5.5 一个通用选择策略

如果你对项目不熟悉，我建议按以下顺序试：

第一优先级：ReLU，适用于大多数 CNN 分类任务，快且稳定。

第二优先级：GELU 或 SiLU，适用于 Transformer、深度网络、需要平滑梯度的任务。

第三优先级：Leaky ReLU 或 PReLU，适用于存在死亡 ReLU 问题的深层网络。

第四优先级：ELU 或 SELU，适用于自编码器、全连接网络等需要稳定输出分布的场景。

实际测试时，固定其他超参，只切换激活函数，观察前 10 个 epoch 的 loss 下降速度和验证集指标，就能快速判断哪种更适合你的数据。

6. 激活函数导致的常见训练问题与排查

激活函数很多问题不是立即暴露的，而是表现为训练异常。下面列几个高频问题。

6.1 梯度消失

如果网络层数很多，且激活函数使用 Sigmoid 或 Tanh，反向传播时梯度会越乘越小。现象是浅层参数更新极慢，loss 下降一段时间后停滞。排查时打印每层梯度范数，如果从输出层到输入层梯度数量级递减，说明梯度消失。解决方案是更换 ReLU 族激活函数、增加残差连接、使用 BatchNorm 或调整初始化。

6.2 死亡 ReLU

训练中某层输出大量 0，甚至整个特征图全 0。这通常是因为输入分布偏向负值，负区间梯度为 0，导致神经元无法恢复。排查时统计激活函数输出的零值比例，如果超过 80%，基本可以判断死亡 ReLU。解决方法：降低学习率、使用 Leaky ReLU/PReLU、调整初始化方式、加入 BatchNorm 或增大偏置初始值。

6.3 输出尺度爆炸

使用 ReLU 或 Swish 这类无上界的激活函数时，如果权重初始化过大或学习率过高，输出可能越来越大，导致 loss 变为 NaN。排查激活函数输出数值的均值和标准差，如果逐层增大到数百，就要降低初始化尺度、加入梯度裁剪或使用 BatchNorm。GELU 和 Swish 的无上界特性同样需要注意。

6.4 数值溢出

Sigmoid、Tanh、ELU、GELU 都要计算 exp。当输入 x 为较大的负数时，torch.exp(x)可能下溢为 0，这通常没问题；但 x 为较大的正数时，torch.exp(-x)在 Sigmoid 中可能下溢为 0，不影响结果。真正危险的是在自定义 ELU/SELU 里直接用exp(x)，如果 x 很大，会造成溢出。所以深度框架中都会用数值稳定的实现，比如 PyTorch 的F.sigmoid内部会自动处理溢出。你自己写自定义函数时要考虑这一点。

6.5 激活分布偏离

即使没有梯度问题，激活函数的输出分布也会影响后续层的归一化。例如 Sigmoid 输出全正且均值 0.5，可能导致下一层接收的输入偏向正数。用直方图可视化每一层激活值，如果分布严重偏斜，可以调整初始化或换用零中心化的 Tanh、ELU。这也是 SELU 自归一化想解决的问题。

7. 工程实践：用 PyTorch 监控激活值与梯度

实际调试时，建议在训练循环里插入钩子，打印每一层的激活值统计和梯度范数。下面给出一套完整的示例代码。

首先定义一个包含多种激活函数的简单多层感知机：

import torch import torch.nn as nn class MLP(nn.Module): def __init__(self, in_dim=64, hidden_dim=128, out_dim=10, activation='relu'): super().__init__() layers = [] for i in range(4): if i == 0: layers.append(nn.Linear(in_dim, hidden_dim)) else: layers.append(nn.Linear(hidden_dim, hidden_dim)) if activation == 'relu': layers.append(nn.ReLU()) elif activation == 'leaky': layers.append(nn.LeakyReLU(0.01)) elif activation == 'gelu': layers.append(nn.GELU()) elif activation == 'silu': layers.append(nn.SiLU()) layers.append(nn.Linear(hidden_dim, out_dim)) self.net = nn.Sequential(*layers) def forward(self, x): return self.net(x)

接着注册前向钩子和反向钩子，统计每层输出和梯度：

def hook_forward(name): def fn(module, input, output): if isinstance(output, torch.Tensor): print(f"[{name}] output shape={tuple(output.shape)}, mean={output.mean().item():.4f}, std={output.std().item():.4f}, zero_ratio={(output == 0).float().mean().item():.4f}") return fn def hook_backward(name): def fn(module, grad_input, grad_output): if grad_output[0] is not None: grad = grad_output[0] print(f"[{name}] grad mean={grad.mean().item():.4f}, grad std={grad.std().item():.4f}, grad norm={grad.norm().item():.4f}") return fn

创建一个模型并注册钩子：

model = MLP(activation='relu') for name, module in model.named_modules(): if isinstance(module, nn.Linear): module.register_forward_hook(hook_forward(f"{name}.forward")) module.register_full_backward_hook(hook_backward(f"{name}.backward"))

训练几个 step 观察：

optimizer = torch.optim.Adam(model.parameters(), lr=1e-3) loss_fn = nn.CrossEntropyLoss() for step in range(3): x = torch.randn(16, 64) y = torch.randint(0, 10, (16,)) out = model(x) loss = loss_fn(out, y) optimizer.zero_grad() loss.backward() optimizer.step() print(f"step {step}, loss={loss.item():.4f}")

通过观察 zero_ratio 和 grad norm，你可以快速判断当前激活函数是否引发神经元死亡或梯度消失。建议在切换激活函数后都跑一遍这段代码，对比统计结果。

如果想实现一个自定义激活函数，并且想要它支持反向传播，可以通过继承torch.autograd.Function实现：

class SwishFunction(torch.autograd.Function): @staticmethod def forward(ctx, x): ctx.save_for_backward(x) return x * torch.sigmoid(x) @staticmethod def backward(ctx, grad_output): x, = ctx.saved_tensors sigmoid_x = torch.sigmoid(x) grad = grad_output * (sigmoid_x + x * sigmoid_x * (1 - sigmoid_x)) return grad swish_custom_autograd = SwishFunction.apply

再用nn.Module包装它：

class Swish(nn.Module): def forward(self, x): return SwishFunction.apply(x)

在模型里替换nn.SiLU即可测试。要注意：数值不稳定时，优先使用框架内置算子，避免自定义实现带来的精度和性能损失。

8. 激活函数的性能与显存影响

很多人忽略激活函数对性能和显存的影响，其实它并不只是几行代码那么简单。

训练时，框架为了反向传播，需要保存激活函数的输入或输出。ReLU 通常只需保存一个掩码（是否大于 0），占用很小；Sigmoid/Tanh 可能需要保存原始输入以便计算梯度；GELU/Swish 需要保存输入和中间变量，或者在前向时进行近似计算，存储开销和计算开销都会增加。在深层网络里，激活值占用显存可能占总显存的大头。尤其 Transformer 的 FFN 层会展开到好几倍隐藏维度，GELU 的中间缓存对显存的影响不可忽视。

推理时，激活函数可以与前面的线性层进行算子融合，减少显存读写。ReLU 在很多推理引擎里都可以与 Conv 或 Linear 融合，几乎零成本。GELU 如果使用近似形式也可以融合，但精度和性能需要权衡。Swish 包含 Sigmoid，融合时同样可以优化。如果部署到边缘设备，优先选择推理框架原生支持的激活函数。

实际使用时，你应该从两个维度评估：一是准确率，二是吞吐量/延迟。在相同训练配置下，不同激活函数可能带来 1 到 3 个百分点的精度差异，同时延迟可能变化 5% 到 20%。建议在你自己的数据和目标硬件上跑一次小规模基准，再决定默认激活函数。

9. 常见问题与排查方法

10. 最佳实践与使用建议

激活函数不是孤立组件，它要和其他模块配合。下面几条建议来自工程经验，虽然不是绝对真理，但可以帮你少走弯路。

第一，优先使用框架内置激活函数。PyTorch 和 TensorFlow 内置函数经过数值稳定优化、梯度校验和算子融合，比自己手写的效率高、出错少。只有实验需要时才自定义，并且一定要用torch.autograd.gradcheck验证梯度。

第二，初始化方式要和激活函数匹配。ReLU 族适合 Kaiming 初始化，Tanh/Sigmoid 适合 Xavier 初始化，SELU 要求 LeCun 初始化。如果初始化不匹配，激活函数效果会大打折扣。

第三，不要频繁切换激活函数来“调参”。先把数据预处理、学习率、优化器、归一化层调好，再试激活函数。每次只换一个变量，否则你无法判断指标变化是哪个因素引起的。

第四，在 Transformer 和深层 CNN 中，输入分布和 LayerNorm/BatchNorm 的位置会影响激活函数效果。如果网络已经加了大量归一化层，ReLU 通常就够用了；如果归一化较薄弱，GELU/Swish 这类平滑函数更稳妥。

第五，涉及模型部署时，要提前调查目标推理框架支持哪些激活算子。很多边缘框架只优化了 ReLU，GELU 或 Swish 可能被迫降级为通用实现，延迟上升。此时需要在精度和延迟之间取舍。

第六，如果你在做研究或对比实验，建议把激活值分布和梯度范数作为固定指标保存下来。这样不仅能解释结果，还能定位训练异常，比只看 loss 曲线高效得多。

11. 总结与下一步

这篇文章从激活函数的作用讲起，梳理了 Sigmoid、Tanh、ReLU、Leaky ReLU、PReLU、ELU、SELU、Swish、Mish、GELU 这 10 种主流激活函数。核心观点是：激活函数决定了网络梯度的流动方式，没有最好的激活函数，只有更适合当前网络结构和数据分布的激活函数。模型越叠越深不是问题，越叠越“蠢”通常意味着梯度传递失败或神经元大量死亡，这时换一种激活函数，可能比加深网络更有效。

建议你先用第 7 节的 PyTorch 监控代码跑一遍自己当前的模型，看看每一层激活值的零值比例和梯度范数。如果发现死亡 ReLU 或梯度消失，再按第 5 节的选择策略切换到对应激活函数。下一步可以继续做三件事：一是对同一网络结构分别测试 ReLU、GELU、Swish，记录训练曲线和测试精度；二是尝试使用可学习的 PReLU，观察斜率收敛到多少；三是在推理硬件上对比不同激活函数的延迟和显存占用。激活函数这个变量很小，但对模型上限的影响非常大，值得花时间做系统实验。