使用 pytorch 进行深度学习的一般步骤

最近尝试学习最近几年越来越火的深度学习，目前最流行的深度学习构建工具是 pytorch。为了方便自己使用，总结一下 pytorch 进行深度学习的一般步骤或标砖流程。

文章目录

[1. 加载数据](#1. 加载数据)
[2. 数据标准化](#2. 数据标准化)
[3. 数据转化为 tensor](#3. 数据转化为 tensor)
[4. 划分训练/验证/测试集](#4. 划分训练/验证/测试集)
[5. 创建 Dataset, DataLoader](#5. 创建 Dataset, DataLoader)
[6. 创建模型类，并新建一个实例](#6. 创建模型类，并新建一个实例)
[7. 确定损失函数和优化器](#7. 确定损失函数和优化器)
- [7.1 常用损失函数：](#7.1 常用损失函数：)
- - [(1) 回归任务](#(1) 回归任务)
  - [(2) 分类任务](#(2) 分类任务)
- [7.2 优化器（Optimizer）](#7.2 优化器（Optimizer）)
[8. 训练](#8. 训练)
[9. 预测（评估）](#9. 预测（评估）)

1. 加载数据

加载原始数据并进行数据清洗

一般通过 pandas 或 numpy 完成
要明确哪些列是输入，哪些是输出

2. 数据标准化

一般是 z 标准化或 minmax 标准化

z 标准化将数据转化为均值为 0，标准差为 1 的正态分布数据
minmax 标准化将数据都转化为 [0, 1] 之间的数
可以通过 sklearn 中的 StandardScaler 或 MinMaxScaler，然后调用 fit_transform 方法

3. 数据转化为 tensor

第三步与第四步可以互换。

需要调用 torch.tensor() 函数

python 复制代码

X = torch.tensor(X, dtype=torch.float32)  
y = torch.tensor(y, dtype=torch.long)

对于浮点型数据或二分类数据，以及所有的输入数据 X，一般跟参数 dtype=torch.float32
对于多分类数据，跟参数 dtype=torch.long
对于单列数据，一般还要进一步跟上参数 view(-1, 1) 或 unsqueeze(1)增加一个维度。例如：

python 复制代码

import torch

x = [1, 2, 3, 4]
t = torch.tensor(x)
print(t)
print(t.view(-1, 1)) # 或 print(t.unsqueeze(1))

输出为：

tensor([1, 2, 3, 4])

tensor([[1],
$2\], \[3\], \[4\]\])$

大多数模型（如 nn.Linear、CNN 等）都要求输入形状为：batch_size × features，因此对于单列数据，需要增加一个维度。

4. 划分训练/验证/测试集

一般训练集的比例为 80%，剩余的为验证集或测试集。验证集、测试集很多时候是同一个。

对于大规模数据，训练集的比例可以更高

5. 创建 Dataset, DataLoader

Dataset 是 PyTorch 用来管理、索引和处理数据的接口。DataLoader 则是 Dataset 的批量加载工具。

在 DataLoader 中，可以定义 batch_size 并且打乱数据

例如：

python 复制代码

dataset = TensorDataset(X_tensor, y_tensor)
loader = DataLoader(dataset, batch_size=32, shuffle=True)

若不需要打乱数据，不需要将数据 batch，也可以不定义 Dataset 和 DataLoader
比较复杂的数据可能需要创建专门的类来生成 Dataset 和 DataLoader

6. 创建模型类，并新建一个实例

一般通过继承 Pytorch 的 Module 类，创建一个神经网络模型。在网络模型中，要定义网络结构（即输入单元，隐含单元，输出单元的数量，层数）与前向输出函数 forward(self, x)。

forward 的输入参数 x 为一个 batch 的输入数据

例如：

python 复制代码

class IrisNet(nn.Module):
    def __init__(self, input_size=4, hidden_size=10, output_size=3):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(input_size, hidden_size),
            nn.Sigmoid(),
            nn.Linear(hidden_size, output_size)
        )

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

或

python 复制代码

class LSTMModel(nn.Module):
    def __init__(self, input_size=1, hidden_size=10, num_layers=1, output_size=1):
        super().__init__()
        self.lstm = nn.LSTM(input_size, hidden_size, num_layers, batch_first=True)
        self.linear = nn.Linear(hidden_size, output_size)  # 线性输出
        
    def forward(self, x):
        out, _ = self.lstm(x)
        # out 的维度 (batch_size, seq_length, hidden_size)
        out = out[:, -1, :]
        out = self.linear(out)
        return out

创建好神经网络类后，再新建一个实例，例如

python 复制代码

model = IrisNet()

python 复制代码

model = LSTMModel()

7. 确定损失函数和优化器

在训练神经网络时，损失函数（Loss Function）用于衡量模型预测值与真实值的差距，而优化器（Optimizer）负责根据梯度更新模型参数，从而最小化损失。

7.1 常用损失函数：

(1) 回归任务

nn.MSELoss：均方误差（Mean Squared Error）
nn.L1Loss：平均绝对误差（Mean Absolute Error）

(2) 分类任务

nn.CrossEntropyLoss：多分类任务（类别编码为整数）
nn.BCEWithLogitsLoss：二分类任务（类别编码为浮点数）

BCE 是 binary cross entropy 的缩写，即二元交叉熵，它的公式为：

l o s s = − [ y log ⁡ ( p ) + ( 1 − y ) log ⁡ ( 1 − p ) ] loss=-[y\log(p)+(1-y)\log(1-p)] loss=−[ylog(p)+(1−y)log(1−p)]

7.2 优化器（Optimizer）

常用优化器：

torch.optim.SGD：随机梯度下降

python 复制代码

optimizer = torch.optim.SGD(model.parameters(), lr=0.01)

torch.optim.Adam：自适应矩估计（收敛更快）

python 复制代码

optimizer = torch.optim.Adam(model.parameters(), lr=0.001)

8. 训练

对于一定数量的 epoches, 循环训练。

例如：

python 复制代码

for epoch in range(epochs):
    model.train()  # 显式设置训练模式
    optimizer.zero_grad() # 每次循环时梯度清零，因为默认梯度在循环时是累加的
    y_pred = model(X_train) # 把输入数据传入到模型
    loss = criterion(y_pred, y) # 计算误差
    loss.backward() # 执行反向传播
    optimizer.step() # 更新模型的参数

9. 预测（评估）

到预测（评估）阶段，代码一般如下：

python 复制代码

model.eval()              # 切换到评估模式
with torch.no_grad():      # 关闭梯度计算
    model.eval()  # 切换到评估模式
    pred = model(X_test) # 得到模型输出（带梯度）
    pred = pred.detach() # 返回一个共享相同数据但不需要梯度的新张量
    pred = pred.numpy()  # 转化为 numpy

统计预测准确率或误差率也在这一步