企业官网建设流程全解析

1. 线性变换的本质：先从矩阵和向量的关系说起

很多读者第一次接触nn.Linear时，只是把它当作一个"全连接层"，输入一个向量，输出一个向量，中间经过了一次矩阵乘法。这个理解没错，但如果你只停留在"会用"的层面，那很容易在调试网络、分析梯度、设计自定义层的时候栽跟头。我自己刚用 PyTorch 时也踩过不少坑，后来发现根源都是对nn.Linear的数学本质不够清楚。

从数学上看，nn.Linear做的事情就是一个仿射变换（Affine Transformation），它是线性映射的一个推广。我们回忆一下线性代数的定义：给定两个向量空间 (V) 和 (W)，如果映射 (T: V \to W) 满足两个条件——可加性和齐次性——那么 (T) 就是一个线性映射。写成公式就是：

• 可加性：(T(u + v) = T(u) + T(v))
• 齐次性：(T(c \cdot u) = c \cdot T(u))

如果你把一个 1 维向量 (x) 输入到nn.Linear中，它输出的 (y) 满足 (y = Wx + b)。当偏置 (b = 0) 时，这就是一个严格的线性映射；当 (b \neq 0) 时，它是一个仿射变换。很多教材里会把这两者统称为"线性层"，但实际数学上仿射变换并不满足齐次性——因为 (T(0) = b \neq 0)。不过 PyTorch 的文档和社区习惯都直接叫它 Linear，我们不用在术语上较真，但要清楚这一点。

为什么要理解这个本质？因为你的网络每一次前向传播，都是在做一系列这样的变换和激活函数的交替。nn.Linear本身不包含任何非线性能力，它的作用是改变数据的维度空间，把输入张量投影到另一个线性空间中。这也是为什么在深度学习中，非线性必须由激活函数（如 ReLU、Sigmoid）来提供。如果整个网络只有nn.Linear，那无论堆多少层，最终都可以等价为一个线性变换，这是线性代数的基本结论。有个最直观的例子：两个线性变换的复合：(T_2(T_1(x)) = W_2(W_1 x + b_1) + b_2 = (W_2 W_1) x + (W_2 b_1 + b_2))，这本质上还是一个线性变换。所以没有激活函数，深层网络就失去了"深度"的意义。

从几何角度理解，这个变换把输入空间中的一组基向量映射到输出空间。比如输入是 (R^d)，输出是 (R^m)，权重矩阵 (W) 的每一列都可以看作输出空间中的一个基向量的原像。训练过程就是在不断调整这些基的方向和大小，使得输入数据经过变换后，在输出空间能被更好地分割或拟合。

PyTorch 里，nn.Linear的核心参数就是in_features和out_features。从数学上看，in_features决定了输入向量的维度 (d)，out_features决定了输出向量的维度 (m)。权重矩阵的形状是 ((m, d))，偏置的形状是 ((m,))。这里有个很关键的细节：为什么权重矩阵的形状不是 ((d, m))？如果你手写前向传播时会发现，如果你的输入是形状为 ((batch_size, d)) 的张量，那么要得到 ((batch_size, m)) 的输出，就需要用 (x \cdot W^T) 或者 (W \cdot x^T) 的方式。PyTorch 内部选择的是 (W) 的形状为 ((out_features, in_features))，这样在前向计算时，直接做 (x \cdot W^T) 即可。这种设计是为了在反向传播时让梯度的维度计算更直观。

我遇到过不少刚接触的读者，会混淆矩阵乘法和逐元素乘法的区别。nn.Linear中绝对没有任何逐元素乘法，它全是矩阵乘法。如果你误用了逐元素乘法，那输出的每个维度就会变成对应输入维度的某种加权，完全破坏了线性映射的语义。

2. nn.Linear 的前向传播公式与张量维度推导

前面提到nn.Linear的数学表达式是 (y = xW^T + b)。但实际在 PyTorch 中，输入往往不是一个 2D 张量，而是带有批量维度的，甚至可能是任意高维张量。这里我们必须把它和张量形状的规则一起搞清楚。

假设你有一个输入张量x，形状为(batch_size, *, in_features)，其中*表示任意数量的中间维度。nn.Linear会对除了最后一个维度之外的所有维度进行广播（broadcast），也就是说，它把这个张量看作多个"向量"的组合，每个向量都有in_features个元素，然后对每个向量独立做一个线性变换。用 PyTorch 的话来说，它只对输入的最后一个维度应用仿射变换，其他维度保持不动。

举个例子：

import torch import torch.nn as nn layer = nn.Linear(in_features=4, out_features=3) x = torch.randn(2, 5, 4) # 输入形状 (batch_size=2, 中间维度=5, in_features=4) y = layer(x) # 输出形状 (2, 5, 3)

在这个例子中，layer内部有一个形状为(3, 4)的权重矩阵W和一个形状为(3,)的偏置b。前向计算时，x会被 reshape 成形状(2*5, 4)，也就是一共10个向量，每个向量都乘以 (W^T) 并加上 (b)，得到形状(2*5, 3)，最后再重新 reshape 回(2, 5, 3)。这与把x原样进行x @ W.T + b的结果完全等价。

这种设计有一个数学上的优雅之处：它保证了对每个样本、每个时间步（如果是序列数据）、每个空间位置（如果是图像特征图）都使用同一个权重矩阵进行变换。权重共享让模型参数量大大减少，同时让模型具备平移不变性——至少在特征维度上是如此。卷积神经网络的权值共享思想也可以在这里看到影子，只不过nn.Linear是全局共享，而卷积是局部共享。

矩阵乘法的具体过程可以拆解成行视角与列视角两种理解方式。行视角：输出的第 (i) 个元素是权重矩阵第 (i) 行与输入向量的点积加上偏置。也就是 (y_i = \sum_{j=1}^{d} W_{i,j} x_j + b_i)。这个公式揭示了每个输出维度都依赖于全部输入维度，这也是"全连接"名称的由来。列视角：权重矩阵的第 (j) 列表示输入的第 (j) 个特征对输出的整体贡献。如果某一列的值很大，说明对应输入特征对输出有很大影响。这种视角对解释特征重要性很有用。

在我自己调试网络时，经常遇到维度不匹配的错误，比如mat1 and mat2 shapes cannot be multiplied (4x3 and 4x5)。这种错误的根源就是忘记在nn.Linear中，权重矩阵形状是(out_features, in_features)，而输入是(batch, in_features)，所以必须把输入放到矩阵乘法的左边，权重放到右边。数学上这是线性映射 (T(x) = W x) 的标准写法，但由于我们在代码里通常用行向量表示一个样本，所以需要转置权重矩阵。这是初学者最容易混淆的地方，我甚至见到过有人自己实现nn.Linear时手忙脚乱地把维度转错。

还有一个细节是关于偏置的广播机制。偏置虽然形状是(out_features,)，但在批处理时，它会自动广播到(batch_size, out_features)，给每个样本都加上同样的偏置。在数学上，这相当于在每个样本的仿射变换中使用同一个平移向量，保证了同一次前向传播对相同的输入维度施加一致的偏移。

3. 权重和偏置的梯度推导：反向传播中的链式法则

理解nn.Linear的反向传播，是真正从"会用"到"懂原理"的分水岭。你不需要像数学专业那样背公式，但至少要能推导出权重 (W)、偏置 (b) 和输入 (x) 分别对应的梯度，这样在面对梯度消失、梯度爆炸或者自定义复杂网络时才有章可循。

我们设输入是一个向量 (x)，当前层输出 (y = W x + b)，假设从损失函数 (L) 到 (y) 的梯度是 (\frac{\partial L}{\partial y})，这个梯度完全由后续的层决定。那么根据链式法则，我们需要求三个偏导：(1) (\frac{\partial L}{\partial W})，(2) (\frac{\partial L}{\partial b})，(3) (\frac{\partial L}{\partial x})。

先看 (W) 的梯度。因为 (y_i = \sum_{j} W_{i,j} x_j + b_i)，所以 (\frac{\partial y_i}{\partial W_{i,j}} = x_j)。由此可得： [ \frac{\partial L}{\partial W_{i,j}} = \frac{\partial L}{\partial y_i} \cdot \frac{\partial y_i}{\partial W_{i,j}} = \frac{\partial L}{\partial y_i} \cdot x_j ] 用矩阵形式表示：(\frac{\partial L}{\partial W} = (\frac{\partial L}{\partial y})^T \cdot x)。注意这里的结果形状与 (W) 相同，也是(out_features, in_features)，这是保持梯度形状与参数形状一致的约定。

再看 (b) 的梯度。因为 (y_i = \sum_j W_{i,j} x_j + b_i)，所以 (\frac{\partial y_i}{\partial b_i} = 1)。于是： [ \frac{\partial L}{\partial b_i} = \frac{\partial L}{\partial y_i} ] 也就是说，偏置的梯度就是损失函数对输出梯度的直接拷贝。在批量训练时，需要对所有样本的梯度取平均，所以实际计算通常是 (\frac{1}{N} \sum_{n=1}^N \frac{\partial L}{\partial y_i^{(n)}})。

最关键的是输入 (x) 的梯度，因为它要传给上一层的传播。
[ \frac{\partial y_i}{\partial x_j} = W_{i,j} ] 所以： [ \frac{\partial L}{\partial x_j} = \sum_i \frac{\partial L}{\partial y_i} \cdot \frac{\partial y_i}{\partial x_j} = \sum_i \frac{\partial L}{\partial y_i} \cdot W_{i,j} ] 用矩阵形式：(\frac{\partial L}{\partial x} = \frac{\partial L}{\partial y} \cdot W)。这里不需要转置，在批量维度上，就是grad_output @ weight。

如果你用 PyTorch 的自动求导机制，torch.autograd会自动帮你完成这些运算，但理解原始推导会让你在设置requires_grad、检查梯度、调整学习率时心里更有数。我自己就有过一次惨痛经历：自定义了一个没有偏置的线性层，并在反向传播中手动实现了grad_weight = grad_output.T @ input，但由于忘记对 batch 维度取平均，导致训练时 loss 直接飞到了 NaN。后来我才意识到，PyTorch 的nn.Linear在默认情况下会对 batch 内部所有样本的梯度做求和（不是平均），而优化器更新时则通过学习率来控制步长。这个细微差别如果不懂数学推导，很难定位到问题。

另外，关于梯度的稳定性有一个值得注意的点：当输入 (x) 的维度很大时，权重矩阵每一行的梯度计算就是所有输入特征的加权求和。如果输入特征数值范围波动很大，梯度也会随之产生大的波动，可能导致梯度爆炸。这就是为什么我们总是强调要对输入做标准化（如 BatchNorm），或者在初始化时对权重做方差缩放——本质上是在控制梯度的尺度。

4. 参数初始化的数学逻辑：为什么不能全置为零

初始化是影响nn.Linear训练效果的一个极为隐秘的因素。很多人刚开始写代码时会把权重全部初始化为 0，这时问题就来了：如果所有权重都是 0，那么前向传播时所有神经元的输出都是 0 加上偏置，反向传播时所有输入梯度都相同，这会导致同一层的所有神经元都变得一模一样，称为"对称性问题"。在数学上，这意味着损失函数关于权重矩阵的方向导数处处相等，模型无法打破对称，更新后的权重依然保持一致，这会让整个网络的表达能力退化成一个线性模型，和只用一个神经元没有区别。

PyTorch 的nn.Linear默认采用一种均匀分布初始化（根据源码，其权重在 (U(-\sqrt{k}, \sqrt{k})) 中采样，其中 (k = \frac{1}{in_features})）。这个选择不是拍脑袋决定的。从数学上分析，如果初始权重方差过大，输入信号经过线性变换后，方差会被放大很多倍，导致输出极易落在激活函数的饱和区（如 Sigmoid 的两端），使得梯度很小，训练停滞。如果权重初始化方差过小，信号则会逐渐消失，深度网络中梯度更新量级不足，也难收敛。

在我刚使用 PyTorch 时，我经常懒得管初始化，直接用默认值。但有一个任务需要训练一个深度只有 50 层的 MLP，默认初始化一直难以收敛，loss 下降得非常缓慢。后来我改成了 Kaiming 初始化（kaiming_uniform_），loss 才开始正常下降。这里的数学解释在于，ReLU 激活函数的输出有一半为 0，相当于信号衰减一半，如果初始权重不补偿这个衰减，前向传播和反向传播的方差都会逐层递减，导致梯度消失。Kaiming 初始化正是为了在每层之间维持一个恒定的方差，它只需要知道输入的神经元数量（即in_features）就可以设定权重标准差为 (\sqrt{2 / in_features})。

还有一种常见的初始化是 Xavier 初始化，它假设激活函数接近线性（如 Tanh、Sigmoid 的未饱和区域），所以权重标准差设定为 (\sqrt{2 / (in_features + out_features)})。两种初始化的区别不仅仅在公式上，更在于它们对应的激活函数行为不同、网络深度的假设不同。你如果从头实现一个自定义的线性层，强烈建议至少要调用init.kaiming_uniform_(self.weight, a=math.sqrt(5))，而不是随机初始化torch.randn后乘一个固定倍数。我之前犯过这样的错误：手动初始化标准差为 0.01，结果训练 100 轮后 acc 还是 50%。换成合适的初始化策略后，10 轮就超过了 90%。训练神经网络的很多 "玄学" 问题，追根溯源往往都能归结为初始化方差没有匹配网络结构。

偏置初始化也有讲究。在默认情况下，PyTorchnn.Linear的偏置使用 (U(-\sqrt{k}, \sqrt{k})) 均匀分布，其中 (k = 1 / in_features)。偏置主要作用是平移决策边界，初始化时通常不希望它过大地影响早期前向输出。如果你想要更好的收敛，尤其是最后一层同时接分类头，很多实践会把偏置初始化为 0，只保留权重初始化。这不是绝对正确，但在大多数分类任务中都能稳定工作。

5. 从数学角度看 nn.Linear 的参数量与计算量

nn.Linear的参数量公式极其简单：一个线性层的参数量 =in_features * out_features + out_features（权重加偏置）。这个数字在网络设计时非常重要，因为它决定了模型的整体大小、内存占用和过拟合风险。假设你有一个输入维度为 1024、输出维度为 1024 的线性层，参数量就是 (1024 \times 1024 + 1024 = 1, 049, 600)，约 100 万。如果这个层数很多，模型瞬间就会变得巨大。

计算量方面，单次前向传播对一个形状为(batch_size, in_features)的输入，需要多少次乘加操作？输出是(batch_size, out_features)，每个输出元素需要对in_features个输入做乘法和加法，所以总的乘加次数是batch_size * out_features * in_features。对于批量大小 32、输入 512、输出 512 的网络，就是 (32 \times 512 \times 512 = 8, 388, 608) 次乘加，约 800 万次。在训练时，你还需要乘上反向传播的两倍计算量（对于权重梯度和输入梯度），实际计算负担会更重。

这些数学指标能帮你判断一个网络的复杂度和瓶颈。比如你在nn.Linear之后接一个nn.LayerNorm，前者的计算量是线性的，后者则需要计算每个特征维度的均值和方差，也涉及 O(batch × features) 的开销。如果两者并用，整体计算量会叠加。在我的一个 NLP 项目中，模型的核心就是多层nn.Linear堆叠，参数量超过了 5000 万，在没有 GPU 的环境下训练一轮需要几十分钟。后来我通过把其中两个线性层的维度从 2048 降到 1024，参数量直接减少了四分之三，训练速度提升了接近三倍，而任务性能只下降了 0.2%。这就是利用参数量的直接计算来指导模型设计的一个实际例子。

另一个让人容易忽略的点是bias项是否启用。从数学上说，偏置向量的参数量虽然小，但对表达能力的贡献却很重要。去掉偏置后，决策边界只能通过原点，这会显著降低模型的拟合能力。在有些情况下，比如你已经在输入上做了中心化处理，或者网络后面跟着某个归一化层，那么去掉偏置也许没什么影响。但我自己的经验是，除非有特别的理由（如权重共享约束），否则保留偏置通常是更方便、更稳妥的选择。

6. 多维输入与批量矩阵乘法：实现层面的数学细节

前面提到nn.Linear支持任意高维输入，但内部到底是怎么利用矩阵乘法实现的？对于形状为(batch_size, sequence_length, in_features)的输入，比如一个 transformer 中的序列数据，你会想用nn.Linear对每个时间步的特征做线性变换。PyTorch 会直接在最后一个维度上做矩阵乘法，效果等同于把(batch_size * sequence_length, in_features)作为输入矩阵，然后乘以(in_features, out_features)的权重转置。

我们可以用批量矩阵乘法的视角理解这个过程。对于批量维度B，原始输入形状(B, N, d)，nn.Linear的实现在底层可能把它看作一个(B * N, d)的矩阵乘上(d, m)的权重转置。但在一些特殊场景下（比如你在做时间序列预测），你需要明确每个时间步都会共享同一个权重矩阵，这就像一个循环神经网络中的线性变换一样。

这里有一个很容易踩坑的实际问题：如果你想同时对一个 batch 中的不同样本使用不同的线性权重矩阵，nn.Linear是不支持的——它只有一组共享的权重和偏置。如果你真的需要"每个样本有自己的线性变换"，你需要用torch.einsum或者torch.bmm来实现。比如你想对形状为(B, N, d)的输入，每个 batch 样本使用一个不同的W矩阵，形状为(B, N, m)，你就可以用torch.bmm(x, W.transpose(1, 2))来实现。这在数学上与nn.Linear并不一致，但它展示了线性变换的底层逻辑。

用代码来对比更直观：

# 标准 nn.Linear layer = nn.Linear(4, 3) x = torch.randn(2, 5, 4) y1 = layer(x) # shape: (2, 5, 3) # 手动实现批量矩阵乘 W = layer.weight # shape: (3, 4) b = layer.bias # shape: (3,) # 需要先将 W 扩展到 batch 维度 W_expanded = W.unsqueeze(0).expand(2, 3, 4) y2 = torch.bmm(x, W_expanded.transpose(1, 2)) + b # y1 和 y2 完全一致

这个例子说明了nn.Linear的本质操作就是一次标准的矩阵乘法加上广播偏置。当你理解了这一点，你在面对自定义层时就可以自如地做扩展，比如实现线性层共享权重、施加不同的 mask 等。

7. 实际训练中的数值稳定性问题：梯度消失与梯度爆炸

从数学角度分析nn.Linear，还有一个绕不开的话题：数值稳定性。假设网络有 100 个nn.Linear层，每层输出和输入的方差关系是 (\text{Var}(y) = \text{Var}(W) \cdot \text{Var}(x) \cdot in_features)。如果初始化方差没有做好缩放，方差可能会以指数级递增。举个例子，输入方差为 1，权重标准差 0.1，那么每经过一层，输出的方差就变为 (0.1^2 \times in_features \times 1)。如果in_features是 512，那么输出方差直接放大到 5.12 倍。100 层之后，信号的尺度会变得极大或极小，最终要么梯度爆炸，要么梯度消失。

为什么说这是数学决定的？因为矩阵连乘的谱半径决定了信号衰减或放大的速度。权重矩阵的谱半径（最大奇异值）如果大于 1，信号就会逐层放大，反之则会逐层缩小。初始化的核心就是在所有层之间保持谱半径尽量接近 1。这在实际操作中意味着，当你堆叠大量nn.Linear层时，你最好使用残差连接（Residual Connection）来缓解退化问题。虽然残差连接最初是为了解决深度网络的退化问题，但从数学上看，它把信号传播路径变成了"恒等映射 + 非线性变换"，相当于为信号提供了多条穿透路径，因此梯度和前向传播都能更顺畅。

在我的实践中，当网络超过 20 层线性层时，我会考虑加 LayerNorm 或残差连接，而不是单纯去调整初始化。有一次我尝试了一个 50 层的纯 MLP，无论怎么调学习率和初始化，训练 loss 都会在某个点突然变成 NaN。后来我用torch.autograd.set_detect_anomaly(True)定位到某个线性层的梯度出现了数值溢出，根源是前面若干层的权重矩阵特征值过大。我换成了 Kaiming 初始化并添加了 LayerNorm 后，问题立刻消失了。这个排查过程让我深刻体会到，理解nn.Linear的数学稳定性比记住某个 API 的调用方式更有价值。

8. 从源码验证：PyTorch 官方的实现思路

可能有人会觉得，理解了数学原理就不用看源码了，但我要说，看源码能帮你把抽象的数学符号和具体的实现一一对应起来。nn.Linear的forward函数可以类比如下伪代码：

def forward(self, input): return F.linear(input, self.weight, self.bias)

F.linear的底层调用是torch.addmm(bias, input, weight.t())，也就是计算bias + input @ weight.T。如果你在 GPU 上跑过大批量数据，你会发现这个操作可能走 cuBLAS 或 cuDNN 的优化路径。PyTorch 的源码里addmm是一个非常常见的底层算子，它把矩阵乘法与加法融合在一起，减少了内存访问次数。理解这一点对性能调优很有帮助：如果你需要在一个大矩阵上做多次线性变换，考虑合并权重矩阵一次性计算，往往比循环调用nn.Linear高效得多。

另外，PyTorch 的nn.Linear在构造函数中有bias=True参数。设置bias=False时，偏置项就不再参与计算，参数数量也随之减少。源代码中还会根据bias的标志决定是否注册bias参数。在自定义网络时，如果你要让一个线性层的权重与另一个层共享，可以直接把两个模块的weight指向同一个Parameter对象。但要注意，共享权重的两个层的梯度会叠加，这在数学上等价于对多个输出位置施加同一个线性映射，类似于多任务学习中的硬参数共享。

还有一个源码中的细节：nn.Linear的权重和偏置默认都参与优化器的更新，因为它们都被标记为requires_grad=True。如果你想让某个层冻结不更新，需要手动设置requires_grad=False，这经常用于迁移学习中的特征提取器。冻结层在前向传播时仍然会参与计算，只是梯度不再回传，优化器也不会更新其参数。从数学上说，这相当于把一个线性变换视为固定不变的常量，你只更新模型的其他部分。

9. 常见误用与改进替代方案的数学依据

nn.Linear在绝大多数场景下够用，但有时你需要在数学上做一些调整，否则模型的表达力会受限。最常见的一个调整是去掉偏置项。为什么有时要去偏置？因为你可能在一个归一化层之后使用线性层，而归一化层已经让数据变成零均值、单位方差了，此时偏置的存在与否对表达能力的影响较小。另一个常见场景是在做矩阵低秩分解时，把一个大线性层分解为两个较小的线性层，数学上这近似于对权重矩阵做低秩近似。假设原来的权重形状是(m, d)，可以分解成一个(m, r)和一个(r, d)的线性层，其中 (r < \min(m, d))。这种分解最早在 LoRA 类工作中被广泛使用，能够大幅减少可训练参数量，同时保持几乎相同的效果。

我在做一个推荐系统模型时就采用过这种思路。原始的 embeddings 拼接之后通过一个nn.Linear(512, 256)输出预测分数，规模较大的权重矩阵训练代价不小。后来我把这层替换成了两个线性层：先nn.Linear(512, 64)，再nn.Linear(64, 256)。参数量从 (512 \times 256 + 256) 约 13 万降低到 (512 \times 64 + 64 + 64 \times 256 + 256) 约 5 万，减少了约 60%，而最终的离线指标几乎没有变化。这说明基于低秩近似的改进在数学上是可靠的，因为很多真实任务中的权重矩阵本身就是低秩的。

另外一个常见的替代改进是把线性层换成卷积层的特殊情况。严格地说，nn.Conv1d在kernel_size=1时等价于一个对最后一维的线性变换，其参数共享和局部连接方式都是一致的。如果输入形状是(batch, channels, seq_len)，你既可以用nn.Conv1d(chan_in, chan_out, kernel_size=1)，也可以用nn.Linear(chan_in, chan_out)并置换维度。两种方式在数学上等价，但计算效率和内存布局不同。我的建议是，如果你要对序列数据做特征映射，优先考虑nn.Linear，因为它更清晰；如果你已经在处理图像特征图或卷积网络，则用 1x1 卷积会更自然。

最后，还有一点值得从数学上明确：nn.Linear不会改变输入的 batch 大小，也不会改变除了最后一维以外的其它维度。它满足维度守恒规则：形状(..., in_features)变为(..., out_features)。这保证了你可以自由地在序列、时间步、特征之间组合模块，这为构建复杂的神经网络架构提供了极大的灵活性。理解这条规则后，你在拼接网络时才不会出现"维度对不上"的疑惑。

10. 实战心法：如何调试线性层的输出与梯度

仅掌握公式还不够，真正到了调试网络的时候，你会用到一些非常实用的技巧。第一个技巧是在前向传播后检查输出张量的统计量：均值和标准差是否在合理范围。如果某个线性层的输出方差突然变得特别大，比如超过 (10^4)，你就要怀疑前一层的权重初始化或者数据分布有问题。反向传播时，你也可以通过 register_hook 来查看每一层的梯度范数。梯度范数可以用torch.norm(grad)得到，如果某一层的梯度范数是 NaN 或者为 0，说明网络在前向或反向传播中已经数值崩溃。

第二个实用技巧是使用torch.autograd.gradcheck验证自定义层的反向传播是否正确实现。它会根据数值差分来校验你提供的梯度公式是否与解析梯度一致。这个工具对理解nn.Linear也十分有帮助：你可以写一个自定义的线性函数，然后用gradcheck来确认你的反向传播推导是否正确。在我自己写网络组件时，这几乎是必做的步骤。

第三个技巧是控制变量法。当你的模型训练效果不佳，不要急着调整优化器或学习率，先检查线性层本身的输出是否符合预期。比如在一个简单任务上把模型缩减为一个只有一两个nn.Linear层的网络，如果最小网络都学不好，那问题很可能不在模型结构，而在数据或训练设置。如果把nn.Linear换成torch.matmul手动实现同样计算，结果完全一致，也能帮助排除代码层面的 bug。

我在开源的模型代码中见过不少把in_features和out_features搞反的情况。这种错误的典型表现就是维度报错，但如果你用torch.matmul手动实现就不会出错，因为你会自然地把维度理顺。所以我的建议是，在初次接触nn.Linear时，不妨手动实现一遍前向传播和反向传播，哪怕只是在纸上推导一遍，也比只看文档的理解要深得多。数学是定义，但真正的理解来自于你亲手写出那个正确维度的矩阵乘法，并观察到它在反向传播中产生对应的梯度的过程。

以上这些是我在使用nn.Linear这个模块时，从数学角度积累下来的核心经验。希望它能帮你从"调 API"升级到"懂原理"，在面对更复杂的网络结构时，能够有一个清晰的数学直觉作为支撑。