发帖
雷达卡
PyTorch 入门教程：基本概念与代码实例
一、什么是 PyTorch？
PyTorch 是一个基于 Python 的开源机器学习框架，广泛应用于深度学习（Deep Learning）、神经网络（Neural Networks）以及人工智能研究。
PyTorch 的主要功能包括：
- 张量运算（Tensor Operations）：执行类似 NumPy 的多维数组运算。
- 自动微分（Automatic Differentiation）：自动计算梯度。
- 神经网络建模（Neural Networks）：建立和训练深度学习模型。
- 模型优化（Optimization）：使用梯度下降等算法更新模型参数。
- GPU 加速：利用 GPU 提高大型模型的训练效率。
本教程通过六个简单实例介绍 PyTorch 的基本用法。
二、安装与导入 PyTorch
在终端中执行：
pip install torch torchvision
安装完成后，在 Python 中运行：
import torch
import torch.nn as nn
import torch.optim as optim
print("PyTorch 版本：", torch.__version__)
print("是否支持 CUDA：", torch.cuda.is_available())
如果没有 GPU，PyTorch 仍然可以在 CPU 上正常运行。
三、实例一：张量（Tensor）运算
Tensor 是 PyTorch 最基本的数据结构，类似 NumPy 中的 ndarray。
import torch
# 创建一维张量
x = torch.tensor([1.0, 2.0, 3.0])
# 创建二维张量
A = torch.tensor([
[1.0, 2.0],
[3.0, 4.0]
])
# 基本运算
print("加法：", x + 2)
print("乘法：", x * 3)
print("矩阵乘法：", A @ A)
# 查看张量维度
print("张量形状：", A.shape)
运行结果：
加法： tensor([3., 4., 5.])
乘法： tensor([3., 6., 9.])
矩阵乘法：
tensor([[ 7., 10.],
[15., 22.]])
张量形状： torch.Size([2, 2])
重点： * 表示逐元素乘法，@ 表示矩阵乘法。
四、实例二：自动微分（Autograd）
自动微分是 PyTorch 最重要的功能之一。
假设有以下数学函数：
y=3x^2+2x+1
其导数为：
\frac{dy}{dx}=6x+2
当 时，导数为 14。
使用 PyTorch 自动计算：
# 创建需要计算梯度的变量
x = torch.tensor(2.0, requires_grad=True)
# 定义函数
y = 3 * x**2 + 2 * x + 1
# 自动计算梯度
y.backward()
# 显示结果
print("函数值：", y.item())
print("导数：", x.grad.item())
输出：
函数值： 17.0
导数： 14.0
解释： requires_grad=True 告诉 PyTorch 追踪计算过程，而 backward() 使用反向传播计算梯度。
这正是神经网络训练的数学基础。
五、实例三：使用 PyTorch 进行线性回归
假设我们希望估计以下线性回归模型：
y_i=\beta_0+\beta_1x_i+\varepsilon_i
使用一组简单的模拟数据：
import torch
import torch.nn as nn
import torch.optim as optim
# 创建训练数据
torch.manual_seed(123)
X = torch.linspace(0, 10, 100).reshape(-1, 1)
y = 2 + 3 * X + torch.randn(100, 1)
# 建立线性回归模型
model = nn.Linear(1, 1)
# 定义损失函数：均方误差
criterion = nn.MSELoss()
# 定义优化算法
optimizer = optim.SGD(model.parameters(), lr=0.01)
# 模型训练
for epoch in range(2000):
# 计算预测值
y_pred = model(X)
# 计算损失
loss = criterion(y_pred, y)
# 清除旧梯度
optimizer.zero_grad()
# 反向传播
loss.backward()
# 更新参数
optimizer.step()
# 查看估计参数
print("截距：", model.bias.item())
print("斜率：", model.weight.item())
估计结果通常接近：
\hat{\beta}_0\approx 2,\qquad
\hat{\beta}_1\approx 3
由于加入了随机误差，估计值不一定恰好等于真实参数。
训练过程的数学原理
PyTorch 使用梯度下降法更新模型参数：
\beta_j^{(t+1)}
\beta_j^{(t)}
\eta\frac{\partial L}{\partial\beta_j}
其中：
- ：损失函数（Loss Function）。
- ：学习率（Learning Rate）。
- ：训练迭代次数。
对于线性回归，通常使用均方误差：
L=\frac{1}{n}\sum_{i=1}^{n}(y_i-\hat y_i)^2
六、实例四：建立简单神经网络
下面建立一个具有两个输入变量、一个隐藏层和一个输出变量的神经网络。
神经网络结构：2 → 4 → 1
Python 代码：
import torch
import torch.nn as nn
# 定义神经网络
model = nn.Sequential(
# 输入层：2 个变量
# 隐藏层：4 个神经元
nn.Linear(2, 4),
# 激活函数
nn.ReLU(),
# 输出层：1 个变量
nn.Linear(4, 1)
)
# 创建一笔输入数据
X = torch.tensor([[1.0, 2.0]])
# 前向传播
output = model(X)
print("模型输出：", output)
print(model)
其中：
- nn.Linear(2, 4)：建立从两个输入到四个隐藏神经元的线性变换。
- nn.ReLU()：引入非线性关系。
- nn.Linear(4, 1)：将四个隐藏层输出转换为一个预测值。
数学上，神经网络可写为：
\mathbf h=\operatorname{ReLU}(W_1\mathbf x+\mathbf b_1)\hat y=W_2\mathbf h+b_2
注意：上述代码只执行前向传播，尚未训练网络，因此输出只是随机初始化参数产生的数值。
七、实例五：二元分类（Binary Classification）
假设我们要预测学生是否通过考试：
Y=
\begin{cases}
1 & \text{通过考试}\\
0 & \text{未通过考试}
\end{cases}
输入变量包括学习时间和出勤率。
import torch
import torch.nn as nn
import torch.optim as optim
torch.manual_seed(42)
# 模拟 200 名学生的数据
n = 200
# 学习时间（标准化到 0–1）
study = torch.rand(n, 1)
# 出勤率（标准化到 0–1）
attendance = torch.rand(n, 1)
X = torch.cat([study, attendance], dim=1)
# 生成二元响应变量
logits = -4 + 5 * study + 3 * attendance
prob = torch.sigmoid(logits)
y = torch.bernoulli(prob)
# 建立神经网络
model = nn.Sequential(
nn.Linear(2, 8),
nn.ReLU(),
nn.Linear(8, 1)
)
# 定义损失函数与优化器
criterion = nn.BCEWithLogitsLoss()
optimizer = optim.Adam(
model.parameters(),
lr=0.01
)
# 训练模型
for epoch in range(1000):
logits_pred = model(X)
loss = criterion(logits_pred, y)
optimizer.zero_grad()
loss.backward()
optimizer.step()
# 计算预测概率
with torch.no_grad():
pred_prob = torch.sigmoid(model(X))
pred_class = (pred_prob >= 0.5).float()
accuracy = (pred_class == y).float().mean()
print("分类准确率：", accuracy.item())
这里：
- BCEWithLogitsLoss()：二元交叉熵损失函数，内部结合了 Sigmoid 运算。
- Adam()：常用的参数优化算法。
- torch.sigmoid()：将模型输出转换为 0 到 1 之间的概率。
- accuracy：衡量分类正确的比例。
该示例在同一批模拟数据上训练并计算准确率，主要用于教学。实际研究中应划分训练集和测试集，以评估模型的泛化能力。
八、实例六：使用 PyTorch 进行预测
训练完成后，可以使用模型预测新观测值。
例如，假设一名学生的标准化学习时间为 0.8，出勤率为 0.9：
# 新学生的数据
new_student = torch.tensor([[0.8, 0.9]])
# 切换到评估模式
model.eval()
# 预测通过考试的概率
with torch.no_grad():
logit = model(new_student)
probability = torch.sigmoid(logit)
print("通过考试的预测概率：",
probability.item())
model.eval() 将模型切换到评估模式，对于包含 Dropout 或 Batch Normalization 的神经网络尤其重要。
torch.no_grad() 则可以避免在预测阶段记录梯度，从而节省内存。
九、PyTorch 常用函数总结
函数 | 主要用途 |
torch.tensor() | 创建张量 |
torch.rand() | 生成均匀随机数 |
torch.randn() | 生成标准正态随机数 |
torch.matmul() | 矩阵乘法 |
torch.sigmoid() | Sigmoid 函数 |
nn.Linear() | 全连接层 |
nn.ReLU() | ReLU 激活函数 |
nn.Sequential() | 顺序建立神经网络 |
nn.MSELoss() | 均方误差损失 |
nn.BCEWithLogitsLoss() | 二元分类损失 |
optim.SGD() | 随机梯度下降 |
optim.Adam() | Adam 优化算法 |
loss.backward() | 反向传播 |
optimizer.step() | 更新模型参数 |
model.eval() | 切换到评估模式 |
十、PyTorch 神经网络训练的完整流程
1. 准备数据
Tensor / DataLoader
2. 建立模型
nn.Sequential / nn.Module
3. 前向传播
model(X)
4. 计算损失
criterion(pred, y)
5. 反向传播
loss.backward()
6. 更新参数
optimizer.step()
重复步骤 3–6，直到训练结束
十一、建议的学生练习
练习 1：线性回归
将实例三中的真实模型修改为 y = 5 + 2X + ε，重新训练模型，检查估计系数是否接近真实值。
查看提示
练习 2：神经网络结构
将实例四中的隐藏层神经元数量从 4 改成 10，并增加第二个隐藏层。
查看提示
练习 3：二元分类
在实例五中，将样本随机分为 80% 训练集和 20% 测试集，分别计算分类准确率。
查看提示
十二、总结
PyTorch 的核心思想是将数学模型表示为可微分的计算过程，通过自动微分与优化算法训练模型参数。
对于初学者，建议按照以下顺序学习：
Tensor → Autograd → Linear Regression → Neural Networks → Backpropagation → Classification
掌握这些基本概念后，就可以进一步学习卷积神经网络（CNN）、循环神经网络（RNN）、Transformer，以及其他深度学习模型。
京公网安备 11010802022788号
