目录
线性回归示例
这段代码使用 PyTorch 构建并训练了一个简单的线性回归模型，使其能够拟合输入 x和目标 y之间的关系，然后用训练好的模型预测 x=4.0 时的结果。
执行过程
这段代码是 PyTorch 实现线性回归的完整流程，展示了：
模型定义 → 损失函数 → 训练数据 → 前向传播 → 反向传播（链式法则） → 参数更新 → 预测的全过程。
执行代码
import torch
import torch.nn as nn
import torch.optim as optim
# 定义一个简单的线性回归模型
class LinearRegression(nn.Module):
def __init__(self):
super(LinearRegression, self).__init__()
self.fc = nn.Linear(1, 1) # 输入1维，输出1维
def forward(self, x):
return self.fc(x)
# 初始化模型、损失函数和优化器
model = LinearRegression()
criterion = nn.MSELoss()
optimizer = optim.Adam(model.parameters(), lr=0.01)
# 训练数据
x = torch.tensor([[1.0], [2.0], [3.0]])
y_true = torch.tensor([[3.0], [5.0], [7.0]])
# 训练循环
for epoch in range(1000): # 增加训练次数
# 前向传播
y_pred = model(x)
loss = criterion(y_pred, y_true)
# 反向传播
optimizer.zero_grad()
loss.backward()
optimizer.step()
if epoch % 100 == 0:
print(f"Epoch: {epoch}, Loss: {loss.item()}")
# 预测结果
print(f"预测结果：{model(torch.tensor([[4.0]])).item():.2f}") # 应接近9.0
运行结果
Epoch: 0, Loss: 28.679777145385742
Epoch: 100, Loss: 6.986947536468506
Epoch: 200, Loss: 1.1998177766799927
Epoch: 300, Loss: 0.3503131866455078
Epoch: 400, Loss: 0.26410627365112305
Epoch: 500, Loss: 0.23391492664813995
Epoch: 600, Loss: 0.20561623573303223
Epoch: 700, Loss: 0.17805127799510956
Epoch: 800, Loss: 0.15187351405620575
Epoch: 900, Loss: 0.12759387493133545
预测结果：8.31代码解析
1 库名讲解
import torch
import torch.nn as nn
import torch.optim as optimimport torch
PyTorch 的核心库
主要功能：
张量（
torch.Tensor）的创建与操作（类似 NumPy，但支持 GPU）自动求导（如
x.requires_grad=True,loss.backward()）与 CUDA GPU 的交互（如
tensor.cuda()）各种底层数学函数和操作（矩阵乘法、转置、广播等）
import torch.nn as nn
PyTorch 的 神经网络模块（neural network），简称
nn，是构建模型的主要工具箱。
【它提供了什么？】
所有层结构：如
nn.Linear,nn.Conv2d,nn.LSTM...激活函数：如
nn.ReLU(),nn.Sigmoid(),nn.Tanh()...损失函数：如
nn.MSELoss(),nn.CrossEntropyLoss()...网络容器：如
nn.Sequential,nn.ModuleList...自定义模型继承基类：
nn.Module
【常见用途示例】layer = nn.Linear(3, 1) # 线性层 activation = nn.ReLU() # 激活函数 loss_fn = nn.MSELoss() # 损失函数
import torch.optim as optim
PyTorch 的 优化器模块（optimizer），简称
optim，用于更新模型参数。
【它提供了什么？】
各种优化算法：
optim.SGD（随机梯度下降）
optim.Adam（常用、高效）
optim.RMSprop，optim.Adagrad等等每个优化器都负责调用
.step()去更新参数【常见用途示例】
optimizer = optim.Adam(model.parameters(), lr=0.01) # 用Adam优化器训练模型
🧠 总结表格
| 导入模块 | 简称 | 作用说明 | 举例功能 |
|---|---|---|---|
import torch |
无 | PyTorch 核心，张量与自动微分支持 | 张量运算、GPU支持 |
import torch.nn |
nn |
模型构建相关，如层、损失、激活函数 | nn.Linear(), nn.ReLU() |
import torch.optim |
optim |
参数优化器（训练时更新参数） | optim.Adam(), .step() |
2 定义模型结构
# 定义一个简单的线性回归模型
class LinearRegression(nn.Module):
def __init__(self):
super(LinearRegression, self).__init__()
self.fc = nn.Linear(1, 1) # 输入1维，输出1维
def forward(self, x):
return self.fc(x)class LinearRegression(nn.Module)
【LinearRegression】
定义了一个名叫
LinearRegression的类。
【nn.Module】
它是继承自
nn.Module，这是 PyTorch 所有神经网络模型的基类，你自定义模型时必须继承它。
def __init__(self):
这是类的构造函数（初始化函数），你每次创建模型对象时都会自动调用这个函数。
super(LinearRegression, self).__init__()
【整体含义】
解析：调用 PyTorch 模型父类的初始化函数，保证模型能正常注册参数、追踪梯度、训练运行。
这样才能初始化模型的一些内部结构，比如参数注册表、计算图、等。
△模型参数的注册功能
△计算图的构建逻辑
△
.to()、.cuda()、.eval()等方法
【super(...).__init__()】
LinearRegression：是自定义的类super(...).__init__()：调用它的父类的构造函数
是 PyTorch 模型的“开机自检”，你不写它，等于模型“没开机”。
换句话说：你写这个模型是“在 PyTorch 框架下造轮子”，必须先告诉 PyTorch“我在用你家的车架”，用这句
super()就是这个意思。
self.fc = nn.Linear(1, 1)
【nn.Linear(1, 1)】
表示这是一个 线性层（也叫全连接层、全线性变换层）：
输入是 1 个特征值（即一维）
输出是 1 个预测值（也是一维）
换句话说，这一层会自动帮你实现：
这就是线性回归公式 y=wx+b。
它做的事情是：
对输入数据进行线性变换
【Linear的语法】
格式：
layer = nn.Linear(in_features, out_features, bias=True)
参数名 作用 in_features输入特征维度（输入有多少个数） out_features输出特征维度（要输出多少个数） bias是否使用偏置项（默认是 True）
【self.fc】
这个线性层取的名字（随便取，比如
self.linear也可以）
【常见的用法场景】
线性回归模型：
model = nn.Linear(1, 1)神经网络中的隐藏层：
self.fc1 = nn.Linear(128, 64) # 隐藏层从128维压缩到64维输出层变换为分类概率：
self.out = nn.Linear(64, 10) # 最终输出10类
【在训练中它能干嘛】
它会自动创建：
权重：
W，形状为(out_features, in_features)偏置：
b，形状为(out_features,)这些参数会在你调用
.backward()时参与梯度计算，并在.step()时更新。
【✅ 总结】
项目 内容 函数 nn.Linear(in_features, out_features)本质 实现：输出 = 输入 × 权重 + 偏置 作用 模型中最基本的线性层，用于特征转换 参数 自动训练并更新 常用场景 线性回归、分类输出、隐藏层
定义了一个神经网络模型，只有一层线性层（Linear）。
nn.Linear(1, 1)表示输入是一个数，输出也是一个数，本质就是学一个y=wx+b。
3 初始化模型、损失函数、优化器
model = LinearRegression()
criterion = nn.MSELoss()
optimizer = optim.Adam(model.parameters(), lr=0.01)
model: 创建线性模型。criterion: 使用**均方误差（MSE）**作为损失函数，度量预测和真实值的差距。optimizer: 使用 Adam 优化器 来更新模型的参数（权重和偏置）。optimizer = optim.Adam(model.parameters(), lr=0.01)
创建一个 Adam 优化器，用来更新
model模型中的所有可学习参数，学习率设为 0.01。
optimizer = optim.Adam( model.parameters(), # 要优化的参数（通常是模型中的） lr=0.01 # 学习率（控制参数更新的幅度） )【optim.Adam(...)】
PyTorch 提供的一种优化器，来自
torch.optim模块作用：根据梯度
grad，自动更新模型中的参数w和b，让模型更接近目标输出。比传统的 SGD 更智能，因为它有：
自适应学习率
动量机制
所以它通常收敛更快、效果更稳定。
【model.parameters()】
PyTorch 模型（
nn.Module写的那个）自带的一个函数
model.parameters()会返回：模型中所有**可训练的参数（权重和偏置）**的一个迭代器。
这些参数是 PyTorch 帮你注册的，比如你用了：
self.fc = nn.Linear(1, 1)PyTorch 会自动记录下
fc.weight和fc.bias，然后通过model.parameters()一次性把所有这些需要训练的参数交给优化器。
✅ 总结
| 代码 | 含义 |
|---|---|
optim.Adam(...) |
创建 Adam 优化器 |
model.parameters() |
获取模型中所有需要训练的参数 |
lr=0.01 |
设置学习率（控制参数更新的速度） |
这句代码把优化器和模型参数绑定起来了，你在训练中每次调用：
loss.backward() # 计算梯度
optimizer.step() # 更新参数
优化器就知道该更新谁、更新多少。
4 构造训练数据
x = torch.tensor([[1.0], [2.0], [3.0]])
y_true = torch.tensor([[3.0], [5.0], [7.0]])
训练的数据就是：
| 输入 x | 输出 y |
|---|---|
| 1 | 3 |
| 2 | 5 |
| 3 | 7 |
【torch.tensor()】
创建张量（PyTorch 的核心数据结构），是 PyTorch 中进行所有数值计算的基本单位。
5 开始训练（重复 1000 次）
for epoch in range(1000):
y_pred = model(x) # 前向传播：预测输出
loss = criterion(y_pred, y_true) # 计算预测与真实之间的损失
optimizer.zero_grad() # 梯度清零
loss.backward() # 反向传播：计算梯度（链式法则起作用）
optimizer.step() # 更新权重参数
每次循环就是一次“看数据 → 算误差 → 调整参数”的过程。
每100次打印一次 loss，显示学习过程。
6 模型训练好之后进行预测
print(f"预测结果：{model(torch.tensor([[4.0]])).item():.2f}")
输入 x=4，如果模型学得好，输出应该接近 y=2×4+1=9。
🚀最终效果：
训练完成后，模型学会了通过 x预测 y，相当于找到了最优的权重 w 和偏置 b，满足：
