基于PyTorch的线性回归实战：从原理到代码实现

先聊聊这次的话题。机器学习入门绕不开的第一个模型，几乎都是线性回归，它就像编程里的“Hello World”，地位不是因为它简单，而是因为它把“从数据中学习规律”这件事最直观地演示出来了。而PyTorch作为深度学习的主流框架，虽然名字里带着“深度”，但你用它来做线性回归，反而能把框架的核心机制——张量计算、自动求导、梯度下降——一次性摸清楚。这篇博文我按照“原理讲透、代码能跑、坑点说清”的思路，把基于PyTorch的线性回归完整拆解一遍，配套完整的可执行代码，新手照着敲就能跑出结果，后面学逻辑回归、神经网络也会顺很多。

1. 线性回归的核心逻辑：模型、损失与优化

1.1 从“猜数游戏”理解线性回归在干什么

先把线性回归的本质说透。假设你面前有一组数据，比如房屋面积和房价的对应关系。面积是输入，房价是输出。线性回归要做的事情，就是找到一条直线，让这条直线尽可能贴合所有数据点。这条直线在数学上就是 y = wx + b，w是权重，b是偏置。训练模型的过程，本质上是不断调整w和b，让直线离真实数据点的平均距离最小。

PyTorch在这里扮演的角色，是把你从复杂的数学运算中解放出来。你不需要手写求导公式，不需要自己实现梯度下降的迭代逻辑，框架的自动求导机制会帮你算好梯度，你只需要告诉它“怎么评判好坏”和“朝哪个方向调整参数”。这就是我推荐用PyTorch入门线性回归的原因——它把“算法思路”和“工程实现”解耦得非常干净，你能专注理解模型本身，而不是陷入到微积分的计算细节里。

1.2 损失函数和梯度下降：优化问题的两大支柱

有了直线方程，下一个问题就是：怎么判断这条直线“好不好”？答案是用损失函数。线性回归最常用的损失函数是均方误差（MSE），它把每个数据点的预测值和真实值的差平方后取平均。平方的作用有两个：一是消除正负误差抵消的问题，二是放大较大误差的惩罚力度。这个损失值越小，说明直线拟合效果越好。

梯度下降就是寻找最小损失值的工具。你可以把损失函数想象成一座起伏的山丘，模型参数(w和b)就是你在山丘上的位置坐标，损失值就是当前位置的海拔。梯度下降的策略很简单：算出当前位置的梯度（也就是最陡峭的上升方向），然后朝反方向迈一步。步长就是学习率。每迈一步，参数就更新一次，损失值就下降一点，直到收敛到山底。PyTorch中的optim.SGD或optim.Adam，就是这些“迈步策略”的现成实现。

注意：学习率是这个过程中最敏感的超参数之一。学习率太大会导致损失值震荡甚至发散，太小会让训练变得极其缓慢。在后面实操部分，我会专门演示不同学习率的效果差异。

1.3 为什么选PyTorch而不直接用NumPy

很多入门教程会用NumPy手写线性回归，代码量也不大，几十行就能搞定。但我不推荐新手从那种方式入手，原因很实际：手写方式最大的问题是反向传播需要自己推导梯度公式，一旦模型结构变得复杂（比如加多层、加非线性激活函数），手推梯度的难度会指数级上升，这在深度学习中完全不现实。而PyTorch的autograd机制能自动计算所有参数的梯度，你只管设计模型结构和损失函数，梯度计算交给框架。

另外，PyTorch的代码结构跟深度学习模型的通用开发流程高度一致：定义模型类、定义损失函数、选择优化器、写训练循环。这套流程你在以后学习CNN、RNN、Transformer时依然适用。所以，用PyTorch入门线性回归不是“大材小用”，而是“一举多得”——你学的是框架的核心用法，而不只是一个孤立算法。

2. 环境准备与数据构造：把跑通代码的坑提前踩平

2.1 PyTorch环境搭建的两种方案对比

在写代码之前，先把环境搞定。很多初学者在环境配置这一步就被劝退了，其实问题不大，只要选对安装方式。我推荐两个方案，任选其一即可。

第一个方案是使用Anaconda创建虚拟环境再安装PyTorch。这适合需要在不同项目间切换依赖的情况，比如有的项目要PyTorch 1.x，有的要2.x，虚拟环境可以隔离互不干扰。命令如下：

bash复制conda create -n ml_linear python=3.9
conda activate ml_linear
pip install torch torchvision --index-url https://download.pytorch.org/whl/cpu

第二个方案是直接用pip安装。如果你已经装了Python 3.8以上版本，并且只想快速跑通这个教程，直接pip安装就够了：

bash复制pip install torch
pip install matplotlib

没有GPU的机器完全不用担心，线性回归这种规模的模型，CPU跑起来毫无压力。在PyTorch官网安装页面选择对应操作系统和CUDA版本时，如果没有NVIDIA显卡，直接选CPU版本就行。这里有个很多人会犯的迷糊点：选了CUDA版本的PyTorch，但电脑上没装对应版本的显卡驱动，或者显卡太老不支持，运行时会直接报错说CUDA不可用。所以，只是入门学习的话，先装CPU版本是最省心的。

2.2 构造带噪声的线性数据：让“学习”有据可循

环境准备好之后，我们需要一批“有规律可循”的数据。真实的机器学习是从真实数据集开始的，但作为教学演示，用人工构造数据更可控——我们知道真实的w和b是多少，就能直观检验模型学得准不准。

这里我用一个简单的做法：设定真实的权重w_true = 2.0，偏置b_true = 1.0，然后随机生成100个x值，带入y = 2x + 1之后，再给每个y加上一些随机噪声。这样生成的数据既有明确的线性规律，又不会太“完美”——真实世界的数据总是带噪声的，模型要学的就是在噪声中找到规律。代码如下：

python复制import torch
import matplotlib.pyplot as plt

# 设置随机种子，保证结果可复现
torch.manual_seed(42)

# 生成100个在[-1, 1]区间均匀分布的x
X = torch.linspace(-1, 1, 100).reshape(-1, 1)
# 真实参数
w_true = 2.0
b_true = 1.0
# 添加高斯噪声，标准差0.2
noise = torch.randn(X.size()) * 0.2
y = w_true * X + b_true + noise

# 可视化一下数据分布
plt.scatter(X.numpy(), y.numpy(), alpha=0.6)
plt.xlabel("x")
plt.ylabel("y")
plt.title("Synthetic Linear Data with Noise")
plt.show()

这里torch.linspace(-1, 1, 100)生成从-1到1均匀分布的100个点，reshape(-1, 1)把形状变成(100, 1)——这是PyTorch中常见的“样本数×特征数”格式。torch.randn生成的是服从标准正态分布的随机数，乘0.2是控制噪声的强度。噪声太大会让数据点散成一团，太小又体现不出“学习”的过程，0.2在这个场景下效果不错。

2.3 数据预处理：归一化要不要做

很多教程在数据构造完就直接进入建模，但我还是想提一嘴数据预处理。对于单特征线性回归来说，数据范围在[-1, 1]之间，天然不需要做归一化，因为梯度下降在这种尺度下收敛很顺利。但如果你的数据特征取值范围差异巨大，比如一个特征在[0, 1]，另一个在[0, 10000]，那就必须做归一化处理。原因在于：没有归一化时，损失函数的等高线是狭长的椭圆形，梯度下降更新时会走很多弯路；归一化之后，等高线接近圆形，梯度下降的路径就会很“直”，收敛速度快得多。这个后遗症在后续学习多特征回归、逻辑回归时会经常遇到，提前有认知能少踩很多坑。

3. 核心代码实现：从模型定义到训练循环拆解

3.1 模型定义：用nn.Module还是直接用nn.Linear

PyTorch中定义线性回归模型有两种常见方式。第一种是直接使用nn.Linear，一行代码搞定，因为线性回归本质上就是一个不带激活函数的全连接层。第二种是自定义类继承nn.Module，这种方式更通用，以后搭建复杂网络时是必须掌握的。我建议初学者两种都写一遍，先感受nn.Linear的简洁，再理解nn.Module的扩展性。

python复制import torch.nn as nn

# 方式一：直接用nn.Linear
model = nn.Linear(in_features=1, out_features=1)

# 方式二：自定义模型类
class LinearRegressionModel(nn.Module):
    def __init__(self):
        super(LinearRegressionModel, self).__init__()
        self.linear = nn.Linear(in_features=1, out_features=1)

    def forward(self, x):
        return self.linear(x)

model = LinearRegressionModel()

in_features=1表示输入是1个特征，out_features=1表示输出是1个值。nn.Linear内部会自动初始化权重和偏置，不是设为0，而是采用一种均匀分布的随机初始化策略，这是为了让模型在一开始就具备“打破对称性”的能力。如果在某些框架里看到所有权重初始化为0，模型就永远学不出东西，因为所有神经元都在做同样的计算，梯度也一致，更新后参数依然相同，这就是“对称性问题”。PyTorch的默认初始化策略就是为了避免这个情况。

3.2 损失函数与优化器：MSE和SGD的组合逻辑

模型定义好了，接下来配齐损失函数和优化器。均方误差损失在PyTorch中对应nn.MSELoss()，随机梯度下降对应optim.SGD。这里的“随机”并不是说每次都随机选一个方向，而是指每个batch的样本是随机抽取的。当batch大小等于全部样本时，就是标准的批量梯度下降（BGD）；当batch大小等于1时，就是随机梯度下降（SGD）；中间状态叫小批量随机梯度下降（Mini-batch SGD），是最常用的一种。

python复制import torch.optim as optim

criterion = nn.MSELoss()
optimizer = optim.SGD(model.parameters(), lr=0.01)

学习率这里先设为0.01。为什么要从0.01开始试？这是经验值。对于单特征线性回归，0.01通常能给出平稳的收敛曲线；如果太小（比如0.0001），训练2000轮都未必收敛到理想结果；如果太大（比如1.0），损失值会疯狂震荡，甚至变成NaN。这个“恰到好处”的值需要通过实验来确定，我后面会专门演示。

3.3 训练循环：前向传播、反向传播、参数更新的闭环

这是整个代码的核心，也是理解PyTorch工作机制的关键。训练循环的骨架是固定的，四个步骤一个都不能少：

python复制epochs = 1000
losses = []

for epoch in range(epochs):
    # 前向传播：计算预测值
    y_pred = model(X)
    # 计算损失
    loss = criterion(y_pred, y)
    # 反向传播：计算梯度
    loss.backward()
    # 参数更新
    optimizer.step()
    # 梯度清零
    optimizer.zero_grad()

    losses.append(loss.item())
    if (epoch + 1) % 100 == 0:
        print(f'Epoch [{epoch+1}/1000], Loss: {loss.item():.4f}')

让我把这个闭环讲清楚，每个初学者都会在这里犯迷糊。

第一步是前向传播。把X输入模型，经过nn.Linear内部的计算y = x * weight + bias，得到预测值y_pred。此时y_pred是一个形状为(100, 1)的张量，每个样本都有一个预测值。

第二步是计算损失。criterion(y_pred, y)计算每个样本预测值和真实值的平方差，再取平均。这个数值就是当前模型的表现评估。

第三步是反向传播。loss.backward()这行代码是整个PyTorch最神奇的地方——它会自动计算损失关于所有模型参数（即weight和bias）的梯度，并把这些梯度累积在对应参数的.grad属性中。原理上它是在执行微积分中的链式法则，从损失函数开始，一层一层往回传播梯度。你不需要手写任何求导代码，框架全帮你处理了。

第四步是参数更新。optimizer.step()的本质是做param.data -= lr * param.grad这个操作。优化器读取参数的梯度值，乘以学习率后，以减法的方向更新参数，目的是让损失函数值下降。注意这里用的是param.data而不是param本身，是为了绕过自动求导系统，避免更新过程被记录进计算图。

最后一步是梯度清零。这一步很容易被新手忽略，但非常重要。loss.backward()计算得到的梯度是“累积”进.grad属性的——也就是说，如果不清零，下一轮计算出的梯度会加到现有梯度上，这会导致参数更新方向出错，训练过程发散。PyTorch之所以设计成累积模式，是为了适配某些需要梯度累积的场景（比如显存不够时凑batch），但对标准训练流程来说，必须在每个batch后清零。

3.4 训练结果分析：模型学到了什么

训练完成后，我们来检验模型的学习成果。打印出模型的权重和偏置，与前面设定的真实值做个对比：

python复制w_learned = model.linear.weight.item()
b_learned = model.linear.bias.item()
print(f'Learned w: {w_learned:.4f}, True w: {w_true}')
print(f'Learned b: {b_learned:.4f}, True b: {b_true}')

如果一切顺利，你会看到学习到的w大约在1.98到2.02之间，b大约在0.95到1.05之间。噪声的存在让模型不可能精确还原出真实的w和b，但大概率会在真值附近。这就是机器学习的本质：我们不是要背下每个数据点，而是要找到背后最可能的规律。另外值得注意的一点是，学习到的参数会受到噪声的具体样本影响——换一个随机种子生成数据，学到的参数会略有浮动，但都会落在真实值附近。这也是为什么机器学习的评估不能只看一次训练结果，而是要看统计意义上的表现。

再画一下预测直线和数据点的对比图：

python复制plt.scatter(X.numpy(), y.numpy(), alpha=0.6, label='True data')
plt.plot(X.numpy(), model(X).detach().numpy(), 'r-', label='Fitted line')
plt.xlabel("x")
plt.ylabel("y")
plt.legend()
plt.show()

预测直线会从数据点“中间”穿过去，而不是试图经过每一个点。这是因为MSE损失函数对远离直线的点惩罚很大（差平方放大），所以最优直线总是尽量“平衡”所有点的误差，而不是“迁就”某个离群点。这个行为可以通过调整损失函数来改变，后面学鲁棒回归（如Huber损失）时会讲到。

3.5 训练过程中的损失可视化：判断收敛状态

只看最终的参数对比还不够，最好把训练过程中的损失值变化画出来，这是判断模型是否收敛的重要依据：

python复制plt.plot(range(epochs), losses)
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.title('Training Loss Curve')
plt.show()

正常训练的损失曲线应该是这样的：前期下降很快，中期逐渐放缓，后期平缓趋近于某个值。前期快是因为初始参数离最优解远，梯度大，每次迈步的方向感明确；后期慢是因为接近最优点时梯度趋近于零，参数更新幅度变得很小。如果你看到损失曲线在某个数值附近来回震荡、降不下去，可能的原因包括学习率偏大、数据噪声偏大、或者模型容量不足。如果你看到损失曲线先降后升，大概率是学习率太大导致参数迈过了最优点。

4. 关键参数调优实验：学习率与迭代次数的实际影响

4.1 学习率过小的“龟速收敛”实例

代码能跑通只是第一步，真正理解算法还需要亲手做实验。我强烈建议你把学习率改成几个不同的值，观察训练曲线的变化。这里我直接给你看结论。

把学习率设为0.0001会发生什么？训练1000轮之后，损失值可能只从初始的3.5降到2.8左右。损失确实在下降，但速度太慢，参数距离最优解还很远。如果继续训练到10000轮，也许能收敛，但代价是宝贵的训练时间。实际上，学习率过小的问题在训练曲线上表现得很明显：曲线下降得平缓得几乎像一条水平线。

我见过不少初学者在调模型时遇到“损失不下降”的问题，第一反应是模型写错了，其实很多时候就是学习率设小了。遇到这种情况，先试试把学习率调大10倍或100倍看看效果。

4.2 学习率过大的“灾难性发散”实例

反过来，把学习率设为1.0会看到完全不同的场景。第一轮训练后，损失值不是变小，而是直接爆炸到几百甚至几千。训练到后面，损失值直接变成NaN（Not a Number）。

原因在于：在最优解附近，梯度可能很大，如果学习率也大，参数的更新量就会过大，导致参数“跳”到了损失函数曲面的极远端甚至更差的位置。下一轮计算梯度时，这个位置的梯度更大，再乘以学习率，参数被推得更远——恶性循环，最终数值溢出变成NaN。

观察这个现象的意义在于：当你以后训练真实的深度学习模型时，如果看到NaN出现，有很大概率是学习率太大了。这时候先不要怀疑代码逻辑，优先调小学习率。

4.3 寻找合适学习率的“从大到小”策略

既然学习率太大不行、太小也不行，那正确的调法是什么？我的经验是“从大到小”试：先尝试0.1，如果发散就除以10变成0.01，如果还是发散再除以10变成0.001。用这个策略，通常两三次实验就能定位到一个合适的量级。

关于迭代次数（epochs），一个常见疑问是“多少轮才够”。答案取决于学习率和损失函数的形状。在看损失曲线的前提下，如果1000轮之后损失还在明显下降，说明还没收敛，加大epochs；如果损失曲线早就变成水平线了，再加epochs也意义不大，提前停止是更好的选择。这也是现代深度学习训练中的“早停法”思想——在验证集损失开始上升之前停止训练，防止过拟合。

4.4 损失曲线里的信息量：不止是单调递减

最后说一个容易被忽略的点：损失曲线不是越光滑越好。如果数据带的噪声较大，损失曲线的尾部会呈现一种“毛刺”感，这其实是正常的。关键看趋势，而不是局部的抖动。如果曲线出现明显的周期性波动，比如每100轮损失突然上升再下降，那可能是数据样本顺序的问题——在SGD中，每个 batch 的数据分布有差异，会导致损失波动。这也解释了为什么很多框架在训练前都会对数据做 shuffle（随机打乱顺序），为的是让每个 batch 的数据分布尽量接近总体分布。

5. 从线性回归延伸到更广的机器学习视野

5.1 正规方程法与梯度下降的对比

线性回归除了用梯度下降求解，还有一个解析解的方法叫正规方程（Normal Equation）。它的思路是直接通过矩阵运算算出最优参数：w = (X^T X)^{-1} X^T y。这个方法的优势是无需迭代，一步到位，在小规模数据集上计算速度极快。但缺点也很明显：当特征维度很高时，计算(X^T X)的逆矩阵代价极大，尤其是特征数达到几万甚至几十万时，矩阵求逆的计算量会让人崩溃。

PyTorch中虽然没有直接封装正规方程，但你可以用torch.linalg.solve来求解。在单特征线性回归这种极端简单的场景下，正规方程和梯度下降得到的最终参数几乎一致，但梯度下降的方式更通用——它能扩展到任何可微的模型上，而正规方程只适用于线性最小二乘问题。这就是为什么深度学习框架清一色走梯度下降路线。

5.2 模型评估：光看损失还不够

训练完模型之后，还要回答一个更重要的问题：这个模型到底“有多好”？标准的评估指标是把测试集上的均方根误差（RMSE）或平均绝对误差（MAE）计算出来。RMSE就是把MSE开根号，它的量纲跟原始数据的y一致，更容易直观理解误差水平。

还有一个更直观的指标是R²（R平方，决定系数）。R²越接近1，说明模型解释了数据中越多的方差，拟合效果越好；R²为0说明模型预测效果等同于直接用均值预测。对于线性回归，R²计算并不复杂，但没必要自己手写，用sklearn.metrics.r2_score一行代码就能搞定。训练得到的模型在当前构造的数据上R²应该在0.95以上，这个数值也算是对“学习效果”的一种量化校验。

5.3 下一步：从线性回归到逻辑回归与神经网络

当你完整跑通了这套线性回归流程，你已经掌握了机器学习最核心的训练范式：定义模型结构、设计损失函数、选择优化器、迭代训练、评估效果。这套流程将贯穿你后续所有的机器学习学习路径。

接下来你可以尝试的扩展方向有几个：把单特征扩展到多特征，理解多维输入下的矩阵运算；把损失函数换成交叉熵，把线性回归升级为逻辑回归，开启分类任务的大门；在模型中加一个非线性激活函数，再把多个线性层堆叠起来，本质上这就是一个最基础的神经网络。你会发现，PyTorch的nn.Module扩展能力让这些变化变得非常自然——你只需要修改模型定义和损失函数，训练循环几乎不用动。

6. 常见报错与排查技巧实战记录

6.1 shape不匹配：初学者遇到频率最高的报错

运行代码时第一个可能遇到的报错就是shape不匹配。比如你把nn.Linear设置成in_features=2，但输入X的特征维度是1，PyTorch会直接报错说mat1 and mat2 shapes cannot be multiplied (100x1 and 2x1)。这类错误需要你重点检查输入数据的形状，以及模型定义的输入输出维度是否匹配。快速调试的方法是打印出X.shape和y_pred.shape：

python复制print(X.shape)
print(y_pred.shape)

创建数据时用reshape(-1, 1)把X变成二维张量，是线性回归里的标准操作。如果不做reshape，直接把一维张量传入nn.Linear，PyTorch会把它当成“100个样本、每个样本0维特征”来处理，同样会报维度错误。

6.2 梯度累积导致的NaN问题

还有一个常见问题是训练几轮后loss变成NaN，但初始学习率并没有特别大。这种情况通常出在optimizer.zero_grad()的位置。如果忘了在每轮训练开始时清零梯度，上一轮的梯度会和下一轮的梯度累积在一起，导致参数更新量失控，数值爆炸。检查你的训练循环里是不是漏了这行代码。

另外注意zero_grad()调用的位置。标准做法是放在loss.backward()之前，也就是for epoch循环的第一行或最后一行。把它放在optimizer.step()之后也是可以的，但一定要确保每个batch都执行一次。如果你在代码里写了多个loss.backward()但没有相应的zero_grad()，累积的梯度会让模型参数走向不可控的方向。

6.3 tensor的requires_grad状态问题

训练循环之外，还有一个隐蔽的坑。当你想画图或者打印预测值时，直接使用model(X)返回的是一个带有梯度信息的张量，如果你对它执行plt.plot()传入tensor，代码可以运行但会包含额外信息。更稳妥的做法是用.detach().numpy()把张量从计算图中“摘下来”再转成NumPy数组。

当你尝试用model(X).numpy()时，如果这个张量设置了requires_grad=True，PyTorch会直接报错说Can't call numpy() on Tensor that requires grad。正确的方式是先调用.detach()，切断梯度信息，然后再转NumPy。这个细节在调试时经常遇到，提前了解能省下不少排查时间。

6.4 可视化相关的小技巧

用matplotlib画损失曲线时，记得用loss.item()而不是直接传入张量。loss.item()会把一个只含单个数值的Tensor转换成Python标量，这样可以直接存入列表，方便后续画图。如果你不小心把loss张量本身append进了列表，最后画图时会发现列表元素是Tensor对象而不是数值，plot函数无法正确处理。

7. 一套完整可复用的模型训练代码模板

最后我把整个流程整理成一个完整脚本，你直接复制就能跑通，后面做任何线性回归的变体都可以在这个模板上修改。全文代码注释尽量写清楚，方便你对照上文的理解。

python复制import torch
import torch.nn as nn
import torch.optim as optim
import matplotlib.pyplot as plt

# 1. 生成仿真数据
torch.manual_seed(42)
X = torch.linspace(-1, 1, 100).reshape(-1, 1)
w_true, b_true = 2.0, 1.0
y = w_true * X + b_true + torch.randn(X.size()) * 0.2

# 2. 定义模型（推荐自定义类方式，便于扩展）
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()

# 3. 定义损失函数和优化器
criterion = nn.MSELoss()
optimizer = optim.SGD(model.parameters(), lr=0.01)

# 4. 训练循环
epochs = 1000
losses = []
for epoch in range(epochs):
    y_pred = model(X)
    loss = criterion(y_pred, y)
    losses.append(loss.item())
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    if (epoch + 1) % 200 == 0:
        print(f'Epoch [{epoch+1}/{epochs}], Loss: {loss.item():.6f}')

# 5. 查看学习到的参数
learned_w = model.linear.weight.item()
learned_b = model.linear.bias.item()
print(f'Learned w: {learned_w:.4f} (true: {w_true})')
print(f'Learned b: {learned_b:.4f} (true: {b_true})')

# 6. 可视化
plt.figure(figsize=(10, 4))
plt.subplot(1, 2, 1)
plt.scatter(X.numpy(), y.numpy(), alpha=0.6)
plt.plot(X.numpy(), model(X).detach().numpy(), 'r-', linewidth=2)
plt.title('Fitted Line')
plt.xlabel('x'); plt.ylabel('y')

plt.subplot(1, 2, 2)
plt.plot(range(epochs), losses)
plt.title('Loss Curve')
plt.xlabel('Epoch'); plt.ylabel('Loss')
plt.tight_layout()
plt.show()

这份代码就是整篇博文的“可交付成果”。跑通之后，你可以尝试几个小改动来做实验：把学习率改成0.001和0.1，观察损失曲线形状的变化；把噪声标准差从0.2改成0.5，看模型的参数估计是否还那么准确；把数据量从100改成1000，看收敛速度是否变快。多动手改改参数，比只看文章的理解要深刻得多。

我当时做这个实验时有个体会挺深的：在PyTorch里实现线性回归，代码量虽然不多，但每一步都有它存在的理由。前向传播、反向传播、参数更新、梯度清零，这四个动作在训练循环里形成了一个闭环。你把这个闭环的每一步都吃透了，后面无论学什么模型，都能一眼看出它的训练流程在哪个环节做了变化。比如GAN多了一个判别器的训练闭环，Transformer在注意力机制上做了文章，但核心的“前向—算损失—反向—更新”骨架是始终不变的。框架会不断更新，模型会更复杂，但理解清楚线性回归这一步的意义，始终是这一切的地基。