I. 引言
在深度学习项目中，模型的保存和加载是两个至关重要的环节。无论是为了保存训练过程中的中间状态以便后续恢复训练，还是为了部署训练好的模型进行推理，高效且灵活的 Checkpoint 机制都能为我们的工作提供极大的便利。本文将深入探讨 Trae 中的模型保存与加载机制，帮助读者全面掌握这一关键技能。
II. Checkpoint 基础概念
2.1 Checkpoint 的作用
Checkpoint 主要有以下两大作用：
| 场景 | 说明 |
|---|---|
| 中断恢复 | 在长时间训练过程中，若遇到意外中断（如断电、硬件故障），可通过最近的 Checkpoint 快速恢复训练，避免从头开始。 |
| 模型版本管理 | 训练过程中保存多个 Checkpoint，便于比较不同训练阶段的模型性能，选择最优模型进行部署。 |
| 性能评估与调试 | 在训练的不同阶段保存 Checkpoint，可用于评估模型在不同训练程度下的性能变化，辅助调试模型。 |
2.2 Checkpoint 的保存内容
Checkpoint 主要保存以下内容：
| 内容 | 说明 |
|---|---|
| 模型架构 | 描述模型的结构，包括各层的类型、连接方式、参数形状等信息。 |
| 模型权重 | 模型各层的参数值，是模型进行推理的核心数据。 |
| 优化器状态 | 包括学习率、动量等优化器相关的参数，对于恢复训练至关重要。 |
| 训练迭代数 | 记录当前训练进行到的步数或 epoch，帮助恢复训练时定位到正确的位置。 |
| 其他自定义内容 | 可根据需要保存其他辅助信息，如训练时的随机数种子、自定义的监控指标等。 |
2.3 Checkpoint 保存格式
Trae 支持多种 Checkpoint 保存格式，各有特点：
| 格式 | 说明 |
|---|---|
| HDF5 (.h5, .hdf5) | 通用的二进制格式，支持分层存储数据，适合保存包含多种信息的 Checkpoint。 |
| TensorFlow SavedModel (.pb) | TensorFlow 原生格式，将模型架构、权重、计算图等信息保存为一个独立目录，便于部署和迁移学习。 |
2.4 Checkpoint 基础总结（mermaid）
graph TD
A[Checkpoint 基础概念] --> B[作用]
A --> C[保存内容]
A --> D[保存格式]
B --> E[中断恢复]
B --> F[模型版本管理]
B --> G[性能评估与调试]
C --> H[模型架构]
C --> I[模型权重]
C --> J[优化器状态]
C --> K[训练迭代数]
C --> L[其他自定义内容]
D --> M[HDF5]
D --> N[TensorFlow SavedModel]
III. 模型保存机制
3.1 保存完整模型
保存完整模型是最常用的方式之一，它将模型架构和权重一起保存，便于后续直接加载使用。
3.1.1 HDF5 格式保存
python
import trae
# 构建一个简单的模型
model = trae.keras.Sequential([
trae.keras.layers.Dense(64, activation='relu', input_shape=(20,)),
trae.keras.layers.Dense(32, activation='relu'),
trae.keras.layers.Dense(1, activation='sigmoid')
])
# 编译并训练模型（此处省略训练代码）
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
# 保存完整模型为 HDF5 格式
model.save('my_model.h5')
# 保存内容说明
print("HDF5 格式保存内容包括：")
print("1. 模型架构（层类型、连接方式等）")
print("2. 模型权重")
print("3. 优化器配置（如优化器类型、学习率等）")
print("4. 训练配置（如损失函数、指标等）")代码解释：
model.save()方法将模型保存为 HDF5 文件。- 保存的文件包含了模型的所有必要信息，包括架构、权重、优化器状态和训练配置。
3.1.2 SavedModel 格式保存
python
# 保存完整模型为 SavedModel 格式
model.save('my_model', save_format='tf')
# 保存内容说明
print("SavedModel 格式保存内容包括：")
print("1. 模型架构（以计算图形式保存）")
print("2. 模型权重")
print("3. 优化器配置")
print("4. 训练配置")
print("5. 模型的推理入口（便于直接进行预测）")代码解释：
- SavedModel 是 TensorFlow 推荐的格式，保存后为一个文件夹。
- 它不仅保存了模型的架构和权重，还保存了模型的计算图，便于在不同环境中部署。
3.2 仅保存模型权重
在某些场景下，我们可能只需要保存模型的权重，而不保存架构信息。这种方式适用于需要自定义模型架构或进行模型迁移的场景。
python
# 仅保存模型权重
model.save_weights('my_model_weights.h5')
# 保存内容说明
print("仅保存权重的内容包括：")
print("1. 模型各层的权重参数")
print("2. 不包含模型架构、优化器配置和训练配置")代码解释：
- 使用
save_weights()方法仅保存模型的权重。 - 该方法保存的文件较小，但加载时需要重新定义模型架构。
3.3 定期保存 Checkpoint
在训练过程中定期保存 Checkpoint，便于恢复训练或分析模型性能变化。
python
import trae.keras.callbacks as callbacks
# 定义回调函数，每 2 个 epoch 保存一次 Checkpoint
checkpoint_callback = callbacks.ModelCheckpoint(
filepath='model_checkpoint_{epoch:02d}.h5',
save_weights_only=False, # 是否仅保存权重
save_freq='epoch', # 保存频率，可设置为 'epoch' 或具体步数
period=2 # 每隔多少个 epoch 保存一次
)
# 在训练时添加回调
history = model.fit(
X_train, y_train,
epochs=10,
validation_data=(X_test, y_test),
callbacks=[checkpoint_callback]
)
# 输出保存的 Checkpoint 文件名
print("保存的 Checkpoint 文件：")
for epoch in range(1, 11, 2):
print(f"model_checkpoint_{epoch:02d}.h5")代码解释：
ModelCheckpoint回调函数可在训练过程中自动保存 Checkpoint。filepath参数支持格式化占位符，如{epoch}表示当前 epoch 数。save_weights_only参数决定是保存完整模型还是仅保存权重。period参数控制保存的间隔。
3.4 模型保存机制总结（mermaid）
graph TD
A[模型保存机制] --> B[保存完整模型]
A --> C[仅保存模型权重]
A --> D[定期保存 Checkpoint]
B --> E[HDF5 格式]
B --> F[SavedModel 格式]
D --> G[定义回调函数]
D --> H[训练时添加回调]
IV. 模型加载机制
4.1 加载完整模型
从保存的文件中加载完整模型，包括架构和权重。
4.1.1 加载 HDF5 格式模型
python
# 加载 HDF5 格式的完整模型
loaded_model = trae.keras.models.load_model('my_model.h5')
# 验证加载的模型
print("加载的模型架构：")
loaded_model.summary()
print("模型已编译状态：", loaded_model.optimizer is not None)代码解释：
load_model()方法用于加载保存的 HDF5 模型文件。- 加载后的模型包含架构、权重、优化器配置和训练配置，可直接用于训练或推理。
4.1.2 加载 SavedModel 格式模型
python
# 加载 SavedModel 格式的完整模型
loaded_model = trae.keras.models.load_model('my_model')
# 验证加载的模型
print("加载的模型架构：")
loaded_model.summary()
print("模型已编译状态：", loaded_model.optimizer is not None)代码解释：
- 加载 SavedModel 格式的模型与加载 HDF5 格式类似，但加载的是一个文件夹。
- SavedModel 格式的模型在加载后同样包含所有必要的信息，且更适合部署。
4.2 加载模型权重
将保存的权重加载到已有架构的模型中。
python
# 定义新的模型架构（与保存的模型架构一致）
new_model = trae.keras.Sequential([
trae.keras.layers.Dense(64, activation='relu', input_shape=(20,)),
trae.keras.layers.Dense(32, activation='relu'),
trae.keras.layers.Dense(1, activation='sigmoid')
])
# 加载权重到新模型
new_model.load_weights('my_model_weights.h5')
# 验证权重是否加载成功
print("新模型架构：")
new_model.summary()
print("权重加载状态：", new_model.weights)代码解释：
load_weights()方法将保存的权重加载到已定义的模型架构中。- 加载权重时，模型架构必须与保存时一致，否则会报错。
4.3 模型加载注意事项
加载模型时需要注意以下几点：
| 事项 | 说明 |
|---|---|
| 架构一致性 | 加载完整模型时，架构自动恢复；仅加载权重时，需确保加载的模型架构与保存时一致。 |
| 自定义层支持 | 若模型包含自定义层，加载时需通过 custom_objects 参数提供自定义类的定义。 |
| 编译状态 | 加载的模型是否已编译取决于保存时的设置，若需继续训练，需确保优化器和损失函数正确恢复。 |
python
# 加载包含自定义层的模型示例
class CustomLayer(trae.keras.layers.Layer):
def __init__(self):
super(CustomLayer, self).__init__()
self.dense = trae.keras.layers.Dense(32)
def call(self, inputs):
return self.dense(inputs)
# 定义包含自定义层的模型
model = trae.keras.Sequential([
trae.keras.layers.Dense(64, activation='relu', input_shape=(20,)),
CustomLayer(),
trae.keras.layers.Dense(1, activation='sigmoid')
])
# 保存模型
model.save('model_with_custom_layer.h5')
# 加载模型时提供自定义层定义
loaded_model = trae.keras.models.load_model(
'model_with_custom_layer.h5',
custom_objects={'CustomLayer': CustomLayer}
)4.4 模型加载机制总结（mermaid）
graph TD
A[模型加载机制] --> B[加载完整模型]
A --> C[加载模型权重]
B --> D[HDF5 格式]
B --> E[SavedModel 格式]
C --> F[确保架构一致性]
C --> G[加载权重到新模型]
A --> H[注意事项]
H --> I[架构一致性]
H --> J[自定义层支持]
H --> K[编译状态]
V. 高级保存加载技巧
5.1 保存自定义训练循环的 Checkpoint
在使用自定义训练循环时，我们需要手动管理 Checkpoint 的保存和加载。
5.1.1 定义自定义训练循环
python
import trae
# 创建模型、优化器和损失函数
model = trae.keras.Sequential([
trae.keras.layers.Dense(64, activation='relu', input_shape=(20,)),
trae.keras.layers.Dense(32, activation='relu'),
trae.keras.layers.Dense(1, activation='sigmoid')
])
optimizer = trae.keras.optimizers.Adam(learning_rate=0.001)
loss_fn = trae.keras.losses.BinaryCrossentropy()
# 准备数据（假设 X_train 和 y_train 已定义）
train_dataset = trae.data.Dataset.from_tensor_slices((X_train, y_train)).batch(32)5.1.2 定义 Checkpoint 内容
python
# 定义 Checkpoint 包含的内容
checkpoint = {
'model_weights': model.trainable_variables,
'optimizer_weights': optimizer.variables(),
'epoch': trae.Variable(0, dtype=trae.int32)
}
# 创建 Checkpoint 对象
ckpt = trae.train.Checkpoint(**checkpoint)
ckpt_manager = trae.train.CheckpointManager(
ckpt,
directory='./custom_training_checkpoints',
max_to_keep=5 # 最多保存 5 个 Checkpoint
)代码解释：
Checkpoint对象定义了需要保存的内容，包括模型权重、优化器状态和当前 epoch。CheckpointManager用于管理 Checkpoint 的保存路径和数量。
5.1.3 训练并保存 Checkpoint
python
# 自定义训练循环并保存 Checkpoint
for epoch in range(10):
# 训练一个 epoch
for batch, (x, y) in enumerate(train_dataset):
with trae.GradientTape() as tape:
logits = model(x, training=True)
loss_value = loss_fn(y, logits)
gradients = tape.gradient(loss_value, model.trainable_variables)
optimizer.apply_gradients(zip(gradients, model.trainable_variables))
# 更新 Checkpoint 中的 epoch 信息
ckpt.epoch.assign_add(1)
# 保存 Checkpoint
save_path = ckpt_manager.save()
print(f"Epoch {int(ckpt.epoch)}: Checkpoint saved to {save_path}")5.2 恢复自定义训练循环的 Checkpoint
从保存的 Checkpoint 恢复训练状态。
python
# 创建新的模型、优化器和 Checkpoint 对象（架构需与保存时一致）
new_model = trae.keras.Sequential([
trae.keras.layers.Dense(64, activation='relu', input_shape=(20,)),
trae.keras.layers.Dense(32, activation='relu'),
trae.keras.layers.Dense(1, activation='sigmoid')
])
new_optimizer = trae.keras.optimizers.Adam(learning_rate=0.001)
new_checkpoint = {
'model_weights': new_model.trainable_variables,
'optimizer_weights': new_optimizer.variables(),
'epoch': trae.Variable(0, dtype=trae.int32)
}
new_ckpt = trae.train.Checkpoint(**new_checkpoint)
new_ckpt_manager = trae.train.CheckpointManager(new_ckpt, directory='./custom_training_checkpoints', max_to_keep=5)
# 恢复最新的 Checkpoint
latest_checkpoint = new_ckpt_manager.latest_checkpoint
if latest_checkpoint:
new_ckpt.restore(latest_checkpoint)
print(f"恢复 Checkpoint 成功，继续从 Epoch {int(new_checkpoint['epoch'])} 开始训练")
else:
print("未找到 Checkpoint，从头开始训练")5.3 模型转换与兼容性
在不同框架或版本之间转换模型时，可能会遇到兼容性问题。以下是一些解决方法：
| 问题 | 解决方案 |
|---|---|
| 版本不兼容 | 尝试将模型和代码升级到最新版本；如不可行，可考虑使用旧版本的 API 加载模型后再转换为新格式。 |
| 自定义层丢失 | 加载时提供 custom_objects 参数，包含自定义层的定义。 |
| 权重形状不匹配 | 检查模型架构是否完全一致，尤其是各层的输入输出形状、参数数量等。 |
| 保存格式不支持 | 尝试将模型转换为通用格式（如 ONNX），再进行跨框架加载。 |
5.4 高级技巧总结（mermaid）
graph TD
A[高级保存加载技巧] --> B[自定义训练循环 Checkpoint]
A --> C[模型转换与兼容性]
B --> D[定义 Checkpoint 内容]
B --> E[训练并保存]
B --> F[恢复 Checkpoint]
C --> G[版本不兼容]
C --> H[自定义层丢失]
C --> I[权重形状不匹配]
C --> J[保存格式不支持]
VI. Checkpoint 管理与最佳实践
6.1 Checkpoint 管理策略
合理管理 Checkpoint 文件，避免磁盘空间浪费，同时确保训练过程的可靠性。
6.1.1 限制保存数量
使用 CheckpointManager 限制保存的 Checkpoint 数量。
python
# 限制最多保存 3 个 Checkpoint
ckpt_manager = trae.train.CheckpointManager(
ckpt,
directory='./checkpoints',
max_to_keep=3
)
# 每次保存时自动删除最早的 Checkpoint
for epoch in range(10):
# 训练代码
save_path = ckpt_manager.save()
print(f"Checkpoint saved to {save_path}")6.1.2 自定义保存条件
根据自定义条件决定是否保存 Checkpoint，例如基于验证集性能。
python
# 定义回调函数，仅当验证损失降低时保存 Checkpoint
class CustomCheckpoint(callbacks.Callback):
def __init__(self, model, filepath):
self.model = model
self.filepath = filepath
self.best_loss = float('inf')
def on_epoch_end(self, epoch, logs=None):
current_loss = logs.get('val_loss')
if current_loss < self.best_loss:
self.best_loss = current_loss
self.model.save(self.filepath)
print(f"Validation loss improved to {current_loss}, saving model to {self.filepath}")
# 使用自定义回调
model.fit(
X_train, y_train,
epochs=10,
validation_data=(X_test, y_test),
callbacks=[CustomCheckpoint(model, 'best_model.h5')]
)6.2 最佳实践
| 实践建议 | 说明 |
|---|---|
| 定期保存 Checkpoint | 在长时间训练任务中，定期保存 Checkpoint 以防意外中断导致数据丢失。 |
| 验证 Checkpoint 完整性 | 定期加载最近的 Checkpoint 进行验证，确保其能够正常恢复训练或推理。 |
| 使用独立存储介质 | 将 Checkpoint 文件保存到独立的存储介质（如 NAS、云存储），防止本地磁盘故障导致数据丢失。 |
| 记录保存信息 | 在保存 Checkpoint 时记录相关信息（如训练 epoch、数据集版本、超参数设置），便于后续追溯和分析。 |
| 分离保存架构与权重 | 在需要跨环境部署或进行模型架构变更时，可考虑分别保存模型架构和权重，以提高灵活性。 |
6.3 Checkpoint 管理与最佳实践总结（mermaid）
graph TD
A[Checkpoint 管理与最佳实践] --> B[管理策略]
A --> C[最佳实践]
B --> D[限制保存数量]
B --> E[自定义保存条件]
C --> F[定期保存]
C --> G[验证完整性]
C --> H[独立存储]
C --> I[记录信息]
C --> J[分离架构与权重]
VII. 实战演练：完整工作流示例
7.1 构建模型与训练
python
import trae
from trae.keras import layers, models
import numpy as np
# 构建模型
def build_model():
model = models.Sequential()
model.add(layers.Dense(64, activation='relu', input_shape=(20,)))
model.add(layers.Dense(32, activation='relu'))
model.add(layers.Dense(1, activation='sigmoid'))
return model
# 创建数据集
def generate_data():
X = np.random.random((1000, 20))
y = np.random.randint(2, size=(1000,))
return trae.train_test_split(X, y, test_size=0.2, random_state=42)
# 主训练函数
def main():
# 构建模型和数据
model = build_model()
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
X_train, X_test, y_train, y_test = generate_data()
# 定义 Checkpoint 回调
checkpoint_path = 'training_checkpoints/cp-{epoch:04d}.ckpt'
checkpoint_callback = trae.keras.callbacks.ModelCheckpoint(
filepath=checkpoint_path,
save_weights_only=True,
verbose=1,
period=2 # 每 2 个 epoch 保存一次
)
# 开始训练
model.fit(
X_train, y_train,
epochs=20,
validation_data=(X_test, y_test),
callbacks=[checkpoint_callback]
)
# 保存完整模型
model.save('final_model.h5')
print("完整模型已保存为 final_model.h5")
if __name__ == '__main__':
main()7.2 恢复训练与推理
python
# 恢复训练
def resume_training():
# 重新构建模型
model = build_model()
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
# 加载最新的 Checkpoint
latest_checkpoint = 'training_checkpoints/cp-0020.ckpt' # 假设已训练到 20 个 epoch
model.load_weights(latest_checkpoint)
print(f"从 Checkpoint {latest_checkpoint} 恢复训练")
# 继续训练
X_train, X_test, y_train, y_test = generate_data()
model.fit(
X_train, y_train,
epochs=10,
validation_data=(X_test, y_test),
initial_epoch=20 # 从第 20 个 epoch 继续训练
)
# 推理
def inference():
# 加载完整模型
loaded_model = models.load_model('final_model.h5')
print("加载的模型架构：")
loaded_model.summary()
# 随机生成测试数据
X_sample = np.random.random((10, 20))
predictions = loaded_model.predict(X_sample)
print("预测结果：", predictions)
if __name__ == '__main__':
resume_training()
inference()