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

1. 加载数据

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

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

2. 数据标准化

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

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

3. 数据转化为 tensor

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

需要调用 torch.tensor() 函数

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

或者用 torch.FloatTensor 直接转化为 float32

• 对于浮点型数据或二分类数据，以及所有的输入数据 X，一般跟参数 dtype=torch.float32
• 对于多分类数据，跟参数 dtype=torch.long，表示长整醒数据
• 对于单列数据，一般还要进一步跟上参数 view() 或 unsqueeze()增加一个维度；有时候可能需要减少维度，用 squeeze()。
• unsqueeze(dim) 的作用是：在指定位置 dim，新增一个 size = 1 的维度

例如：

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]])

• view 里面的 -1 表示让程序自动推断行数

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

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

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

• 对于大规模数据，训练集的比例可以更高
• 非 batch 训练相当于 full batch

5. 创建 TensorDataset, DataLoader

划分为训练测试集后，若想要 batch training，则需要 TensorDataset, DataLoader。TensorDataset 是 PyTorch 用来管理、索引和处理数据的接口。DataLoader 则是 Dataset 的批量加载工具。

• 在 DataLoader 中，可以定义 batch_size 并且打乱数据
• 若不是 batch training，相当于 full batch

例如：

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

• 若不需要打乱数据，不需要将数据 batch，也可以不定义 Dataset 和 DataLoader
• DataLoader 还可以跟 num_workers 来启动多线程处理数据
• 比较复杂的数据可能需要创建专门的类来生成 Dataset 和 DataLoader

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

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

• forward 的输入参数 x 为一个 batch 的输入数据
• input_size 为输入数据的特征维度
• output_size 为输出数据的特征维度
• 一些分类数据的 embedding 也是在构建模型时进行

例如：

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)

或

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

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

model = IrisNet()

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 的缩写，即二元交叉熵，它的公式为：

$$loss=-[y\log (p)+(1-y)\log (1-p)]$$

7.2 优化器（Optimizer）

常用优化器：

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

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

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

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

8. 训练

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

例如：

# non batch training
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. 预测（评估）

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

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

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

一个实例

下面的代码使用原始的神经网络对 iris 数据集进行预测分类：

"""
@Python version: 3.12
@Author: Zhen Chen
@Email: chen.zhen5526@gmail.com
@Time: 29/11/2025, 19:40
@Desc: vanilla neuro network: batch and adam can increase the accuracy rate.
使用 CrossEntropyLoss() 最为多分类损失函数，就不用将输入数据转化为 one hot了
"""

import torch
import torch.nn as nn
from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from torch.utils.data import Dataset, DataLoader

# 1. 加载数据
iris = datasets.load_iris()
X = iris.data  # (150, 4)
y = iris.target  # (150,)

# 2. 数据标准化
scaler = StandardScaler()
X = scaler.fit_transform(X)

# 3. 转成 tensor
X = torch.tensor(X, dtype=torch.float32)  # [150, 4]
y = torch.tensor(y, dtype=torch.long)  # CrossEntropyLoss 要 long


# 4. 划分训练与测试集（8:2）
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)


# 5. 创建 Dataset
class IrisDataset(Dataset):
    def __init__(self, X, y):
        self.X = X
        self.y = y

    def __len__(self):
        return len(self.X)

    def __getitem__(self, idx):
        return self.X[idx], self.y[idx]


train_dataset = IrisDataset(X_train, y_train)
test_dataset = IrisDataset(X_test, y_test)

# 采用 batch 能减少噪声
train_loader = DataLoader(train_dataset, batch_size=1, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=1, shuffle=True)


# 6. 构建分类模型（简单 MLP）
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 __init__(self):
    #     super().__init__()
    #     self.net = nn.Sequential(
    #         nn.Linear(4, 10),
    #         nn.Sigmoid(),
    #         nn.Linear(10, 3),  # 3 类输出
    #     )

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


model = IrisNet()

# 7. 损失函数 + 优化器
criterion = nn.CrossEntropyLoss()  # 多分类损失
optimizer = torch.optim.SGD(model.parameters(), lr=0.1)


# 8. 训练
epochs = 50
for epoch in range(epochs):
    model.train()
    total_loss = 0

    for Xb, yb in train_loader:
        optimizer.zero_grad()
        output = model(Xb)
        loss = criterion(output, yb)
        loss.backward()
        optimizer.step()
        total_loss += loss.item()
    if epoch % 10 == 0:
        print(f"Epoch {epoch+1}, Loss = {total_loss:.4f}")


# 9. 测试集准确率
model.eval()  # 切换到评估模式
correct = 0
total = 0

with torch.no_grad():  # 关闭梯度计算
    for Xb, yb in test_loader:
        output = model(Xb)
        pred = torch.argmax(output, dim=1)
        correct += (pred == yb).sum().item()
        total += yb.size(0)

print(f"\n测试集准确率：{correct / total * 100:.2f}%")