英译法案例 - 模型预测代码测试

1 课程概览

本课讲解模型预测测试代码。加载训练好的编码器和解码器模型，对比真实法语和生成的法语。重点讲解 map_location 参数（CPU/GPU 互换）和 weights_only 参数（只加载模型权重参数）。提到迁移学习：拿着别人训练好的模型直接用。

2 核心概念与定义

map_location：指定加载模型的设备，实现 CPU/GPU 互换。
weights_only：只加载模型权重参数，忽略保存的其他参数。
迁移学习：拿着别人训练好的模型直接用。
load_state_dict：加载模型参数。

3 模型与算法详解

测试流程

第一步：获取数据加载器对象

my_dataloader = get_dataloader()

第二步：加载编码器模型

# 创建编码器对象
my_encoder_rnn = Encoder(ENGLISH_WORD_N, hidden_size=256).to(device)

# 加载模型参数
my_encoder_rnn.load_state_dict(
    torch.load(path1, map_location=device)
)

第三步：加载解码器模型

# 创建解码器对象
my_attn_decoder = AttnDecoder(FRENCH_WORD_N, hidden_size=256).to(device)

# 加载模型参数
my_attn_decoder.load_state_dict(
    torch.load(path2, map_location=device)
)

map_location 参数

确保 CPU 和 GPU 都能加载。

训练设备	预测设备	是否需要 map_location
GPU	GPU	不需要
CPU	CPU	不需要
GPU	CPU	需要
CPU	GPU	需要

示例：

用 GPU 训练，用 CPU 预测：需要 map_location='cpu'
用 CPU 训练，用 GPU 预测：需要 map_location='cuda'

weights_only 参数

torch.load(path, map_location=device, weights_only=True)

weights_only=True：只加载模型权重参数
忽略保存的其他参数

迁移学习

拿着别人训练好的模型直接用。

假设有人训练了 6 小时，跑完所有数据
把 .pth 文件拷贝给你
你可以直接加载使用

模型路径

path1 = './model/encoder_rnn_iter5.pth'  # 编码器（第5轮）
path2 = './model/attention_decoder_iter5.pth'  # 解码器（第5轮）

选择第 5 轮（最后一轮）的模型，效果最好

4 数学原理与推导

本课为模型加载，无数学原理。

5 代码示例

import torch


def dm_test_seq2seq_evaluate():
    """模型预测测试函数"""
    
    # 第一步：获取数据加载器对象
    my_dataloader = get_dataloader()
    
    # 第二步：加载编码器模型
    # 2.1 创建编码器对象
    my_encoder_rnn = Encoder(
        ENGLISH_WORD_N,  # 英语词汇表大小
        hidden_size=256
    ).to(device)
    
    # 2.2 加载模型参数
    path1 = './model/encoder_rnn_iter5.pth'
    my_encoder_rnn.load_state_dict(
        torch.load(path1, map_location=device)
    )
    
    # 第三步：加载解码器模型
    # 3.1 创建解码器对象
    my_attn_decoder = AttnDecoder(
        FRENCH_WORD_N,  # 法语词汇表大小
        hidden_size=256
    ).to(device)
    
    # 3.2 加载模型参数
    path2 = './model/attention_decoder_iter5.pth'
    my_attn_decoder.load_state_dict(
        torch.load(path2, map_location=device)
    )
    
    # 第四步：模型预测
    for i, (x, y) in enumerate(my_dataloader):
        # 真实法语
        real_french = [FRENCH.index2word[idx.item()] for idx in y]
        
        # 生成的法语
        generated_french, attns = evaluate(
            x, my_encoder_rnn, my_attn_decoder
        )
        
        # 打印对比
        print(f"英文: {' '.join([ENGLISH.index2word[idx.item()] for idx in x])}")
        print(f"真实法语: {' '.join(real_french)}")
        print(f"生成法语: {' '.join(generated_french)}")
        print("-" * 50)
        
        break  # 只测试一条


# 测试
if __name__ == "__main__":
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    print(f"当前设备: {device}")
    dm_test_seq2seq_evaluate()