PyTorch深度学习框架60天进阶学习计划第13天：模型保存与部署

PyTorch深度学习框架60天进阶学习计划第13天：

模型保存与部署

在深度学习项目中，模型训练只是整个流程的一部分。训练好的模型需要被保存并部署到生产环境中，才能发挥实际价值。

今天，我们将详细探讨PyTorch中的模型保存与部署方法，包括不同的保存方式、ONNX格式导出、TorchScript序列化以及移动端部署的量化压缩技术。

目录

1. 模型保存的方法
   • 完整模型保存
   • 仅保存参数（state_dict）
   • 两种方法的对比
2. 模型加载与恢复
   • 加载完整模型
   • 加载state_dict
   • 加载到不同设备
3. 跨框架部署 - ONNX
   • ONNX简介
   • 导出ONNX模型
   • 在其他框架中使用ONNX模型
4. TorchScript序列化
   • TorchScript简介
   • Scripting vs Tracing
   • 使用TorchScript部署
5. 移动端部署
   • 模型量化技术
   • 移动优化的最佳实践
6. 实践案例

---

模型保存的方法

PyTorch提供了两种主要的模型保存方法：保存整个模型和只保存模型参数（state_dict）。了解这两种方法的区别对于正确选择保存策略至关重要。

完整模型保存

完整模型保存方法会将整个模型对象序列化到磁盘，包括模型结构、参数以及优化器状态等所有信息。

import torch
import torch.nn as nn
import torch.optim as optim

# 定义一个简单的模型
class SimpleModel(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super(SimpleModel, self).__init__()
        self.layer1 = nn.Linear(input_size, hidden_size)
        self.relu = nn.ReLU()
        self.layer2 = nn.Linear(hidden_size, output_size)
        
    def forward(self, x):
        x = self.layer1(x)
        x = self.relu(x)
        x = self.layer2(x)
        return x

# 创建模型、优化器和损失函数
model = SimpleModel(10, 50, 2)
optimizer = optim.SGD(model.parameters(), lr=0.01)
criterion = nn.CrossEntropyLoss()

# 假设我们已经训练了模型...

# 保存完整模型（包括模型结构和参数）
torch.save(model, 'full_model.pth')

# 保存包含模型和优化器状态的检查点
checkpoint = {
    'model': model,
    'optimizer': optimizer.state_dict(),
    'epoch': 10  # 假设我们训练了10个epoch
}
torch.save(checkpoint, 'checkpoint.pth')

仅保存参数（state_dict）

state_dict是一个Python字典，它将每一层映射到其参数张量。只保存state_dict是更加灵活和推荐的方法。

# 只保存模型参数
torch.save(model.state_dict(), 'model_state_dict.pth')

# 保存包含模型参数和优化器状态的检查点
checkpoint = {
    'model_state_dict': model.state_dict(),
    'optimizer_state_dict': optimizer.state_dict(),
    'epoch': 10
}
torch.save(checkpoint, 'checkpoint_state_dict.pth')

两种方法的对比

下表比较了两种保存方法的优缺点：

特性	完整模型保存	仅保存参数（state_dict）
文件大小	较大	较小
可移植性	差（依赖于代码结构）	好（只包含参数）
加载灵活性	低（固定模型结构）	高（可用于不同结构）
版本兼容性	低（受PyTorch版本影响）	高（主要是参数值）
适用场景	快速原型设计、单一环境	生产部署、跨平台、版本迁移

模型加载与恢复

加载完整模型

# 加载完整模型
loaded_model = torch.load('full_model.pth')
loaded_model.eval()  # 设置为评估模式

# 加载含有模型和优化器的检查点
checkpoint = torch.load('checkpoint.pth')
loaded_model = checkpoint['model']
loaded_optimizer = checkpoint['optimizer']
epoch = checkpoint['epoch']

加载state_dict

# 首先需要定义相同结构的模型
model = SimpleModel(10, 50, 2)

# 加载模型参数
model.load_state_dict(torch.load('model_state_dict.pth'))
model.eval()  # 设置为评估模式

# 加载含有模型参数和优化器状态的检查点
checkpoint = torch.load('checkpoint_state_dict.pth')
model.load_state_dict(checkpoint['model_state_dict'])
optimizer = optim.SGD(model.parameters(), lr=0.01)
optimizer.load_state_dict(checkpoint['optimizer_state_dict'])
epoch = checkpoint['epoch']

加载到不同设备

在加载模型时，可以指定将模型加载到CPU或GPU：

# 加载到CPU
device = torch.device('cpu')
model = torch.load('model.pth', map_location=device)

# 加载到GPU
device = torch.device('cuda')
model = torch.load('model.pth', map_location=device)
# 或者加载后再转移
model = torch.load('model.pth')
model = model.to(device)

跨框架部署 - ONNX

ONNX简介

ONNX（Open Neural Network Exchange）是一种开放的神经网络交换格式，允许在不同的深度学习框架之间转换模型。通过ONNX，你可以在PyTorch中训练模型，然后将其部署到TensorFlow、ONNX Runtime、TensorRT等框架中。

导出ONNX模型

下面是一个将PyTorch模型导出为ONNX格式的完整示例：

import torch
import torch.nn as nn

class SimpleModel(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super(SimpleModel, self).__init__()
        self.layer1 = nn.Linear(input_size, hidden_size)
        self.relu = nn.ReLU()
        self.layer2 = nn.Linear(hidden_size, output_size)
        
    def forward(self, x):
        x = self.layer1(x)
        x = self.relu(x)
        x = self.layer2(x)
        return x

# 创建模型实例
input_size = 10
hidden_size = 50
output_size = 2
model = SimpleModel(input_size, hidden_size, output_size)

# 设置模型为评估模式
model.eval()

# 创建一个示例输入（模型期望的输入格式）
dummy_input = torch.randn(1, input_size)

# 导出模型为ONNX格式
onnx_model_path = "simple_model.onnx"
torch.onnx.export(
    model,              # 要导出的模型
    dummy_input,        # 模型输入示例
    onnx_model_path,    # 保存路径
    export_params=True, # 导出模型参数
    opset_version=11,   # ONNX操作集版本
    do_constant_folding=True, # 是否执行常量折叠优化
    input_names=['input'],    # 输入的名称
    output_names=['output'],  # 输出的名称
    dynamic_axes={            # 动态轴（支持批处理）
        'input': {0: 'batch_size'},
        'output': {0: 'batch_size'}
    }
)

print(f"模型已导出到 {onnx_model_path}")

在其他框架中使用ONNX模型

以下是使用ONNX Runtime推理的示例：

import onnxruntime
import numpy as np

# 创建ONNX Runtime推理会话
ort_session = onnxruntime.InferenceSession("simple_model.onnx")

# 准备输入数据（注意，这里使用numpy数组而不是PyTorch张量）
input_data = np.random.randn(1, 10).astype(np.float32)
input_name = ort_session.get_inputs()[0].name
output_name = ort_session.get_outputs()[0].name

# 执行推理
output = ort_session.run([output_name], {input_name: input_data})[0]
print("ONNX模型输出:", output)

ONNX导出流程图：

┌─────────────┐     ┌─────────────┐     ┌─────────────┐     ┌─────────────┐
│ PyTorch模型  │────>│ torch.onnx  │────>│  ONNX模型   │────>│ 其他框架    │
│             │     │   .export    │     │ (.onnx文件) │     │ 加载并推理  │
└─────────────┘     └─────────────┘     └─────────────┘     └─────────────┘

TorchScript序列化

TorchScript简介

TorchScript是PyTorch的一个中间表示，可以被PyTorch的JIT编译器优化和执行。它提供了一种将PyTorch模型转换为序列化格式的方法，使模型可以在没有Python解释器的环境中运行。

Scripting vs Tracing

TorchScript提供了两种将模型转换为TorchScript的方法：

1. Scripting: 通过分析Python代码直接生成TorchScript。
2. Tracing: 通过执行模型并记录操作来生成TorchScript。

下面展示两种方法的实现：

import torch
import torch.nn as nn

class ScriptModel(nn.Module):
    def __init__(self):
        super(ScriptModel, self).__init__()
        self.conv1 = nn.Conv2d(1, 20, 5)
        self.relu = nn.ReLU()
        self.conv2 = nn.Conv2d(20, 64, 5)
        self.fc = nn.Linear(64*4*4, 10)
        
    def forward(self, x):
        x = self.relu(self.conv1(x))
        x = torch.max_pool2d(x, 2, 2)
        x = self.relu(self.conv2(x))
        x = torch.max_pool2d(x, 2, 2)
        x = x.view(-1, 64*4*4)
        x = self.fc(x)
        return x
    
    # 包含控制流的方法
    def control_flow_method(self, x, condition):
        if condition:
            return self.relu(x)
        else:
            return x * 0.5

# 创建模型实例
model = ScriptModel()
model.eval()

# 方法1: 脚本化 (Scripting) - 可以处理控制流
scripted_model = torch.jit.script(model)
scripted_model.save("scripted_model.pt")

# 方法2: 追踪 (Tracing) - 只记录实际执行的操作
example_input = torch.rand(1, 1, 28, 28)
traced_model = torch.jit.trace(model, example_input)
traced_model.save("traced_model.pt")

Scripting vs Tracing 对比表

特性	Scripting	Tracing
控制流	支持	不支持（固定执行路径）
动态形状	支持	有限支持（需要指定动态维度）
复杂Python操作	有限支持	不支持
速度	较慢（需要分析代码）	较快（只记录操作）
适用场景	含有条件语句、循环的模型	固定计算图的模型

使用TorchScript部署

加载并使用TorchScript模型：

# 加载脚本化模型
loaded_script_model = torch.jit.load("scripted_model.pt")

# 加载追踪模型
loaded_trace_model = torch.jit.load("traced_model.pt")

# 使用加载的模型进行推理
test_input = torch.rand(1, 1, 28, 28)
script_output = loaded_script_model(test_input)
trace_output = loaded_trace_model(test_input)

print("Script模型输出:", script_output)
print("Trace模型输出:", trace_output)

移动端部署

模型量化技术

量化是减小模型大小和加速推理的关键技术，特别是在移动端等资源受限的设备上。

import torch
import torch.nn as nn
import torch.quantization

# 定义一个量化友好的模型
class QuantizableModel(nn.Module):
    def __init__(self):
        super(QuantizableModel, self).__init__()
        self.quant = torch.quantization.QuantStub()
        self.conv1 = nn.Conv2d(3, 16, 3, padding=1)
        self.relu1 = nn.ReLU()
        self.maxpool = nn.MaxPool2d(2)
        self.conv2 = nn.Conv2d(16, 32, 3, padding=1)
        self.relu2 = nn.ReLU()
        self.fc = nn.Linear(32 * 8 * 8, 10)
        self.dequant = torch.quantization.DeQuantStub()
        
    def forward(self, x):
        x = self.quant(x)
        x = self.conv1(x)
        x = self.relu1(x)
        x = self.maxpool(x)
        x = self.conv2(x)
        x = self.relu2(x)
        x = self.maxpool(x)
        x = x.view(-1, 32 * 8 * 8)
        x = self.fc(x)
        x = self.dequant(x)
        return x

# 创建模型
model = QuantizableModel()

# 准备量化配置
model.qconfig = torch.quantization.get_default_qconfig('qnnpack')  # 移动端优化

# 准备量化（融合模块）
model_prepared = torch.quantization.prepare(model)

# 校准（通常使用验证集数据运行一些样本）
# 这里假设有一个校准数据集
calibration_data = [torch.randn(1, 3, 32, 32) for _ in range(10)]
with torch.no_grad():
    for input_data in calibration_data:
        model_prepared(input_data)

# 转换为量化模型
quantized_model = torch.quantization.convert(model_prepared)

# 保存量化模型
torch.jit.save(torch.jit.script(quantized_model), "quantized_model_for_mobile.pt")

量化的主要类型：

1. 动态量化：权重是在模型加载时量化的，而激活值是在运行时动态量化的。
2. 静态量化：权重和激活值都是预先量化的。
3. 量化感知训练（QAT）：在训练过程中模拟量化效果，产生更高质量的量化模型。

移动优化的最佳实践

1. 选择合适的模型架构：在移动端，轻量级架构如MobileNet、EfficientNet更为适用。
2. 优先使用静态量化：静态量化在移动端通常比动态量化有更好的性能。
3. 使用量化感知训练：如果准确率下降明显，考虑使用QAT。
4. 剪枝技术：移除不重要的连接来减小模型大小。
5. 知识蒸馏：使用大模型训练小模型，保持性能。

实践案例

下面是一个完整的实践案例，展示了如何训练一个简单的图像分类模型，保存它，然后通过各种方法部署：

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader
from torchvision import datasets, transforms
import os

# 定义一个简单的CNN模型
class SimpleCNN(nn.Module):
    def __init__(self):
        super(SimpleCNN, self).__init__()
        self.conv1 = nn.Conv2d(1, 32, kernel_size=3, stride=1, padding=1)
        self.relu1 = nn.ReLU()
        self.pool1 = nn.MaxPool2d(kernel_size=2)
        self.conv2 = nn.Conv2d(32, 64, kernel_size=3, stride=1, padding=1)
        self.relu2 = nn.ReLU()
        self.pool2 = nn.MaxPool2d(kernel_size=2)
        self.fc1 = nn.Linear(64 * 7 * 7, 128)
        self.relu3 = nn.ReLU()
        self.fc2 = nn.Linear(128, 10)
        
    def forward(self, x):
        x = self.pool1(self.relu1(self.conv1(x)))
        x = self.pool2(self.relu2(self.conv2(x)))
        x = x.view(-1, 64 * 7 * 7)
        x = self.relu3(self.fc1(x))
        x = self.fc2(x)
        return x

# 设置设备
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
print(f"使用设备: {device}")

# 数据预处理
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.1307,), (0.3081,))
])

# 加载MNIST数据集
train_dataset = datasets.MNIST('./data', train=True, download=True, transform=transform)
test_dataset = datasets.MNIST('./data', train=False, transform=transform)

train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=1000, shuffle=False)

# 创建模型、损失函数和优化器
model = SimpleCNN().to(device)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# 训练函数
def train(model, device, train_loader, optimizer, criterion, epoch):
    model.train()
    for batch_idx, (data, target) in enumerate(train_loader):
        data, target = data.to(device), target.to(device)
        optimizer.zero_grad()
        output = model(data)
        loss = criterion(output, target)
        loss.backward()
        optimizer.step()
        
        if batch_idx % 100 == 0:
            print(f'训练周期: {epoch} [{batch_idx * len(data)}/{len(train_loader.dataset)} '
                  f'({100. * batch_idx / len(train_loader):.0f}%)]\t损失: {loss.item():.6f}')

# 测试函数
def test(model, device, test_loader, criterion):
    model.eval()
    test_loss = 0
    correct = 0
    with torch.no_grad():
        for data, target in test_loader:
            data, target = data.to(device), target.to(device)
            output = model(data)
            test_loss += criterion(output, target).item()
            pred = output.argmax(dim=1, keepdim=True)
            correct += pred.eq(target.view_as(pred)).sum().item()
    
    test_loss /= len(test_loader)
    accuracy = 100. * correct / len(test_loader.dataset)
    print(f'\n测试集: 平均损失: {test_loss:.4f}, 准确率: {correct}/{len(test_loader.dataset)} ({accuracy:.2f}%)\n')
    return accuracy

# 创建保存模型的目录
if not os.path.exists('saved_models'):
    os.makedirs('saved_models')

# 训练模型
num_epochs = 3
best_accuracy = 0

for epoch in range(1, num_epochs + 1):
    train(model, device, train_loader, optimizer, criterion, epoch)
    accuracy = test(model, device, test_loader, criterion)
    
    # 保存最佳模型
    if accuracy > best_accuracy:
        best_accuracy = accuracy
        
        # 方法1：保存完整模型
        torch.save(model, 'saved_models/full_model.pth')
        
        # 方法2：只保存模型参数
        torch.save(model.state_dict(), 'saved_models/model_state_dict.pth')
        
        # 方法3：保存检查点（包含更多信息）
        checkpoint = {
            'epoch': epoch,
            'model_state_dict': model.state_dict(),
            'optimizer_state_dict': optimizer.state_dict(),
            'loss': criterion,
            'accuracy': accuracy
        }
        torch.save(checkpoint, 'saved_models/checkpoint.pth')
        
        print(f"保存最佳模型，准确率: {accuracy:.2f}%")

print("训练完成！")

# ------------- 加载模型示例 -------------

# 加载完整模型
loaded_full_model = torch.load('saved_models/full_model.pth')
loaded_full_model.eval()  # 设置为评估模式

# 加载state_dict到新模型
new_model = SimpleCNN().to(device)
new_model.load_state_dict(torch.load('saved_models/model_state_dict.pth'))
new_model.eval()

# 加载检查点
checkpoint = torch.load('saved_models/checkpoint.pth')
checkpoint_model = SimpleCNN().to(device)
checkpoint_model.load_state_dict(checkpoint['model_state_dict'])
checkpoint_optimizer = optim.Adam(checkpoint_model.parameters(), lr=0.001)
checkpoint_optimizer.load_state_dict(checkpoint['optimizer_state_dict'])
epoch = checkpoint['epoch']
checkpoint_model.eval()

print(f"成功加载了3种类型的模型，最后保存的周期是: {epoch}")

# ------------- 导出ONNX模型 -------------

# 准备一个样本输入
dummy_input = torch.randn(1, 1, 28, 28, device=device)

# 确保onnx目录存在
if not os.path.exists('onnx'):
    os.makedirs('onnx')

# 导出模型
torch.onnx.export(
    model,                        # 要导出的模型
    dummy_input,                  # 模型输入示例
    "onnx/mnist_model.onnx",      # 导出文件路径
    export_params=True,           # 存储训练好的参数权重
    opset_version=11,             # ONNX版本
    do_constant_folding=True,     # 是否执行常量折叠优化
    input_names=['input'],        # 输入名称
    output_names=['output'],      # 输出名称
    dynamic_axes={                # 动态尺寸设置
        'input': {0: 'batch_size'},
        'output': {0: 'batch_size'}
    }
)

print("模型已导出为ONNX格式")

# ------------- TorchScript序列化 -------------

# 确保torchscript目录存在
if not os.path.exists('torchscript'):
    os.makedirs('torchscript')

# 使用Scripting
scripted_model = torch.jit.script(model)
scripted_model.save("torchscript/scripted_model.pt")

# 使用Tracing
with torch.no_grad():
    traced_model = torch.jit.trace(model, dummy_input)
    traced_model.save("torchscript/traced_model.pt")

print("模型已序列化为TorchScript格式")

# ------------- 模型量化 -------------

# 确保quantized目录存在
if not os.path.exists('quantized'):
    os.makedirs('quantized')

# 在CPU上运行量化
model_to_quantize = SimpleCNN().to('cpu')
model_to_quantize.load_state_dict(torch.load('saved_models/model_state_dict.pth', map_location='cpu'))
model_to_quantize.eval()

# 准备用于量化的模型
model_to_quantize.qconfig = torch.quantization.get_default_qconfig('fbgemm')
prepared_model = torch.quantization.prepare(model_to_quantize)

# 校准步骤
# 在实际应用中，你应该使用一个校准数据集
# 这里为了简单，我们只使用一个小批量的测试数据
calibration_loader = DataLoader(test_dataset, batch_size=32, shuffle=True)
with torch.no_grad():
    for i, (data, _) in enumerate(calibration_loader):
        if i >= 10:  # 使用10批次进行校准
            break
        prepared_model(data)

# 转换为量化模型
quantized_model = torch.quantization.convert(prepared_model)

# 保存量化模型
torch.save(quantized_model.state_dict(), 'quantized/quantized_model_state_dict.pth')

# 同时也可以保存为TorchScript格式以便在C++中使用
quantized_scripted_model = torch.jit.script(quantized_model)
quantized_scripted_model.save('quantized/quantized_scripted_model.pt')

print("模型已量化并保存")

# ------------- 验证不同模型的推理结果 -------------
print("\n验证各种模型的推理结果:")

# 获取一个测试样本
test_batch = next(iter(test_loader))
test_data, test_labels = test_batch
test_data, test_labels = test_data.to(device), test_labels.to(device)
test_sample = test_data[0:1]  # 只取第一个样本
actual_label = test_labels[0].item()

# 原始模型推理
with torch.no_grad():
    original_output = model(test_sample)
    original_pred = original_output.argmax(dim=1).item()

# 加载的完整模型推理
with torch.no_grad():
    full_model_output = loaded_full_model(test_sample)
    full_model_pred = full_model_output.argmax(dim=1).item()

# 从state_dict加载的模型推理
with torch.no_grad():
    state_dict_model_output = new_model(test_sample)
    state_dict_model_pred = state_dict_model_output.argmax(dim=1).item()

# TorchScript模型推理
with torch.no_grad():
    scripted_output = scripted_model(test_sample)
    scripted_pred = scripted_output.argmax(dim=1).item()
    
    traced_output = traced_model(test_sample)
    traced_pred = traced_output.argmax(dim=1).item()

# 打印结果
print(f"实际标签: {actual_label}")
print(f"原始模型预测: {original_pred}")
print(f"完整加载模型预测: {full_model_pred}")
print(f"State Dict加载模型预测: {state_dict_model_pred}")
print(f"Scripted模型预测: {scripted_pred}")
print(f"Traced模型预测: {traced_pred}")

# 如果在CPU上，还可以验证量化模型
if device.type == 'cpu':
    # 将测试样本移到CPU
    cpu_test_sample = test_sample.cpu()
    
    # 量化模型推理
    quantized_output = quantized_model(cpu_test_sample)
    quantized_pred = quantized_output.argmax(dim=1).item()
    print(f"量化模型预测: {quantized_pred}")

print("\n所有模型保存与部署流程已完成!")

部署流程比较

以下是各种模型部署方法的工作流程图：

【模型训练】
      │
      ▼
┌───────────────┐
│   训练完成     │
└───────┬───────┘
        │
        ▼
┌──────────────────────┐
│    模型保存策略选择    │
└──────────┬───────────┘
           │
           ▼
   ┌───────────────────┌───────────────────┐
   │                   │                   │
   ▼                   ▼                   ▼
┌────────┐      ┌─────────────┐     ┌────────────┐
│完整模型 │      │state_dict   │     │检查点(epoch,│
│保存     │      │只保存参数    │     │optimizer等) │
└───┬────┘      └──────┬──────┘     └──────┬─────┘
    │                  │                   │
    └──────────────────┼───────────────────┘
                       │
                       ▼
               ┌───────────────┐
               │  部署目标平台   │
               └───────┬───────┘
                       │
                       ▼
     ┌─────────────────────────────┐
     │                             │
     ▼                             ▼                           ▼
┌────────────┐             ┌───────────────┐           ┌─────────────┐
│TorchScript │             │ONNX跨框架部署 │           │ 移动端部署  │
└─────┬──────┘             └────────┬──────┘           └─────┬───────┘
      │                             │                         │
      ▼                             ▼                         ▼
┌──────────────┐          ┌──────────────────┐      ┌─────────────────┐
│Script vs Trace│         │TensorFlow/TensorRT│      │模型量化        │
│选择合适的方法  │          │/ONNX Runtime等    │      │(静态/动态/QAT) │
└──────────────┘          └──────────────────┘      └─────────────────┘

模型保存与部署的决策指南

为了帮助你选择适合的保存和部署方法，以下是一个决策指南：

需求/场景	推荐方法	注意事项
需要跨深度学习框架部署	ONNX	确保目标框架支持你使用的所有操作
在Python环境中快速原型设计	完整模型保存	方便但文件较大，版本兼容性较差
生产环境部署	state_dict + 模型定义	确保模型定义与训练时一致
需要训练中断和恢复	检查点（包含epoch、optimizer等）	包含足够信息以恢复训练状态
需要在没有Python环境的C++/Java中部署	TorchScript	针对控制流选择Script，固定图选择Trace
模型包含条件语句和循环	TorchScript (Script方式)	避免使用Trace方式
移动设备部署	量化 + TorchScript	考虑使用量化感知训练提高精度
对延迟敏感的服务	TorchScript + 量化	优先考虑静态量化
高吞吐量服务器	ONNX + TensorRT	利用GPU加速

总结

在今天的学习中，我们详细探讨了PyTorch中的模型保存与部署方法，包括：

1. 模型保存的不同方法：

   • 完整模型保存 vs 仅保存参数(state_dict)
   • 检查点保存与恢复训练状态

2. 跨框架部署ONNX：

   • ONNX格式导出
   • 在其他框架中使用ONNX模型

3. TorchScript序列化：

   • Script vs Trace方法的区别
   • 适用场景分析

4. 移动端部署：

   • 模型量化技术
   • 移动优化的最佳实践

这些知识和技能将帮助你不仅能够训练出高质量的深度学习模型，还能够正确地保存并有效地部署它们到各种目标平台，从而实现模型的实际价值。

---

清华大学全三版的《DeepSeek教程》完整的文档需要的朋友，关注我私信：deepseek 即可获得。
怎么样今天的内容还满意吗？再次感谢朋友们的观看，关注GZH：凡人的AI工具箱，回复666，送您价值199的AI大礼包。最后，祝您早日实现财务自由，还请给个赞，谢谢！