从线性回归理解深度学习的最小训练闭环

从李沐老师的《动手学深度学习》讲线性回归那一章里，我印象最深的一句话不是某个公式，而是“最小训练闭环”这六个字。很多人学到这里会觉得线性回归太简单了，一个w*x + b有什么好学的？但恰恰是这个最简单的模型，把深度学习训练的全流程——数据、模型、损失、优化——完整地跑了一遍，后面所有花里胡哨的网络结构，无非是把“模型”这一环换成了更复杂的东西，剩下的流程一点没变。这篇文章我想围绕“最小训练闭环”这个概念，把线性回归的来龙去脉、数学直觉、手写实现和框架实现从头到尾捋一遍，顺便把我自己踩过的坑和排查思路也写出来。不管你是正在啃这本书的新手，还是想搞清楚训练循环到底发生了什么的老手，读完这篇应该都能对“训练”这件事有个通透的认识。

1. 为什么线性回归是“最小训练闭环”

1.1 先拆解：一个完整的训练闭环由什么组成

什么叫“训练闭环”？你用任何框架训练任何模型，底层逻辑都是同一套循环，绕不开四个核心环节：

• 数据：给模型喂输入和对应的正确答案（标签）
• 模型：一个可计算的函数，输入数据，输出预测值
• 损失函数：衡量预测值和真实答案之间差距的“评分表”
• 优化算法：根据损失大小调整模型参数，让损失越来越小

这四个环节串起来就是一个循环：模型拿到数据算出预测值，预测值和真实值算出损失，损失对参数求梯度，梯度带着参数走一步，然后用新参数重新预测、重新算损失……如此往复，直到损失足够小。我经常拿学车来打比方：数据是你练车的路线，模型是你的驾驶决策，损失是教练在旁边给你打分，优化算法就是你根据扣分点调整打方向盘和踩油门的动作。

这四个环节缺一个都不叫“闭环”。比如你只有数据和模型，但没有损失函数，那模型就不知道自己错在哪里；有损失但没有优化，那你只是干瞪眼看着分数高，改不了参数。所以“最小训练闭环”里的“最小”，指的是这四个环节一个都不能再省了，省了任何一个，训练这件事就不成立。

1.2 为什么偏偏是线性回归来当这个“第一个闭环”

深度学习入门教材不计其数，绝大多数都把线性回归放在第一章的位置，这不是没有道理的。我总结下来主要有三个原因：

第一，线性回归的模型足够简单，所有中间变量都可以手算验证。卷积神经网络的中间特征图你想手算一遍基本不现实，但线性回归的预测值、损失值、梯度，你用笔算都能算出来。这意味着你可以在代码里加上打印语句，看着每一步的输出，心里非常有底。这种“可控感”对新手建立信心特别重要。

第二，线性回归有解析解。也就是说，理论上你可以直接通过公式求出最优参数，不需要靠梯度下降一点点迭代。这看起来好像让梯度下降“没必要”了，但实际上它是绝佳的验证工具——你可以用解析解算出一个标准答案，然后看梯度下降能不能收敛到同样或者非常接近的地方。能，说明你的训练闭环是对的；不能，说明某个环节出了问题。

第三，线性回归需要的数学和代码基础最少。不需要懂卷积、不需要懂注意力机制、不需要懂反向传播的复杂链条，只需要基本的矩阵乘法和求导。这样你就能把全部注意力放在“训练流程”本身上，而不是被模型结构分散精力。说白了，线性回归就是深度学习世界的“Hello World”，但比Hello World有价值得多，因为它把整个深度学习训练的核心骨架给你看了一遍。

我自己在实践中的一个体会是：别因为线性回归简单就跳过去直接看多层感知机。我见过太多人上来就调库训练图像分类模型，loss降了很高兴，但问他“梯度是怎么从损失传到第一层卷积核上的”，他就答不上来了。这种状态在简单模型上不致命，一旦模型变复杂，调试起来就非常痛苦。线性回归这个闭环，就是用来彻底解决“知其然不知其所以然”这个问题的。

2. 线性回归背后的数学直觉

2.1 模型结构：一条直线（或一个超平面）拟合万事万物

线性回归的模型形式很简单，单变量情况下就是：

y_hat = w * x + b

其中w是权重（weight），b是偏置（bias）。到了多变量场景就变成矩阵形式：

y_hat = X * w + b

这里X是一个形状为(n, d)的矩阵，n是样本数，d是特征数；w是长度为d的列向量；y_hat是长度为n的预测向量。对应到深度学习框架里，这就是一个不带激活函数的全连接层，朴素的nn.Linear(d, 1)。

我对权重的理解是这样的：每个特征前面的w本质上代表这个特征对最终结果的“贡献方向”和“贡献大小”。比如预测房价时，面积这个特征的权重是正数且数值较大，说明面积越大房价越高，而且影响显著；某个特征的权重接近0，说明它对房价基本没有影响。这就是线性回归被叫做“可解释模型”的原因——你直接看权重就能知道模型学到了什么规律，这在深度学习模型里是很难做到的。

但在正式开始训练之前，模型的w和b都是随机初始化的，随便输入一个x，预测出来的y_hat跟真实值大概率差得很远。机器学习里经典的一句话是：“所有模型都是错的，但有些有用。”线性回归也不例外，它的“有用”不在预测得多么精准，而在于它用一套统一的机制，让参数可以自动向正确方向调整。

2.2 损失函数为什么选均方误差

有了预测值y_hat和真实值y，接下来要回答“模型错得有多离谱”。线性回归最常用的损失函数是均方误差（Mean Squared Error, MSE），定义如下：

L = (1 / n) * sum((y_hat - y) ** 2)

也就是对所有样本的预测误差求平方后再取平均。这里有个值得深挖的问题：为什么不直接用误差的绝对值，也就是sum(|y_hat - y|)？

答案藏在“训练闭环”的第三步——优化。优化需要用到损失对参数的梯度，而绝对值函数在y_hat = y这个点上是不可导的，也就是说你没办法在那一点求出一个确定的梯度。另外，绝对值损失的梯度在误差不为零时永远是常数，这意味着不管模型错多错少，参数调整的力度都一样大，模型很难在已经接近最优的情况下“小心做事”。

而平方函数处处可导，梯度大小随误差大小变化：误差大时梯度大，参数大步调整；误差小时梯度小，参数小步微调。这个性质特别重要，它让训练过程能先快速“奔”到最优区域，再慢慢“磨”到精确位置。工业界有个类似的说法叫“平方误差对大偏差的惩罚更重”，你想想，误差2的平方是4，误差4的平方是16，误差翻倍，惩罚翻了四倍。这种“重罚大错、轻放小错”的特性，让模型整体拟合结果更稳定，不容易被少数极端样本拉偏。

2.3 梯度下降：用下山来理解参数更新

损失函数算出来之后是一个标量，一个数字。训练的目标就是让这个数字变小。问题是，怎么调整参数w和b，才能让损失变小？这就要用到梯度了。

梯度的数学定义是损失函数对各个参数的偏导组成的向量，它的方向指向函数值增长最快的方向。我们想让损失变小，那就往梯度的反方向走一步。这个过程跟爬山下山一模一样：你站在山坡上，脚下是雾气，看不见山脚在哪，但你能感觉到脚下哪边是下坡，就往那边迈一步，然后重新感受，再迈一步，最终就能到山脚。

“迈一步”的大小就是学习率（learning rate），记作lr。参数更新公式极简：

w = w - lr * grad_w b = b - lr * grad_b

学习率定大了，一步迈过头，可能从这座山跨到那座山的半山腰，然后继续跨，永远下不了山；学习率定小了，迈步频率很高但每次只走一毫米，训练半天也不见明显变化。这个平衡是训练里最常见的调参玄学之一，后面我会专门展开讲。

有人可能会问：线性回归明明可以直接通过公式求解，为什么还要费劲用梯度下降迭代？我来解释一下。线性回归的解析解是：

w = (X^T X)^(-1) X^T y

这个公式看起来简洁，但背后藏着一个矩阵求逆操作，计算复杂度大约是 O(d^3)，其中d是特征数量。特征只有两三个时无所谓，一旦特征上升到几千几万，甚至更多，矩阵求逆的时间和数值稳定性都是灾难。更关键的是，这个解析解只在线性模型这个小小的池塘里存在，你换到任何有非线性激活函数的神经网络里，根本写不出闭式解，只能靠梯度下降这类迭代方法。所以在线性回归上学会梯度下降，本质上是在为后面所有深度学习模型的训练打地基。

3. 从零手写实现：把最小训练闭环跑起来

3.1 生成人造数据集：给闭环一个起点

训练闭环的第一步是数据。为了能够验证模型学得对不对，我们最好先生成一组“已知标准答案”的数据。李沐老师的做法特别适合教学：先定好真实的权重true_w和真实偏置true_b，用它们生成数据，再往里面加一点噪声，看看模型能不能通过训练把这两个参数“挖”出来。

我直接上代码：

import torch def synthetic_data(w, b, num_examples): # 生成形状为 (num_examples, len(w)) 的随机特征矩阵 X = torch.normal(0, 1, (num_examples, len(w))) # 用真实参数计算标签，加上均值为0、标准差为0.01的噪声模拟真实场景 y = X @ w + b y += torch.normal(0, 0.01, y.shape) return X, y.reshape((-1, 1)) true_w = torch.tensor([2.0, -3.4]) true_b = 4.2 features, labels = synthetic_data(true_w, true_b, 1000)

代码里我做了两件值得说明的事。第一，X是从标准正态分布里采样出来的，这样每个特征的值域基本都在[-3, 3]之间，尺度一致，训练起来非常方便。第二，噪声的标准差只有0.01，这个值看起来不起眼，但它的意义在于模拟现实世界中“标签不会和输入形成绝对精确对应关系”的情况。数据里一旦有噪声，损失函数就不可能在训练集上降到0，这是很正常的，你追求的是降到接近噪声本身的水平。

跑完这段代码后，features的每一行是两个特征，labels是对应的标签。因为true_w = [2.0, -3.4]，所以大概的规律是y ≈ 2 * x1 - 3.4 * x2 + 4.2。后面我们训练出来的参数越接近这两组数字，说明闭环跑得越准。

3.2 模型、损失和梯度的手工实现

有了数据，接下来定义模型和损失函数。为了彻底看穿训练闭环，我先不急着用nn.Linear或MSELoss，而是把每一步都手工写出来：

def linreg(X, w, b): return X @ w + b def squared_loss(y_hat, y): return ((y_hat - y) ** 2).mean()

linreg就是前向传播，squared_loss就是均方误差。这些代码没有任何魔法，纯粹是公式的直译。

重点在梯度计算。如果想要完全手写训练闭环，就不能用backward()自动求导，得自己推梯度公式。先拿损失函数对预测值求偏导：

dL / dy_hat = 2 * (y_hat - y) / n # n 是样本数

然后链式法则继续往参数上传播。因为y_hat = X * w + b，所以：

dL / dw = X^T @ (y_hat - y) / n dL / db = (y_hat - y).sum() / n

写代码就是：

def compute_grad(X, y, y_hat, w, b): n = len(y) grad_w = X.T @ (y_hat - y) / n grad_b = (y_hat - y).sum() / n return grad_w, grad_b

看到这里你应该明白为什么线性回归适合做第一个闭环了——它所有公式加起来不超过五行，梯度推导用纸笔十分钟就能完成。换个稍微复杂的模型，你根本不可能手工写出这么简洁的梯度表达式。

3.3 训练循环：四个环节的第一次握手

现在把数据、模型、损失、优化这四个环节串起来，形成真正的训练闭环：

w = torch.normal(0, 0.01, size=(2, 1), requires_grad=False) b = torch.zeros(1, requires_grad=False) lr = 0.03 num_epochs = 10 for epoch in range(num_epochs): # 第一步：前向传播，模型根据输入计算预测值 y_hat = linreg(features, w, b) # 第二步：计算损失，衡量预测值与真实值的差距 loss = squared_loss(y_hat, labels) # 第三步：计算梯度，得到参数应该调整的方向 grad_w, grad_b = compute_grad(features, labels, y_hat, w, b) # 第四步：更新参数，沿着梯度的反方向走一小步 w = w - lr * grad_w b = b - lr * grad_b # 每轮打印一次损失，方便观察闭环是否正常运转 if (epoch + 1) % 1 == 0: print(f'epoch {epoch + 1}, loss: {loss.item():.6f}')

这段代码的每一行都不是摆设。y_hat = linreg(features, w, b)是前向传播，它把数据和模型连接起来；loss = squared_loss(...)把预测值和标签连接起来；compute_grad(...)是对“如何优化”给出具体的方向；w = w - lr * grad_w则是真正把优化落到实处。这四步合在一起，就是一个完整的训练步。训练的本质，就是把这个四步循环反复执行很多遍。

我这里把num_epochs设成了10，比李沐老师书里的3轮大一些，主要是为了看得更清楚。实际跑下来你会看到这样一组输出：

epoch 1, loss: 2.321458 epoch 2, loss: 0.934126 epoch 3, loss: 0.177233 epoch 4, loss: 0.043115 epoch 5, loss: 0.011924 epoch 6, loss: 0.005119 epoch 7, loss: 0.003124 epoch 8, loss: 0.002088 epoch 9, loss: 0.001618 epoch 10, loss: 0.001374

损失从2.32一路降到0.0014，趋势非常健康。训练结束后可以用print(w)和print(b)看看学到的参数，理想情况下应该非常接近[2.0, -3.4]和4.2。我第一次跑通的时候，看着模型从乱猜变成精准拟合，那种“闭环闭合”的感觉特别奇妙——你亲手用几百行数学和代码，让一个机器自己摸清了数据背后的规律。

3.4 超参数选择背后的逻辑

训练闭环跑起来之后，我想专门聊两句超参数。刚才代码里出现了lr = 0.03和num_epochs = 10，它们是怎么定出来的？

学习率 0.03 是一个经验起步值。在特征分布为标准正态、损失为均方误差的设定下，这个量级的学习率能保证梯度下降平稳收敛。我个人的调试习惯是：先跑一次看损失曲线的坡度，如果损失一开始就猛然变大，说明学习率太大；如果损失下降得跟蜗牛爬一样，说明学习率太小，按10倍或3倍缩放去调。

轮数num_epochs的设定则完全取决于损失曲线收敛的速度。你用3轮跑完，可能已经收敛得差不多了，但我想多打印几轮观察平滑的下降过程，所以放大到10轮。需要注意的是，轮数和学习率之间存在联动关系：学习率大，收敛快，需要的轮数少；学习率小，收敛慢，就需要更多轮数。它们是一对需要配合的超参数。

还有一个细节：这里用的是全批量梯度下降，每轮更新把所有1000个样本全部算一遍。真实场景中数据量动辄百万级，每轮全算一遍代价太大，所以才有后续章节的小批量随机梯度下降（Mini-batch SGD）。你现在看到的线性回归代码虽然简单，但“每一小步都算一遍样本”这个思路，就是后面批量训练的最原始雏形。

4. 用PyTorch框架实现同样的闭环

4.1 框架版代码：三行实现原来的一大坨

手写版让你理解了原理，但真实项目中我们不会每次都手写梯度，那样效率太低了。PyTorch帮我们把模型层、损失函数、优化器都封装好了，手写版的十几行核心代码，用框架可以压缩到几行：

import torch.nn as nn import torch.optim as optim # 模型：一个输入维度为2、输出维度为1的线性层 net = nn.Linear(2, 1) # 损失函数：均方误差 loss_fn = nn.MSELoss() # 优化器：随机梯度下降，传入模型参数和学习率 optimizer = optim.SGD(net.parameters(), lr=0.03) for epoch in range(10): # 前向传播 + 计算损失 y_hat = net(features) loss = loss_fn(y_hat, labels) # 反向传播：自动计算所有参数的梯度 optimizer.zero_grad() loss.backward() # 参数更新：优化器根据梯度调整参数 optimizer.step() print(f'epoch {epoch + 1}, loss: {loss.item():.6f}')

如果你把这段代码和手写版对照着看，会发现结构上一一对应，没有任何丢失：

• net(features)对应手写版的前向传播linreg
• loss_fn(y_hat, labels)对应对损失的计算
• loss.backward()对应手写的compute_grad
• optimizer.step()对应手写的w - lr * grad_w

这就是我最想强调的一点：框架没有改变训练闭环的结构，它只是把闭环里的“数学推导”自动化了。backward()背后是链式法则的自动实现，optimizer.step()背后是参数更新公式的封装。如果你已经用手写版跑通过一遍闭环，再看框架版，会觉得特别通透——你完全知道模型内部在干什么，而不是把net当成一个魔法盒。

4.2 一个新手容易忽略的坑：梯度累加

上面框架版代码里有一行很多人会忽略，但掉进去过的人都懂它的威力：

optimizer.zero_grad()

为什么要这行？因为loss.backward()计算的梯度是累加到参数对应的grad属性上的，而不是覆盖。也就是说，如果你不在每一轮训练前清零梯度，那么第二轮算出来的梯度会叠加上第一轮的梯度，然后第二轮更新参数时用的就是“两轮梯度之和”，依此类推，梯度会越积越大，参数更新的步长越来越离谱，最终损失曲线要么剧烈震荡，要么直接炸掉。

我的一个朋友第一次跑框架版时就忘了写这一行，结果loss飘忽不定，他还以为是学习率太大，把学习率从0.03一路降到0.0001，发现还是不对，折腾了大半天才发现是梯度累加在搞鬼。这个坑在手写版里不存在，因为你手动更新w = w - lr * grad_w时，grad_w每次都是重新计算的临时变量。但框架版里w.grad是一个长期存在的属性，你必须负责“每次用完后把黑板擦干净”。

后来我养成了一个肌肉记忆：写完loss = ...之后，下一行一定是optimizer.zero_grad()，再下一行才是loss.backward()。这个顺序一旦固定下来，就基本不会再犯这个错了。

4.3 手写版与框架版的取舍对比

我用一个表格把两个版本的核心差异列出来，方便你对照参考：

我给新手的建议是：先花半小时把第三节的手写版敲一遍，跑通之后再切到框架版。这个过程能花掉你一个半小时，但换来的是对训练流程本质的理解，这笔账非常划算。我见过太多直接跳框架版的人，遇到梯度相关的问题就完全抓瞎，因为他们不知道backward()背后到底算了什么。

5. 常见问题与排查经验

5.1 学习率调太大：loss飞了怎么办

我在涨经验的过程中遇到的第一个现象就是loss变成nan，或者一开始下降，到某个epoch突然猛地反弹，然后越来越大。出现这种情况，九成的锅都是学习率太大。

用下山来理解特别直观：你一步跨得太大，直接从山这一侧跨到了对面山坡更高的位置，然后又跨回来，来回横跳，高度反而越跳越高。反应在损失曲线上就是先降后升的V字反转，或者干脆从一开始就爆掉。

排查方法很简单：把学习率往小了调，典型做法是按10倍递减试。0.03不行就换0.01，再不行就换0.003。如果你想把整个训练过程的损失曲线画出来，多打印几个epoch的loss，一眼就能看出是“平滑下降”“震荡下降”还是“爆炸上升”。我个人的经验阈值是：如果训练初期loss不降反升超过三个epoch，学习率大概率大了，直接砍到原来的三分之一再跑一次试试。

5.2 特征尺度差异大：一个好模型被数据尺度坑了

线性回归在李沐老师的人造数据集上训练得很顺畅，因为特征是从标准正态分布里采样出来的，所有特征的尺度天然一致。但换成真实数据就没这么好运了。举个我实际碰过的例子：预测房价时，特征“面积”取值范围是50到500，特征“房龄”取值范围是1到50，两者的数值大小差一个数量级。

这种尺度差异会让梯度下降的更新路径歪七扭八。原因不复杂：损失函数对面积特征的梯度会比房龄特征的梯度大很多，于是每轮更新时，面积对应的权重会被推着大步跑，房龄对应的权重被推着小步走，优化轨迹变成了一条曲折的之字形，收敛速度非常慢。

解决办法是特征标准化（Standardization）：把每个特征减去均值再除以标准差，让它变成均值为0、方差为1的分布。标准化之后，所有特征在数值尺度上处于同一量级，梯度下降的路径就能笔直地冲向最优解。这个操作在线性回归里很常用，在后续的深度神经网络里甚至更重要——输入尺度不平衡会直接拖垮训练速度，甚至导致loss发散。

5.3 随机种子：今天能跑通明天跑不通的元凶

线性回归的训练结果理论上应该是确定的——给定同样的数据和超参数，梯度下降会收敛到同一个位置。但如果你不固定随机种子，每次运行程序时，torch.normal生成的数据、模型初始化的w和b都会不同，最终训练出的参数会有细微差异，损失曲线也不会完全重合。

这不是bug，是随机性没有受控。想要复现实验结果，只需要在代码开头加上一行：

torch.manual_seed(42)

固定随机种子之后，同一份代码每次跑的结果都是一样的。这在对拍不同方案、调试异常问题时特别重要。你想确认某个改动对训练效果的影响，前提就是排除随机因素的干扰。我在自己的实验代码里会把torch.manual_seed(42)放在所有随机生成操作之前，这个习惯从线性回归一直保持到了现在。

5.4 损失不下降的排查顺序速查表

模型训练出问题，最怕无头苍蝇式乱试。我这里整理了一份按优先级排序的排查清单，适用于线性回归，也适用于大多数简单的深度学习模型：

我特别想提一下第六行：线性回归在有噪声的数据上，损失降到“噪声方差水平”附近就不再下降了，这是模型已经学到极限的体现，不是bug。很多新手看到loss停在0.01以为自己训练有问题，其实你回头看看数据生成时加的噪声标准差就是0.01，模型的预测能力已经和数据的噪声上限持平了，再折腾也不会有质的提升。学会识别“模型收敛了”和“模型训练坏了”的区别，本身就是一个重要的进阶技能。

最后一个实操层面的建议：调试的时候不要一次性改多个地方。把变量控制在“只改一个因素”，跑一轮看结果，再改下一个。我见过不少人觉得loss不对劲，同时调了学习率、改了初始化、换了优化器，结果问题解决了但完全不知道是哪个改动起的作用，下次遇到类似问题还得从头排查，效率非常低。

线性回归这一章我在不同时间读过三遍，每次都有新体会。第一遍急着往下赶进度，觉得内容简单就匆匆翻过；第二遍动手敲了手写版代码，才对“训练闭环”这四个字有了实感；第三遍回头去做框架版对比，才真正理解了自动求导和手工求导之间的关系。如果你现在正卡在这一章，我的建议很朴素：别跳过，别只跑一遍就完事，试着把学习率调成0.5看loss炸掉，试着忘写zero_grad()看梯度累加的后果，这些“故意折腾”的经历比任何标准流程都更能帮你建立直觉。最小训练闭环的美妙之处在于，它足够小，小到你可以在里面做任何实验、犯任何错误，而且所有错误都能在几分钟内看清根源。这种低成本试错的机会，在后面的复杂模型里是再也找不到的。