线性回归这个词，在深度学习火起来的今天听起来像个老古董，但你要是真动手写过几个深度学习项目，就会发现它是整个神经网络体系里最不该跳过的一块砖。很多人上来就啃卷积神经网络、Transformer，结果连最基础的损失函数下降曲线都看不懂，问题就出在线性回归这个起点没踩实。这篇东西我想跟你聊透线性回归在深度学习里的真实位置：它不是一个过时的统计工具，而是理解梯度下降、反向传播、过拟合这些核心概念的绝佳实验场。我会从数学原理、NumPy手写实现、PyTorch实战到调参踩坑完整过一遍，不管你是有一定编程基础想转深度学习的初学者，还是已经跑过几个项目但总觉得基础不牢的从业者，这篇文章都能帮你把这块地基重新夯实。
1. 线性回归的本质：它到底在解决什么问题
1.1 一个例子讲清楚线性回归
线性回归解决的是"预测连续数值"这类问题。举个最直白的例子：你想根据房子的面积预测房价。假设你收集了100条真实交易记录，横轴是面积，纵轴是价格，把这些点画在坐标图上，你会发现它们大致沿着一条直线分布。线性回归要做的就是找到一条直线，让这条直线尽量贴合所有数据点，这条直线就是你的预测模型。
这条直线的数学形式是 y = w·x + b，w 是权重，b 是偏置。拿到一个新房子的面积 x，代入公式就能算出预测价格 y。就这么简单。但背后藏着深度学习里最关键的思想：模型不是人手工指定的，而是通过数据自动学出来的。w 和 b 一开始是随机值，模型通过不断看数据、算误差、调整 w 和 b，最终收敛到一组让误差最小的参数，这个过程就是"训练"。
1.2 线性回归在深度学习体系里的真实定位
很多人误以为深度学习就是多层神经网络，线性回归这种"单层"模型根本不算深度学习。这个理解有偏差。严格来说，深度学习强调的是用多层结构自动学习特征表示，但线性回归恰恰是神经网络的最小单元。你把线性回归的公式 y = w·x + b 画成计算图，输入层一个节点直接连到输出层一个节点，这就是一个没有隐藏层、没有激活函数的单层神经网络。
换句话说，线性回归是深度学习中所有模型的基础组件。多层感知机的每一层，本质上都在做线性变换加非线性激活；卷积神经网络的卷积核操作，核心也是线性加权求和。你把线性回归吃透了，再看神经网络里的全连接层、损失函数、梯度更新，会发现全是老朋友。所以很多深度学习课程把线性回归放在第一课，不是因为它简单，而是因为它是理解一切复杂模型的最小可运行范式。
1.3 为什么深度学习入门必须亲手写一次线性回归
我见过太多人直接调 PyTorch 或 TensorFlow 的现成接口跑 MNIST 手写数字识别，跑通了就觉得自己会深度学习了。但真让他解释一下模型是怎么学出来的，损失值为什么从大到小变化，梯度下降每一步在做什么，基本答不上来。这就是基础不牢的典型表现。
亲手实现一次线性回归，哪怕是最简单的版本，你也会被迫面对几个绕不开的问题：损失函数怎么定义、梯度怎么算、参数怎么更新、数据要不要标准化、学习率调大了会怎样。这些问题在你看视频教程时觉得都懂，真正自己动手写代码跑起来，才会发现每一个都是坑。我强烈建议，不管你之后要学 CNN 还是 Transformer，先把线性回归用 NumPy 手写一遍，再用 PyTorch 写一遍，两遍对照着看，基础就扎实了。
2. 数学原理拆解：损失函数与梯度下降为什么长这样
2.1 目标函数与MSE损失
模型要学出好的 w 和 b，首先得有一个量化标准：预测值和真实值差多少。最常用的量化方式是均方误差 MSE，公式是 L = (1/n)∑(y_pred - y_true)²，就是所有样本预测误差的平方取平均。
为什么用平方而不是直接用误差的绝对值？两个原因。第一，平方操作让正负误差不会相互抵消，你不能让一个样本预测高了、另一个预测低了，两个误差"中和"成零误差，这显然不合理。第二，平方函数是凸函数，意味着损失曲面只有一个全局最低点，梯度下降能稳定收敛，不用担心陷入局部最优。绝对值误差虽然也是凸函数，但它在零点不可导，梯度计算不方便，实际使用中 MSE 是更顺手的默认选择。
还有一个细节值得注意：MSE 的系数 1/n 或 1/2n 在不同教材里写法不同。PyTorch 的 MSELoss 默认是 1/n，而有些推导为了方便求导会写成 1/(2n)，本质不影响结果，只是让导数表达式里少个系数 2。初学者看到不同资料里公式不一样容易懵，知道这个背景就不会被绕晕。
2.2 梯度下降的直观理解与推导
有了损失函数，接下来问题是怎么找到让损失最小的 w 和 b。数学上可以直接求导令导数为零解得解析解，也就是最小二乘法的正规方程。但深度学习的场景里样本量巨大、特征维度高，求解析解涉及矩阵求逆，计算量不可接受，而且一旦模型变复杂就不再是线性问题，解析解根本不存在。所以实际训练用的是梯度下降法。
梯度下降的思想可以类比成下山：你站在山顶看不清路，但能感觉到脚下哪个方向坡度最陡，沿着最陡的方向迈一步，反复执行，就能走到山谷最低点。这里"坡度最陡的方向"就是损失函数对参数的梯度（导数），"迈一步的大小"就是学习率。参数的更新公式是 w = w - 学习率 × 梯度，那个负号很关键，因为梯度指向损失增大的方向，要减掉它才能让损失变小。
以 MSE 损失为例，对 w 求导的结果是 (2/n)∑x·(y_pred - y_true)，对 b 求导的结果是 (2/n)∑(y_pred - y_true)。你注意看这个形式，梯度的大小正好由预测误差驱动：误差大，梯度就大，参数更新步子就大；预测越准，梯度越接近零，参数更新越来越细微。这就是"学习"的本质——误差回传指导参数修正。这个思想贯穿深度学习全程，反向传播算法本质上就是利用链式法则高效计算每一层参数的梯度，线性回归里你手动推导的这两条梯度公式，就是反向传播的最简雏形。
2.3 学习率：最容易被忽视的关键参数
学习率是训练过程中最值得反复体会的超参数，没有之一。它直接决定每一步参数更新的幅度。学习率设得太小，模型收敛极慢，训练几百个 epoch 损失还在缓慢下降，浪费计算资源；设得太大，参数更新步子迈过头，损失函数可能不减反增，甚至直接震荡发散，数值变成 NaN。
我自己的经验是，线性回归这种简单模型上，学习率从 0.01 到 0.1 之间通常能找到合适值，但具体多少取决于数据的量级。如果数据没有做标准化，特征值动辄上千，梯度也会很大，学习率就得调得很小才能稳住；数据标准化之后，特征值基本落在 -1 到 1 之间，梯度量级可控，学习率的选择余量就大多了。所以调参的第一步往往不是调学习率本身，而是先把数据处理好。
实践中你还会遇到学习率调度器这个概念。简单场景用固定学习率就够了，但更复杂的模型训练里，常见做法是训练初期用较大的学习率快速下降，后期逐步减小学习率让参数在最优值附近精细收敛。PyTorch 里自带 StepLR、CosineAnnealingLR 这些调度器，等你对固定学习率的训练过程有体感之后，再去尝试这些工具会容易理解得多。
3. 动手实现：从NumPy手写到PyTorch实战
3.1 数据准备：构造一组带噪音的线性数据
开始写代码之前，先准备数据。为了能验证模型学得对不对，最好用已知的真实参数来生成合成数据，这样训练完可以直接对比模型学到的 w 和 b 与真实值差多少。
假设真实模型是 y = 2·x + 1，我们生成 100 个样本，x 在 0 到 10 之间均匀分布，y 按照真实公式计算后加上一些高斯噪音，模拟现实场景中数据不可避免的随机扰动。噪音的标准差设成 1 左右，这样数据点会围绕直线上下波动，但趋势仍然清晰可见。
import numpy as np np.random.seed(42) x = np.linspace(0, 10, 100).reshape(-1, 1) true_w, true_b = 2.0, 1.0 y = true_w * x + true_b + np.random.randn(100, 1) * 1.5 print(x.shape, y.shape)这里 reshape 成列向量的操作值得提一句。后面的矩阵运算是按照"样本数 × 特征数"的组织方式设计的，x 变成 100×1 的二维数组，才能和 w 做矩阵乘法。很多初学者在这里栽过跟头，一维数组直接算也能出结果，但广播规则容易把人搞晕，尤其进入 PyTorch 之后张量维度问题会频繁出现，从一开始就保持维度清晰是个好习惯。
3.2 用NumPy从零手写线性回归
使用 NumPy 手写线性回归是理解整个深度学习训练流程的最佳方式，代码不长，但每一行都有意义。核心就四步：初始化参数、计算预测值、计算损失、计算梯度并更新参数。
import numpy as np def compute_loss(y, y_pred): n = len(y) loss = np.mean((y_pred - y) ** 2) return loss def train_linear_regression(x, y, lr=0.05, epochs=500): n, d = x.shape w = np.random.randn(d, 1) * 0.01 b = np.zeros((1, 1)) history = [] for epoch in range(epochs): y_pred = x @ w + b loss = compute_loss(y, y_pred) history.append(loss) grad_w = (2 / n) * (x.T @ (y_pred - y)) grad_b = (2 / n) * np.sum(y_pred - y) w = w - lr * grad_w b = b - lr * grad_b if epoch % 50 == 0: print(f"epoch {epoch}, loss {loss:.6f}") return w, b, history w, b, history = train_linear_regression(x, y) print(f"学到的参数: w={w[0,0]:.4f}, b={b[0,0]:.4f}")这段代码里有两个地方要特别留意。第一个是参数初始化，w 用了随机值并乘以 0.01，b 直接初始化为 0。随机初始化是必要的，如果 w 初始为 0，所有样本的预测值相同，梯度虽然不为零但容易让训练走弯路，而乘 0.01 是为了让初始梯度不会太大，训练更稳定。第二个是梯度的矩阵写法，x.T @ (y_pred - y) 这一行同时完成了所有样本的误差加权求和，比写 for 循环逐个样本累加高效得多，也简洁得多。
跑完这段代码，你会看到 loss 从几百一路降到个位数甚至更低，学到的 w 接近 2、b 接近 1。这个过程虽然简单，但你已经完整走了一遍深度学习训练的标准流程：前向传播计算预测、计算损失、反向传播求梯度、梯度下降更新参数。后续所有模型，无论多复杂，核心循环都是这个框架。
3.3 用PyTorch实现同样的任务
手写版本帮你理解了原理，PyTorch 版本则让你看到实际工程中怎么用框架把繁琐的求导过程自动化。框架的价值恰恰在于：你只需要定义模型结构和前向计算逻辑，反向传播和梯度更新由框架自动完成。
import torch import torch.nn as nn import torch.optim as optim x_tensor = torch.tensor(x, dtype=torch.float32) y_tensor = torch.tensor(y, dtype=torch.float32) class LinearRegressionModel(nn.Module): def __init__(self): super().__init__() self.linear = nn.Linear(1, 1) def forward(self, x): return self.linear(x) model = LinearRegressionModel() criterion = nn.MSELoss() optimizer = optim.SGD(model.parameters(), lr=0.05) epochs = 500 for epoch in range(epochs): y_pred = model(x_tensor) loss = criterion(y_pred, y_tensor) optimizer.zero_grad() loss.backward() optimizer.step() if epoch % 50 == 0: print(f"epoch {epoch}, loss {loss.item():.6f}") w_pytorch = model.linear.weight.item() b_pytorch = model.linear.bias.item() print(f"PyTorch学到的参数: w={w_pytorch:.4f}, b={b_pytorch:.4f}")这段代码里藏着几个新概念，值得展开讲。第一个是 nn.Linear(1, 1)，第一个参数是输入特征维度，第二个是输出维度，这里都是 1，对应一元线性回归。框架自动帮我们初始化了权重和偏置，你可以通过 model.linear.weight 访问。第二个是 optimizer.zero_grad() 这行，很多初学者第一次写都会忘。PyTorch 的梯度是累加的，如果不清零，下一次 backward 计算出的梯度会叠加到上一次的梯度上，参数更新就会出错。每轮训练开始前手动清零是固定动作。
还有一个细节是 loss.backward() 和 optimizer.step() 的分工。backward 负责计算所有参数的梯度并存储在每个参数的 grad 属性里，step 根据梯度和学习率真正更新参数。理解这两步的分离，你就能明白为什么调试时可以打印参数的 grad 值来检查梯度是否正常，这在排查训练问题时非常有用。
3.4 两种实现的对比与选择建议
手写版本和框架版本跑出来的结果基本一致，但体验完全不同。手写版本对理解原理至关重要，你会清楚地看到每个参数是怎么被梯度一步步推着走的；框架版本则展示了真实项目的写法，模型定义、损失函数、优化器三件套是几乎所有 PyTorch 项目的标配。
我给初学者的建议是：第一次学线性回归，两版都要写。先手写，跑通了再上 PyTorch，对照着看每个环节的对应关系——手写的 loss 计算对应 criterion，手写的参数更新公式对应 optimizer.step()。这样以后再接触更复杂的模型时，你看 PyTorch 代码就不会觉得黑盒，而是知道框架在背后替你完成了哪些事。
数据处理方面还有个容易忽略的小问题。NumPy 的数组转成 PyTorch 张量时，一定要确认数据类型是 float32，因为 PyTorch 的默认浮点类型是 float32，如果传入 float64 的数据，有时会报类型不匹配的错。用 torch.tensor(x, dtype=torch.float32) 显式指定类型，能从源头上避免这类问题。
4. 超参数调优与训练技巧：让模型真正收敛
4.1 数据标准化：不做的后果很严重
很多教程在讲线性回归时会默认你的数据已经"适合直接训练"，但现实中的数据很少这么友好。假设你要预测房价，特征不止面积一个，还有卧室数量、房龄这些，量级差异会很大：面积在几十到几百平方米，房龄在 0 到 50 年之间。如果不做标准化，梯度更新的步伐会被量级大的特征主导，量级小的特征几乎学不到东西。
标准化最常用的方法是 Z-score：每个特征减去均值再除以标准差，转换后数据均值接近 0、标准差接近 1。另一个常用方法是 Min-max 归一化，把数据映射到 0 到 1 区间。选择哪种取决于场景：如果数据分布近似正态，Z-score 更合适；如果数据分布比较均匀且没有太多离群点，Min-max 归一化更直观。
还有一点必须记住：标准化参数只能用训练集计算，然后直接用同一组均值和标准差去处理验证集和测试集。这是防止信息泄露的关键。如果先用全量数据算了均值标准差再做标准化，模型在评估时就已经"见过"测试集的信息了，评估结果会偏乐观，不能反映真实泛化能力。这个错误比较隐蔽，但后果很实在。
4.2 学习率、迭代次数与Batch Size怎么配
学习率、迭代次数（epoch）和 Batch Size 是三个互相纠缠的超参数。线性回归这种小规模问题，通常用全量梯度下降，也就是每次更新用全部样本计算梯度，代码里体现为直接对 100 个样本做矩阵运算。数据规模大了之后，全量计算太慢，就会引入小批量随机梯度下降，每次随机抽一小批样本算梯度。Batch Size 越小，更新越频繁，收敛路径上的噪声越大；越大，更新越稳定，但单次计算量越大。
我实际调参的顺序是：先固定 Batch Size（比如 32 或 64），用默认的 Adam 优化器或 SGD 配一个中等学习率（0.01 到 0.1）跑一遍，观察损失曲线。如果损失一路下降然后趋平，说明学习率基本合适；如果损失震荡剧烈，先把学习率调小十倍再试；如果损失下降极慢，调大学习率。迭代次数则看损失曲线什么时候开始不再明显下降，再往后多训练只会浪费时间甚至引入过拟合风险。
这里推荐一个非常实用的工具：early stopping，在验证集损失连续多个 epoch 不下降时提前终止训练，而不是死板地跑完设定的所有 epoch。很多深度学习框架和训练工具都内置了这个机制，但线性回归实验里你可以手动实现一次，写个"连续 10 个 epoch 损失没有改善就 break"的逻辑，体会一下"训练不是跑完就完事，而是该停就停"的节奏感。
4.3 训练过程的监控指标
训练时只盯着最终 loss 值是不够的，最好把每个 epoch 的损失记录成曲线，直观看到下降趋势。最理想的情况是损失平滑下降，像滑梯一样；常见情况是前几十个 epoch 下降很快，后面逐渐变平，这很正常，因为接近最优解时梯度会越来越小。如果损失曲线像锯齿一样上下剧烈跳动，大概率是学习率偏大；如果曲线基本是平的，可能学习率太小，也可能是代码有 bug。
除了损失值，还有一个被低估的指标：学到的参数与真实参数的差距。用合成数据训练线性回归有个额外好处，就是你手里有 ground truth，可以打印 w 和 b 的收敛过程，看它们是不是一步步逼近真实值。这个观察对建立"模型到底学到了什么"的直觉特别有帮助。你会发现训练早期参数变化快，后期变化慢，和损失曲线的规律完全对应。
实际工程里还会看 R² 分数，衡量模型解释了多少数据方差，越接近 1 说明拟合效果越好。对线性回归来说，R² 可以直观地告诉你模型的好坏程度，而不像损失值那样受数据量纲影响不好横向比较。不过看 R² 时要小心，它随特征数量增加会虚高，所以一般看调整后的 R² 才公平。
5. 常见问题与排查技巧实录
5.1 损失不下降或震荡怎么办
损失完全不下降是最容易让人心态崩溃的情况，但绝大多数时候不是模型的问题，而是训练设置出了问题。先检查学习率：如果是 0.001 甚至更小，数据量又不大的话，可能训练几百轮也没明显变化，试着调大十倍。再检查梯度：打印一下参数的 grad 值，如果梯度接近零，可能是权重初始化太小导致梯度消失，或者是数据没处理好梯度计算本身出了问题。最后检查数据：确认 x 和 y 的对应关系有没有错位，标签有没有混入异常值。
损失震荡幅度很大也很常见。一个容易踩的坑是优化器里没调对 momentum 参数，或者用的优化器本身对当前学习率太敏感。我的排查思路是：把学习率降到原来的十分之一，如果震荡明显缓解，说明是学习率的问题，可以用学习率调度器在训练中动态调整而不是手动改；如果震荡仍然剧烈，就要怀疑数据本身的问题，比如存在极端离群点，一个误差巨大的样本会拖拽整个梯度方向。
5.2 梯度爆炸与NaN问题
训练过程中 loss 突然变成 nan 是新手最容易遇到的噩梦之一。线性回归这种简单模型出现 nan，最常见原因是学习率过大导致参数更新幅度过大，数值计算溢出。比如数据值很大，误差也很大，梯度值可能到几千甚至几万，学习率 0.1 乘上去，参数瞬间跳到离谱的值，再算损失时平方就溢出了。
排查流程很直接：先看 loss 是在哪个 epoch 变成 nan 的，往前回溯参数值的变化；然后把学习率调小一千倍，如果训练恢复正常，基本锁定是学习率问题。此外也可以在代码里加梯度裁剪（gradient clipping），当梯度的模超过设定阈值时按比例缩放到阈值范围内。PyTorch 里一行代码 torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm) 就能搞定，复杂模型的训练中这是家常便饭。
最后提醒一个细节：数据里的 NaN 值。如果你的输入数据本身包含 NaN，训练过程也会出现各种诡异表现。建议在数据预处理阶段就检查一下 np.isnan(data).any()，有 NaN 要么删除对应样本，要么用均值或中位数填充，不要带着脏数据直接训练。
5.3 欠拟合与过拟合怎么区分
线性回归模型结构固定，欠拟合通常表现为训练误差和测试误差都很高。这个模型的学习能力就这么强（只有线性的表达能力），如果数据本身不是线性关系，比如真实关系是抛物线，你用线性模型去拟合，怎么训练都得不到好结果。这种情况不是调参能解决的，而是模型容量不够，需要换更复杂的模型，或者先对特征做非线性变换，比如加入 x² 项变成多项式回归。
过拟合在线性回归这种简单模型上不明显，因为参数少，但如果你不断增加特征数量，比如给一元数据加上 x²、x³、x⁴ 这些高阶项，模型就会开始"死记硬背"训练数据里的每一个点，包括噪声。表现是训练损失极低，测试集上表现反而变差。此时可以引入正则化，L2 正则化（岭回归）让大权重受到惩罚，L1 正则化（Lasso）则会让一部分特征的权重变成零，相当于自动做特征选择。
学会区分这两种情况的价值在于，你后续处理任何深度学习模型都会面对同样的判断。看到模型效果不好，第一步不是无脑加层或调参，而是先判断问题出在容量不足（欠拟合）还是容量过剩外加数据不够（过拟合），对症下药才有效率。
5.4 问题排查速查表
| 症状 | 可能原因 | 排查动作 |
|---|---|---|
| 损失完全不下降 | 学习率过小 | 调大学习率，观察前50轮损失变化 |
| 损失震荡剧烈 | 学习率过大 | 调小学习率，或使用学习率调度器 |
| 损失变成NaN | 梯度爆炸/数据含NaN | 调小学习率，加梯度裁剪，清洗数据 |
| 训练误差高、测试误差也高 | 欠拟合，模型容量不足 | 增加特征复杂度，或更换更强模型 |
| 训练误差低、测试误差高 | 过拟合，模型记住了噪声 | 加正则化，扩大数据量，减少特征 |
| 学出的参数严重偏离真实值 | 数据未标准化 | 做Z-score标准化，重新训练 |
| 相同的代码两次结果不同 | 随机初始化与数据顺序影响 | 设置随机种子 np.random.seed 和 torch.manual_seed |
这张表是我从实际带新人的过程中整理的，每一条都对应真实踩过的坑。里面最值得强调的还是随机种子问题：深度学习中处处有随机性，参数初始化、数据打乱顺序、GPU 运算都不完全确定。如果你的实验结果需要复现，在代码开头固定所有随机种子是基本操作。这看起来是小事，但真到写论文或者做工程交付时，一个跑一次一个结果的项目等于没有交付。
6. 从线性回归走向深度学习：一条清晰的进阶路线
6.1 线性回归与单层神经网络的关系
线性回归是一个没有隐藏层的神经网络，而且没有激活函数。你在 PyTorch 里的实现 LinearRegressionModel，和单层全连接网络的唯一区别就是输出有没有经过激活函数。把线性回归的输出接上一个 Sigmoid 函数，它就变成了逻辑回归，可以解决二分类问题；把多个线性回归的输出组合起来，加一层非线性激活，就变成了多层感知机。
理解这层递进关系非常重要。很多新手觉得从线性回归跳到神经网络是一道巨大的坎，其实就是一层窗户纸。神经网络每一层做的事情，不过是对输入做一次线性变换加上一次非线性变换，然后把结果传给下一层。你在线性回归里学会的损失函数、梯度下降、优化器选择，在神经网络里一个都不会变，变的只是参数更多、计算图更复杂而已。
6.2 引入非线性：激活函数的意义
你可能会问：如果只是把多个线性层堆叠在一起，模型的能力会变强吗？答案是不会。若干个线性变换串联起来，数学上仍然等价于一个线性变换，因为线性函数复合之后还是线性函数。这就像你把手机相机开了三倍变焦再开三倍变焦，效果是九倍变焦，但拍摄效果本质上还是在一张直通图像上做缩放，没有信息增强。
激活函数的作用就是打破这种线性限制。ReLU、Sigmoid、Tanh 这些非线性函数被插在层与层之间，让神经网络可以拟合任意复杂的非线性关系。这也是深度学习"深"的意义所在：每一层逐级提取更抽象的特征，靠的就是非线性激活的反复叠加。下次看到网络结构里"Conv1 -> ReLU -> Conv2 -> ReLU"这样的写法，你要知道 ReLU 就是那个让网络真正拥有表达能力的角色。
6.3 给新手的下一步学习建议
学完线性回归之后，最自然的进阶路径是逻辑回归和 Softmax 分类，它们把线性模型从回归任务扩展到分类任务。然后可以学多层感知机（MLP），在手写数字识别等小数据集上跑通一个真正的"深度"模型。之后再根据你的方向选择：做视觉的走卷积神经网络，做序列数据的走循环神经网络，或者直接转向 Transformer 系架构也算水到渠成。
每个阶段都建议保持同一个习惯：先手写核心逻辑，再引入框架。手写会让你的调试能力真正长在自己身上，框架只是在成熟项目中提升效率的工具。遇到问题先看损失曲线、看梯度值、看参数变化，这种排查思路比背几个 API 有价值得多。
我在实际带人过程中的体会是，线性回归这个起点值得反复回来复习。你学到反向传播、学到正则化、学到学习率调度，再回头看线性回归，总会有新的理解。比如当初只在代码里写过 gradient clipping 的一行调用，直到训练深层网络遇到真正的梯度爆炸，才明白那一行背后救了你多少次。基础概念的复利效应，在深度学习这条路上体现得特别明显。建议你把这篇文章里手写版本和 PyTorch 版本的代码都跑通，改一改学习率、换一换数据分布、加一点噪声，亲手制造几个"错误"，再亲手把它们修好，这些经历比任何教程都更能帮你建立对模型训练的直觉。
