返回专栏
· 24 分钟阅读

深度学习的训练流程与工程实现:从数据准备到模型部署


一、深度学习训练:从理论模型到工程系统

深度学习模型的训练,本质上是通过数据和优化算法,不断调整神经网络参数,使模型在给定任务上的预测结果逐渐接近目标结果。

从数学角度看,训练过程可以抽象为:

\theta^*=\arg\min_{\theta}L(\theta;D)

其中:

  • \theta:模型的可学习参数。
  • D:训练数据集。
  • L:模型在数据集上的损失函数。
  • \theta^*:优化得到的模型参数。

但在实际工程中,模型训练并不只是执行一次梯度下降。

一个完整的深度学习训练系统通常需要处理:

  1. 数据采集与数据清洗。
  2. 数据集划分与预处理。
  3. 模型结构设计与参数初始化。
  4. 前向传播与损失计算。
  5. 反向传播与梯度计算。
  6. 优化器更新参数。
  7. 验证集评估与超参数调整。
  8. 模型检查点保存与恢复。
  9. 测试集评估与模型选择。
  10. 模型导出、部署与监控。

这些环节共同构成深度学习的训练工程。

二、深度学习训练的完整流程

2.1 整体训练流程

从工程视角看,深度学习训练可以分为数据准备、模型训练、模型评估和模型交付四个阶段。

flowchart TB
    A["原始数据"] --> B["数据清洗与预处理"]
    B --> C["训练集 / 验证集 / 测试集"]
    C --> D["构建 Dataset 与 DataLoader"]
    D --> E["定义模型结构"]
    E --> F["初始化模型参数"]
    F --> G["前向传播"]
    G --> H["计算损失函数"]
    H --> I["反向传播计算梯度"]
    I --> J["优化器更新参数"]
    J --> K{"达到验证或停止条件?"}
    K -->|"否"| G
    K -->|"是"| L["验证集评估与模型选择"]
    L --> M["测试集最终评估"]
    M --> N["保存模型与训练配置"]
    N --> O["模型部署与推理"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#EAF3EC,stroke:#83A995,color:#315D49
    style C fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style D fill:#EAF3EC,stroke:#83A995,color:#315D49
    style E fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style F fill:#EAF3EC,stroke:#83A995,color:#315D49
    style G fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style H fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style I fill:#EAF3EC,stroke:#83A995,color:#315D49
    style J fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style K fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style L fill:#EAF3EC,stroke:#83A995,color:#315D49
    style M fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style N fill:#EAF3EC,stroke:#83A995,color:#315D49
    style O fill:#DCEFE5,stroke:#4F8B70,color:#24563F

2.2 一个训练步骤包含什么?

在一个典型的 Mini-batch 训练步骤中,主要执行以下操作:

flowchart TB
    A["获取一个 Batch"] --> B["清空历史梯度"]
    B --> C["模型前向传播"]
    C --> D["计算 Loss"]
    D --> E["Loss.backward()"]
    E --> F["梯度裁剪(可选)"]
    F --> G["optimizer.step()"]
    G --> H["记录训练指标"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#EAF3EC,stroke:#83A995,color:#315D49
    style C fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style D fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style E fill:#EAF3EC,stroke:#83A995,color:#315D49
    style F fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style G fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style H fill:#E5F0E9,stroke:#83A995,color:#315D49

这几个步骤是理解深度学习训练代码的基础:

  • zero_grad():清除上一次迭代累积的梯度。
  • forward():根据当前参数计算预测结果。
  • loss:衡量预测结果与目标之间的差异。
  • backward():计算损失对模型参数的梯度。
  • step():根据梯度更新模型参数。

需要明确:反向传播负责计算梯度,优化器负责根据梯度更新参数。两者不是同一件事。

三、第一阶段:数据准备与预处理

数据质量直接影响模型能够学习到什么。

深度学习模型通常需要将原始数据转换成适合神经网络计算的张量,并按照训练、验证和测试的职责进行组织。

3.1 数据采集

不同任务的数据形式不同。

任务类型 数据形式 示例
图像识别 图像、标签 图片与类别
文本分类 Token 序列、标签 句子与情感类别
目标检测 图像、边界框 图片与目标坐标
语音识别 音频、文本 语音与转录文本
时间序列预测 连续数值序列 历史传感器数据
大语言模型训练 Token 序列 文本经过分词后的 ID

数据采集阶段需要重点关注:

  • 数据来源是否合法、可靠。
  • 数据是否覆盖真实业务场景。
  • 标签是否准确。
  • 是否存在重复样本。
  • 是否存在异常值和缺失值。
  • 不同类别的数据是否严重不均衡。
  • 是否包含隐私信息或敏感数据。

数据量并不等于数据质量。大量重复、错误或存在偏差的数据,不一定能够提升模型能力。

3.2 数据清洗

数据清洗的目标是提高数据质量,减少无效信息对训练过程的干扰。

常见操作包括:

缺失值处理

  • 删除缺失严重的样本。
  • 使用均值、中位数等方式填补。
  • 使用专门的缺失值标记。
  • 根据业务语义处理。

异常值处理

  • 统计分布分析。
  • 分位数检测。
  • 规则校验。
  • 根据任务决定是否截断或删除。

重复数据处理

  • 完全重复样本检测。
  • 近似重复数据检测。
  • 数据集跨分区重复检查。

标签质量检查

  • 标签格式校验。
  • 标签范围检查。
  • 类别映射统一。
  • 抽样人工复核。

特别需要注意:数据清洗规则不能使用测试集的信息来拟合。例如,标准化所需的均值和标准差,应当只从训练集计算。

3.3 数据预处理

不同类型的数据通常需要不同的预处理方法。

数据类型 常见预处理
图像 Resize、Crop、Normalize、数据增强
文本 Tokenization、Padding、Truncation
音频 重采样、分帧、Mel Spectrogram
数值特征 标准化、归一化、缺失值处理
时间序列 滑动窗口、时间对齐、趋势处理

以图像数据为例:

x'=\frac{x-\mu}{\sigma}

其中:

  • x:原始像素值。
  • \mu:训练集计算得到的均值。
  • \sigma:训练集计算得到的标准差。
  • x':标准化后的像素值。

需要注意,训练和推理阶段应使用相同的预处理配置。

3.4 数据增强(Data Augmentation)

数据增强通过对训练样本进行合理变换,增加训练数据的多样性。

常见方法:

  • 图像随机裁剪。
  • 水平翻转。
  • 颜色扰动。
  • 随机旋转。
  • 文本替换与扰动。
  • 音频噪声注入。
  • 时间序列窗口扰动。

数据增强的目的不是简单制造更多数据,而是引入合理的变化,使模型学习更稳定的特征。

需要根据任务确定增强策略。例如,数字识别任务中的图像旋转可能改变数字语义,不能无条件使用。

3.5 数据集划分

常见的数据集划分方式:

  • 训练集(Training Set)。
  • 验证集(Validation Set)。
  • 测试集(Test Set)。
数据集 主要用途 是否参与参数梯度更新
训练集 学习模型参数 是
验证集 模型选择、超参数调整 否
测试集 最终泛化能力评估 否

常见比例包括:

  • 70% / 15% / 15%。
  • 80% / 10% / 10%。
  • 训练集占更大比例,验证和测试集根据数据规模调整。

这些比例不是固定标准。

数据划分需要考虑任务特点:

  • 分类任务可以使用分层抽样。
  • 时间序列任务应按照时间顺序划分。
  • 用户行为数据需要考虑用户维度隔离。
  • 同一主体的高度相关样本不应随意分散到训练集和测试集。

如果训练集和测试集存在信息交叉,可能产生数据泄漏(Data Leakage),导致评估结果虚高。

四、第二阶段:Dataset 与 DataLoader

在 PyTorch 中,数据通常通过 Dataset 和 DataLoader 管理。

两者承担不同职责。

4.1 Dataset:数据集抽象

Dataset 负责描述如何访问单个样本。

通常需要实现:

  • __len__():返回数据集大小。
  • __getitem__():根据索引返回一个样本。

示例:

import torch
from torch.utils.data import Dataset


class CustomDataset(Dataset):

    def __init__(self, features, labels):
        self.features = features
        self.labels = labels

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

    def __getitem__(self, index):
        x = self.features[index]
        y = self.labels[index]

        return x, y


features = torch.randn(1000, 20)
labels = torch.randint(0, 3, (1000,))

dataset = CustomDataset(features, labels)

print(len(dataset))
# 1000

x, y = dataset[0]

print(x.shape)
# [20]

Dataset 通常不负责整个批次的组织,而是提供单个样本的读取接口。

4.2 DataLoader:批量加载

DataLoader 负责将 Dataset 中的样本组织成批次,并支持:

  • Batch Size。
  • Shuffle。
  • 多进程加载。
  • 数据整理(Collate)。
  • Pin Memory。
  • 不完整批次处理。

示例:

from torch.utils.data import DataLoader

train_loader = DataLoader(
    dataset,
    batch_size=32,
    shuffle=True,
    num_workers=4,
    pin_memory=True,
    drop_last=True
)

for inputs, labels in train_loader:
    print(inputs.shape)
    print(labels.shape)
    break

输出形状:

torch.Size([32, 20])
torch.Size([32])

4.3 Batch Size 的意义

假设训练集有 1000 个样本,Batch Size 为 32。

每个 Epoch 的迭代次数:

Steps= \left\lceil\frac{1000}{32}\right\rceil =32

如果设置 drop_last=True,最后不足一个完整 Batch 的样本会被丢弃,实际只处理:

\left\lfloor\frac{1000}{32}\right\rfloor=31

因此,Epoch、Batch、Iteration 和 Optimizer Step 需要明确区分。

  • Epoch:完整遍历一次训练数据集。
  • Batch:一次送入模型的数据集合。
  • Iteration:一次训练批次的处理过程。
  • Optimizer Step:优化器执行一次参数更新。

在常见训练循环中,一次 Iteration 对应一次 Optimizer Step,但梯度累积时并不一定如此。

五、第三阶段:模型构建与参数初始化

数据准备完成后,需要定义神经网络结构。

模型结构决定了输入如何转换为输出,以及模型能够表达怎样的函数关系。

5.1 定义模型结构

以多层感知机(MLP)为例:

import torch.nn as nn


class MLP(nn.Module):

    def __init__(self, input_dim, hidden_dim, num_classes):
        super().__init__()

        self.network = nn.Sequential(
            nn.Linear(input_dim, hidden_dim),
            nn.ReLU(),

            nn.Linear(hidden_dim, hidden_dim),
            nn.ReLU(),

            nn.Linear(hidden_dim, num_classes)
        )

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

模型包含:

  1. 输入层。
  2. 隐藏层。
  3. 激活函数。
  4. 输出层。

这里的 forward() 定义模型从输入到输出的计算过程。

5.2 参数初始化

神经网络的权重通常需要合理初始化。

常见初始化方式:

初始化方法 主要特点 常见场景
Zero Initialization 所有参数初始化为零 不适合普通网络权重
Xavier Initialization 控制前后层激活与梯度尺度 Sigmoid、Tanh 等
He Initialization 考虑 ReLU 类激活函数 ReLU、Leaky ReLU
Orthogonal Initialization 初始化为正交矩阵 部分循环网络

如果所有神经元使用完全相同的权重初始化,可能产生对称性问题,导致神经元无法学习不同的特征。

5.3 模型参数与超参数

需要区分两个概念。

模型参数(Parameters):

训练过程中通过梯度更新的变量。

例如:

  • 权重矩阵。
  • 偏置。
  • Embedding 参数。
  • Attention 投影矩阵。

超参数(Hyperparameters):

训练前或训练过程中由开发者配置的参数。

例如:

  • Learning Rate。
  • Batch Size。
  • Epoch。
  • Hidden Size。
  • Dropout。
  • Weight Decay。
  • 优化器类型。

模型参数由训练数据和优化算法学习,超参数通常通过实验、搜索或经验确定。

六、第四阶段:前向传播与损失计算

6.1 前向传播

前向传播(Forward Propagation)是模型根据当前参数计算预测结果的过程。

对于一个多层神经网络:

a^{(1)}=f(W^{(1)}x+b^{(1)})
a^{(2)}=f(W^{(2)}a^{(1)}+b^{(2)})
\hat y=W^{(3)}a^{(2)}+b^{(3)}

其中:

  • x:输入数据。
  • W:权重。
  • b:偏置。
  • f:激活函数。
  • \hat y:模型预测结果。

在 PyTorch 中:

outputs = model(inputs)

这一行代码通常就会执行模型内部定义的完整前向计算。

6.2 损失函数

损失函数衡量模型预测结果与真实目标之间的差异。

常见损失函数:

任务 常见损失函数
回归 MSE、MAE、Huber Loss
二分类 Binary Cross Entropy
多分类 Cross Entropy
多标签分类 BCEWithLogitsLoss
目标检测 分类损失、边界框回归损失
语言模型 Token 级 Cross Entropy

例如,多分类任务:

criterion = nn.CrossEntropyLoss()

loss = criterion(outputs, labels)

这里需要注意:

CrossEntropyLoss 通常直接接收未经 Softmax 的 Logits,而不是先经过 Softmax 的概率。

6.3 一个 Batch 的损失

对于包含 N 个样本的批次,常见平均损失可以表示为:

L= \frac{1}{N} \sum_{i=1}^{N} \ell(\hat y_i,y_i)

其中:

  • N:Batch Size。
  • \hat y_i:预测结果。
  • y_i:真实标签。
  • \ell:单样本损失。

训练过程就是通过参数更新,使损失函数在训练目标上逐渐降低。

七、第五阶段:反向传播与梯度计算

7.1 什么是反向传播?

反向传播(Backpropagation)是计算损失函数对模型参数梯度的算法。

例如:

L=L(\theta)

反向传播计算:

\nabla_{\theta}L = \frac{\partial L}{\partial\theta}

这些梯度用于告诉优化器:

  • 参数变化对损失有什么影响。
  • 哪些参数需要增大。
  • 哪些参数需要减小。
  • 参数变化的局部敏感程度。

7.2 链式法则

神经网络通常由多个函数组合构成。

假设:

y=f(g(x))

那么:

\frac{dy}{dx} = \frac{df}{dg} \cdot \frac{dg}{dx}

神经网络通过链式法则,将输出损失对各层参数的梯度逐层计算出来。

7.3 反向传播的工程实现

PyTorch 使用自动微分机制计算梯度:

loss.backward()

在正常训练场景中,模型参数会自动记录计算图。

调用 backward() 后,梯度通常累积到参数的 .grad 属性中。

需要注意:PyTorch 默认不会在每次反向传播时自动清空已有梯度。

因此,通常需要在下一次迭代前调用:

optimizer.zero_grad()

7.4 梯度累积

默认情况下,一个 Batch 通常执行一次反向传播和一次优化器更新。

但在显存有限时,可以将多个小 Batch 的梯度累积起来,再进行一次参数更新。

例如:

accumulation_steps = 4

optimizer.zero_grad(set_to_none=True)

for step, (inputs, labels) in enumerate(train_loader):

    outputs = model(inputs)
    loss = criterion(outputs, labels)

    (loss / accumulation_steps).backward()

    if (step + 1) % accumulation_steps == 0:
        optimizer.step()
        optimizer.zero_grad(set_to_none=True)

如果每个小 Batch 大小为 8,累积 4 次,那么在样本数量相同且损失缩放正确等条件下,其梯度效果近似于 Batch Size 为 32 的一次更新。

但需要注意:

  • 梯度累积不会减少总的前向和反向计算量。
  • BatchNorm 等依赖当前 Batch 统计量的层,行为可能与真正的大 Batch 不同。
  • Dropout 等随机操作也会使两者不完全等价。
  • 最后不足一个累积窗口的梯度需要单独处理,不能直接丢失。

八、第六阶段:优化器更新参数

8.1 优化器的作用

反向传播计算出梯度后,还需要优化器根据梯度更新模型参数。

最基础的梯度下降更新公式:

\theta_{t+1} = \theta_t-\eta\nabla_{\theta}L

其中:

  • \theta_t:当前参数。
  • \eta:学习率。
  • \nabla_{\theta}L:损失对参数的梯度。
  • \theta_{t+1}:更新后的参数。

8.2 常见优化器

优化器 核心机制 常见特点
SGD 使用梯度更新参数 结构简单
SGD + Momentum 引入动量 改善更新方向稳定性
RMSprop 平方梯度移动平均 自适应调整步长
Adam 一阶矩与二阶矩估计 应用广泛
AdamW 解耦权重衰减 常用于 Transformer

8.3 PyTorch 优化器配置

optimizer = torch.optim.AdamW(
    model.parameters(),
    lr=1e-3,
    weight_decay=1e-4
)

这里:

  • model.parameters():需要优化的模型参数。
  • lr:学习率。
  • weight_decay:权重衰减系数。

调用:

optimizer.step()

执行一次参数更新。

优化器只会更新参与优化且具有有效梯度的参数。冻结参数或未参与当前计算图的参数不会按普通方式更新。

8.4 学习率调度器

学习率对训练过程有重要影响。

训练初期可以使用较大的学习率加快收敛,后期逐渐降低学习率,以便进行更细致的参数调整。

常见策略:

  • StepLR。
  • MultiStepLR。
  • ExponentialLR。
  • CosineAnnealingLR。
  • ReduceLROnPlateau。
  • Warmup + Cosine Decay。

示例:

scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(
    optimizer,
    T_max=100
)

调度器的调用时机需要根据具体类型确定。

对于按 Epoch 更新的调度器,通常在每个 Epoch 结束后调用 scheduler.step();对于按训练步数更新的调度器,则需要在对应的优化器更新后调用。

九、第七阶段:完整训练循环

前面的环节组合起来,就形成了实际的训练循环。

9.1 PyTorch 完整训练示例

下面使用一个简单的多分类任务,将数据加载、模型训练、验证、优化器更新和检查点保存整合在一起。

import torch
import torch.nn as nn
from torch.utils.data import TensorDataset, DataLoader


# -------------------------
# 1. 准备数据
# -------------------------

X_train = torch.randn(1000, 20)
y_train = torch.randint(0, 3, (1000,))

X_val = torch.randn(200, 20)
y_val = torch.randint(0, 3, (200,))

train_dataset = TensorDataset(X_train, y_train)
val_dataset = TensorDataset(X_val, y_val)

train_loader = DataLoader(
    train_dataset,
    batch_size=32,
    shuffle=True
)

val_loader = DataLoader(
    val_dataset,
    batch_size=64,
    shuffle=False
)


# -------------------------
# 2. 定义模型
# -------------------------

class MLP(nn.Module):

    def __init__(self):
        super().__init__()

        self.network = nn.Sequential(
            nn.Linear(20, 128),
            nn.ReLU(),
            nn.Linear(128, 64),
            nn.ReLU(),
            nn.Linear(64, 3)
        )

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


device = torch.device(
    "cuda" if torch.cuda.is_available() else "cpu"
)

model = MLP().to(device)


# -------------------------
# 3. 定义损失函数与优化器
# -------------------------

criterion = nn.CrossEntropyLoss()

optimizer = torch.optim.AdamW(
    model.parameters(),
    lr=1e-3,
    weight_decay=1e-4
)


# -------------------------
# 4. 训练与验证
# -------------------------

num_epochs = 20
best_val_loss = float("inf")

for epoch in range(num_epochs):

    # ===== 训练阶段 =====
    model.train()

    train_loss_sum = 0.0
    train_samples = 0

    for inputs, labels in train_loader:

        inputs = inputs.to(device)
        labels = labels.to(device)

        optimizer.zero_grad(set_to_none=True)

        outputs = model(inputs)

        loss = criterion(outputs, labels)

        loss.backward()

        nn.utils.clip_grad_norm_(
            model.parameters(),
            max_norm=1.0
        )

        optimizer.step()

        batch_size = inputs.size(0)

        train_loss_sum += loss.item() * batch_size
        train_samples += batch_size

    train_loss = train_loss_sum / train_samples


    # ===== 验证阶段 =====
    model.eval()

    val_loss_sum = 0.0
    val_samples = 0
    correct = 0

    with torch.no_grad():

        for inputs, labels in val_loader:

            inputs = inputs.to(device)
            labels = labels.to(device)

            outputs = model(inputs)

            loss = criterion(outputs, labels)

            batch_size = inputs.size(0)

            val_loss_sum += loss.item() * batch_size
            val_samples += batch_size

            predictions = outputs.argmax(dim=1)

            correct += (
                predictions == labels
            ).sum().item()

    val_loss = val_loss_sum / val_samples
    val_accuracy = correct / val_samples

    print(
        f"Epoch {epoch + 1:02d} | "
        f"Train Loss: {train_loss:.4f} | "
        f"Val Loss: {val_loss:.4f} | "
        f"Val Acc: {val_accuracy:.4f}"
    )


    # ===== 保存最佳模型 =====
    if val_loss < best_val_loss:

        best_val_loss = val_loss

        torch.save(
            {
                "epoch": epoch + 1,
                "model_state_dict": model.state_dict(),
                "optimizer_state_dict": optimizer.state_dict(),
                "best_val_loss": best_val_loss
            },
            "best_model.pth"
        )

这里使用随机生成的数据,仅用于展示训练代码结构,并不代表模型具有实际分类能力。

9.2 为什么训练和验证需要分别处理?

训练阶段:

model.train()

启用训练模式。

验证阶段:

model.eval()

启用评估模式。

这两个方法会影响部分网络层的行为。

例如:

Dropout

  • 训练时随机丢弃部分激活。
  • 推理和评估时关闭随机丢弃。

BatchNorm

  • 训练时使用当前 Batch 的统计量,并更新运行统计量。
  • 评估时通常使用训练阶段积累的运行统计量。

此外:

with torch.no_grad():

会关闭当前代码块中的梯度记录,减少验证阶段的显存占用。

model.eval() 和 torch.no_grad() 作用不同,不能相互替代。

十、第八阶段:验证集评估与模型选择

训练损失下降,并不意味着模型在真实数据上一定表现良好。

模型需要通过验证集评估泛化能力。

10.1 常见评估指标

不同任务需要选择不同指标。

分类任务

  • Accuracy。
  • Precision。
  • Recall。
  • F1 Score。
  • ROC-AUC。
  • PR-AUC。

回归任务

  • MAE。
  • MSE。
  • RMSE。
  • R^2。

目标检测任务

  • IoU。
  • Precision。
  • Recall。
  • mAP。

语言模型

  • Cross Entropy Loss。
  • Perplexity。
  • 任务相关评测指标。

指标选择应当结合任务目标,而不是简单追求某一个数值。

10.2 训练集与验证集表现

常见情况:

训练集表现 验证集表现 可能问题
好 好 模型可能具有较好的泛化能力
好 差 可能过拟合
差 差 可能欠拟合或优化失败
差 好 可能存在数据分布差异或评估问题

需要结合数据分布、损失曲线和评估指标综合判断。

10.3 Early Stopping

Early Stopping(早停)是一种训练停止策略。

当验证集指标在连续若干个 Epoch 内没有改善时,停止训练。

例如:

patience = 5

如果验证损失连续 5 个 Epoch 没有改善,就可以考虑停止训练,并恢复验证集表现最佳的检查点。

早停可以减少无效训练,并在一定程度上缓解过拟合。

10.4 训练曲线分析

通常需要同时观察:

  • Training Loss。
  • Validation Loss。
  • Training Accuracy。
  • Validation Accuracy。
  • Learning Rate。

典型现象:

训练损失持续下降,验证损失开始上升:

可能发生过拟合。

训练损失和验证损失都很高:

可能模型欠拟合、学习率不合适,或者数据处理存在问题。

训练损失突然变成 NaN:

可能涉及学习率过大、数值不稳定、异常数据或混合精度溢出等问题。

十一、第九阶段:模型保存、恢复与实验管理

在实际工程中,训练可能持续数小时、数天甚至更久。

因此,需要建立可靠的模型保存和恢复机制。

11.1 保存模型参数

torch.save(
    model.state_dict(),
    "model_weights.pth"
)

这是 PyTorch 中常见的模型参数保存方式。

加载时:

model = MLP()

state_dict = torch.load(
    "model_weights.pth",
    map_location="cpu",
    weights_only=True
)

model.load_state_dict(state_dict)

model.eval()