NLP - 迁移经验汇总¶

一、迁移概述¶

模型迁移本质上需要从模型训练与预测的角度去完成该任务，保证训练结果与预测结果与参考代码保持一致。

• 在模型预测过程中，模型组网、数据处理与加载、评估指标等均需要严格对齐，否则无法产出与参考代码完全相同的模型及预测结果。

• 在训练阶段，除了模型结构等元素，训练的损失函数、梯度、训练超参数、初始化方法以及训练精度也是我们需要迁移并对齐的内容。一个完整的模型训练包括定义模型结构并初始化，将处理后的数据送进网络，对输出的内容与真值计算损失函数，并反向传播与迭代的过程。

# 安装 GPU 版本的飞桨
pip install paddlepaddle-gpu
# 安装 CPU 版本的 Paddle
pip install paddlepaddle

import paddle
paddle.utils.run_check()

PaddlePaddle is installed successfully! Let's start deep learning with PaddlePaddle now.

python -m pip install paddlepaddle-gpu==0.0.0.post102 -f https://www.paddlepaddle.org.cn/whl/linux/gpu/develop.html

pip3 install reprod_log --force-reinstall

import torch
print(torch.__version__)
# 如果安装的是 cpu 版本，可以按照下面的命令确认 torch 是否安装成功
# 期望输出为 tensor([1.])
print(torch.Tensor([1.0]))
# 如果安装的是 gpu 版本，可以按照下面的命令确认 torch 是否安装成功
# 期望输出为 tensor([1.], device='cuda:0')
print(torch.Tensor([1.0]).cuda())

进入文件夹
cd pipeline/reprod_log_demo
随机生成矩阵，写入文件中
python3.7 write_log.py
进行文件对比，输出日志
python3.7 check_log_diff.py

2021-09-28 01:07:44,832 - reprod_log.utils - INFO - demo_test_1:
2021-09-28 01:07:44,832 - reprod_log.utils - INFO -     mean diff: check passed: True, value: 0.0
2021-09-28 01:07:44,832 - reprod_log.utils - INFO - demo_test_2:
2021-09-28 01:07:44,832 - reprod_log.utils - INFO -     mean diff: check passed: False, value: 0.3336232304573059
2021-09-28 01:07:44,832 - reprod_log.utils - INFO - diff check failed

result
├── log
├── data_paddle.npy
├── data_ref.npy
├── forward_paddle.npy
├── forward_ref.npy           # 与 forward_paddle.npy 作为一并核查的文件对
├── metric_paddle.npy
├── metric_ref.npy            # 与 metric_paddle.npy 作为一并核查的文件对
├── loss_paddle.npy
├── loss_ref.npy              # 与 loss_paddle.npy 作为一并核查的文件对
├── losses_paddle.npy
├── losses_ref.npy            # 与 losses_paddle.npy 作为一并核查的文件对

基于 reprod_log 的 ReprodDiffHelper 模块，产出下面 5 个日志文件。

log
├── data_diff.log            # data_paddle.npy 与 data_torch.npy 生成的 diff 结果文件
├── forward_diff.log         # forward_paddle.npy 与 forward_torch.npy 生成的 diff 结果文件
├── metric_diff.log          # metric_paddle.npy 与 metric_torch.npy 生成的 diff 结果文件
├── loss_diff.log            # loss_paddle.npy 与 loss_torch.npy 生成的 diff 结果文件
├── backward_diff.log        # losses_paddle.npy 与 losses_torch.npy 生成的 diff 结果文件

def gen_fake_data():
    fake_data = np.random.randint(1, 30522, size=(4, 64)).astype(np.int64)
    fake_label = np.array([0, 1, 1, 0]).astype(np.int64)
    np.save("fake_data.npy", fake_data)
    np.save("fake_label.npy", fake_label)

bert_torch
    |-accuracy.py                                 # 评价指标
    |-train.py                                    # 模型训练代码
    |-utils.py                                    # 工具类及函数
    |-log.log                                     #日志记录
    |-glue.py                                     #数据生成代码
    |-train.sh                                    #启动训练的 bash 脚本

# 克隆参考代码所在的项目 repo 到本地
git clone https://github.com/PaddlePaddle/PaddleNLP.git
cd examples/torch_migration/

bert_torch
    |-accuracy.py                                 # 评价指标
    |-train.py                                    # 模型训练代码
    |-utils.py                                    # 工具类及函数
    |-log.log                                     #日志记录
    |-glue.py                                     #数据生成代码
    |-train.sh                                    #启动训练的 bash 脚本

二、模型前向对齐¶

模型前向对齐是模型迁移的最核心部分。在这一部分工作中，需要保证迁移之后的模型结构与原始模型一致，当两个模型固定为相同的权重时，对于相同的输入，二者的输出结果相同（即“前向对齐”）。模型前向对齐主要包括以下步骤：

1. 网络结构代码转换：将定义模型网络结构的 PyTorch 代码转换成飞桨代码。由于飞桨定义模型网络结构的方式与 PyTorch 非常相似，因此主要的工作在于 API 的转换（例如内置的模块、函数）。

2. 权重转换：只有当两个模型的权重相同时，对于相同的输入数据，两个模型才能输出相同的结果（即“前向对齐”）。为了检查模型前向对齐，需要使飞桨模型具有与原始模型相同的权重，因此需要把原始模型的权重转换为飞桨格式的模型权重，供飞桨模型加载。

3. 模型前向对齐验证：让转换前后的模型加载相同的权重，给两个模型输入相同的数据，利用差异核验工具检查两个模型的输出是否一致。若二者的差异小于一定的阈值，则迁移后模型的正确性得到了验证。

from transformers import BertModel
import torch

hf_model = BertModel.from_pretrained("bert-base-uncased")
hf_model.eval()
PATH = './torch_weight.bin'
torch.save(hf_model.state_dict(), PATH)

def convert_pytorch_checkpoint_to_paddle(
    pytorch_checkpoint_path="pytorch_model.bin",
    paddle_dump_path="model_state.pdparams",
    version="old",
):
    do_not_transpose = []
    if version == "old":
        hf_to_paddle.update({
            "predictions.bias": "predictions.decoder_bias",
            ".gamma": ".weight",
            ".beta": ".bias",
        })
        do_not_transpose = do_not_transpose + ["predictions.decoder.weight"]

    pytorch_state_dict = torch.load(pytorch_checkpoint_path, map_location="cpu")
    paddle_state_dict = OrderedDict()
    for k, v in pytorch_state_dict.items():
        is_transpose = False
        if k[-7:] == ".weight":
            # embeddings.weight and LayerNorm.weight do not transpose
            if all(d not in k for d in do_not_transpose):
                if ".embeddings." not in k and ".LayerNorm." not in k:
                    if v.ndim == 2:
                        if 'embeddings' not in k:
                            v = v.transpose(0, 1)
                            is_transpose = True
                        is_transpose = False
        oldk = k
        print(f"Converting: {oldk} => {k} | is_transpose {is_transpose}")
        paddle_state_dict[k] = v.data.numpy()

    paddle.save(paddle_state_dict, paddle_dump_path)

三、小数据集数据读取对齐¶

为快速验证数据读取以及后续的训练/评估/预测，可以准备一个小数据集（对句子二分类，其中包括 32 个句子以及他们对应的标签），数据位于 https://github.com/PaddlePaddle/PaddleNLP/tree/develop/examples/torch_migration/pipeline/Step2/demo_sst2_sentence/demo.tsv

对于一个数据集，一般有以下一些信息需要重点关注：

• 数据集名称、下载地址

• 训练集/验证集/测试集

• 数据集通用的预处理方法

【基本流程】

1. Dataset 迁移：使用paddle.io.Dataset完成数据集的单个样本读取。飞桨中数据集相关的 API 为paddle.io.Dataset，PyTorch 中对应为torch.utils.data.Dataset，二者功能一致，在绝大多数情况下，可以使用该类构建数据集。

此接口是描述 Dataset 方法和行为的抽象类，在具体实现的时候，需要继承这个基类，实现其中的__getitem__和__len__方法。

除了参考代码中相关实现，也可以参考待迁移项目中的说明。

1. DataLoader 迁移：迁移完 Dataset 之后，可以使用paddle.io.DataLoader，构建 Dataloader，对数据进行组 batch、批处理，送进网络进行计算。

paddle.io.DataLoader可以进行数据加载，将数据分成批数据，并提供加载过程中的采样。PyTorch 对应的实现为torch.utils.data.DataLoader，二者在功能上一致，仅在参数方面稍有差异：

• • 飞桨增加了use_shared_memory参数来选择是否使用共享内存加速数据加载过程。

【实战】

BERT 模型复现过程中，数据预处理和 Dataset、Dataloader 的检查可以参考该文件：https://github.com/PaddlePaddle/PaddleNLP/tree/develop/examples/torch_migration/pipeline/Step2/test_data.py 使用方法可以参考数据检查文档。

【注意事项】

• 如果代码中存在 random.random 或者其他 random 库的，可以先把随机数替换成固定数值，避免 random 对对齐结果产生影响。设置 seed 的方式当调用 random 库的顺序不同时产生的随机值也不同，可能导致对齐存在问题。

• 论文中一般会提供数据集的名称以及基本信息。复现过程中，我们在下载完数据之后，建议先检查下是否和论文中描述一致，否则可能存在的问题有：

• 数据集版本不同，比如论文中使用了 cnn_dailymail 的 v3.0.0 版本数据集，但是我们下载的是 cnn_dailymail 的 v1.0.0 版本数据集，如果不对其进行检查，可能会导致我们最终训练的数据量等与论文中有 diff

• 数据集使用方式不同，有些论文中，可能只是抽取了该数据集的子集进行方法验证，此时需要注意抽取方法，需要保证抽取出的子集完全相同。

• 在评估指标对齐时，我们可以固定 batch size，关闭 Dataloader 的 shuffle 操作。

此外，

• 有些自定义的数据处理方法，如果不涉及到深度学习框架的部分，可以直接复用。

• 对于特定任务中的数据预处理方法，比如说 Tokenizer，如果没有现成的 API 可以调用，可以参考 PaddleNLP 套件中的一些实现方法，比如BertTokenizer, XLNetTokenizer等。

【FAQ】

Q：还有其他导致不能对齐的因素么？

A：可以能存在以下因素：

• 预处理方法顺序不一致：预处理的方法相同，顺序不同，比如先 padding 再做归一化与先做归一化再 padding，得到的结果可能是不同的。

• 没有关闭 shuffle：在评估指标对齐时，需要固定 batch size，关闭 Dataloader 的 shuffle 操作。

四、评估指标对齐¶

评估指标是模型精度的度量。在自然语言处理中，不同任务使用的评估指标有所不同，为了检验迁移后的模型能否达到原模型的精度指标，需要保证使用的评估指标与原始代码一致以便对照。在这一步骤中，需要将原始代码中的评价指标替换成飞桨的等价实现。在前面的步骤中，已经检查了两个模型已前向对齐。因此，在此基础上让两个模型固定相同的权重，给两个模型输入相同的数据，分别计算评估指标，若二者评估指标结果相同，则说明评估指标对齐完成。

飞桨提供了一系列 Metric 计算类，比如说Accuracy, Auc, Precision, Recall等，而 PyTorch 中，目前可以通过组合的方式实现评估指标的计算，或者调用 torchmetrics。在迁移过程中，需要注意保证对于该模块，给定相同的输入，二者输出完全一致。

【基本流程】

1. 获取 PyTorch 模型评估结果：定义 PyTorch 模型，加载训练好的权重，获取评估结果。

2. 获取飞桨模型评估结果：定义飞桨模型，加载训练好的权重（需要是从 PyTorch 转换得到），获取评估结果。

3. 比较结果差异：使用 reprod_log 比较两个结果的差值，如果小于阈值，即可完成自测。

【实战】

评估指标对齐检查方法脚本：test_metric.py

【核验】

对于待迁移的项目，评估指标对齐核验流程如下。

1. 输入：dataloader, model

2. 输出：

• 飞桨/PyTorch：dict，key 为 tensor 的 name（自定义），value 为具体评估指标的值。最后将 dict 使用 reprod_log 保存到各自的文件中，建议命名为metric_paddle.npy和metric_pytorch.npy。

• 自测：使用 reprod_log 加载 2 个文件，使用 report 功能，记录结果到日志文件中，建议命名为metric_diff_log.txt，观察 diff，二者 diff 小于特定的阈值即可。

1. 提交内容：将metric_paddle.npy、metric_pytorch.npy与metric_diff_log.txt文件备份到result和result/log新建的文件夹中，后续的输出结果和自查日志也对应放在文件夹中，一并打包上传即可。

2. 注意：

• 这部分需要使用真实数据

• 需要检查 PyTorch 项目是否只是抽取了验证集/测试集中的部分文件。如果是的话，则需要保证飞桨和参考代码中 dataset 使用的数据集一致。

【FAQ】

Q：有哪些会导致评估出现精度偏差呢？

A：比如：

• • 使用 dataloader 参数没有保持一致：例如需要检查飞桨代码与 PyTorch 代码在paddle.io.DataLoader 的 drop_last 参数上是否保持一致 (文档链接，如果不一致，最后不够 batch-size 的数据可能不会参与评估，导致评估结果会有 diff。

  • 转换到不同设备上运行代码：在识别或者检索过程中，为了加速评估过程，往往会将评估函数由 CPU 实现改为 GPU 实现，由此会带来评估函数输出的不一致。这是由于 sort 函数对于相同值的排序结果不同带来的。在迁移的过程中，如果可以接受轻微的指标不稳定，可以使用飞桨的 sort 函数，如果对于指标非常敏感，同时对速度性能要求很高，可以给飞桨提ISSUE，由研发人员高优开发。

  • 评估参数和训练参数不一致：在检测任务中，评估流程往往和训练流程有一定差异，例如 RPN 阶段 NMS 的参数等，这里需要仔细检查评估时的超参数，不要将训练超参和评估超参弄混淆。

  • 评估时数据过滤规则不一致：在 OCR 等任务中，需要注意评估过程也会对 GT 信息进行修正，比如大小写等，也会过滤掉一些样本，这里需要注意过滤规则，确保有效评估数据集一致。

五、损失函数对齐¶

损失函数是训练模型时的优化目标，使用的损失函数会影响模型的精度。在模型迁移时，需要保证迁移后模型训练时使用的损失函数与原始代码中使用的损失函数一致，以便二者对照。在前面的步骤中，已经检查了两个模型已前向对齐。因此，在此基础上让两个模型固定相同的权重，给两个模型输入相同的数据，分别计算损失函数，若二者 loss 相同，则说明损失函数对齐完成。

飞桨与 PyTorch 均提供了很多损失函数，用于模型训练，具体的 API 映射表可以参考：Loss 类 API 映射列表。

【基本流程】

1. 计算 PyTorch 损失：定义 PyTorch 模型，加载权重，加载 fake data 和 fake label（或者固定 seed，基于 numpy 生成随机数），转换为 torch.Tensor，送入网络，获取 loss 结果。

2. 计算飞桨损失：定义飞桨模型，加载 fake data 和 fake label（或者固定 seed，基于 numpy 生成随机数），转换为 paddle.Tensor，送入网络，获取 loss 结果。

3. 比较结果差异：使用 reprod_log 比较两个结果的差值，如果小于阈值，即可完成自测。

【差异分析】

以 CrossEntropyLoss 为例，主要区别为：

飞桨提供了对软标签、指定 softmax 计算维度的支持。如果 Pytorch 使用的 loss function 没有指定的 API，则可以尝试通过组合 API 的方式，实现自定义的 loss function。

【实战】

该部分可以参考Step3/readme

使用该文件生成 pytorch 损失函数:Step3/torch_loss.py

使用该文件生成 paddle 损失函数:Step3/paddle_loss.py

【核验】

对于待迁移的项目，损失函数对齐核验流程如下。

1. 输入：fake data & label

2. 输出：飞桨/PyTorch：dict，key 为 tensor 的 name（自定义），value 为具体评估指标的值。最后将 dict 使用 reprod_log 保存到各自的文件中，建议命名为loss_paddle.npy和loss_pytorch.npy。

3. 自测：使用 reprod_log 加载 2 个文件，使用 report 功能，记录结果到日志文件中，建议命名为loss_diff_log.txt，观察 diff，二者 diff 小于特定的阈值即可。

【注意事项】

• 计算 loss 的时候，建议设置model.eval()，避免模型中随机量的问题。

• 飞桨目前支持在 optimizer 中通过设置 params_groups 的方式设置不同参数的更新方式，可以参考代码示例 。

• 某些模型训练时，会使用梯度累加策略，即累加到一定 step 数量之后才进行参数更新，这时在实现上需要注意对齐。

【FAQ】

Q：为什么nn.CrossEntropyLoss出现不能对齐问题？

A：paddle.nn.CrossEntropyLoss 默认是在最后一维(axis=-1)计算损失函数，而 torch.nn.CrossEntropyLoss 是在 axis=1 的地方计算损失函数，因此如果输入的维度大于 2，这里需要保证计算的维(axis)相同，否则可能会出错。

六、模型训练超参对齐¶

模型的训练超参包括学习率、优化器、正则化策略等。这些超参数指定了模型训练过程中网络参数的更新方式，训练超参数的设置会影响到模型的收敛速度及收敛精度。在模型迁移时，需要保证迁移前后模型使用的训练超参数一致，以便对照二者的收敛情况。

【基本流程】

本部分对齐建议对照飞桨优化器 API 文档、飞桨正则化 API 文档与参考代码的优化器实现进行对齐，用之后的反向对齐统一验证该模块的正确性。

• 优化器：飞桨中的 optimizer 有paddle.optimizer等一系列实现，PyTorch 中则有torch.optim等一系列实现。需要仔细对照飞桨与参考代码的优化器参数实现，确保优化器参数严格对齐。

• 学习率策略：主要用于指定训练过程中的学习率变化曲线，这里可以将定义好的学习率策略，不断 step，即可得到对应的学习率值。对于迁移代码和 PyTorch 代码，学习率在整个训练过程中在相同的轮数相同的 iter 下应该保持一致，可以通过打印学习率值或者可视化二者学习率的 log 来查看差值。可以参考学习率对齐代码learning.py。

• 正则化策略：在模型训练中，L2 正则化可以防止模型对训练数据过拟合，L1 正则化可以用于得到稀疏化的权重矩阵。飞桨中有paddle.regularizer.L1Decay与paddle.regularizer.L2Decay API。PyTorch 中，torch.optim 集成的优化器只有 L2 正则化方法，直接在构建 optimizer 的时候，传入weight_decay参数即可。在如 Transformer 或者少部分 CNN 模型中，存在一些参数不做正则化(正则化系数为 0)的情况。这里需要找到这些参数并对齐取消实施正则化策略，可以参考这里，对特定参数进行修改。

【区别】

以 SGD 等优化器为例，飞桨与 Pytorch 的优化器区别主要如下：

• 飞桨中，需要首先构建学习率策略，再传入优化器对象中；对于 PyTorch，如果希望使用更丰富的学习率策略，需要先构建优化器，再传入学习率策略类 API。

• 飞桨在优化器中增加了对梯度裁剪的支持，在训练 GAN、NLP、多模态等任务时较为常用。

• 飞桨的 SGD 不支持动量更新、动量衰减和 Nesterov 动量。若需实现这些功能，请使用paddle.optimizer.Momentum API。

• 飞桨的 optimizer 中支持 L1Decay/L2Decay。

【FAQ】

1. 怎么实现参数分组学习率策略？

飞桨目前支持在 optimizer 中通过设置 params_groups 的方式设置不同参数的更新方式，可以参考代码示例 。

1. 有没有什么其他影响优化不对齐的原因？

• 有些模型训练时，会使用梯度累加策略，即累加到一定 step 数量之后才进行参数更新，这时在实现上需要注意对齐。

• 在文本分类领域，大多数 Transformer 模型都采用了 AdamW 优化器，并且会设置 weigh decay，同时部分参数设置为 no weight decay，例如位置编码的参数通常设置为 no weight decay，no weight decay 参数设置不正确，最终会有明显的精度损失，需要特别注意。一般可以通过分析模型权重来发现该问题，分别计算官方模型和复现模型每层参数权重的平均值、方差，对每一层依次对比，有显著差异的层可能存在问题，因为在 weight decay 的作用下，参数权重数值会相对较小，而未正确设置 no weight decay，则会造成该层参数权重数值异常偏小设置 no weight decay 可以参照这里。

• 在 OCR 识别等任务中，Adadelta优化器常常被使用，该优化器与 PyTorch 实现目前稍有不同，但是不影响模型训练精度对齐。在做前反向对齐时，可以将该优化器替换为 Adam 等优化器（飞桨与参考代码均需要替换）；对齐完成之后，再使用Adadelta优化器进行完整的训练精度对齐。

1. 有没有什么任务不需要进行优化对齐的呢？

在某些任务中，比如说深度学习可视化、可解释性等任务中，一般只要求模型前向过程，不需要训练，此时优化器、学习率等用于模型训练的模块对于该类模型迁移是不需要的。

1. 飞桨的学习率策略对不齐怎么办？

• 飞桨中参数的学习率受到优化器学习率和ParamAttr中设置的学习率影响，在对齐时也需要保证这个部分的行为一致。

• 有些网络的学习率策略比较细致，比如带 warmup 的学习率策略，这里需要保证起始学习率等参数都完全一致。

七、反向梯度对齐¶

反向梯度对齐的目的是确保迁移后的模型反向传播以及权重更新的行为与原始模型一致，同时也是对上一步模型训练超参对齐的验证。具体的检验方法是通过两次（或以上）迭代训练进行检查（这是因为第一次迭代之后，会根据反向传播计算得到的梯度与设定的训练超参更新模型参数，第二次迭代前向传播时，使用的是更新后的参数），若迁移前后的模型第二个迭代的训练 loss 一致，说明二者更新后的参数一致，则可以认为二者反向已对齐。

【基本流程】

此处可以通过 numpy 生成 fake data 和 label（推荐），也可以准备固定的真实数据。具体流程如下：

1. 检查训练超参：检查两个代码的训练超参数全部一致，如优化器及其超参数、学习率、BatchNorm/LayerNorm 中的 eps 等。

2. 关闭随机操作：将飞桨与 PyTorch 网络中涉及的所有随机操作全部关闭，如 dropout、drop_path 等，推荐将模型设置为 eval 模式（model.eval()）。

3. 训练并比较损失：加载相同的 weight dict（可以通过 PyTorch 来存储随机的权重），将准备好的数据分别传入网络并迭代，观察二者 loss 是否一致（此处 batch-size 要一致，如果使用多个真实数据，要保证传入网络的顺序一致）。如果经过 2 次迭代以上，loss 均可以对齐，则基本可以认为反向对齐。

【实战】

本部分可以参考文档：反向对齐操作文档。

【核验】

对于待迁移的项目，反向对齐核验流程如下。

1. 输入：fake data & label

2. 输出：

• 飞桨/PyTorch：dict，key 为 tensor 的 name（自定义），value 为具体 loss 的值。最后将 dict 使用 reprod_log 保存到各自的文件中，建议命名为losses_paddle.npy和losses_pytorch.npy。

1. 自测：使用 reprod_log 加载 2 个文件，使用 report 功能，记录结果到日志文件中，建议命名为losses_diff_log.txt，观察 diff，二者 diff 小于特定的阈值即可。

2. 注意：

• loss 需要保存至少 2 轮以上。

• 在迭代的过程中，需要保证模型的 batch size 等超参数完全相同

• 在迭代的过程中，需要设置model.eval()，使用固定的假数据，同时加载相同权重的预训练模型。

【FAQ】

1. 怎么打印反向梯度？

• 飞桨打印反向和参数更新，可以参考代码实例。

• PyTorch 打印反向和参数更新，可以参考代码实例。

1. 反向没有对齐怎么办？

反向对齐时，如果第一轮 loss 就没有对齐，则需要仔细先排查模型前向部分。

如果第二轮开始，loss 开始无法对齐，则首先需要排查下超参数的差异，没问题的话，在loss.backward()方法之后，使用tensor.grad获取梯度值，二分的方法查找 diff，定位出飞桨与 PyTorch 梯度无法对齐的 API 或者操作，然后进一步验证。

梯度的打印方法示例代码如下所示，注释掉的内容即为打印网络中所有参数的梯度 shape。

# 代码地址：https://github.com/PaddlePaddle/PaddleNLP/blob/develop/examples/torch_migration/pipeline/Step4/test_bp.py
    def pd_train_some_iters(model,
                        criterion,
                        optimizer,
                        fake_data,
                        fake_label,
                        max_iter=2):
        paddle_dump_path = '../weights/paddle_weight.pdparams'
        config = PDBertConfig()
        model = PDBertForSequenceClassification(config)
        checkpoint = paddle.load(paddle_dump_path)
        model.bert.load_dict(checkpoint)

        classifier_weights = paddle.load(
            "../classifier_weights/paddle_classifier_weights.bin")
        model.load_dict(classifier_weights)
        model.eval()
        criterion = paddle.nn.CrossEntropy()
        decay_params = [
            p.name for n, p in model.named_parameters()
            if not any(nd in n for nd in ["bias", "norm"])
        ]
        optimizer = paddle.optimizer.AdamW(
            learning_rate=3e-5,
            parameters=model.parameters(),
            weight_decay=1e-2,
            epsilon=1e-6,
            apply_decay_param_fun=lambda x: x in decay_params,
        )
        loss_list = []
        for idx in range(max_iter):
            input_ids = paddle.to_tensor(fake_data)
            labels = paddle.to_tensor(fake_label)

            output = model(input_ids)
            loss = criterion(output, labels)
            loss.backward()
            optimizer.step()
            optimizer.clear_grad()
            loss_list.append(loss)
        return loss_list

如果只希望打印特定参数的梯度，可以用下面的方式。

import paddle

def print_hook_fn(grad):
    print(grad)

x = paddle.to_tensor([0., 1., 2., 3.], stop_gradient=False)
h = x.register_hook(print_hook_fn)
w = x * 4
w.backward()
# backward 之后会输出下面的内容
#     Tensor(shape=[4], dtype=float32, place=CPUPlace, stop_gradient=False,
#            [4., 4., 4., 4.])

八、训练集数据读取对齐¶

【基本流程】

该部分内容与 “三、小数据集数据读取对齐” 内容基本一致，也可使用 PaddleNLP内置数据集，参考 PyTorch 的代码，实现训练集数据读取与预处理模块即可。

【注意事项】

该部分内容，可以参考 “七、反向梯度对齐” 的自测方法，将输入的fake_data与fake_label替换为训练的 dataloader，但是需要注意的是：

在使用 train dataloader 的时候，建议设置 random seed。

PyTorch 设置 seed 的方法：

torch.manual_seed(config.SEED)
torch.cuda.manual_seed_all(config.SEED)
np.random.seed(config.SEED)
random.seed(config.SEED)

飞桨设置 seed 的方法：

paddle.seed(config.SEED)
np.random.seed(config.SEED)
random.seed(config.SEED)

【FAQ】

1. 数据预处理时，报错信息过于复杂怎么办？

在前向过程中，如果数据预处理过程运行出错，请先将 paddle.io.DataLoader的 num_workers 参数设为 0，然后根据单个进程下的报错日志定位出具体的 bug。

1. 数据读取无法对齐怎么办？

• 如果是全量数据使用，对结果不会有影响，如果是按照比例选取子集进行训练，则建议重新根据参考代码实现数据读取部分，保证子集完全一致。

• 如果数据处理过程中涉及到随机数生成，建议固定 seed (np.random.seed(0), random.seed(0))，查看迁移代码和参考代码处理后的数据是否有 diff。

• 对文本进行 tokenizer 处理时，需要确定文本的截断策略，padding 策略。

九、网络初始化对齐¶

本部分对齐建议对照飞桨初始化 API 文档与参考代码的初始化实现对齐。

下面给出了部分初始化 API 的映射表。

更多初始化 API 可以参考PyTorch 初始化 API 文档以及飞桨初始化 API 文档。

【FAQ】

1、使用相同的分布初始化模型还是不能对齐怎么办？

• 对于不同的深度学习框架，网络初始化在大多情况下，即使值的分布完全一致，也无法保证值完全一致，这里也是论文复现中不确定性比较大的地方。如果十分怀疑初始化导致的问题，建议将参考的初始化权重转成 paddle 模型，加载该初始化模型训练，看下收敛精度。

• CNN 对于模型初始化相对来说没有那么敏感，在迭代轮数与数据集足够的情况下，最终精度指标基本接近；而 transformer 系列模型对于初始化比较敏感，在 transformer 系列模型训练对齐过程中，建议对这一块进行重点检查。

2、如何对齐 torch.nn.init.constant_() ？

飞桨中目前没有 torch.nn.init.constant_()的方法，如果希望对参数赋值为常数，可以使用 paddle.nn.initializer.ConstantAPI；或者可以参考下面的实现。更加具体的解释可以参考：模型参数初始化对齐。

import paddle
import paddle.nn as nn
import numpy as np
# Define the linear layer.
m = paddle.nn.Linear(2, 4)
print(m.bias)
if isinstance(m, nn.Layer):
    print("set m.bias")
    m.bias.set_value(np.ones(shape=m.bias.shape, dtype="float32"))
    print(m.bias)

3、初始化是怎么影响不同类型的模型的？

• 对于 CNN 模型而言，模型初始化对最终的收敛精度影响较小，在迭代轮数与数据集足够的情况下，最终精度指标基本接近；

• Transformer、等模型对于初始化比较敏感，在这些模型训练对齐过程中，建议对这一块进行重点检查；

十、训练精度对齐¶

【基本流程】

完成前面的步骤之后，就可以开始全量数据的训练对齐任务了。按照下面的步骤进行训练精度对齐。

1. 准备 train/eval data, loader, model

2. 对 model 按照论文所述进行初始化(如果论文中提到加载了预训练模型，则按需加载 pretrained model)

3. 加载配置，开始训练，迭代得到最终模型与评估指标，将评估指标使用 reprod_log 保存到文件中。

4. 将 PaddlePaddle 提供的参考指标使用 reprod_log 提交到另一个文件中。

5. 使用 reprod_log 排查 diff，小于阈值，即可完成自测。

【注意事项】

• 【强烈】建议先做完反向对齐之后再进行模型训练对齐，二者之间的不确定量包括：数据集、PaddlePaddle 与参考代码在模型 training mode 下的区别，初始化参数。

• 在训练对齐过程中，受到较多随机量的影响，精度有少量 diff 是正常的，以 SST-2 数据集的分类为例，diff 在 0.15%以内可以认为是正常的，这里可以根据不同的任务，适当调整对齐检查的阈值(ReprodDiffHelper.report函数中的diff_threshold参数)。

• 训练过程中的波动是正常的，如果最终收敛结果不一致，可以

  • 仔细排查 Dropout、BatchNorm 以及其他组网模块及超参是否无误。

  • 基于参考代码随机生成一份预训练模型，转化为 PaddlePaddle 的模型，并使用 PaddlePaddle 加载训练，对比二者的收敛曲线与最终结果，排查初始化影响。

  • 使用参考代码的 Dataloader 生成的数据，进行模型训练，排查 train dataloader 的影响。

【实战】

本部分可以参考文档：训练对齐操作文档。

【核验】

对于待复现的项目，训练对齐核验流程如下。

1. 输入：train/eval dataloader, model

2. 输出：

• PaddlePaddle：dict，key 为保存值的 name（自定义），value 为具体评估指标的值。最后将 dict 使用 reprod_log 保存到文件中，建议命名为train_align_paddle.npy。

• benchmark：dict，key 为保存值的 name（自定义），value 为模型迁移的评估指标要求的值。最后将 dict 使用 reprod_log 保存到文件中，建议命名为train_align_benchmark.npy。

自测：使用 reprod_log 加载 2 个文件，使用 report 功能，记录结果到日志文件中，建议命名为train_align_diff_log.txt，观察 diff，二者 diff 小于特定的阈值即可。

【FAQ】

1. 训练过程怎么更好地对齐呢？

• 有条件的话，迁移工作之前最好先基于 PyTorch 代码完成训练，保证与 PyTorch 的代码训练精度符合预期，并且将训练策略和训练过程中的关键指标记录保存下来，比如每个 epoch 的学习率、Train Loss、Eval Loss、Eval Acc 等，在迁移网络的训练过程中，将关键指标保存下来，这样可以将 Paddle 与 PyTorch 训练中关键指标的变化曲线绘制出来，能够很方便地进行对比；

• 如果训练较大的数据集，1 次完整训练的成本比较高，此时可以隔一段时间查看一下，如果精度差异比较大，建议先停掉实验，排查原因。

1. 如果训练过程中出现不收敛的情况，怎么办？

• 简化网络和数据，实验是否收敛；

• 如果是基于原有实现进行改动，可以尝试控制变量法，每次做一个改动，逐个排查；

• 检查学习率是否过大、优化器设置是否合理，排查下 weight decay 是否设置正确；

• 保存不同 step 之间的模型参数，观察模型参数是否更新。

1. 如果训练的过程中出 nan 怎么办？一般是因为除 0 或者 log0 的情况， 可以着重看下几个部分：

   1. 如果有预训练模型的话，可以确认下是否加载正确

   2. 确认下 reader 的预处理中是否会出现空的 tensor（检测任务中一般会出现该问题）

   3. 模型结构中计算 loss 的部分是否有考虑到正样本为 0 的情况

   4. 该问题也可能是某个 API 的数值越界导致的，可以测试较小的输入是否还会出现 nan。

2. 其他细分场景下有什么导致训练不对齐的原因？

• 小数据上指标波动可能比较大，时间允许的话，可以跑多次实验，取平均值。

• Transformer 系列模型，在模型量级比较小的情况下，使用更大的 batch size 以及对应的学习率进行训练往往会获得更高的精度，在迁移时，建议保证 batch size 和学习率完全一致，否则即使精度对齐了，也可能会隐藏其他没有对齐的风险项。

• 目标检测、图像分割等任务中，训练通常需要加载 backbone 的权重作为预训练模型，注意在训练对齐时，需要加载转换过来的 backbone 权重。

• 生成任务中，训练时经常需要固定一部分网络参数。对于一个参数param，可以通过param.trainable = False来固定。

• 在训练 GAN 时，通常通过 GAN 的 loss 较难判断出训练是否收敛，建议每训练几次迭代保存一下训练生成的图像，通过可视化判断训练是否收敛。

• 在训练 GAN 时，如果飞桨实现的代码已经可以与参考代码完全一致，参考代码和飞桨代码均难以收敛，则可以在训练的时候，可以判断一下 loss，如果 loss 大于一个阈值或者直接为 NAN，说明训崩了，就终止训练，使用最新存的参数重新继续训练。可以参考该链接的实现：链接。

1. 怎样设置运行设备?

对于飞桨来说，通过paddle.set_device函数（全局，会决定 Dataloader、模型组网、to_tensor 等操作产出的数据所在的设备）来确定模型结构是运行在什么设备上，对于 torch 来说，则是通过model.to("device") （局部，这句话仅影响 model 所在的设备）来确定模型结构的运行设备。

十一、模型预测验证¶

【基本流程】

模型训练完成之后，使用该模型基于训练引擎进行预测，主要包含：

1. 定义模型结构，加载模型权重。

2. 加载文本，对其进行数据预处理。

3. 模型预测。

4. 对模型输出进行后处理，获取最终输出结果。

【注意事项】

在模型评估过程中，为了保证数据可以组成图片尺寸相同的 batch，一般会使用 resize/padding 等方法以保持尺度的一致性。

【实战】

主要源代码如下所示：

@paddle.no_grad()
def main():
    # 模型定义
    paddle_dump_path = '../weights/paddle_weight.pdparams'
    config = BertConfig()
    model = BertForSequenceClassification(config)
    checkpoint = paddle.load(paddle_dump_path)
    model.bert.load_dict(checkpoint)

    classifier_weights = paddle.load(
        "../classifier_weights/paddle_classifier_weights.bin")
    model.load_dict(classifier_weights)

    model.eval()
    tokenizer = PPNLPBertTokenizer.from_pretrained("bert-base-uncased")
    # 要预测的句子
    data = get_data()
    softmax = nn.Softmax()
    # 预测的各类别的概率值
    output = softmax(model(**data)[0]).numpy()

    # 概率值最大的类别
    class_id = output.argmax()
    # 对应的概率值
    prob = output[0][class_id]
    print(f"class_id: {class_id}, prob: {prob}")
    return output

完整代码地址：predict.py

【核验】

预测程序按照文档中的命令操作可以正常跑通，终端输出结果。

十二、单机多卡训练¶

单机多卡训练使用一台机器上的多个 GPU 并行进行训练，可以提升训练效率。与单机单卡相比，在单机多卡的条件下训练模型，需要对以下几个方面进行修改：

• 多卡并行数据读取

• 多卡并行训练环境及模型初始化

• 模型保存、日志保存

• 训练启动指令

【基本流程】

若要将单机单卡训练的代码修改为多机多卡训练的代码，需要：

• 修改数据读取代码，将paddle.io.RandomSampler改为paddle.io.DistributedRandomSampler

• 初始化多卡并行训练环境，并使用paddle.DataParallel()对模型进行封装

• 模型保存、日志保存的代码需要增加对卡号的判断，仅在 0 号卡上保存即可

【实战】

单机多卡的代码实现请参考：链接，单机单卡属于单机多卡的特殊形式（卡数为 1），这里也可以用于单机单卡的训练过程。

train_sampler = paddle.io.RandomSampler(dataset)
train_batch_sampler = paddle.io.BatchSampler(
    sampler=train_sampler, batch_size=args.batch_size)

train_batch_sampler = paddle.io.DistributedBatchSampler(
        dataset=dataset,
        batch_size=args.batch_size,
        shuffle=True,
        drop_last=False
    )

# 如果当前节点用于训练的设备数量大于 1，则初始化并行训练环境
if paddle.distributed.get_world_size() > 1:
    paddle.distributed.init_parallel_env()

if paddle.distributed.get_world_size() > 1:
    model = paddle.DataParallel(model)

if paddle.distributed.get_rank() == 0:
    paddle.save(params_state_dict, model_path + ".pdparams")

unset CUDA_VISIBLE_DEVICES
python -m paddle.distributed.launch --gpus "0" run_glue.py \
    --model_type bert \
    --model_name_or_path bert-base-uncased \
    --task_name SST-2 \
    --max_seq_length 128 \
    --batch_size 32   \
    --learning_rate 2e-5 \
    --num_train_epochs 3 \
    --logging_steps 1 \
    --save_steps 500 \
    --output_dir ./tmp/ \
    --device gpu \
    --use_amp False

unset CUDA_VISIBLE_DEVICES
python -m paddle.distributed.launch --gpus "0,1,2,3" run_glue.py \
    --model_type bert \
    --model_name_or_path bert-base-uncased \
    --task_name SST-2 \
    --max_seq_length 128 \
    --batch_size 32   \
    --learning_rate 2e-5 \
    --num_train_epochs 3 \
    --logging_steps 1 \
    --save_steps 500 \
    --output_dir ./tmp/ \
    --device gpu \
    --use_amp False

十三、常见 bug 汇总¶

在论文复现中，可能因为各种原因出现报错，下面列举了常见的问题和解决方法，从而提供 debug 的方向：

a = paddle.range(3)
c = paddle.ones([3])
b = a>1
# 会增加引用的一种写法
c[b] = 0
# 修改后
paddle.where(b, paddle.zeros(c.shape), c)

cross_entropy_loss = paddle.nn.CrossEntropyLoss()
loss = cross_entropy_loss(pred, gt)
# 会导致内存泄漏的操作
loss_total += loss
# 修改后
loss_total += loss.numpy() # 如果可以转化为 numpy
loss_total += loss.detach().clone() # 如果需要持续使用 tensor