线性回归可能是机器学习领域里最不起眼的一个模型，但要让我说，它也是最适合拿来入门PyTorch的模型。原因很简单：它的数学原理足够直观，整个训练闭环却能覆盖到PyTorch的每一个核心概念——张量、自动求导、模型定义、损失计算、优化器、训练循环。这一篇把线性回归吃透，后面的神经网络、CNN、RNN，本质上都是在同一个骨架上换不同的部件。
这篇博文不打算只给你一段能跑的代码。我会把这套完整的实操流程拆开讲清楚：为什么这样设计模型、数据预处理里有哪些新手必踩的坑、训练循环里每一行代码到底在干什么、学习率怎么调、Loss不降怎么排查。适合已经会一点Python、想认真把PyTorch基础打牢的读者，也适合之前用过TensorFlow、想快速切到PyTorch生态的朋友。这篇文章基于PyTorch 2.x版本编写，代码和API在1.13以上版本都可以直接运行。
1. 项目概述与整体设计思路
1.1 为什么从线性回归开始学PyTorch
很多教程喜欢把线性回归放在深度学习的第一课，不是因为它简单，而是因为它能完整展示深度学习训练的“四段式”流程：前向传播计算预测值、计算损失、反向传播求梯度、优化器更新参数。这四个步骤是所有深度学习的通用骨架，区别只在于模型结构、损失函数、优化策略的不同。
用线性回归做载体还有一个好处——它的数学形式非常透明。y = wx + b，哪怕你对微积分已经生疏了，也能一眼看出参数的物理含义。训练完成后，你可以拿模型的权重和真实权重对比，验证整个训练过程是否正确。这种“可验证性”是其他复杂模型给不了的。你调了半天的学习率、动量、权重初始化，效果是好是坏，在MNIST分类这种任务上要等几百个epoch才能看出来，在线性回归上几十步训练就能看到差异，非常适合用来建立对训练过程的直觉。
1.2 项目核心需求与实现方案
这篇文章的核心任务是：用PyTorch训练一个线性模型，拟合带噪声的线性数据，并验证训练结果。听起来简单，但拆解下来需要覆盖以下几个环节：
| 模块 | 关键内容 | 主要工具 |
|---|---|---|
| 环境准备 | PyTorch安装、CUDA验证 | Anaconda、pip |
| 数据准备 | 生成合成数据、构建数据集 | NumPy、PyTorch Tensor |
| 模型构建 | 定义线性层、前向传播逻辑 | nn.Module、nn.Linear |
| 训练配置 | 损失函数、优化器、迭代参数 | nn.MSELoss、optim.SGD |
| 训练循环 | 批量喂入、梯度清零、参数更新 | for循环、tqdm |
| 验证评估 | 可视化拟合结果、对比参数 | Matplotlib |
这里我要特别强调一个原则：先把数据准备好，再谈模型训练。很多初学者拿到任务就开始搭模型，结果训练半天发现Loss不降、结果不对，最后排查出来是数据出了问题。数据是模型学习的唯一信息来源，数据得先干净、格式正确、分布合理，模型训练才有意义。
1.3 整体任务拆解与技术选型分析
整套流程我把它拆成三个层次：第一层是环境与数据准备，第二层是模型训练的核心实现，第三层是结果分析调优。每个层次都有对应的知识点，也会有新手容易踩的坑。
技术选型上，PyTorch 2.x的自动求导功能让反向传播变得极其简单，你不用自己推导梯度的数学表达式，只需要把前向传播逻辑写对，PyTorch会自动记录计算图并完成梯度计算。但这里有个容易误解的点：你可以不手写梯度公式，不代表你可以不了解梯度下降的原理。数据归一化、学习率调整、Loss不降的调试，全都需要你理解优化过程在做什么。这也是我这篇文章里会花相当的篇幅讲训练逻辑的原因——工具替你省掉了计算，但替你省不掉理解。
2. 环境准备与数据预处理
2.1 PyTorch安装的完整说明
安装PyTorch是很多初学者卡住的第一关，尤其是GPU版本的配置，涉及CUDA版本选择、显卡驱动兼容、Anaconda路径等问题。如果在装环境上浪费太多时间，会非常影响学习节奏。
我的建议：用Anaconda创建独立环境，再装PyTorch。Anaconda的虚拟环境可以隔离不同的Python和包版本，避免搞坏系统Python环境。打开Anaconda Prompt或终端，依次执行：
conda create -n dl_basic python=3.10 conda activate dl_basic然后访问PyTorch官网（pytorch.org），选择自己的操作系统、包管理器、CUDA版本，网站会自动生成对应的安装命令。如果电脑没有NVIDIA显卡，或者不确定CUDA怎么配，先装CPU版本：
pip install torch torchvision torchaudio如果你的电脑有NVIDIA显卡，想装GPU版本，可以用以下命令（以CUDA 11.8为例）：
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118安装完成之后，用一行命令验证是否成功：
import torch print(torch.__version__) print(torch.cuda.is_available())如果第二行输出True，说明GPU版本装好了。如果输出False，说明你装的是CPU版本，或者CUDA驱动有问题。这里有个实用的排查顺序：先确认nvidia-smi命令能正常显示显卡信息，再确认PyTorch版本与CUDA版本的对应关系。实测下来，绝大多数GPU版装不上，都是因为PyTorch的CUDA版本和显卡驱动的CUDA版本不匹配。但也别忽视一个情况：CPU版本在跑线性回归的时候完全够用，训练速度差异不会成为瓶颈。
2.2 生成合成数据：模拟真实场景
为了让线性回归的例子既简单又不失真，我选择用带噪声的线性数据来模拟真实场景。实际的业务数据里，几乎不存在完美的线性关系，总是带着各种噪声和异常值。通过给数据添加高斯噪声，我们能更真实地体会到损失函数的作用。
import torch import matplotlib.pyplot as plt torch.manual_seed(42) # 固定随机种子，保证结果可复现 # 生成100个样本点 X = torch.linspace(0, 10, 100).reshape(-1, 1) # 真实权重是2.0，真实偏置是1.0，加上标准差为1.5的高斯噪声 true_w = 2.0 true_b = 1.0 y = true_w * X + true_b + torch.randn(X.size()) * 1.5这里的核心技巧是torch.randint或者torch.randn等随机函数需要一个固定的随机种子。深度学习里，实验的可复现性非常关键——你调参之后发现效果变好了，如果数据每次都是随机生成的，你怎么确定是参数改善带来的提升，而不是运气？
数据生成后，我先用Matplotlib画个散点图，确认数据分布符合预期再开始训练。这一步看似多余，但能帮你培养一个习惯：每次训练前先可视化数据。数据分布有异常（比如有明显离群点、数据全集中在一小块区域），光看统计数据不一定能发现，画个图一目了然。
plt.scatter(X, y, alpha=0.6) plt.xlabel("X") plt.ylabel("y") plt.title("Generated Data with Noise") plt.show()2.3 训练集与测试集划分
说到数据准备，就绕不开训练集与测试集的划分。很多初学教程为了简化，直接把所有数据拿去做训练。但在实际项目中，你总得知道模型在新数据上表现如何。这个例子比较简单，但好习惯从第一课培养起。
from sklearn.model_selection import train_test_split X_train, X_test, y_train, y_test = train_test_split( X, y, test_size=0.2, random_state=42 ) print(f"训练集样本数: {X_train.shape[0]}, 测试集样本数: {X_test.shape[0]}")如果你不想引入sklearn，也可以手动做：
indices = torch.randperm(X.size(0)) train_size = int(X.size(0) * 0.8) train_indices = indices[:train_size] test_indices = indices[train_size:] X_train, X_test = X[train_indices], X[test_indices] y_train, y_test = y[train_indices], y[test_indices]数据集划分的另一个好处是：可以用测试集上的损失来辅助判断模型是欠拟合还是过拟合。如果训练集Loss低、测试集Loss高，是过拟合；两者都高，首先是欠拟合。线性回归本身不会太复杂，这个判断思路在后面的深度学习模型里会越来越重要。
3. PyTorch实现线性回归的关键步骤
3.1 模型定义：nn.Module的核心用法
在PyTorch中，定义模型的标准做法是继承nn.Module类，在__init__方法里定义网络层，在forward方法里定义前向传播逻辑。
import torch.nn as nn class LinearRegressionModel(nn.Module): def __init__(self): super().__init__() self.linear = nn.Linear(in_features=1, out_features=1) def forward(self, x): return self.linear(x)这段代码定义了一个输入维度为1、输出维度为1的线性层，对应数学公式y = wx + b。nn.Linear会自动初始化权重weight和偏置bias，但初始值是随机的。我们可以在训练开始前打印模型的参数：
model = LinearRegressionModel() print(model) # 输出: LinearRegressionModel( # (linear): Linear(in_features=1, out_features=1, bias=True) # ) for name, param in model.named_parameters(): print(f"{name}: {param.data.item():.4f}")这里有个容易忽略的细节：认真看模型结构打印的信息。nn.Linear默认bias=True，如果你的任务确认没有偏置项（直线必须过原点），可以设置bias=False。但在大多数场景下，偏置应该保留，它能让模型拟合更灵活。
另一种更简洁的写法是直接使用nn.Sequential，不需要定义类：
model = nn.Sequential( nn.Linear(1, 1) )对于线性回归这种简单模型，两种写法等价。但从学习角度，我更推荐继承nn.Module的写法，因为它是PyTorch最通用的模型定义方式，后面的CNN、RNN都沿用这个结构。
3.2 损失函数与优化器选择
线性回归的标配损失函数是均方误差（MSE），对应PyTorch中的nn.MSELoss()。它的计算公式是：
criterion = nn.MSELoss()均方误差为什么是回归任务的默认选择？因为它对大的误差给予平方级别的惩罚，让模型优先处理那些预测偏差很大的样本。同时它在数学上有很好的可导性质，梯度计算简单稳定。
优化器选择上，线性回归最经典的是随机梯度下降（SGD）：
import torch.optim as optim optimizer = optim.SGD(model.parameters(), lr=0.01)这里的model.parameters()是模型所有可训练参数的集合，优化器会在每次step()时沿着梯度的反方向更新这些参数。学习率lr=0.01的含义是每一步参数更新的步长。学习率设置过大，参数会在最优点附近震荡；设置过小，训练速度太慢，甚至看起来Loss几乎不降。这个超参数严重影响训练效果，后面在第4部分会单独做一组实验来说明。
3.3 训练循环的逐行拆解
训练循环是整个训练过程的心脏。这里给出完整代码，然后逐部分讲解：
num_epochs = 1000 train_losses = [] for epoch in range(num_epochs): model.train() # 1. 前向传播：计算预测值 y_pred = model(X_train) # 2. 计算损失：评估预测值与真实值的差距 loss = criterion(y_pred, y_train) # 3. 梯度清零：清空上一次反向传播累积的梯度 optimizer.zero_grad() # 4. 反向传播：计算当前参数的梯度 loss.backward() # 5. 更新参数：按梯度方向调整参数 optimizer.step() train_losses.append(loss.item()) if (epoch + 1) % 100 == 0: print(f"Epoch [{epoch+1}/{num_epochs}], Loss: {loss.item():.4f}")我来解释这段代码里几个容易被忽视的细节。
第一，为什么要调用optimizer.zero_grad()？PyTorch的梯度默认是累加的，如果不手动清零，下一次backward()时，新梯度会和历史梯度叠加。这会直接导致参数更新方向错误、训练不稳定。把梯度清零放在每一次反向传播前，是训练循环的标配。
第二，loss.item()和直接打印loss的区别。loss是PyTorch张量，如果直接打印会输出类似tensor(5.2321, grad_fn=<MseLossBackward0>)的信息。.item()提取的是Python浮点数，打印更简洁，也更方便存入列表绘制图表。另外，训练循环里用.item()取出的数值不会保留计算图，不占内存。
第三，model.train()和model.eval()的意义。在线性回归这种简单模型里，train()和eval()不会改变行为。但在有Dropout和BatchNorm的模型里，这两个模式的结果完全不同。从现在养成显式设置训练/评估模式的好习惯，后面会少踩很多坑。
3.4 用DataLoader组织批量训练
前面的代码是全量数据一次性喂入模型，这在数据量小的时候没问题。但实际训练中，数据量常常达到数十万甚至上百万，全量放内存既不现实，也没必要。PyTorch提供DataLoader来管理数据集的批量迭代。
from torch.utils.data import TensorDataset, DataLoader dataset = TensorDataset(X_train, y_train) dataloader = DataLoader(dataset, batch_size=16, shuffle=True)DataLoader的shuffle=True会在每个epoch开始时将数据顺序随机打乱，这能避免模型学习到数据顺序中的伪模式。batch_size是每次迭代送入模型的样本数，在线性回归中影响不大，但在深度学习中，batch_size直接影响梯度估计的稳定性和显存占用。
使用DataLoader后，训练循环会多一层内层循环：
for epoch in range(num_epochs): epoch_loss = 0.0 for batch_X, batch_y in dataloader: y_pred = model(batch_X) loss = criterion(y_pred, batch_y) optimizer.zero_grad() loss.backward() optimizer.step() epoch_loss += loss.item() avg_loss = epoch_loss / len(dataloader) train_losses.append(avg_loss) if (epoch + 1) % 100 == 0: print(f"Epoch [{epoch+1}/{num_epochs}], Avg Loss: {avg_loss:.4f}")注意，len(dataloader)返回的是批次数量，不是样本数量。这里算的是每个epoch的平均损失，方便跨epoch对比。
4. 训练结果分析与调参实战
4.1 损失曲线：训练健康的信号灯
训练完成后，第一步不是看拟合效果图，而是先画Loss曲线。
plt.plot(range(1, num_epochs + 1), train_losses) plt.xlabel("Epoch") plt.ylabel("Loss") plt.title("Training Loss Curve") plt.show()一个健康的训练过程，Loss曲线应该呈现“快速下降后趋平”的形状。前几十个epoch Loss急速下降，说明模型正在快速逼近最优参数；之后的缓慢下降或平稳波动，说明已经进入精细调整阶段。
如果你看到Loss曲线是一条水平直线完全没有下降，通常原因有三个：数据没有归一化导致梯度太小或太大、学习率设置不合理、模型结构有问题。如果是Loss值不变但数值很大（比如成千上万），大概率是数据数值范围过大，输入特征值动辄几百上千，梯度的数值范围远超合理区间，优化器无法有效工作。
4.2 学习率实验：一个参数看懂优化过程
学习率是整个训练过程中最重要的超参数，没有之一。我在实战中会做一组对照实验，用不同学习率训练同一个模型，观察收敛速度和最终效果。
def train_with_lr(lr, num_epochs=200): model = LinearRegressionModel() criterion = nn.MSELoss() optimizer = optim.SGD(model.parameters(), lr=lr) losses = [] for epoch in range(num_epochs): model.train() y_pred = model(X_train) loss = criterion(y_pred, y_train) optimizer.zero_grad() loss.backward() optimizer.step() losses.append(loss.item()) return losses, model for lr in [0.001, 0.01, 0.1, 1.0, 10.0]: losses, _ = train_with_lr(lr) plt.plot(range(len(losses)), losses, label=f"lr={lr}") plt.xlabel("Epoch") plt.ylabel("Loss") plt.legend() plt.title("Loss Curves with Different Learning Rates") plt.show()实测下来你会发现，lr=0.01和lr=0.1通常能正常收敛，lr=0.001会明显收敛得更慢，lr=1.0可能在开始几个epoch损失异常飙升，lr=10.0直接数值爆炸、输出nan。这就是学习率过大的典型表现——每一次更新步子跨得太大，直接跨过了最优点，然后震荡到更远的地方。
lr=1.0在200个epoch内没有收敛，其实就是发散的前兆。对线性回归来说，比较合适的起始学习率范围是0.01到0.1。对更深的网络，这个范围会调整，但排查思路是一致的：Loss爆高或变nan，优先把学习率调小几个数量级试试。
4.3 验证结果：模型是否学到了真规律
训练结束后，把测试集数据在评估模式下跑一遍，计算测试损失，并和训练损失对比。然后画出拟合直线与真实数据点、真实直线的对比图：
model.eval() with torch.no_grad(): y_pred = model(X_test) test_loss = criterion(y_pred, y_test) print(f"Test Loss: {test_loss.item():.4f}") # 绘制拟合直线 w = model.linear.weight.item() b = model.linear.bias.item() print(f"Learned weight: {w:.4f}, Learned bias: {b:.4f}") print(f"True weight: {true_w:.4f}, True bias: {true_b:.4f}") # 在全部数据范围内绘制拟合直线 x_line = torch.linspace(0, 10, 100).reshape(-1, 1) y_line = model(x_line) plt.scatter(X.numpy(), y.numpy(), alpha=0.6, label="Data") plt.plot(x_line.numpy(), y_line.detach().numpy(), color="red", label="Fitted Line") plt.plot(x_line.numpy(), true_w * x_line.numpy() + true_b, color="green", linestyle="--", label="True Line") plt.xlabel("X") plt.ylabel("y") plt.legend() plt.title("Linear Regression Result") plt.show()这里有两个代码层面的细节。第一，with torch.no_grad()块内的计算不会构建计算图、不会追踪梯度，因此在评估阶段能显著减少内存占用、加快计算速度。第二，model(x_line)计算出的y_line仍然带有梯度信息，通过.detach()断开与计算图的关联，然后才能转成NumPy做可视化。
如果你看到学习到的权重接近2.0、偏置接近1.0，测试损失和训练损失大致在同一水平，说明模型确实从数据中学会了真实规律。大概率你会得到类似Learned weight: 1.97, Learned bias: 1.12这样的结果，因为噪声的存在，和真实值有一定偏差是正常的。
4.4 模型保存与加载
训练完成后，模型参数需要保存下来，方便后续部署或继续训练。PyTorch推荐只保存状态字典：
torch.save(model.state_dict(), "linear_regression_model.pth")加载时要先创建模型实例，再加载参数：
model_loaded = LinearRegressionModel() model_loaded.load_state_dict(torch.load("linear_regression_model.pth")) model_loaded.eval()文件扩展名用.pth还是.pt都行，关键是理解保存和加载的对象。state_dict()是一个字典，包含所有参数的张量数据，加载时要求模型结构和保存时完全一致。不建议直接torch.save(model, ...)保存整个模型对象，因为这种方式在你修改模型定义后，旧模型加载会报错，跨环境使用也不稳定。
5. 常见问题与排查技巧
5.1 新手的典型报错与修复
我在辅导其他人学习时，发现大家在环境配置和训练环节遇到的报错高度相似。整理成一张速查表，可以快速定位问题：
| 症状 | 可能原因 | 排查与修复方法 |
|---|---|---|
ImportError: No module named 'torch' | PyTorch未安装 | 激活对应conda环境，重新执行pip install torch |
RuntimeError: Expected all tensors to be on the same device | 数据和模型不在同一设备上 | 检查是否有.to(device)遗漏，数据和模型都要移动到同一设备 |
RuntimeError: element 0 of tensors does not require grad | 输入张量不参与计算图 | 确认输入Tensor默认requires_grad=False，模型参数requires_grad=True |
ValueError: Expected input batch_size (X) to match target batch_size (Y) | 预测值和真实值形状不匹配 | 打印y_pred.shape和y_train.shape，检查数据reshape是否正确 |
Loss输出为nan | 学习率过大或数据数值不稳定 | 把学习率调小10倍到100倍；检查数据是否有异常极大值 |
| Loss完全不下降 | 梯度消失或数据未归一化 | 打印梯度大小param.grad.norm()，检查是否为0或极小值 |
5.2 维度问题：深度学习中最常见的翻车点
PyTorch中对张量维度的要求非常严格。以线性回归为例，输入必须是一个二维张量，形状为(样本数, 特征数)。如果你用torch.linspace(0, 10, 100)生成数据，它是一维的，直接喂给nn.Linear会报错。上面代码里的.reshape(-1, 1)就是在把一维张量转成100行1列的二维矩阵。
我见过不少初学者在生成数据时忘了reshape，一路报错一路查，最后发现只是输入形状不对。这里给一个快速自查方法：在任何模型接收输入前，先用print(x.shape)看一眼张量形状。耗时不到一秒钟，但能省下大量排查时间。这个习惯对后面处理图像数据尤其重要——图像张量的形状是(通道数, 高, 宽)还是(高, 宽, 通道数)，不同框架约定不同，PyTorch用的是前者，一开始就要建立这个意识。
5.3 模型不收敛的血泪排查指南
Loss不降或训练异常，是深度学习实践中最痛苦的问题。我按根因概率从高到低，梳理了一套排查顺序。
**第一步，检查数据。**训练数据有没有归一化？特征和标签的数值尺度是否在一个合理的范围内？如果特征值范围是0到10000，而标签是0到1，梯度计算很容易爆炸或不稳定。线性回归的输入特征范围很大时，一个很长的梯度更新可能造成参数剧烈跳动。对于线性回归将X归一化到0到10区间就够用了，更深层的网络往往需要标准化到均值为0、方差为1，甚至更精细的处理。
第二步，检查学习率。一个实用的做法：先用很小的学习率（如0.001）跑几个epoch，看Loss是否有下降趋势。如果有，再逐步调大。如果小学习率下Loss也不降，那问题大概率出在数据或模型逻辑上。
**第三步，检查代码逻辑。**无数次经验证明，代码逻辑错误的概率远高于理论层面的问题。确认y_pred的计算是不是用了训练数据，确认损失计算时是不是把两个不同的张量搞混了，确认optimizer.step()和optimizer.zero_grad()的顺序是否正确。曾经有一次，我的模型在MNIST上训练Loss一直不降，排查了一整天才发现，是前向传播时把输入数据x错写成了X_train——模型根本没有见过当前的输入。这种错误在线性回归这种简单模型里不容易犯，但提前养成检查前向传播逻辑的习惯非常值得。
**第四步，打印梯度。**在线性回归后加上下面这行代码，在loss.backward()之后、optimizer.step()之前执行，看看梯度有没有正常更新：
for name, param in model.named_parameters(): print(f"{name} grad: {param.grad}")如果梯度是0，说明数据或模型定义有误；如果梯度数值巨大或全是nan，优先检查数据是否含有异常值。这个排查技巧在更复杂的网络里同样适用。
5.4 环境配置中的常见问题
环境配置是另一个重灾区，这里汇总几个高频问题。
Windows环境下的CUDA安装，最容易踩的坑是版本不匹配。运行nvidia-smi看到的顶部CUDA Version代表驱动支持的最高版本，只要PyTorch要求的CUDA版本不高于它，就可以正常工作。比如驱动显示CUDA Version 12.4，那么PyTorch的cu118和cu121版本都可以装。装错了通常会在torch.cuda.is_available()返回False时暴露出来，不用太焦虑。
Anaconda环境搞混也是常见问题。在终端里输入python，注意看路径前面有没有显示当前conda环境名。如果显示的是base，而你明明在dl_basic环境里安装的PyTorch，那import时报错就不奇怪了。
**一个核心原则：遇到环境问题先看错误信息的第一行和最后一行。**很多报错的下半部分是一大堆调用栈，真正有价值的信息往往在开头或者末尾的异常类型和描述里。把RuntimeError、ImportError、ValueError后面的完整文字看清楚，大多数问题能自行定位。
6. 实操心得与后续进阶建议
整个流程跑通之后，我想分享几个个人的经验。
**第一个体会是：线性回归虽然模型简单，但它是验证你理解深度学习底层逻辑的最佳工具。**因为整个训练循环的每一条语句、每一个函数，你都可以在小小的模型上找到直观的对应。模型参数怎么更新、学习率大小如何影响收敛、梯度到底是从哪算出来的，这些问题在一张纸上画一画都能理解。做深度学习如果一上来就堆大模型，这些基本概念里任何一个没学扎实，后面排查起问题来会非常痛苦。
**第二个技巧是：保持代码的可复现性。**随机种子、固定数据版本、记录超参数配置，这些看似不经意的习惯，能让你每次实验都在同一基准下比较。在深度学习这个实验驱动的领域，好代码和好实验记录是同等重要的。
**第三个建议是：把线性回归代码里的模块替换成其他结构，就能快速入门更多模型。**把nn.Linear(1,1)换成nn.Linear(2,1)，就是二元线性回归；把损失函数换成交叉熵损失，模型输出加上nn.Sigmoid，就是逻辑回归；把多个线性层堆叠，中间加上激活函数，就变成一个多层感知机。你可以沿着这个方向，把这份代码一步步改造成真正的神经网络，那个过程你会发现，深度学习的神秘面纱其实没那么厚重。
