推广TrustAI可信分析：通过提升数据质量来增强在ERNIE模型下性能

TrustAI是集可信分析和增强于一体的可信AI工具集，助力NLP开发者提升深度学习模型效果和可信度。在后续应用中，希望将TrustAI和智能标注以及模型构螺迭代打造持续学习链路。

解决训练数据存在脏数据的问题
解决训练数据覆盖不足的问题(稀疏数据)
解决训练数据分布偏置的问题
解决文本冗余导致精度下降的问题

模型	DuReader-robust dev	DuReader-robust Test	【Zero shot】 DuReader-checklist dev (Remove no answer)
EM	F1	EM	F1	EM	F1
bert-base[官方数据]	71.70	85.47	30.80	53.14	-	-
roberta-base[复现]	73.48	86.98	45.97	69.43	28.66	50.47
Selector-Predictor	76.32(+2.84)	89.03(+2.05)	50.93(+4.96)	72.22(+2.79)	31.04(+2.33)	53.29(+2.82)

0.例证分析算法简介

随着深度学习模型的越发复杂，人们很难去理解其内部的工作原理。“黑盒”的可解释性正成为许多优秀研究者的焦点。

通过这些非常有效的可解释性方法，人们可以更好知道模型为什么好，为什么不好，进而可以针对性提高模型性能。

目前，可解释性研究领域缺乏一个用于评估解释方法的科学评估体系。

对于ante-hoc可解释性而言，其评估挑战在于如何量化模型的内在解释能力。

对于post-hoc可解释性而言，其评估挑战在于如何量化解释结果的保真度和一致性。

0.1 实例级证据分析算法简介

0.1.1 表示点方法（Representer Point）

论文：NeurIPS 2018 Representer Point Selection：https://proceedings.neurips.cc/paper/2018/file/8a7129b8f3edd95b7d969dfc2c8e9d9d-Paper.pdf

这篇论文做的跟ICML 2017 best paper influence function那篇论文一样，想分析对于一个测试点来说，哪些训练样本对这个决策影响最大，包括positive（这里叫excitatory）和negative（这里叫inhibitory）的训练样本点。方法上，这篇论文将输出层的margin（pre-activation prediction）分解成训练样本点的激活值的加权线性组合，这个权重叫做representer value，表达训练样本点对网络参数的影响。文中主要claim的比influence function有优势的是计算效率。

开源的代码里sklearn，tensorflow，pytorch都有用到，比较混乱，应用可能需要梳理这部分代码，从双方开源的代码看，该论文也借鉴了一部分influence function的代码，比如genericNeuralNet.py和genericNeuralNet.py。论文中提出的方法需要一些fine-tune，预估到最后一层的输入值等额外的步骤，也给工程框架上带来一定的困难。
相比于文中3.2估计预估误差是对比预估输出和真实输出的差异，influence function是对比去掉该训练样本前后训练得到模型的loss。输出对不同的训练样本的依赖可能有相关性，有可能当前模型比较依赖该训练样本，但不见得去掉该训练样本后，预测值有大的变化。相比之下，去掉该样本重新训练模型得到的结论会更鲁棒一些。
这篇论文提出的方法相比influence function的主要优势是计算量小，但也有一些限制（L2或者fine-tune），可以用在对计算效率要求比较高的场景。

开源代码：https://github.com/chihkuanyeh/Representer_Point_Selection

参考链接：https://zhuanlan.zhihu.com/p/114461143

0.1.2 基于梯度的相似度方法(Grad-Cosin, Grad-Dot)

论文：Input Similarity from the Neural Network Perspective https://proceedings.neurips.cc/paper/2019/hash/c61f571dbd2fb949d3fe5ae1608dd48b-Abstract.html

https://proceedings.neurips.cc/paper/2019/file/c61f571dbd2fb949d3fe5ae1608dd48b-Paper.pdf

在许多应用中，了解模型做出特定预测的原因可能与预测的准确性一样重要。然而，大型现代数据集的最高精度通常是通过甚至专家都难以解释的复杂模型来实现的，例如集成或深度学习模型，这在准确性和可解释性之间造成了矛盾。作为回应，最近提出了各种方法来帮助用户解释复杂模型的预测，但通常不清楚这些方法是如何相关的，以及何时一种方法优于另一种方法。为了解决这个问题，我们提出了一个解释预测的统一框架，SHAP（SHapley Additive exPlanations）。SHAP 为每个特征分配一个特定预测的重要性值。其新颖的组件包括：(1) 识别一类新的加性特征重要性度量，以及 (2) 理论结果表明该类中存在一个具有一组理想属性的唯一解。新类统一了六种现有方法，值得注意的是，该类中最近的几种方法缺乏建议的理想属性。基于这种统一的见解，我们提出了新的方法，这些方法显示出比以前的方法更好的计算性能和/或与人类直觉更好的一致性。

0.1.3 基于特征的相似度方法(Feature-Cosin, Feature-Dot, Feature-Euc)

论文：An Empirical Comparison of Instance Attribution Methods for NLP https://arxiv.org/abs/2104.04128

https://github.com/successar/instance_attributions_NLP

深度模型的广泛采用激发了对解释网络输出和促进模型调试的方法的迫切需求。实例归因方法构成了通过检索（可能）导致特定预测的训练实例来实现这些目标的一种方法。影响函数（IF；Koh 和 Liang 2017）通过量化扰动单个列车实例对特定测试预测的影响，提供了实现这一目标的机制。然而，即使逼近 IF 在计算上也是昂贵的，在许多情况下可能会令人望而却步。更简单的方法（例如，检索与给定测试点最相似的训练示例）可能具有可比性吗？在这项工作中，我们评估不同潜在实例归因在训练样本重要性方面的一致性程度。我们发现，简单的检索方法产生的训练实例与通过基于梯度的方法（例如 IF）识别的训练实例不同，但仍然表现出与更复杂的归因方法相似的理想特征

0.2 特征级证据分析算法简介

参考链接 https://blog.csdn.net/wxc971231/article/details/121184091

0.2.1 可解释性之积分梯度算法（Integrated Gradients）

论文：IntegratedGraients: Axiomatic Attribution for Deep Networks, Mukund Sundararajan et al. 2017 https://arxiv.org/abs/1703.01365

我们研究将深度网络的预测归因于其输入特征的问题，这是之前由其他几项工作研究过的问题。我们确定了归因方法应该满足的两个基本公理——敏感性和实现不变性。我们表明，大多数已知的归因方法都不满足它们，我们认为这是这些方法的根本弱点。我们使用这些公理来指导一种称为集成梯度的新归因方法的设计。我们的方法不需要对原始网络进行修改，实现起来非常简单；它只需要对标准梯度运算符进行几次调用。我们将这种方法应用于几个图像模型、几个文本模型和一个化学模型，展示了它调试网络、从网络中提取规则的能力

一种神经网络的可视化方法：积分梯度（Integrated Gradients），它首先在论文《Gradients of Counterfactuals》中提出，后来《Axiomatic Attribution for Deep Networks》再次介绍了它，两篇论文作者都是一样的，内容也大体上相同，后一篇相对来说更易懂一些，如果要读原论文的话，建议大家优先读后一篇。当然，它已经是2016～2017年间的工作了，“新颖”说的是它思路上的创新有趣，而不是指最近发表。所谓可视化，简单来说就是对于给定的输入x以及模型F(x)，我们想办法指出x的哪些分量对模型的决策有重要影响，或者说对x各个分量的重要性做个排序，用专业的话术来说那就是“归因”。一个朴素的思路是直接使用梯度∇xF(x)来作为x各个分量的重要性指标，而积分梯度是对它的改进

参考链接：https://www.spaces.ac.cn/archives/7533

https://zhuanlan.zhihu.com/p/428131762

https://zhuanlan.zhihu.com/p/365815861

https://blog.csdn.net/wxc971231/article/details/121184091

0.2.2 LIME算法

论文： Lime: “Why Should I Trust You?”: Explaining the Predictions of Any Classifier, Marco Tulio Ribeiro et al. 2016 https://arxiv.org/abs/1602.04938

尽管被广泛采用，机器学习模型仍然主要是黑匣子。然而，了解预测背后的原因对于评估信任非常重要，如果一个人计划根据预测采取行动，或者在选择是否部署新模型时，这是至关重要的。这种理解还提供了对模型的洞察力，可用于将不可信的模型或预测转换为可信的模型。在这项工作中，我们提出了 LIME，这是一种新颖的解释技术，通过在预测周围学习可解释的模型，以可解释和忠实的方式解释任何分类器的预测。我们还提出了一种通过以非冗余方式呈现具有代表性的个体预测及其解释来解释模型的方法，将任务定义为子模块优化问题。我们通过解释文本（例如随机森林）和图像分类（例如神经网络）的不同模型来展示这些方法的灵活性。我们通过模拟和人类受试者的新实验展示了解释的效用，在各种需要信任的场景中：决定是否应该信任预测、在模型之间进行选择、改进不可信的分类器以及确定为什么不应该信任分类器.

Local: 基于想要解释的预测值及其附近的样本，构建局部的线性模型或其他代理模型；

Interpretable: LIME做出的解释易被人类理解。利用局部可解释的模型对黑盒模型的预测结果进行解释，构造局部样本特征和预测结果之间的关系；

Model-Agnostic: LIME解释的算法与模型无关，无论是用Random Forest、SVM还是XGBoost等各种复杂的模型，得到的预测结果都能使用LIME方法来解释；

Explanations: LIME是一种事后解释方法。

参考链接：https://cloud.tencent.com/developer/news/617057

https://blog.csdn.net/weixin_42347070/article/details/106455763

https://blog.csdn.net/weixin_42347070/article/details/106076360

0.2.3 Quantifying Attention Flow in Transformers

Rollout: Quantifying Attention Flow in Transformers, Abnar et al. 2020 https://arxiv.org/abs/2005.00928

在 Transformer 模型中，“self-attention”将来自参与嵌入的信息组合到下一层焦点嵌入的表示中。因此，在 Transformer 的各个层中，来自不同令牌的信息变得越来越混合。这使得注意力权重在解释探测时变得不可靠。在本文中，我们考虑通过自我注意来量化这种信息流的问题。我们提出了两种在给定注意力权重、注意力推出和注意力流的情况下将注意力近似于输入令牌的方法，作为使用注意力权重作为输入令牌的相对相关性时的事后方法。我们表明，这些方法对信息流给出了互补的观点，并且与原始注意力相比，

参考链接
https://blog.csdn.net/Western_europe/article/details/109611695

0.3 依赖包安装

paddlenlp（https://github.com/PaddlePaddle/PaddleNLP）
trustai（https://github.com/PaddlePaddle/TrustAI）

#环境安装
!pip install -U trustai
!pip install --upgrade paddlenlp

1.解决训练数据存在脏数据的问题

背景：训练数据标注质量对模型效果有较大影响，但受限于标注人员水平、标注任务难易程度等影响，训练数据中都存在一定比例的脏数据，即标注质量差的数据。这些数据往往会阻碍模型效果提升。但当标注数据规模较大时，数据检查就成为一个难题。

TrustAI提供了脏数据识别能力，从训练数据中识别候选脏数据。当选择占比约为全部数据的10%的数据作为脏数据时，可召回超40%的脏数据。开发者对候选脏数据进行人工修正，可显著提升模型效果。

脏数据识别包含三个步骤：依赖安装、脏数据识别模型训练和候选脏数据选择。

1.1 脏数据识别模型训练（保险业务数据）

基于全部训练数据，训练一个脏数据识别模型。

注意：当前的脏数据识别能力主要适用于分类任务。这里的脏数据识别模型就是一个普通的分类模型

# 训练脏数据识别模型，使用者可以更改train_file和对应的num_classes，来训练新数据集的脏数据识别模型。
# --dataset_dir   数据路径
# --train_file   训练数据
# --dev_file   验证数据
# --num_classes   分类数量
# --save_dir   脏数据识别模型保存地址# %cd /home/aistudio/Dirty_data #进入目录!python -u train.py \
--dataset_dir ./data \
--train_file train.txt \
--dev_file train.txt \
--num_classes 2 \
--batch_size 16\
--learning_rate 2e-5 \
--weight_decay 0.01 \
--early_stop True \
--early_stop_nums 4 \
--warmup True \
--warmup_steps 300 \
--logging_steps 100 \
--epochs 10 \
--save_dir ./checkpoint

训练结果：

[2022-09-29 15:32:28,925] [    INFO] - global step 400, epoch: 2, batch: 21, loss: 0.00214, acc: 0.99702, speed: 4.49 step/s
[2022-09-29 15:32:35,774] [    INFO] - global step 500, epoch: 2, batch: 121, loss: 0.00194, acc: 0.99587, speed: 14.64 step/s
[2022-09-29 15:32:42,641] [    INFO] - global step 600, epoch: 2, batch: 221, loss: 0.00139, acc: 0.99717, speed: 14.60 step/s
[2022-09-29 15:32:49,474] [    INFO] - global step 700, epoch: 2, batch: 321, loss: 0.00125, acc: 0.99727, speed: 14.67 step/s
[2022-09-29 15:33:04,833] [    INFO] - dev: eval loss: 0.00233, acc: 0.99967

1.2脏数据选择（实例级证据分析方法`RepresenterPointModel`）

表示点方法(Representer Point)将训练数据对当前预测数据的重要度影响（即表征值），分解为训练数据对模型的影响和训练数据与预测数据的语义相关度。对于一条给定的测试数据和测试结果，表征值为正的训练数据表示支持该预测结果，相反，表征值为负的训练数据表示不支持该预测结果。同时，表征值的大小表示了训练数据对测试数据的影响程度。

使用脏数据识别模型，对所有的训练数据计算它们作为脏数据的分数。分数越大，表明越可能是脏数据。

脏数据选择方法：使用TrustAI提供的实例级证据分析方法RepresenterPointModel，计算每一条训练样本对模型loss的影响度。经分析，发现影响度较大的数据，有较大比例都是标注质量差的数据。所以，我们使用这个影响分数来识别脏数据。

实例级证据分析方法RepresenterPointModel具体见：https://github.com/PaddlePaddle/TrustAI/tree/main/trustai/interpretation/example_level

# 候选脏数据选择，从train_file中选择dirty_num条脏数据，保存在dirty_path目录下
# --dataset_dir   数据路径
# --train_file   训练数据
# --num_classes   分类数量
# --init_from_ckpt 脏数据识别模型
# --dirty_path  脏数据保存地址
# --dirty_num 选择的脏数据数量 推荐10-20%
# --rest_path 其他训练数据（非脏数据）!python -u find_dirty_data.py \
--train_file ./train.txt  \
--num_classes 2  \
--rest_path ./data/rest_train.tsv \
--init_from_ckpt ./checkpoint/model_state.pdparams  \
--dirty_path ./data/dirty_train.tsv \
--dirty_num 500

[32m[2022-09-29 17:13:40,365] [    INFO][0m - We are using <class 'paddlenlp.transformers.ernie.tokenizer.ErnieTokenizer'> to load 'ernie-3.0-base-zh'.[0m
[32m[2022-09-29 17:13:40,365] [    INFO][0m - Already cached /home/aistudio/.paddlenlp/models/ernie-3.0-base-zh/ernie_3.0_base_zh_vocab.txt[0m
[32m[2022-09-29 17:13:40,392] [    INFO][0m - tokenizer config file saved in /home/aistudio/.paddlenlp/models/ernie-3.0-base-zh/tokenizer_config.json[0m
[32m[2022-09-29 17:13:40,392] [    INFO][0m - Special tokens file saved in /home/aistudio/.paddlenlp/models/ernie-3.0-base-zh/special_tokens_map.json[0m
[32m[2022-09-29 17:13:40,393] [    INFO][0m - We are using <class 'paddlenlp.transformers.ernie.modeling.ErnieForSequenceClassification'> to load 'ernie-3.0-base-zh'.[0m
[32m[2022-09-29 17:13:40,393] [    INFO][0m - Already cached /home/aistudio/.paddlenlp/models/ernie-3.0-base-zh/ernie_3.0_base_zh.pdparams[0m
W0929 17:13:40.394987 10590 gpu_resources.cc:61] Please NOTE: device: 0, GPU Compute Capability: 7.0, Driver API Version: 11.2, Runtime API Version: 11.2
W0929 17:13:40.399011 10590 gpu_resources.cc:91] device: 0, cuDNN Version: 8.2.
Extracting feature from given dataloader, it will take some time...
100%|█████████████████████████████████████████| 379/379 [00:13<00:00, 27.82it/s]
Training representer point model, it will take several minutes...
L1 difference between ground truth prediction and prediction by representer theorem decomposition
[0.00069498]
pearson correlation between ground truth  prediction and prediciton by representer theorem
0.9999821414904151
[0m

1.3 数据集LCQMC上验证（相似度计算任务）

基于相似度计算任务开源数据集LCQMC的部分数据上进行模拟实验，在LCQMC的测试集和DuQM鲁棒性数据集上评估效果。评估指标为准确率。

首先，从LCQMC的训练数据中随机抽取5000条作为训练集。基于抽取的训练集train_5000.tsv训练一个基线模型，。运行命令如下所示：

!wget --no-check-certificate https://trustai.bj.bcebos.com/application_data/dirty_data.tar && tar xf dirty_data.tar && rm dirty_data.tar

# !python -u train.py --dataset_dir ./data --train_file train_5000.tsv --dev_file dev.tsv --test_files test.tsv --num_classes 2 --save_dir ./checkpoint
%cd dirty2
!python -u train.py \
--dataset_dir ./data \
--train_file train_5000.tsv \
--dev_file dev.tsv \
--test_files test.tsv DuQM \
--num_classes 2 \
--batch_size 16\
--learning_rate 2e-5 \
--weight_decay 0.01 \
--early_stop True \
--early_stop_nums 4 \
--warmup True \
--warmup_steps 300 \
--logging_steps 100 \
--epochs 10 \
--save_dir ./checkpoint

[2022-09-29 17:52:00,439] [    INFO] - test_0: eval loss: 0.72723, acc: 0.83896
[2022-09-29 17:52:06,057] [    INFO] - global step 2900, epoch: 10, batch: 83, loss: 0.00629, acc: 0.99623, speed: 2.01 step/s
[2022-09-29 17:52:12,854] [    INFO] - global step 3000, epoch: 10, batch: 183, loss: 0.00286, acc: 0.99419, speed: 14.71 step/s
[2022-09-29 17:52:19,721] [    INFO] - global step 3100, epoch: 10, batch: 283, loss: 0.00270, acc: 0.99337, speed: 14.57 step/s
[2022-09-29 17:52:39,487] [    INFO] - dev: eval loss: 0.59061, acc: 0.87037
[2022-09-29 17:53:04,554] [    INFO] - test_0: eval loss: 0.71747, acc: 0.84248
[2022-09-29 17:53:04,554] [    INFO] - test_1: eval loss: 0.71747, acc: 0.69322
[2022-09-29 17:53:04,556] [    INFO] - Final best dev accuracy: 0.87048
[2022-09-29 17:53:04,556] [    INFO] - Final best test_0 accuracy: 0.84360
[2022-09-29 17:53:04,557] [    INFO] - Final best test_1 accuracy: 0.69322

# 从训练集中选取候选脏数据
!python -u find_dirty_data.py --dataset_dir ./data --train_file train_5000.tsv  \
--num_classes 2  --rest_path ./data/rest_train.tsv --init_from_ckpt ./checkpoint/model_state.pdparams
--dirty_path ./data/dirty_train.tsv --dirty_num 500

[32m[2022-09-29 17:54:15,529] [    INFO][0m - We are using <class 'paddlenlp.transformers.ernie.tokenizer.ErnieTokenizer'> to load 'ernie-3.0-base-zh'.[0m
[32m[2022-09-29 17:54:15,530] [    INFO][0m - Already cached /home/aistudio/.paddlenlp/models/ernie-3.0-base-zh/ernie_3.0_base_zh_vocab.txt[0m
[32m[2022-09-29 17:54:15,556] [    INFO][0m - tokenizer config file saved in /home/aistudio/.paddlenlp/models/ernie-3.0-base-zh/tokenizer_config.json[0m
[32m[2022-09-29 17:54:15,556] [    INFO][0m - Special tokens file saved in /home/aistudio/.paddlenlp/models/ernie-3.0-base-zh/special_tokens_map.json[0m
[32m[2022-09-29 17:54:15,557] [    INFO][0m - We are using <class 'paddlenlp.transformers.ernie.modeling.ErnieForSequenceClassification'> to load 'ernie-3.0-base-zh'.[0m
[32m[2022-09-29 17:54:15,557] [    INFO][0m - Already cached /home/aistudio/.paddlenlp/models/ernie-3.0-base-zh/ernie_3.0_base_zh.pdparams[0m
W0929 17:54:15.558984 17028 gpu_resources.cc:61] Please NOTE: device: 0, GPU Compute Capability: 7.0, Driver API Version: 11.2, Runtime API Version: 11.2
W0929 17:54:15.562927 17028 gpu_resources.cc:91] device: 0, cuDNN Version: 8.2.
Extracting feature from given dataloader, it will take some time...
100%|█████████████████████████████████████████| 313/313 [00:10<00:00, 29.00it/s]
Training representer point model, it will take several minutes...
L1 difference between ground truth prediction and prediction by representer theorem decomposition
[0.00089304]
pearson correlation between ground truth  prediction and prediciton by representer theorem
0.9999679273357627
[0m

对候选脏数据dirty_train.tsv进行人工检查和修正（占全部训练集10%），修正后的数据为correction_data.tsv。数据修正的比例为38.4%，而在随机选取的数据集中需要修正的数据比例仅为5%。

基于修正后的新训练集train_5000_correction.tsv训练模型，即可提升模型效果。

# 下载的数据中包含train_5000_correction.tsv文件
!python -u train.py --dataset_dir ./data --train_file train_5000_correction.tsv \
--dev_file dev.tsv --test_files test.tsv DuQM --num_classes 2 --save_dir ./new_checkpoint

[2022-09-29 18:02:59,601] [    INFO] - dev: eval loss: 0.50976, acc: 0.86855
[2022-09-29 18:03:25,775] [    INFO] - test_0: eval loss: 0.57743, acc: 0.85696
[2022-09-29 18:03:46,472] [    INFO] - test_1: eval loss: 1.43956, acc: 0.71613
[2022-09-29 18:03:46,474] [    INFO] - Early stop!
[2022-09-29 18:03:46,474] [    INFO] - Final best dev accuracy: 0.87503
[2022-09-29 18:03:46,474] [    INFO] - Final best test_0 accuracy: 0.86912
[2022-09-29 18:03:46,474] [    INFO] - Final best test_1 accuracy: 0.75911

1.4 小结：性能对比结果

开发者可基于修正后的训练集和修正前的训练集进行对比实验，由下表可知，对候选脏数据进行人工检查及修正（规模为原始训练集的10%），模型在LCQMC测试集上提升2.13%，在相似度匹配鲁棒性数据集（DuQM）上提升4.01。

数据集	LCQMC_dev	LCQMC_test	DuQM
基线	87.04%	84.36%	69.32%
数据修正	87.53%	86.91%	75.91%

注：epoch为10情况下测试。

2.解决训练数据覆盖不足的问题（相似度计算任务LCQMC）

标注尽量少的数据，提升模型效果

方法介绍
训练数据覆盖不足会导致模型在对应的测试数据上表现不好。数据扩充是提升模型效果直接的方法，然而数据标注是一个费时费力的工作，如何标注更少的数据带来更大的效果提升是大多数NLP开发者面临的难题。

TrustAI提供了“目标数据识别->有效数据选择->训练数据丰富”流程，用尽量少的标注数据有效提升模型效果。首先，基于可信分析中的实例级证据分析方法，从测试数据中识别因训练数据覆盖不足而导致的预测效果差的测试样本，称作目标集。然后，在大量的未标注数据中，选择可以支持目标集中数据预测的证据进行标注。最后，将新标注的数据加入到训练数据中重训模型。

%cd sparse
!wget --no-check-certificate https://trustai.bj.bcebos.com/application_data/sparse_data.tar && tar xf sparse_data.tar && rm sparse_data.tar

2.1稀疏数据选择（实例级证据分析方法`FeatureSimilarityModel`）

基于特征的相似度方法(Feature-Cosin, Feature-Dot, Feature-Euc)通过模型的特征挑选对当前测试数据有正影响和负影响的数据。

同样的：从LCQMC的训练数据中随机抽取5000条作为训练集，剩余数据作为未标注数据集。基于抽取的训练集train_5000.tsv训练一个基线模型，用于在后续步骤中做可信分析

!python -u train.py \
--dataset_dir ./data \
--train_file train_5000.tsv \
--dev_file dev.tsv \
--test_files test.tsv DuQM \
--num_classes 2 \
--batch_size 16\
--learning_rate 2e-5 \
--weight_decay 0.01 \
--early_stop True \
--early_stop_nums 4 \
--warmup True \
--warmup_steps 300 \
--logging_steps 100 \
--epochs 10 \
--save_dir ./checkpoint

[2022-09-30 11:30:52,167] [    INFO] - global step 3000, epoch: 10, batch: 183, loss: 0.00379, acc: 0.99112, speed: 16.47 step/s
[2022-09-30 11:30:58,270] [    INFO] - global step 3100, epoch: 10, batch: 283, loss: 0.00486, acc: 0.99139, speed: 16.39 step/s
[2022-09-30 11:31:15,572] [    INFO] - dev: eval loss: 0.60011, acc: 0.86708
[2022-09-30 11:31:36,912] [    INFO] - test_0: eval loss: 0.72033, acc: 0.84256
[2022-09-30 11:31:53,617] [    INFO] - test_1: eval loss: 1.66100, acc: 0.68916
[2022-09-30 11:31:53,618] [    INFO] - Final best dev accuracy: 0.87151
[2022-09-30 11:31:53,618] [    INFO] - Final best test_0 accuracy: 0.84824
[2022-09-30 11:31:53,618] [    INFO] - Final best test_1 accuracy: 0.69776
[2022-09-30 11:31:53,618] [    INFO] - Save best accuracy text classification model in ./checkpoint

基于训练的基线模型checkpoint从验证集中选择目标数据，即为目标集。

目标集选择方法为：使用TrustAI提供的实例级可信分析FeatureSimilarityModel方法，计算验证集中样本的正影响证据的平均分数。分数较低的样本表明其训练证据不足，训练数据对此类数据覆盖度较低，模型在这些样本上表现也相对较差。

#选取目标数据
!python -u find_sparse_data.py --dataset_dir ./data --train_file train_5000.tsv \
--dev_file dev.tsv --num_classes 2  \
--init_from_ckpt ./checkpoint/model_state.pdparams \
--sparse_num 50 --sparse_path ./data/sparse_data.tsv\
# sparse_num表示选择的目标数据的数量
# sparse_path表示目标集存储的路径

输出结果：

Extracting feature from given dataloader, it will take some time...
100%|█████████████████████████████████████████| 313/313 [00:09<00:00, 32.63it/s]
accuracy in sparse data: 0.74
average score in sparse data: 0.6370762230952579

在目标数据选择好后，只需要再次利用FeatureSimilarityModel方法从未标注的数据集rest_train.tsv中选择支持目标集的有效数据进行人工标注即可。

注：此处为模拟实验，rest_train.tsv的数据已被标注

# 选取有效数据
!python -u find_valid_data.py --dataset_dir ./data --unlabeled_file rest_train.tsv \
--target_file sparse_data.tsv --num_classes 2  --init_from_ckpt ./checkpoint/model_state.pdparams\--valid_threshold 0.7 --valid_num 1000 --valid_path ./data/valid_data.tsv
# valid_threshold表示目标集证据的分数阈值，开发者可根据自己数据自主调整，默认为0.7
# valid_num表示抽取有效数据的数量
# valid_path表示有效数据的存储路径

Extracting feature from given dataloader, it will take some time...
100%|█████████████████████████████████████| 14610/14610 [06:52<00:00, 35.38it/s]
100%|█████████████████████████████████████████████| 4/4 [01:19<00:00, 19.79s/it]

在完成有效数据的标注后，将其与原始数据拼接后训练模型，即可提升模型效果。

# 将标注过的有效集和原始训练集拼接
# !cat ./data/train_5000.tsv ./data/valid_data.tsv > ./data/merge_valid.tsv

# 基于增强后的数据训练模型
!python -u train.py \
--dataset_dir ./data \
--train_file merge_valid.tsv  \
--dev_file dev.tsv \
--test_files test.tsv DuQM sparse_data.tsv\
--num_classes 2 \
--batch_size 16\
--learning_rate 2e-5 \
--weight_decay 0.01 \
--early_stop True \
--early_stop_nums 4 \
--warmup True \
--warmup_steps 300 \
--logging_steps 100 \
--epochs 10 \
--save_dir ./valid_checkpoint

[2022-09-30 11:48:40,721] [    INFO] - dev: eval loss: 0.49278, acc: 0.87151
[2022-09-30 11:49:02,597] [    INFO] - test_0: eval loss: 0.58590, acc: 0.85344
[2022-09-30 11:49:19,863] [    INFO] - test_1: eval loss: 1.27613, acc: 0.72236
[2022-09-30 11:49:19,981] [    INFO] - test_2: eval loss: 0.92333, acc: 0.70000
[2022-09-30 11:51:59,365] [    INFO] - Final best dev accuracy: 0.87821
.....
[2022-09-30 11:51:59,365] [    INFO] - Final best test_0 accuracy: 0.86752
[2022-09-30 11:51:59,366] [    INFO] - Final best test_1 accuracy: 0.71989
[2022-09-30 11:51:59,366] [    INFO] - Final best test_2 accuracy: 0.66000

!python -u train.py \
--dataset_dir ./data \
--train_file train.tsv  \
--dev_file dev.tsv \
--test_files test.tsv DuQM sparse_data.tsv\
--num_classes 2 \
--batch_size 16\
--learning_rate 2e-5 \
--weight_decay 0.01 \
--early_stop True \
--early_stop_nums 4 \
--warmup True \
--warmup_steps 300 \
--logging_steps 100 \
--epochs 10 \
--save_dir ./valid_checkpoint

部分结果展示：

[2022-09-30 13:12:28,188] [    INFO] - dev: eval loss: 0.33631, acc: 0.90548
[2022-09-30 13:12:49,561] [    INFO] - test_0: eval loss: 0.42277, acc: 0.87032
[2022-09-30 13:13:06,440] [    INFO] - test_1: eval loss: 0.99127, acc: 0.73817
[2022-09-30 13:13:06,555] [    INFO] - test_2: eval loss: 0.47766, acc: 0.82000
[2022-09-30 13:13:06,556] [    INFO] - Current best dev accuracy: 0.90548
[2022-09-30 13:13:06,556] [    INFO] - Current best test_0 accuracy: 0.87032
[2022-09-30 13:13:06,556] [    INFO] - Current best test_1 accuracy: 0.73817
[2022-09-30 13:13:06,556] [    INFO] - Current best test_2 accuracy: 0.82000

2.2 小结：性能对比结果

同时，可以随机选择相同数量的随机数据以及和全量样本进行训练进行对比实验。实验结果如下表所示：

数据集	数据量	LCQMC_dev	LCQMC_test	DuQM	目标集
基线	5000	87.15%	84.82%	69.78%	-----
基线 + 随机1000条	6000	86.78%	85.15%	69.88%	56.21%
基线 + 策略1000条	6000	87.15%	85.34%	72.23%	70.00%
基线 + 全样本训练	1.6w+	90.55%	87.03%	73.81%	82.00%

注：10epoch结果

3.解决训练数据分布偏置的问题 - 数据权重修正（相似度任务）

缓解数据偏置对模型训练的影响，提升模型鲁棒性!

方法介绍

受限于数据集收集方法、标注人员经验等影响，构建的训练数据集存在分布偏置问题。模型会利用数据集中的偏置作为预测的捷径，如在情感分析任务中，遇到否定词或描述直接给出“负向”情感预测。这种偏置会导致模型没有学会真正的理解和推理能力，在与训练数据分布一致的测试数据上表现非常好，但在与训练数据分布不一致的测试数据上表现很差，也就是说模型的泛化性和鲁棒性很差。

TrustAI提供了基于数据集统计方法偏置识别方法，并提供了数据分布修正和权重修正两种优化策略。

基于数据集统计方法偏置识别方法：即统计训练数据中词与标注标签的分布，基于此进行偏置词和数据的识别。

数据权重修正通过降低偏置样本对训练loss的影响来减少模型从偏置样本中学习，即在训练loss计算时引入样本的偏置度(详见Du, Yanrui, et al. 2022)。

实验步骤

首先，统计训练数据中偏置词。

偏置词的统计方法为：统计词在不同类别上的分布，若词出现的频次大于cnt_threshold，且最少在一个类别上出现的比例大于p_threshold，则将该词视为偏置词。

!pip install -U trustai
!pip install --upgrade paddlenlp
!pip install -U lac

%cd find_bias/
!wget --no-check-certificate https://trustai.bj.bcebos.com/application_data/lls_data.tar && tar xf lls_data.tar && rm lls_data.tar

3.1 计算样本偏置度的策略（考虑词有偏性、词频）

!python -u find_bias_word.py --output_dir output --input_path ./data/train.tsv \
--num_classes 2 --cnt_threshold 5 --p_threshold 0.90 --output_dir output\
# cnt_threshold表示为偏置词最少需要出现的频次
# p_threshold表示偏置比例的阈值，偏置词至少需要在一个类别上大于此阈值
# output_dir表示统计结果的存储路径

W0930 14:49:45.056458  5600 analysis_predictor.cc:1736] Deprecated. Please use CreatePredictor instead.
100%|██████████████████████████████████| 238766/238766 [05:46<00:00, 688.18it/s]
number of bias_words: 4134

基于偏置词的统计结果，计算训练集中样本偏置度的大小，生成包含样本权重的训练数据。

当前方案提供了lls_d和lls_d_f两种计算样本偏置度的策略，前者考虑了词的有偏性，而后者同时考虑词的有偏性和频次。

# 基于`lls_d`策略计算样本偏置度
!python -u lls.py --input_path ./data/train.tsv --bias_dir ./output \
--stopwords_path ./data/stop_words.txt --num_classes 2 \
--mode lls_d --output_path ./data/train_lls_d.tsv

# 基于`lls_d_f`策略计算样本偏置度
!python -u lls.py --input_path ./data/train.tsv --bias_dir ./output \
--stopwords_path ./data/stop_words.txt --num_classes 2 \
--mode lls_d_f --output_path ./data/train_lls_d_f.tsv
# mode表示计算样本偏置度的策略，当前有`lls_d`和`lls_d_f`两种策略
# output_path表示为生成带偏置度训练集的存储路径

# 基于`lls_d`策略产生的数据训练模型
!python -u train.py --dataset_dir ./data --train_file train_lls_d.tsv \
--dev_file dev.tsv --test_files test.tsv DuQM --num_classes 2 --save_dir ./lls_d_checkpoint

[2022-09-30 15:15:07,590] [    INFO] - Final best dev accuracy: 0.90757
[2022-09-30 15:15:07,590] [    INFO] - Final best test_0 accuracy: 0.87504
[2022-09-30 15:15:07,590] [    INFO] - Final best test_1 accuracy: 0.74827

# 基于`lls_d_f`策略产生的数据训练模型
!python -u train.py --dataset_dir ./data --train_file train_lls_d_f.tsv \
--dev_file dev.tsv --test_files test.tsv DuQM \
--num_classes 2 --save_dir ./lls_d_f_checkpoint

[2022-09-30 15:56:30,616] [    INFO] - Early stop!
[2022-09-30 15:56:30,616] [    INFO] - Final best dev accuracy: 0.90883
[2022-09-30 15:56:30,616] [    INFO] - Final best test_0 accuracy: 0.87188
[2022-09-30 15:56:30,616] [    INFO] - Final best test_1 accuracy: 0.74072

3.2小结：性能对比

数据集	LCQMC_dev	LCQMC_test	DuQM
基线	90.55	87.03	73.81
lls_d	90.76	87.50	74.82
lls_d_f	90.88	87.19	74.07

4.解决训练数据分布偏置的问题 - 数据分布修正（情感分析任务）

缓解数据偏置对模型训练的影响，提升模型鲁棒性

数据分布修正通过对非偏置数据多次重复采样，使训练数据分布尽量均衡。该方案通过可信分析方法识别训练数据中对模型预测其重要贡献的证据，然后通过分析训练中标签和证据的分布识别偏置样本，对偏置样本重复采样来达到数据均衡的目的。

实验步骤

本方案在情感分析数据集ChnsentiCorp上进行实验，在情感分析鲁棒性数据集上评估效果。

首先，通过可信分析识别训练数据中对模型预测其重要贡献的证据。
重要证据统计方法为：基于特征级可信分析方法IntGradInterpreter识别训练数据中起重要贡献的证据和频次。

%cd balance_data
!wget --no-check-certificate https://trustai.bj.bcebos.com/application_data/distribution_data.tar && tar xf distribution_data.tar && rm distribution_data.tar

# 训练基线模型
!python -u train.py --dataset_dir ./data --train_file train.tsv --dev_file robust.tsv --num_classes 2 --save_dir ./checkpoint

[2022-09-30 15:26:40,533] [    INFO] - dev: eval loss: 1.37897, acc: 0.66264
[2022-09-30 15:27:01,124] [    INFO] - global step 1300, epoch: 5, batch: 100, loss: 0.02047, acc: 0.99094, speed: 4.14 step/s
[2022-09-30 15:27:21,585] [    INFO] - global step 1400, epoch: 5, batch: 200, loss: 0.01824, acc: 0.99031, speed: 4.91 step/s
[2022-09-30 15:27:42,074] [    INFO] - global step 1500, epoch: 5, batch: 300, loss: 0.00789, acc: 0.98948, speed: 4.90 step/s
[2022-09-30 15:27:45,746] [    INFO] - dev: eval loss: 1.31838, acc: 0.68013
[2022-09-30 15:27:45,747] [    INFO] - Final best dev accuracy: 0.69857
[2022-09-30 15:27:45,747] [    INFO] - Save best accuracy text classification model in ./checkpoint

4.1 重要证据统计方法为：重要贡献的证据和频次（实例级证据分析IntGradInterpreter）

基于梯度的相似度方法(Grad-Cosin, Grad-Dot)通过模型的梯度挑选对当前测试数据产生正影响和负影响的数据。

# 统计重要证据和频次
!python -u get_rationale_importance.py --dataset_dir ./data \
--input_file train.tsv --num_classes 2  \
--rationale_path ./data/rationale_importance.txt  --init_from_ckpt ./checkpoint/model_state.pdparams
# rationale_path为证据及其频次保存的地址

[32m[2022-09-30 15:28:15,433] [    INFO][0m - We are using <class 'paddlenlp.transformers.ernie.tokenizer.ErnieTokenizer'> to load 'ernie-3.0-base-zh'.[0m
[32m[2022-09-30 15:28:15,433] [    INFO][0m - Already cached /home/aistudio/.paddlenlp/models/ernie-3.0-base-zh/ernie_3.0_base_zh_vocab.txt[0m
[32m[2022-09-30 15:28:15,458] [    INFO][0m - tokenizer config file saved in /home/aistudio/.paddlenlp/models/ernie-3.0-base-zh/tokenizer_config.json[0m
[32m[2022-09-30 15:28:15,458] [    INFO][0m - Special tokens file saved in /home/aistudio/.paddlenlp/models/ernie-3.0-base-zh/special_tokens_map.json[0m
[32m[2022-09-30 15:28:15,459] [    INFO][0m - We are using <class 'paddlenlp.transformers.ernie.modeling.ErnieForSequenceClassification'> to load 'ernie-3.0-base-zh'.[0m
[32m[2022-09-30 15:28:15,460] [    INFO][0m - Already cached /home/aistudio/.paddlenlp/models/ernie-3.0-base-zh/ernie_3.0_base_zh.pdparams[0m
W0930 15:28:15.461091 10925 gpu_resources.cc:61] Please NOTE: device: 0, GPU Compute Capability: 7.0, Driver API Version: 11.2, Runtime API Version: 11.2
W0930 15:28:15.464720 10925 gpu_resources.cc:91] device: 0, cuDNN Version: 8.2.
Building prefix dict from the default dictionary ...
Loading model from cache /tmp/jieba.cache
Loading model cost 0.660 seconds.
Prefix dict has been built successfully.
The Interpreter method will take some minutes, please be patient.
100%|█████████████████████████████████████████| 600/600 [40:57<00:00,  4.10s/it]
[0m

基于统计的证据及其频次分析偏置样本，在偏置样本的不均衡类别上重复采样，达到数据均衡的目的。

# 安装lac
!pip install lac
# 生成均衡训练数据
!python -u balance_train_data.py  --input_path ./data/train.tsv \
--rationale_path ./data/rationale_importance.txt \
--output_path ./data/balanced_train.tsv

部分输出结果：

100%|█████████████████████████████████████| 9600/9600 [00:05<00:00, 1852.85it/s]
100%|███████████████████████████████████████| 1554/1554 [00:27<00:00, 55.61it/s]
一共 [0.12121212121212122, 4, 29, ['d']] 4 29
一塌糊涂 [0.0625, 1, 15, ['a']] 1 15
一如既往 [0.09999999999999998, 18, 2, ['v']] 18 2
一次性 [0.14814814814814814, 4, 23, ['n']] 4 23
上当 [0.016129032258064516, 1, 61, ['v']] 1 61
上当受骗 [0.1111111111111111, 1, 8, ['v']] 1 8
下水道 [0.1, 1, 9, ['n']] 1 9
不合理 [0.1, 5, 45, ['d', 'a']] 5 45
不差 [0.08333333333333337, 11, 1, ['a']] 11 1
不怕 [0.125, 7, 1, ['v']] 7 1
不知所云 [0.08333333333333333, 1, 11, ['v']] 1 11
不负责任 [0.043478260869565216, 1, 22, ['d', 'n']] 1 22
不错 [0.1487889273356401, 1722, 301, ['a']] 1722 301
世界 [0.11290322580645162, 110, 14, ['n']] 110 14
....defaultdict(<class 'int'>, {153: 1, 3733: 2, 3271: 1, 5741: 1, 743: 2, 8823: 2, 5525: 1, 909: 1, 977: 1, 9171: 2, 8860: 1, 8293: 2, 704: 1, 8490: 1, 3423: 1, 8658: 1, 7916: 1, 9134: 1, 7173: 1, 5963: 2, 2974: 5, 239: 2, 8008: 1, 4828: 2, 7012: 3, 8248: 4, 6985: 2, 8687: 3, 4183: 1, 7482: 3, 4557: 1, 8804: 2, 779: 2, 1396: 1, 2291: 1, 9124: 2, 4446: 3, 6202: 2, 5193: 3, 3914: 1, 3504: 3, 5928: 3, 5927: 1, 8560: 2, 6759: 1, 8769: 2, 7941: 4, 9532: 1, 6716: 2, 1702: 1, 7977: 3, 5732: 2, 2215: 1, 7653: 2, 5839:

基于生成的均衡数据balanced_train.tsv训练模型，即可提升模型效果。

!python -u train.py --dataset_dir ./data --train_file balanced_train.tsv \
--dev_file robust.tsv --num_classes 2 \
--save_dir ./checkpoint

4.2小结：性能对比

实验结果如下表所示：

数据集	鲁棒性数据集
基线	69.85
分布修正	70.17

5.解决文本冗余导致精度下降的问题(机器阅读理解(MRC)任务)

参考链接：

https://github.com/PaddlePaddle/TrustAI/tree/main/tutorials/redundancy_removal

5.1 背景和方法介绍

背景

机器阅读理解(MRC)是一项通过让机器回答基于给定上下文的问题来测试机器理解自然语言的程度的任务，它有可能彻底改变人类和机器之间的互动方式。具有MRC技术的搜索引擎可以直接以自然语言返回用户提出的问题的正确答案，而不是返回一系列相关的web页面。

而答案抽取式MRC任务是一个典型的MRC任务。首先给定一个文章，一个问题，要求机器根据问题从文章中找出一个连续的片段作为答案。示例如下

文章：目前中信银行信用卡额度一般从3000元到五万元不等。中信普卡的额度一般为3000元到10000元之间，中信白金卡额度在一万到五万之间。中信信用卡的取现额度为实际额度的50%。如果信用卡批卡之后，持卡者便就可以查询您的信用额度。
问题：中信信用卡白金卡额度是多少？
答案：一万到五万。

在长文本的理解问题上，机器阅读理解(MRC)模型往往存在着严重的理解困难问题，同时也存在严重的虚假相关性，即会根据与答案无关的文本信息以抽取答案。具体来说，模型可能会出现下述2种情况：

文章：目前中信银行信用卡额度一般从3000元到五万元不等。中信普卡的额度一般为3000元到10000元之间，中信白金卡额度在一万到五万之间。中信信用卡的取现额度为实际额度的50%。如果信用卡批卡之后，持卡者便就可以查询您的信用额度。
问题：中信信用卡白金卡额度是多少？
预测答案：3000元到五万元文章：中信银行信用卡额度一般从3000元到五万元不等。一万到五万之间。
问题：中信信用卡白金卡额度是多少？
预测答案：一万到五万。

方法
TrustAI提供了“长文本MRC数据证据抽取->抽取式阅读理解预测”流程。在长文本阅读任务中，即，我们先通过Selector抽取一个与问题相关的关键句子，然后再在关键句子上通过Predictor进行预测。

比如说，我们给定一个样本：

文章：目前中信银行信用卡额度一般从3000元到五万元不等。中信普卡的额度一般为3000元到10000元之间，中信白金卡额度在一万到五万之间。中信信用卡的取现额度为实际额度的50%。如果信用卡批卡之后，持卡者便就可以查询您的信用额度。
问题：中信信用卡白金卡额度是多少？
答案：一万到五万。

Selector会抽取与问题相关的句子，抽取后的文章部分如下所示：

文章：中信普卡的额度一般为3000元到10000元之间，中信白金卡额度在一万到五万之间。
问题：中信信用卡白金卡额度是多少？

Predictor会根据Selector抽取后的文章部分，进行预测：

文章：中信普卡的额度一般为3000元到10000元之间，中信白金卡额度在一万到五万之间。
问题：中信信用卡白金卡额度是多少？
预测答案：一万到五万。

该方案实现了端到端的可解释和预测，即主动学习证据，基于证据做预测，避免后验分析的弊端。通过在长文本任务上的效果验证，方案在体改性能的同时也有效地提升了模型鲁棒性。

#解压文件
!unzip -d ./redundancy_removal TrustAI-tutorials-redundancy_removal.zip

初始文件结构介绍

root
├──predictor
│   ├── dataloader_factory.py   #数据加载
│   ├── model_manager.py        #模型训练、验证流程管理
│   └── model.py                #核心模型
├──selector
│   ├── dataloader_factory.py   #数据加载
│   ├── model_manager.py        #模型训练、验证流程管理
│   └── model.py                #核心模型
├──utils
│   ├── checklist_process.py    #checklist移除no answer脚本
│   ├── dureader_robust.py      #robust数据读取脚本
│   ├── logger.py               #日志模块
│   ├── predict.py              #预测结果统计脚本
│   └── tools.py                #分句等处理工具脚本
├──args.py                       #参数管理
├──run_predict.py                #predictor运行启动脚本
├──run_selector.py               #selector运行启动脚本
├──requirements.txt              #环境配置文件
├──README.md                     #帮助文档
├──download.sh                   #数据加载脚本
├──test.sh                       #测试脚本
├──train.sh                      #一键训练脚本
├──train_selector.sh             #selector训练脚本
├──train_select_data.sh          #selector数据筛选脚本
└──train_predictor.sh            #predictor训练脚本

数据集准备

实验基于roberta-wwm-ext微调，评估指标为EM 和 F1 分数，数据集为Dureader_robust 和 Dureader_checklist。

在运行基线系统之前，请下载Dureader_robust 数据集和Dureader_checklist 数据集。
你可以前往千言进行数据集的手动下载。

可以运行如下命令以快速获得这两个数据集(数据集将保存到data/中)：

%cd redundancy_removal
!sh download.sh

最终，在项目根目录下会出现一个data文件夹，内部结构如下：

data
├── robust
│   ├── train.json
│   ├── dev.json
├── checklist
│   ├── train.json
│   ├── dev.json
└── checklist_wo_no_answer├── train.json  └── dev.json

5.2 模型训练

5.2.1 训练基线模型

我们运行如下命令以启动数据集的训练过程。在训练结束时，模型参数、中间筛选证据和最终dev集预测结果将被保存到output/。

!sh train_roberta.sh -d ./data/robust -o ./output/roberta

[2022-10-08 11:10:10,500] [    INFO] - {"exact": 71.70077628793226,"f1": 85.47831319323168,"total": 1417,"HasAns_exact": 71.70077628793226,"HasAns_f1": 85.47831319323168,"HasAns_total": 1417
}
[2022-10-08 11:10:10,506] [    INFO] - Early Stop!
[2022-10-08 11:10:10,507] [    INFO] - Congratulations! You have finished selector training!

其次，在训练完基线模型后，我们会在output文件夹下获得类似下面的目录：

output
└── roberta├── model_xxx │   └── prediction.json #预测结果├── model_xxx...├── best_model #模型的最好效果的存档│   ├── added_tokens.json │   ├── model_state.pdparams│   ├── special_tokens_map.json│   ├── tokenizer_config.json│   └── vocab.txt└── logging.json #模型的输出日志

接着，我们可以测试基线模型在Checklist上的效果：

!sh test_roberta.sh -d ./data/checklist_wo_no_answer -m ./output/roberta/best_model -o ./output/checklist --split dev
!python ./utils/predict.py --test_data_dir ./data/checklist_wo_no_answer/dev.json --pred_data_dir ./output/checklist/predict-result/model_0/prediction.json

[2022-10-08 11:17:59,321] [    INFO] - {"exact": 30.805687203791468,"f1": 53.14359232217494,"total": 422,"HasAns_exact": 30.805687203791468,"HasAns_f1": 53.14359232217494,"HasAns_total": 422
}

5.2.2训练Selector模型

首先我们运行如下指令训练Selector模型：

!sh train_selector.sh -d ./data/robust -o ./output

[2022-10-08 10:12:13,450] [    INFO] - Global step 4380, epoch: 9, batch: 140, loss: 0.068464, speed: 1.60 step/s
[2022-10-08 10:12:20,277] [    INFO] - Global step 4390, epoch: 9, batch: 150, loss: 0.011039, speed: 1.53 step/s
[2022-10-08 10:12:26,639] [    INFO] - Global step 4400, epoch: 9, batch: 160, loss: 0.029238, speed: 1.64 step/s
{'F1': 0.8503712164477442, 'precision': 0.8557471264367816, 'recall': 0.8450624290578888, 'losse_f1': 0.9684908789386402, 'losse_precision': 1.0, 'losse_recall': 0.9389067524115756}
[2022-10-08 10:12:46,318] [    INFO] - Early Stop!
[2022-10-08 10:12:46,319] [    INFO] - Congratulations! You have finished selector training!

其次，在训练完selector模型后，我们会在output文件夹下获得类似下面的目录：

output
└── selector├── model_xxx │   └── prediction.json #预测结果├── model_xxx...├── best_model #模型的最好效果的存档│   ├── added_tokens.json │   ├── model_state.pdparams│   ├── special_tokens_map.json│   ├── tokenizer_config.json│   └── vocab.txt└── logging.json #模型的输出日志

下一步地，我们需要根据训练好的selector筛选相应dev集数据：

!sh train_select_data.sh -d ./data/robust -o ./output

在select完dev集合数据后，我们会在output文件夹下获得类似下面的目录：

output
└── selected-data├── dev.json└── train.json

然后，基于此，我们训练模型的Predictor:

sequence through the model will result in indexing errors
[2022-09-13 16:23:20,564] [    INFO] - Loading Finished.
[2022-09-13 16:23:20,564] [    INFO] - Preprocessing....
[2022-09-13 16:23:20,564] [    INFO] - Preprocessing finished.
100%|███████████████████████████████████████████| 52/52 [00:20<00:00,  2.56it/s]

!sh train_predictor.sh -o ./output

[2022-10-08 12:09:38,680] [    INFO] - Global step 5090, epoch: 6, batch: 810, loss: 0.494863, speed: 2.10 step/s
[2022-10-08 12:09:43,622] [    INFO] - Global step 5100, epoch: 6, batch: 820, loss: 0.331382, speed: 2.11 step/s
100%|███████████████████████████████████████████| 79/79 [00:15<00:00,  5.23it/s]
[2022-09-14 12:10:04,448] [    INFO] - {"exact": 71.84191954834156,"f1": 85.69746502041924,"total": 1417,"HasAns_exact": 71.84191954834156,"HasAns_f1": 85.69746502041924,"HasAns_total": 1417
}

5.3预测其他数据

由于我们的模型训练过程仅预测dev集结果，我们需要运行以下命令以预测其他数据集：

sh test.sh -d [test数据集所在文件夹路径] -o ./output -s [selector模型文件夹路径] -p [predictor模型文件夹路径] --split [dev/test]

首先我们测试robust dev数据集：

!sh test.sh -d ./data/robust -o ./output/robust -s ./output/selector/best_model -p ./output/predictor/best_model --split dev
!python ./utils/predict.py --test_data_dir ./data/robust/dev.json --pred_data_dir ./output/robust/predict-result/model_0/prediction.json

 "exact": 73.39449541284404,"f1": 86.23775867843243,"total": 1417,"HasAns_exact": 73.39449541284404,"HasAns_f1": 86.23775867843243,"HasAns_total": 1417
}

其次，我们测试checklist(移除no answer) dev数据集：

!sh test.sh -d ./data/checklist_wo_no_answer -o ./output/checklist -s ./output/selector/best_model -p ./output/predictor/best_model --split dev
!python ./utils/predict.py --test_data_dir ./data/checklist_wo_no_answer/dev.json --pred_data_dir ./output/checklist/predict-result/model_0/prediction.json

  "exact": 29.620853080568722,"f1": 52.74756430518254,"total": 422,"HasAns_exact": 29.620853080568722,"HasAns_f1": 52.74756430518254,"HasAns_total": 422
}

5.4方法效果对比

由下表可知，通过冗余处理方案，在EM指标上在Dev集上效果提升2.84%，在Challenge Test集上提升了4.96%，说明方案在提升模型性能的同时较好地提高了模型的鲁棒性。

同时方案在Zero Shot设置上也取得了较高的收益。在Robust上训练的该方案在Checklist数据集（移除no answer设置）上将效果提升2.33%。
实验结果(V100上结果)如下表所示：

模型	DuReader-robust dev		DuReader-robust Test		【Zero shot】 DuReader-checklist dev (Remove no answer)
模型	EM	F1	EM	F1	EM	F1
bert-base[官方数据]	71.70	85.47	30.80	53.14	-	-
roberta-base[复现]	73.48	86.98	45.97	69.43	28.66	50.47
Selector-Predictor	76.32(+2.84)	89.03(+2.05)	50.93(+4.96)	72.22(+2.79)	31.04(+2.33)	53.29(+2.82)

6.情感分析任务的实例级证据&特征级分析

参考见：项目开始

6.1 情感分析任务的实例级证据分析示例

TrustAI的实例级分析接口需要用户提供一个在相关任务上训练好的模型和全部的训练数据，用于分析测试样本。

相关文章参考：

AiTrust下预训练和小样本学习在中文医疗信息处理挑战榜CBLUE表现

下面以中文情感分析任务为例，向大家展示TrustAI实例级证据分析接口的使用步骤，以及代码详细讲解

!pip install -U trustai
!pip install -U paddlenlp

import numpy as np
import paddle
from paddlenlp.transformers import ErnieForSequenceClassification, ErnieTokenizer# Select pre-trained model
MODEL_NAME = "ernie-3.0-base-zh"
# choose from ["ernie-1.0", "ernie-1.0-base-zh", "ernie-1.0-large-zh-cw", "ernie-2.0-base-zh", "ernie-2.0-large-zh",
#"ernie-3.0-xbase-zh", "ernie-3.0-base-zh", "ernie-3.0-medium-zh", "ernie-3.0-mini-zh", "ernie-3.0-micro-zh", "ernie-3.0-nano-zh"]
# Select dataset for model training
DATASET_NAME = 'chnsenticorp'
# Set the path to save the trained model
MODEL_SAVE_PATH = f'./save_model/{DATASET_NAME}-{MODEL_NAME}'# Init model and tokenizer
model = ErnieForSequenceClassification.from_pretrained(MODEL_NAME, num_classes=2)
tokenizer = ErnieTokenizer.from_pretrained(MODEL_NAME)from paddlenlp.datasets import load_dataset
from assets.utils import training_model# Load dataset
train_ds, dev_ds = load_dataset(DATASET_NAME, splits=["train", "dev"])import os
from assets.utils import training_model# 重新训练一个中文情感分析模型
training_model(model, tokenizer, train_ds, dev_ds, save_dir=MODEL_SAVE_PATH)# 加载已训练好模型的参数
state_dict = paddle.load(os.path.join(MODEL_SAVE_PATH, "model_state.pdparams"))
model.set_dict(state_dict)

#!mv /home/aistudio/.paddlenlp/models/ernie-3.0-base-zh/ernie_3.0_base_zh.pdparams /home/aistudio/save_model/chnsenticorp-ernie-3.0-base-zh

将待分析的测试数据转化为模型的输入格式。

from assets.utils import preprocess_fndata = [{"text": '这个宾馆比较陈旧了，特价的房间也很一般。总体来说一般'},{"text": '怀着十分激动的心情放映，可是看着看着发现，在放映完毕后，出现一集米老鼠的动画片'},{"text": '作为老的四星酒店，房间依然很整洁，相当不错。机场接机服务很好，可以在车上办理入住手续，节省时间。'},
]
model_input = preprocess_fn(data, tokenizer)
# model_input是模型的输入，格式必须满足`logits = model(*model_input)`。
# 模型的输出格式必须包含且仅包含`logits`，若不满足这种格式（如模型的输出为`logit，probs = model(*model_input)`），需要用户自定义predict_fn，相关细节见后面的内容。
model_input

(Tensor(shape=[3, 50], dtype=int64, place=Place(gpu:0), stop_gradient=False,[[1    , 47   , 27   , 1468 , 774  , 277  , 420  , 830  , 1100 , 15   ,4    , 169  , 463  , 5    , 458  , 143  , 105  , 321  , 7    , 689  ,12043, 238  , 82   , 61   , 178  , 7    , 689  , 2    , 0    , 0    ,0    , 0    , 0    , 0    , 0    , 0    , 0    , 0    , 0    , 0    ,0    , 0    , 0    , 0    , 0    , 0    , 0    , 0    , 0    , 0    ],[1    , 1049 , 184  , 167  , 59   , 821  , 70   , 5    , 111  , 182  ,364  , 1204 , 4    , 48   , 10   , 335  , 184  , 335  , 184  , 34   ,87   , 4    , 11   , 364  , 1204 , 328  , 833  , 49   , 4    , 39   ,87   , 7    , 271  , 256  , 355  , 1706 , 5    , 70   , 446  , 433  ,2    , 0    , 0    , 0    , 0    , 0    , 0    , 0    , 0    , 0    ],[1    , 25   , 13   , 355  , 5    , 274  , 604  , 661  , 737  , 4    ,458  , 143  , 569  , 187  , 321  , 407  , 1308 , 4    , 156  , 153  ,16   , 990  , 12043, 98   , 191  , 293  , 98   , 231  , 112  , 321  ,170  , 4    , 48   , 22   , 11   , 320  , 28   , 315  , 38   , 109  ,520  , 247  , 607  , 4    , 377  , 244  , 36   , 143  , 12043, 2    ]]),Tensor(shape=[3, 50], dtype=int64, place=Place(gpu:0), stop_gradient=False,[[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,0, 0],[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,0, 0],[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,0, 0]]))

#准备模型训练集的dataloader
from assets.utils import create_dataloader_from_scratch
from assets.utils import print_result# 满足`logits = model(*next(train_data_loader))`
train_dataloader = create_dataloader_from_scratch(train_ds.data, tokenizer, batch_size=16)

# TrustAI可信分析接口调用
#提供FS、GS、RP等多种分析方法，可根据实际实验结果选取最有效的一种方法。from trustai.interpretation import FeatureSimilarityModel# init interpreter
# classifier_layer_name: 模型最后一层全连接层的layer name, 用户需要手动指定， 默认为'classifier'
interpreter = FeatureSimilarityModel(model, train_dataloader, classifier_layer_name='classifier')# sim_fn：计算相似度的函数，可从`cos`, `dot`, `euc`中任选其一
# sample_num：将训练数据按照影响分数排序后，分别返回的正影响和负影响证据的数量，设置为-1时返回排序后的全部训练数据，目前返回两条。
fs_result = interpreter(model_input, sample_num=2, sim_fn="cos")
# fs_result: List[ExampleResult], len(fs_result)等于测试样本的数量
# ExampleResult.pos_indexes: List[int], 正影响证据（支持模型预测）在训练集中的索引。
# ExampleResult.neg_indexes: List[int], 负影响证据（不支持模型预测）在训练集中的索引。
# ExampleResult.pos_scores: List[float], 正影响证据的证据分数
# ExampleResult.neg_scores: List[float], 负影响证据的证据分数# 格式化打印结果
print_result(data, train_ds, fs_result, data_name='chnsenticorp')

Extracting feature from given dataloader, it will take some time...100%|██████████| 600/600 [00:23<00:00, 26.08it/s]test data
text: 这个宾馆比较陈旧了，特价的房间也很一般。总体来说一般 predict label: 0
examples with positive influence
text: 该酒店达不到五星水准。价格高，环境差，服务一般 gold label: 0   score: 0.9849212765693665
text: 整体看起来比较美观，运行的效率在想象之中。这个价位带来的性能不错   gold label: 1   score: 0.9847701787948608
examples with negative influence
text: 因为两岁半的儿子非常喜欢车，看到大家的评论，买了两套外加一本本系列书。拿到手上的第一感觉是轻飘飘的，尽管书的开本很大，但纸张一般。跟它的价位相差太远。翻开轱辘轱辘转这本书，因为当时是冲这本书买的，果然像以前很多买家评论的一样，乱，太乱。画面太满，情节不清晰。最重要的是很多车跟我们中国的完全不符，比如：出租车、吉普车，我儿子最喜欢的皮卡车，在里面没有翻译，多翻译成小卡车或**运输车。对他来讲比较迷惑，我讲起来也很费劲。也许我的孩子太小，不适合这套书。总之这系列书买的比较不值，性价比太低。  gold label: 0   score: -0.06484049558639526
text: 因为两岁半的儿子非常喜欢车，看到大家的评论，买了两套外加一本本系列书。拿到手上的第一感觉是轻飘飘的，尽管书的开本很大，但纸张一般。跟它的价位相差太远。翻开轱辘轱辘转这本书，因为当时是冲这本书买的，果然像以前很多买家评论的一样，乱，太乱。画面太满，情节不清晰。最重要的是很多车跟我们中国的完全不符，比如：出租车、吉普车，我儿子最喜欢的皮卡车，在里面没有翻译，多翻译成小卡车或**运输车。对他来讲比较迷惑，我讲起来也很费劲。也许我的孩子太小，不适合这套书。总之这系列书买的比较不值，性价比太低。  gold label: 0   score: -0.06484049558639526test data
text: 怀着十分激动的心情放映，可是看着看着发现，在放映完毕后，出现一集米老鼠的动画片  predict label: 0
examples with positive influence
text: 1、驱动盘里面没有XP的声卡驱动，要去网站下载 2、驱动一大堆，几乎安装一个重启一次 3、塑料感觉太强烈    gold label: 0   score: 0.9690408110618591
text: 为什么要刷主板，导入代码证书才能装VISTA呢；USB口太少，而且插鼠标很不方便啊，用惯了倒也无所谓；电源插口很容易碰到啊，我就经常断电，55555555555 gold label: 0   score: 0.9678899645805359
examples with negative influence
text: 因为两岁半的儿子非常喜欢车，看到大家的评论，买了两套外加一本本系列书。拿到手上的第一感觉是轻飘飘的，尽管书的开本很大，但纸张一般。跟它的价位相差太远。翻开轱辘轱辘转这本书，因为当时是冲这本书买的，果然像以前很多买家评论的一样，乱，太乱。画面太满，情节不清晰。最重要的是很多车跟我们中国的完全不符，比如：出租车、吉普车，我儿子最喜欢的皮卡车，在里面没有翻译，多翻译成小卡车或**运输车。对他来讲比较迷惑，我讲起来也很费劲。也许我的孩子太小，不适合这套书。总之这系列书买的比较不值，性价比太低。  gold label: 0   score: 0.0012395160738378763
text: 因为两岁半的儿子非常喜欢车，看到大家的评论，买了两套外加一本本系列书。拿到手上的第一感觉是轻飘飘的，尽管书的开本很大，但纸张一般。跟它的价位相差太远。翻开轱辘轱辘转这本书，因为当时是冲这本书买的，果然像以前很多买家评论的一样，乱，太乱。画面太满，情节不清晰。最重要的是很多车跟我们中国的完全不符，比如：出租车、吉普车，我儿子最喜欢的皮卡车，在里面没有翻译，多翻译成小卡车或**运输车。对他来讲比较迷惑，我讲起来也很费劲。也许我的孩子太小，不适合这套书。总之这系列书买的比较不值，性价比太低。  gold label: 0   score: 0.0012395160738378763test data
text: 作为老的四星酒店，房间依然很整洁，相当不错。机场接机服务很好，可以在车上办理入住手续，节省时间。  predict label: 0
examples with positive influence
text: 酒店位置不错，房间质量也很好，就是停车位少了一点，停车有点紧张。不过也可以理解，因为处于南京市市中心。   gold label: 1   score: 0.9931097626686096
text: 客房和餐厅的服务都不错，总台的办事速度也挺快。但楼层好像没电话，我忘带房卡还要下到总台，电梯有点慢。   gold label: 1   score: 0.9887141585350037
examples with negative influence
text: 地理位置实在是好。我住的是单人大床房，进屋一看竟然跟套房一样，不过一个小屋有桌子和电视，另一个小屋只能放下一张床和电视，实在小得可怜。因为工作所以没有在酒店吃早餐，但是对面的郝刚刚羊杂割的确让人印象深刻，唯一的遗憾就是只有中午开门，晚上不营业……我想在酒店的商务中心买飞机票，竟然被告知不能刷卡，只能现金结帐，因此没买成，不爽！  gold label: 1   score: -0.12822110950946808
text: 地理位置实在是好。我住的是单人大床房，进屋一看竟然跟套房一样，不过一个小屋有桌子和电视，另一个小屋只能放下一张床和电视，实在小得可怜。因为工作所以没有在酒店吃早餐，但是对面的郝刚刚羊杂割的确让人印象深刻，唯一的遗憾就是只有中午开门，晚上不营业……我想在酒店的商务中心买飞机票，竟然被告知不能刷卡，只能现金结帐，因此没买成，不爽！  gold label: 1   score: -0.12822110950946808

from trustai.interpretation import RepresenterPointModel# init interpreter
# classifier_layer_name: 模型最后一层全连接层的layer name, 用户需要手动指定， 默认为'classifier'
interpreter = RepresenterPointModel(model, train_dataloader, classifier_layer_name='classifier')# 结果形式与fs_result相同
# sample_num：将训练数据按照影响分数排序后，分别返回的正影响和负影响证据的数量，设置为-1时返回排序后的全部训练数据。
rp_result = interpreter(model_input, sample_num=2)# 格式化打印结果
print_result(data, train_ds, rp_result, data_name='chnsenticorp')

Extracting feature from given dataloader, it will take some time...100%|██████████| 600/600 [00:23<00:00, 25.94it/s]Training representer point model, it will take several minutes...
L1 difference between ground truth prediction and prediction by representer theorem decomposition
[0.55169713]
pearson correlation between ground truth  prediction and prediciton by representer theorem
-0.40964824163976427
test data
text: 这个宾馆比较陈旧了，特价的房间也很一般。总体来说一般 predict label: 0
examples with positive influence
text: 地理位置实在是好。我住的是单人大床房，进屋一看竟然跟套房一样，不过一个小屋有桌子和电视，另一个小屋只能放下一张床和电视，实在小得可怜。因为工作所以没有在酒店吃早餐，但是对面的郝刚刚羊杂割的确让人印象深刻，唯一的遗憾就是只有中午开门，晚上不营业……我想在酒店的商务中心买飞机票，竟然被告知不能刷卡，只能现金结帐，因此没买成，不爽！  gold label: 1   score: 0.003500879742205143
text: 地理位置实在是好。我住的是单人大床房，进屋一看竟然跟套房一样，不过一个小屋有桌子和电视，另一个小屋只能放下一张床和电视，实在小得可怜。因为工作所以没有在酒店吃早餐，但是对面的郝刚刚羊杂割的确让人印象深刻，唯一的遗憾就是只有中午开门，晚上不营业……我想在酒店的商务中心买飞机票，竟然被告知不能刷卡，只能现金结帐，因此没买成，不爽！  gold label: 1   score: 0.003500879742205143
examples with negative influence
text: 没送包鼠标，不过没什么关系，花个一百多买个好点的也行 vista正在适应中   gold label: 0   score: -0.3232628405094147
text: 整体上感觉还行吧，性价比较高，毕竟这个价位买到这样的机器还可以了。刚刚买，正在熟悉中   gold label: 1   score: -0.29742637276649475test data
text: 怀着十分激动的心情放映，可是看着看着发现，在放映完毕后，出现一集米老鼠的动画片  predict label: 0
examples with positive influence
text: 因为两岁半的儿子非常喜欢车，看到大家的评论，买了两套外加一本本系列书。拿到手上的第一感觉是轻飘飘的，尽管书的开本很大，但纸张一般。跟它的价位相差太远。翻开轱辘轱辘转这本书，因为当时是冲这本书买的，果然像以前很多买家评论的一样，乱，太乱。画面太满，情节不清晰。最重要的是很多车跟我们中国的完全不符，比如：出租车、吉普车，我儿子最喜欢的皮卡车，在里面没有翻译，多翻译成小卡车或**运输车。对他来讲比较迷惑，我讲起来也很费劲。也许我的孩子太小，不适合这套书。总之这系列书买的比较不值，性价比太低。  gold label: 0   score: -2.3267491997103207e-05
text: 因为两岁半的儿子非常喜欢车，看到大家的评论，买了两套外加一本本系列书。拿到手上的第一感觉是轻飘飘的，尽管书的开本很大，但纸张一般。跟它的价位相差太远。翻开轱辘轱辘转这本书，因为当时是冲这本书买的，果然像以前很多买家评论的一样，乱，太乱。画面太满，情节不清晰。最重要的是很多车跟我们中国的完全不符，比如：出租车、吉普车，我儿子最喜欢的皮卡车，在里面没有翻译，多翻译成小卡车或**运输车。对他来讲比较迷惑，我讲起来也很费劲。也许我的孩子太小，不适合这套书。总之这系列书买的比较不值，性价比太低。  gold label: 0   score: -2.3267491997103207e-05
examples with negative influence
text: 没送包鼠标，不过没什么关系，花个一百多买个好点的也行 vista正在适应中   gold label: 0   score: -0.29319778084754944
text: 装修简洁实用，但电源插口少，要配个接线器为好。另外浴缸的hot龙头请配图示，第一次来的一定弄很久。酒店lobby太大，早餐要历经磨难    gold label: 1   score: -0.2671462893486023test data
text: 作为老的四星酒店，房间依然很整洁，相当不错。机场接机服务很好，可以在车上办理入住手续，节省时间。  predict label: 0
examples with positive influence
text: 海景是其一大卖点，但房间面积偏小，离地铁站不近，打的到机场360港币。服务也算不错，门童和蔼可亲，当然给小费的话更是让你有皇帝的感觉。招呼“的士”的“老爷爷”几年来一直打扮得象“红头阿三”，不知是算有创意还是没创意？但老实说他还是蛮敬业的！走到地铁估计10-15分钟（但没一本正经走过，大概罢了）。走天桥可以到新宏基三楼“海都酒楼”饮茶，味道一级，据说朱熔基总理也去吃过饭（楼下服务台说的）！  gold label: 1   score: 0.00795850157737732
text: 地理位置实在是好。我住的是单人大床房，进屋一看竟然跟套房一样，不过一个小屋有桌子和电视，另一个小屋只能放下一张床和电视，实在小得可怜。因为工作所以没有在酒店吃早餐，但是对面的郝刚刚羊杂割的确让人印象深刻，唯一的遗憾就是只有中午开门，晚上不营业……我想在酒店的商务中心买飞机票，竟然被告知不能刷卡，只能现金结帐，因此没买成，不爽！  gold label: 1   score: 0.007669270504266024
examples with negative influence
text: 没送包鼠标，不过没什么关系，花个一百多买个好点的也行 vista正在适应中   gold label: 0   score: -0.2923046052455902
text: 整体上感觉还行吧，性价比较高，毕竟这个价位买到这样的机器还可以了。刚刚买，正在熟悉中   gold label: 1   score: -0.28760650753974915

from trustai.interpretation import GradientSimilarityModel# GradientSimilarity方法传入的训练数据和测试数据的batch_size都必须为1
# 满足`logits = model(*next(train_data_loader))`
train_dataloader = create_dataloader_from_scratch(train_ds.data, tokenizer, batch_size=1)
model_inputs = create_dataloader_from_scratch(data, tokenizer, batch_size=1)# init interpreter
interpreter = GradientSimilarityModel(model, train_dataloader, classifier_layer_name='classifier')gs_result = []
for model_input in model_inputs:# 结果形式与fs_result相同# sim_fn：计算相似度的函数，可从`cos`, `dot`中任选其一# sample_num：将训练数据按照影响分数排序后，分别返回的正影响和负影响证据的数量，设置为-1时返回排序后的全部训练数据。gs_result += interpreter(model_input, sample_num=2, sim_fn="cos")# 格式化打印结果
print_result(data, train_ds, gs_result, data_name='chnsenticorp')

Extracting gradient for given dataloader, it will take some time...100%|██████████| 9600/9600 [08:29<00:00, 18.85it/s]test data
text: 这个宾馆比较陈旧了，特价的房间也很一般。总体来说一般 predict label: 0
examples with positive influence
text: 该酒店达不到五星水准。价格高，环境差，服务一般 gold label: 0   score: 0.9849640130996704
text: 整体看起来比较美观，运行的效率在想象之中。这个价位带来的性能不错   gold label: 1   score: 0.9848136901855469
examples with negative influence
text: 散热口在右边不是很理想。装了XP系统，但没驱动，只能V的驱动，网上找了一些，但蓝牙不能用，一些快捷键也不能用，要有XP的驱动就好了   gold label: 0   score: -0.8751398324966431
text: 价格没有优势，因为不送东西。自己买完后和在电脑城买差不多。不过自己买的鼠标，包呀可以自己选择也不错。那有那么多好事都让你给遇到呢。   gold label: 0   score: -0.867559552192688test data
text: 怀着十分激动的心情放映，可是看着看着发现，在放映完毕后，出现一集米老鼠的动画片  predict label: 0
examples with positive influence
text: 1、驱动盘里面没有XP的声卡驱动，要去网站下载 2、驱动一大堆，几乎安装一个重启一次 3、塑料感觉太强烈    gold label: 0   score: 0.9691342115402222
text: 为什么要刷主板，导入代码证书才能装VISTA呢；USB口太少，而且插鼠标很不方便啊，用惯了倒也无所谓；电源插口很容易碰到啊，我就经常断电，55555555555 gold label: 0   score: 0.9679868817329407
examples with negative influence
text: 房间里铺着像餐馆一样的廉价石砖地，两床之间有一块肮脏的地毯 床上只有及薄的褥子，床垫上的弹簧不分轻重的时刻硌着你。 喷头出的水永远只有两种温度，极热和极冷 出行不方便，地点比较偏颇，从解放碑打车，很多司机都不去。 总之糟糕透顶   gold label: 0   score: -0.8456372618675232
text: 房间里铺着像餐馆一样的廉价石砖地，两床之间有一块肮脏的地毯 床上只有及薄的褥子，床垫上的弹簧不分轻重的时刻硌着你。 喷头出的水永远只有两种温度，极热和极冷 出行不方便，地点比较偏颇，从解放碑打车，很多司机都不去。 总之糟糕透顶   gold label: 0   score: -0.8456372618675232test data
text: 作为老的四星酒店，房间依然很整洁，相当不错。机场接机服务很好，可以在车上办理入住手续，节省时间。  predict label: 0
examples with positive influence
text: 酒店位置不错，房间质量也很好，就是停车位少了一点，停车有点紧张。不过也可以理解，因为处于南京市市中心。   gold label: 1   score: 0.9931327700614929
text: 客房和餐厅的服务都不错，总台的办事速度也挺快。但楼层好像没电话，我忘带房卡还要下到总台，电梯有点慢。   gold label: 1   score: 0.9887524247169495
examples with negative influence
text: 几个月之后再次入住，一进门大厅里一位女工作人员就叫得出我的名字，很不一般。服务没得说，酒店位置也很好，位于威海市中心。   gold label: 1   score: -0.9607528448104858
text: 整体做工尚可，屏幕大有面子，硬盘大够肚量，独立显卡是ati的3430并非3410性能可以，配置够用，上网、看片子完全没问题。用ghostxp装好无需再要装驱动。   gold label: 1   score: -0.9472662210464478

6.2 情感分析任务的特征级证据分析示例

import numpy as np
import paddle
from paddlenlp.transformers import ErnieForSequenceClassification, ErnieTokenizer# Select pre-trained model
MODEL_NAME = "ernie-3.0-base-zh" # choose from ["ernie-1.0", "ernie-1.0-base-zh", "ernie-1.0-large-zh-cw", "ernie-2.0-base-zh", "ernie-2.0-large-zh", "ernie-3.0-xbase-zh", "ernie-3.0-base-zh", "ernie-3.0-medium-zh", "ernie-3.0-mini-zh", "ernie-3.0-micro-zh", "ernie-3.0-nano-zh"]
# Select dataset for model training
DATASET_NAME = 'chnsenticorp'
# Set the path to save the trained model
MODEL_SAVE_PATH = f'./save_model/{DATASET_NAME}-{MODEL_NAME}'# Init model and tokenizer
model = ErnieForSequenceClassification.from_pretrained(MODEL_NAME, num_classes=2)
tokenizer = ErnieTokenizer.from_pretrained(MODEL_NAME)from paddlenlp.datasets import load_dataset
from assets.utils import training_model# Load dataset
train_ds, dev_ds = load_dataset(DATASET_NAME, splits=["train", "dev"])import os
from assets.utils import training_model# 重新训练一个中文情感分析模型
training_model(model, tokenizer, train_ds, dev_ds, save_dir=MODEL_SAVE_PATH)# 加载已训练好模型的参数
state_dict = paddle.load(os.path.join(MODEL_SAVE_PATH, "model_state.pdparams"))
model.set_dict(state_dict)

from assets.utils import preprocess_fndata = [{"text": '15.4寸笔记本的键盘确实爽，基本跟台式机差不多了，蛮喜欢数字小键盘，输数字特方便，样子也很美观，做工也相当不错'},{"text": '房间太小。其他的都一般。。。。。。。。'},{"text": '1.接电源没有几分钟,电源适配器热的不行. 2.摄像头用不起来. 3.机盖的钢琴漆，手不能摸，一摸一个印. 4.硬盘分区不好办'},
]
model_input = preprocess_fn(data, tokenizer)
# model_input是模型的输入，格式必须满足`logits = model(*model_input)`。
# 模型的输出格式必须包含且仅包含`logits`，若不满足这种格式（如模型的输出为`logit，probs = model(*model_input)`），需要用户自定义predict_fn，相关细节见后面的内容。
model_input

(Tensor(shape=[3, 62], dtype=int64, place=Place(gpu:0), stop_gradient=False,[[1  , 903, 42 , 397, 1713, 872, 374, 89 , 5  , 1153, 966, 524, 79 , 2175,4  , 168, 89 , 1057, 357, 220, 98 , 859, 16 , 65 , 15 , 4  , 2562, 692,811, 179, 436, 96 , 1153, 966, 4  , 789, 179, 436, 169, 58 , 518, 4  ,314, 85 , 105, 321, 188, 394, 4  , 388, 35 , 105, 156, 153, 16 , 990,2  , 0  , 0  , 0  , 0  , 0  ],[1  , 458, 143, 512, 96 , 12043, 63 , 44 , 5  , 165, 7  , 689, 12043, 12043,12043, 12043, 12043, 12043, 12043, 12043, 2  , 0  , 0  , 0  , 0  , 0  , 0  , 0  ,0  , 0  , 0  , 0  , 0  , 0  , 0  , 0  , 0  , 0  , 0  , 0  , 0  , 0  ,0  , 0  , 0  , 0  , 0  , 0  , 0  , 0  , 0  , 0  , 0  , 0  , 0  , 0  ,0  , 0  , 0  , 0  , 0  , 0  ],[1  , 208, 42 , 293, 128, 362, 340, 9  , 553, 59 , 959, 30 , 128, 362,582, 483, 361, 506, 5  , 16 , 40 , 42 , 249, 42 , 1083, 635, 306, 29 ,16 , 200, 61 , 42 , 284, 42 , 98 , 934, 5  , 1000, 1516, 2188, 4  , 247,16 , 52 , 2060, 4  , 7  , 2060, 7  , 27 , 749, 42 , 397, 42 , 1003, 966,59 , 121, 16 , 170, 315, 2  ]]),Tensor(shape=[3, 62], dtype=int64, place=Place(gpu:0), stop_gradient=False,[[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]))

提供IG，LIME，attention等多种分析方法，可根据实际实验结果选取最有效的一种方法。

a）IntGradInterpreter

from trustai.interpretation.token_level import IntGradInterpreter# Init an IG interpreter
# 指定gpu device为卡0
ig_interpreter = IntGradInterpreter(model, device="gpu:0")# Use IG interpreter to get the importance scores for all data
ig_results = ig_interpreter(model_input)ig_results[0]
# ig_results: List[IGResult]，len(ig_results)等于测试样本的数量
# IGResult.attributions: List[float]， 测试数据中每一个特征（字或词）的重要度分数（由于model_input包含多条测试样本，因此len(ig_results[0].attributions)中包含padding长度）
# IGResult.pred_label: float， 测试样本预测label
# IGResult.pred_proba: List[float]，测试样本的在每个类别的预测概率

IGResult(attributions=array([ 3.9611611e-01,  8.1771597e-02,  3.6921564e-02,  9.6683139e-03,-1.0506064e-04,  2.2412997e-02, -9.3343882e-03,  2.1760456e-02,-1.9716343e-02, -4.9045999e-03,  3.1103995e-03,  6.9644060e-03,7.6202586e-02,  5.3226702e-02,  3.0545212e-02,  2.9279344e-02,-2.1367073e-03,  2.9657342e-02,  1.3743107e-02, -1.0270997e-02,2.4086799e-02, -2.3649698e-02, -3.0725049e-02, -2.6313607e-03,-8.6087985e-03, -1.0641082e-02, -3.1289157e-02, -4.7809519e-03,-4.8832290e-02, -8.5784774e-03, -7.8825302e-02, -2.4838714e-02,-3.6552493e-02, -1.7311346e-02, -1.4713159e-02, -2.5224429e-02,-2.7506858e-02, -6.0384102e-02, -1.4056545e-02, -3.6945269e-02,2.4092793e-03,  1.1595527e-02, -2.4344958e-02, -7.1093589e-03,-2.2834249e-02, -2.3277557e-02, -1.4660323e-02, -3.4316111e-02,5.2204588e-03, -2.3300830e-02, -1.2386642e-02, -2.0053562e-02,2.6681280e-02,  9.4405189e-02,  6.5910086e-02,  1.4149147e-01,-1.0090332e+00,  0.0000000e+00,  0.0000000e+00,  0.0000000e+00,0.0000000e+00,  0.0000000e+00], dtype=float32), pred_label=1, pred_proba=array([0.00255499, 0.997445  ], dtype=float32), error_percent=array([ 22.875082, 177.12494 ], dtype=float32))

b） AttentionInterpreter

from trustai.interpretation.token_level.common import attention_predict_fn_on_paddlenlp
from trustai.interpretation.token_level import AttentionInterpreter# Init an attention interpreter and get the importance scores
# 每个模型计算attention的方式都不相同，因此用户可以参照`attention_predict_fn_on_paddlenlp`实现对应自己模型的`predict_fn`
att_interpreter = AttentionInterpreter(model, device="gpu:0", predict_fn=attention_predict_fn_on_paddlenlp)# Use attention interpreter to get the importance scores for all data
att_results = att_interpreter(model_input)att_results[0]
# att_results: List[AttentionResult]，len(att_results)等于测试样本的数量
# AttentionResult.attributions: List[float]， 测试数据中每一个特征（字或词）的重要度分数（由于model_input包含多条测试样本，因此len(ig_results[0].attributions)中包含padding长度）
# AttentionResult.pred_label: float， 测试样本预测label
# AttentionResult.pred_proba: List[float]，测试样本的在每个类别的预测概率

AttentionResult(attributions=array([ 27.951666 , -46.192444 , -29.750486 , -51.377174 , -45.480515 ,-33.49736  , -46.91317  , -42.22312  ,   2.4542546, -28.134533 ,-32.574024 ,  12.293074 , -16.04379  , -16.363848 ,  17.602852 ,2.4729812, -50.842373 , -21.796722 , -59.23244  , -58.508694 ,-42.23652  , -23.044878 , -44.877014 , -62.551327 , -11.165628 ,20.797285 , -21.972486 ,   5.1856213, -32.514706 , -29.022219 ,-64.34274  , -44.24015  , -39.693245 , -46.090187 ,  22.954376 ,-46.19861  , -39.829258 , -61.91038  , -12.456142 ,  -5.834831 ,-48.82857  ,  24.527557 ,  11.154478 , -41.953377 ,  12.378511 ,4.471764 ,  -6.163226 , -38.231674 ,  23.95559  ,  12.294624 ,-26.113823 ,  12.5190115,  20.37336  ,   2.3177407,  17.686596 ,9.2182255,  27.951666 ,  22.484247 ,  23.818907 ,  21.831902 ,24.593304 ,  24.091738 ], dtype=float32), pred_label=1, pred_proba=array([0.00255499, 0.997445  ], dtype=float32))

c）LIMEInterpreter

from trustai.interpretation.token_level import LIMEInterpreter
# Hyperparameters
LIME_SAMPLES = 1000# Init an LIME interpreter
# LIMEInterpreter需要用户指定unk和pad字符在词表中的索引
lime_interpreter = LIMEInterpreter(model, device="gpu:0",unk_id=tokenizer.convert_tokens_to_ids('[UNK]'),pad_id=tokenizer.convert_tokens_to_ids('[PAD]'))# Use LIME interpreter to get the importance scores for all data
lime_results = lime_interpreter(model_input)lime_results[0]
# lime_results: List[LimeResult]，len(lime_results)等于测试样本的数量
# LimeResult.attributions: List[float]， 测试数据中每一个特征（字或词）的重要度分数（由于model_input包含多条测试样本，因此len(ig_results[0].attributions)中包含padding长度）
# LimeResult.pred_label: float， 测试样本预测label
# LimeResult.pred_proba: List[float]，测试样本的在每个类别的预测概率
# LimeResult.lime_score: float，lime预测测试样本的决定系数R^2

LimeResult(attributions=array([ 0.14440953,  0.03180836, -0.01459045,  0.02719165,  0.0158539 ,0.00829694,  0.03274776,  0.01557536, -0.00622276, -0.00218786,0.00808915,  0.0140393 ,  0.01218321,  0.04286841,  0.01379906,0.00911424, -0.02019319,  0.02258962,  0.04732991,  0.01382025,0.01449278,  0.03557868,  0.00452219,  0.02012017,  0.05186406,0.03013829,  0.01391893,  0.0299878 ,  0.02464238,  0.00993983,-0.00562427, -0.00734531,  0.05297428,  0.01411321,  0.00555489,-0.01311027,  0.02549417, -0.03504853,  0.01478854,  0.04885025,0.05888825,  0.03400377,  0.01701798,  0.00574751,  0.04210434,0.05682674,  0.04664667,  0.04919846,  0.00659523,  0.023383  ,0.04833108,  0.04119288,  0.04578412,  0.01605453,  0.07399736,0.02509232,  0.1552564 ]), pred_label=1, pred_proba=array([0.00255499, 0.997445  ], dtype=float32), lime_score=0.3547609027505966)

d）GradShapInterpreter

!pip install interpretdl

from trustai.interpretation.token_level import GradShapInterpreter# Init an GradShap interpreter
# gradshap的device参数仅支持输入`gpu`和`cpu`grad_interpreter = GradShapInterpreter(model, device='gpu')# Use GradShap interpreter to get the importance scores for all data
gradshap_results = grad_interpreter(model_input)gradshap_results[0]
# gradshap_results: List[gradshap_results]，len(gradshap_results)等于测试样本的数量
# GradShapResult.attributions: List[float]， 测试数据中每一个特征（字或词）的重要度分数（由于model_input包含多条测试样本，因此len(ig_results[0].attributions)中包含padding长度）
# GradShapResult.pred_label: float， 测试样本预测label
# GradShapResult.pred_proba: List[float]，测试样本的在每个类别的预测概率

GradShapResult(attributions=array([ 4.27702471e-04, -1.11839916e-04,  3.71408714e-06, -3.62199789e-05,-1.78017508e-04, -1.12978014e-04, -2.03211806e-04, -2.44890776e-04,-2.08588754e-04, -2.27118609e-04, -5.54480721e-06,  3.36829107e-04,-1.94214095e-04,  9.23020416e-05, -1.59354677e-05, -1.94958440e-04,-5.46878873e-05, -1.68988881e-05, -2.01176736e-04, -1.02494050e-05,-4.63668635e-04,  2.76391565e-05, -5.78310137e-05, -1.06889151e-04,9.66970620e-05,  1.53168337e-04,  8.33107624e-05,  2.80828448e-04,1.08509324e-04, -2.03269345e-04, -1.23263191e-04, -1.89185928e-04,5.18460256e-05, -9.76677038e-05, -1.66480459e-04, -1.32030094e-04,-3.21249303e-04,  8.67254275e-05, -4.39524083e-05,  9.19012964e-05,-3.67699940e-05, -1.25569277e-05,  1.23039907e-04,  3.74841038e-05,-6.26133115e-05,  2.65673385e-04,  1.81959738e-04, -2.92237601e-05,-8.47377014e-05,  1.64378886e-04,  1.62167398e-05,  4.82851116e-04,7.45651079e-04,  6.15275465e-04,  3.63482774e-04,  4.54223773e-04,3.45898734e-04,  0.00000000e+00,  0.00000000e+00,  0.00000000e+00,0.00000000e+00,  0.00000000e+00], dtype=float32), pred_label=1, pred_proba=array([0.00255499, 0.997445  ], dtype=float32))

6.2.1特征级证据分析结果可视化（细颗粒度）

a.获取测试样本的切词

b.调用可视化接口，传入切词与特征重要度分数

下面以LIME的分析结果为例，进行可视化展示。

from trustai.interpretation import VisualizationTextRecord
from trustai.interpretation import visualize_text# 将id转为为token
tokens = [tokenizer.convert_ids_to_tokens(_input_ids) for _input_ids in model_input[0].tolist()]
# 去除[PAD]字符
tokens = [[token for token in _tokens if token != '[PAD]']   for _tokens in tokens]true_labels = [1, 0, 0]
# IG方法的可视化结果
recs = []
for i in range(len(ig_results)):recs.append(VisualizationTextRecord(lime_results[i], words=tokens[i], true_label=true_labels[i]))
html = visualize_text(recs)

6.2.2特征级证据分析结果可视化（粗颗粒度）

开发者还可以将分析结果对齐到更大粒度的切词上去，但是这需要开发者提供模型的原始切词和更大粒度切词的offset_map（即切词后位置与原始文本位置的映射词典）.

下面的代码将LIME方法的可信分析结果映射到jieba的切词粒度上。

# 安装jieba切词
!pip install jieba

Looking in indexes: https://pypi.tuna.tsinghua.edu.cn/simple
Requirement already satisfied: jieba in /opt/conda/envs/python35-paddle120-env/lib/python3.7/site-packages (0.42.1)[notice] A new release of pip available: 22.1.2 -> 22.2.2
[notice] To update, run: pip install --upgrade pip

#构建`offset_map`词典
import jiebafrom trustai.interpretation import get_word_offset# Add CLS and SEP tags to both original text and standard splited tokens
contexts = []
words = []
for exmaple in data:text = exmaple['text']# 由于本示例使用的ERNIE模型，因此需要在文本前后分别补充"[CLS]"和"[SEP]"两个字符，才能与模型输出结果对齐。# context示例：[CLS]这个宾馆比较陈旧了，特价的房间也很一般。总体来说一般[SEP]contexts.append("[CLS]" + text + "[SEP]")# 相比模型输入，更大粒度的切词，此处使用jieba的切词。# word示例：['[CLS]', '这个', '宾馆', '比较', '陈旧', '了', '，', '特价', '的', '房间', '也', '很', '一般', '。', '总体', '来说', '一般', '[SEP]']words.append(["[CLS]"] + list(jieba.cut(text)) + ["[SEP]"])# Get the offset map of tokenized tokens and standard splited tokens
ori_offset_maps = []
word_offset_maps = []
for i in range(len(contexts)):ori_offset_maps.append(tokenizer.get_offset_mapping(contexts[i]))word_offset_maps.append(get_word_offset(contexts[i], words[i]))

Building prefix dict from the default dictionary ...
Dumping model to file cache /tmp/jieba.cache
Loading model cost 0.783 seconds.
Prefix dict has been built successfully.

将LIME方法的分析结果与jieba分词对齐，并进行可视化展示。

align_res = lime_interpreter.alignment(lime_results, contexts, words, word_offset_maps, ori_offset_maps, special_tokens=["[CLS]", '[SEP]'])# process for vbisualize
recs = []
for i in range(len(align_res)):recs.append(VisualizationTextRecord(align_res[i], true_label=true_labels[i]))
html = visualize_text(recs)

7.总结

各个方法对比可以看每个章节的小结

总结下来：实例级证据分析方法RepresenterPointModel和FeatureSimilarityModel整体取得效果更佳，主要原因在于可以判别出需要标注的数据，这样在部分样本下就能取得更好的效果。

github提了一个issue关于PaddleNLP在持续学习这块的迭代期待：
https://github.com/PaddlePaddle/PaddleNLP/issues/3395

问题背景：
2021-11-29 ：百度ERNIE-Health登顶中文医疗信息处理CBLUE榜单冠军：https://baijiahao.baidu.com/s?id=1717731573139745403&wfr=spider&for=pc

2022-04-13 ：云知声登顶中文医疗信息处理挑战榜CBLUE 2.0：https://baijiahao.baidu.com/s?id=1729960390071520105&wfr=spider&for=pc

2022-05月份：艾登&清华团队在中文医疗信息处理挑战榜喜创佳绩：https://www.cn-healthcare.com/articlewm/20220606/content-1372998.html

1.可以看到在CBLUE榜单上，ERNIE最先刷榜登顶，后续有一些别的团队再更新刷榜。通过模型对比，我相信ERNIE一定是NLP领域前沿模型，效果性能都很优越。而后续新榜单模型，在算法模型的优化侧重点可能没那么大，感觉更多的会对数据集的处理上下了很大功夫。模型差不多情况下，不同数据增强等技术影响还是比较大的，然后不断迭代。

2.看到paddlenlp已经推出了：pipelines面向 NLP 全场景为用户提供低门槛构建强大产品级系统的能力，通过一种简单高效的方式搭建一套语义检索系统，使用自然语言文本通过语义进行智能文档查询。

因此引出了一个问题：关于持续学习

目前看到在paddlenlp 提供了一些数据优化的方法：如：AITrust等可信分析，以及BML平台上看到的智能标注（或者个人依赖ERNIE生成的教师模型），来提供相对较高质量的标注数据。

但感觉在模型迭代过程中更多的是点状，是靠人工进行一个个串行起来。希望可以出现一个持续学习模型的流程（自动化）和这些技术结合起来，还是有很大意义的。

参考论文：

可信分析方法参考论文：NormLime: NormLime: A New Feature Importance Metric for Explaining Deep Neural Networks, Isaac Ahern et al. 2019Attention: Attention is not explanation, S Jain et al. 2019Representer Pointer:Representer point selection for explaining deep neural networks, Chih-Kuan Yeh et al. 2018Evaluation: A Fine-grained Interpretability Evaluation Benchmark for Neural NLP, Wang Lijie, et al. 2022SGDNoise: On the Noisy Gradient Descent that Generalizes as SGD, Wu et al 2019IntegratedGraients: Axiomatic Attribution for Deep Networks, Mukund Sundararajan et al. 2017CAM, GradCAM: Grad-CAM: Visual Explanations from Deep Networks via Gradient-based Localization, Ramprasaath R. Selvaraju et al. 2017SmoothGrad: SmoothGrad: removing noise by adding noise, Daniel Smilkov et al. 2017GradientShap: A Unified Approach to Interpreting Model Predictions, Scott M. Lundberg et al. 2017Occlusion: Visualizing and Understanding Convolutional Networks, Matthew D Zeiler and Rob Fergus 2013Lime: "Why Should I Trust You?": Explaining the Predictions of Any Classifier, Marco Tulio Ribeiro et al. 2016NormLime: NormLime: A New Feature Importance Metric for Explaining Deep Neural Networks, Isaac Ahern et al. 2019ScoreCAM: Score-CAM: Score-Weighted Visual Explanations for Convolutional Neural Networks, Haofan Wang et al. 2020ForgettingEvents: An Empirical Study of Example Forgetting during Deep Neural Network Learning, Mariya Toneva et al. 2019LRP: On Pixel-Wise Explanations for Non-Linear Classifier Decisions by Layer-Wise Relevance Propagation, Bach et al. 2015
Rollout: Quantifying Attention Flow in Transformers, Abnar et al. 2020
TAM: Explaining Information Flow Inside Vision Transformers Using Markov Chain. Yuan et al. 2021
Consensus: Cross-Model Consensus of Explanations and Beyond for Image Classification Models: An Empirical Study. Li et al 2021
Perturbation: Evaluating the visualization of what a deep neural network has learned.
Deletion&Insertion: RISE: Randomized Input Sampling for Explanation of Black-box Models.
PointGame: Top-down Neural Attention by Excitation Backprop.此文章为搬运[原项目链接](https://aistudio.baidu.com/aistudio/projectdetail/4622139)