分类： 人工智能

作为刚入门的小白，有必要去记录一些NLP分类任务的小trick，感觉对于涨点提分十分有用。这个文章后面有新的想法会持续更新

华为有一个NLP关于医学电子病历的疾病多标签分类比赛，因为之前比较少去做NLP方向的东西，仅仅是学习过相关rnn、transformer、bert论文呢，所以，参赛纯粹是为了了解了解NLP方向，好在nlp做文本分类算是比较简单的下游任务，但在参赛过程中，会发现，其实对于文本分类来说，基本的bert-base的效果不是很好，但其实感觉不是出在模型架构方面，对于简单的分类任务，一个12层的bert应该适足以胜任了，因此将注意力不要过多的放在模型结构上。

任务说明

本赛题是利用病人电子病历文本信息推断出其可能患有疾病的疾病诊断任务。电子病历文本信息主要包括病人的性别、年龄、主诉、现病史、既往史、体格检查和辅助检查。标签信息为病人的出院诊断疾病。本赛题任务需要根据病人的电子病历文本信息推断出病人所患有的全部疾病。（注：病人的出院诊断疾病并不是单一的） 

模型输出格式：

{ “ZY000001”: [“高血压”, “肺气肿”, “先天性心脏病”]}

评分标准

本赛题采用macro F1作为评价指标。评价指标计算公式如下：

对于每一个预测的疾病有真阳性（True Positive，TP），假阳性（False Positive，FP），假阴性（False Negative），真阴性（True Negative），n表示n种疾病。

这个得分最高在 0.83左右。我也试了几次，但到0.57就没再动过了…..，后面准备去尝试下下面的方法，看看有啥效果吗。

思路：

在github中找到一个分类会议任务的比赛ppt模型讲解：

https://github.com/TJBioMedNLP/chip2019task3

废话说完，来点或许能提分的干货：

数据方面：

1、数据清洗（很多脏数据）、数据增强

说实话，感觉这个比赛的要点就是数据处理，想提分就看你的数据的好坏，现在是真的意识到数据处理对于一个模型的影响之大了，后面要着重关注下这方面了。

本次提供的训练集中出现了一些不需要诊断的疾病：睾丸鞘膜积液、宫颈炎性疾病、口腔粘膜溃疡、头部外伤、急性阴道炎、女性盆腔炎、急性气管炎，需要自己去将该类数据清洗，另外，通过数据统计分析，可以获得训练集中各个label的数量严重不平衡，如何处理也是一个问题，是否可以通过数据集增强，提高某些类别的测试数据。

另外 性别、年龄、主诉、现病史、既往史、体格检查和辅助检查 等长度会超出模型的最大长度，如何解决、最大化利用上述信息也是一个问题。我做过对这些数据做过分析，对于 性别、年龄、主诉、现病史、既往史、体格检查和辅助检查 等 统计过平均长度、最大最小长度，从几十到几百不等。另外，去看下数据集就可以看到，有大量的标点符号和短语。另外，据说emr_id这个信息也是一个重要的信息？？？我一脸震惊。此外年龄和性别也会影响。

其他：

1、如果训练时使用文本长度为n，测试使用比n长一些的长度，可以涨点分

2、模型预训练会提分（或者找相关领域预训练模型）

这里我找了两个预训练模型：

https://huggingface.co/trueto/medbert-base-chinese

https://huggingface.co/nghuyong/ernie-health-zh

3、增大训练时输入编码长度（文本序列长度），当然，需要显卡的性能支持

all_tokens = self.tokenizer.encode_plus(content, max_length=pad_size, padding=”max_length”, truncation=True)

可以提高max_length的大小，但是比较吃显卡。

4、交叉验证

交叉验证经常用于给定的数据集训练、评估和最终选择机器学习模型，因为它有助于评估模型的结果在实践中如何推广到独立的数据集，最重要的是，交叉验证已经被证明产生比其他方法更低的偏差的模型。重复的k折交叉验证，主要是会重复进行n次的k折交叉验证，这样会产生n次结果，一般通过平均方法或者（投票规则）得到最后的结果

　第一种是简单交叉验证，所谓的简单，是和其他交叉验证方法相对而言的。首先，我们随机的将样本数据分为两部分（比如： 70%的训练集，30%的测试集），然后用训练集来训练模型，在测试集上验证模型及参数。接着，我们再1把样本打乱，重新选择训练集和测试集，继续训练数据和检验模型。最后我们选择损失函数评估最优的模型和参数。

选择分层k-折交叉验证：

分层采样就是在每一份子集中都保持原始数据集的类别比例，保证采样数据跟原始数据的类别分布保持一致，该方法在有效的平衡方差和偏差。当针对不平衡数据时，使用随机的K-fold交叉验证，可能出现在子集中叫少的类别的分布与原始类别分布不一致。因此，针对不平衡数据往往使用stratified k-fold交叉验证。

当训练数据集不能代表整个数据集分布是，这时候使用stratified k折交叉验证可能不是好的方法，而可能比较适合使用简单的重复随机k折交叉验证。

• 1.把整个数据集随机划分成k份
• 2.用其中k-1份训练模型，然后用第k份验证模型
• 3.记录每个预测结果获得的误差
• 4.重复这个过程，知道每份数据都做过验证集
• 5.记录下的k个误差的平均值，被称为交叉验证误差。可以被用做衡量模型性能的标准

>>> from sklearn.model_selection import StratifiedKFold
>>> X = np.array([[1, 2], [3, 4], [1, 2], [3, 4]])
>>> y = np.array([0, 0, 1, 1])
>>> skf = StratifiedKFold(n_splits=2)
>>> skf.get_n_splits(X, y)
2
>>> print(skf)  
StratifiedKFold(n_splits=2, random_state=None, shuffle=False)
>>> for train_index, test_index in skf.split(X, y):
...    print("TRAIN:", train_index, "TEST:", test_index)
...    X_train, X_test = X[train_index], X[test_index]
...    y_train, y_test = y[train_index], y[test_index]
TRAIN: [1 3] TEST: [0 2]
TRAIN: [0 2] TEST: [1 3]

具体来说：

以k-fold CV为例：仍然是把原始数据集分成训练集和测试集，但是训练模型的时候不使用测试集。最常见的一个叫做k_fold CV。

• 具体来说就是把训练集平分为k个fold，其中每个fold依次作为测试集、余下的作为训练集，进行k次训练，得到共计k组参数。取k组参数的均值作为模型的最终参数。

1. 优点：充分压榨了数据集的价值。在样本集不够大的情况下尤其珍贵。
2. 缺点：运算起来花时间。

K折交叉验证训练单个模型：

通过对 k 个不同分组训练的结果进行平均来减少方差，因此模型的性能对数据的划分就不那么敏感，经过多次划分数据集，大大降低了结果的偶然性，从而提高了模型的准确性。具体做法如下：

• step1:不重复抽样将原始数据随机分为 k 份。
• step2:每一次挑选其中 1 份作为验证集，剩余 k-1 份作为训练集用于模型训练。一共训练k个模型。
• step3：在每个训练集上训练后得到一个模型，用这个模型在测试集上测试，计算并保存模型的评估指标，
• step4：计算 k 组测试结果的平均值作为模型最终在测试集上的预测值，求k 个模型评估指标的平均值，并作为当前 k 折交叉验证下模型的性能指标。

6、模型融合

模型融合：通过融合多个不同的模型，可能提升机器学习的性能。这一方法在各种机器学习比赛中广泛应用， 也是在比赛的攻坚时刻冲刺Top的关键。而融合模型往往又可以从模型结果，模型自身，样本集等不同的角度进行融合。即多个模型的组合可以改善整体的表现。集成模型是一种能在各种的机器学习任务上提高准确率的强有力技术。

模型融合是比赛后期一个重要的环节，大体来说有如下的类型方式：

1. 简单加权融合：

• 回归（分类概率）：算术平均融合（Arithmetic mean），几何平均融合（Geometric mean）；
• 分类：投票（Voting）；
• 综合：排序融合(Rank averaging)，log融合。

2. stacking/blending:

• 构建多层模型，并利用预测结果再拟合预测。

3. boosting/bagging:

• 多树的提升方法，在xgboost，Adaboost,GBDT中已经用到。

平均法（Averaging）

基本思想：对于回归问题，一个简单直接的思路是取平均。稍稍改进的方法是进行加权平均。权值可以用排序的方法确定，举个例子，比如A、B、C三种基本模型，模型效果进行排名，假设排名分别是1，2，3，那么给这三个模型赋予的权值分别是3/6、2/6、1/6。

平均法或加权平均法看似简单，其实后面的高级算法也可以说是基于此而产生的，Bagging或者Boosting都是一种把许多弱分类器这样融合成强分类器的思想。

简单算术平均法：Averaging方法就多个模型预测的结果进行平均。这种方法既可以用于回归问题，也可以用于对分类问题的概率进行平均。

加权算术平均法：这种方法是平均法的扩展。考虑不同模型的能力不同，对最终结果的贡献也有差异，需要用权重来表征不同模型的重要性importance。

投票法（voting）

基本思想：假设对于一个二分类问题，有3个基础模型，现在我们可以在这些基学习器的基础上得到一个投票的分类器，把票数最多的类作为我们要预测的类别。

绝对多数投票法：最终结果必须在投票中占一半以上。

相对多数投票法：最终结果在投票中票数最多。

加权投票法：每个弱学习器的分类票数乘以权重，并将各个类别的加权票数求和，最大值对应的类别即最终类别。

硬投票：对多个模型直接进行投票，不区分模型结果的相对重要度，最终投票数最多的类为最终被预测的类。

软投票：增加了设置权重的功能，可以为不同模型设置不同权重，进而区别模型不同的重要度。

堆叠法（Stacking）

基本思想

stacking 就是当用初始训练数据学习出若干个基学习器后，将这几个学习器的预测结果作为新的训练集，来学习一个新的学习器。对不同模型预测的结果再进行建模。

将个体学习器结合在一起的时候使用的方法叫做结合策略。对于分类问题，我们可以使用投票法来选择输出最多的类。对于回归问题，我们可以将分类器输出的结果求平均值。

上面说的投票法和平均法都是很有效的结合策略，还有一种结合策略是使用另外一个机器学习算法来将个体机器学习器的结果结合在一起，这个方法就是Stacking。在stacking方法中，我们把个体学习器叫做初级学习器，用于结合的学习器叫做次级学习器或元学习器（metalearner），次级学习器用于训练的数据叫做次级训练集。次级训练集是在训练集上用初级学习器得到的。

• step1：训练T个初级学习器，要使用交叉验证的方法在Train Set上面训练（因为第二阶段建立元学习器的数据是初级学习器输出的，如果初级学习器的泛化能力低下，元学习器也会过拟合）
• step2：T个初级学习器在Train Set上输出的预测值，作为元学习器的训练数据D，有T个初级学习器，D中就有T个特征。D的label和训练初级学习器时的label一致。
• step3：T个初级学习器在Test Set上输出的预测值，作为训练元学习器时的测试集，同样也是有T个模型就有T个特征。
• step4：训练元学习器，元学习器训练集D的label和训练初级学习器时的label一致。

混合法（Blending）

基本思想：Blending采用了和stacking同样的方法，不过只从训练集中选择一个fold的结果，再和原始特征进行concat作为元学习器meta learner的特征，测试集上进行同样的操作。

把原始的训练集先分成两部分，比如70%的数据作为新的训练集，剩下30%的数据作为测试集。

• 第一层，我们在这70%的数据上训练多个模型，然后去预测那30%数据的label，同时也预测test集的label。
• 在第二层，我们就直接用这30%数据在第一层预测的结果做为新特征继续训练，然后用test集第一层预测的label做特征，用第二层训练的模型做进一步预测。

Blending训练过程：

1. 整个训练集划分成训练集training sets和验证集validation sets两个部分；
2. 在training sets上训练模型；
3. 在validation sets和test sets上得到预测结果；
4. 将validation sets的原始特征和不同基模型base model预测得到的结果作为新的元学习器meta learner的输入，进行训练 ；
5. 使用训练好的模型meta learner在test sets以及在base model上的预测结果上进行预测，得到最终结果。

Stacking与Blending的对比：

优点在于：

• blending比stacking简单，因为不用进行k次的交叉验证来获得stacker feature
• blending避开了一个信息泄露问题：generlizers和stacker使用了不一样的数据集

缺点在于：

• blending使用了很少的数据（第二阶段的blender只使用training set10%的量）
• blender可能会过拟合
• stacking使用多次的交叉验证会比较稳健

Bagging

基本思想：Bagging基于bootstrap（自采样），也就是有放回的采样。训练子集的大小和原始数据集的大小相同。Bagging的技术使用子集来了解整个样本集的分布，通过bagging采样的子集的大小要小于原始集合。

• 采用bootstrap的方法基于原始数据集产生大量的子集
• 基于这些子集训练弱模型base model
• 模型是并行训练并且相互独立的
• 最终的预测结果取决于多个模型的预测结果

Bagging是一种并行式的集成学习方法，即基学习器的训练之间没有前后顺序可以同时进行，Bagging使用“有放回”采样的方式选取训练集，对于包含m个样本的训练集，进行m次有放回的随机采样操作，从而得到m个样本的采样集，这样训练集中有接近36.8%的样本没有被采到。按照相同的方式重复进行，我们就可以采集到T个包含m个样本的数据集，从而训练出T个基学习器，最终对这T个基学习器的输出进行结合。

Boosting

基础思想：Boosting是一种串行的工作机制，即个体学习器的训练存在依赖关系，必须一步一步序列化进行。Boosting是一个序列化的过程，后续模型会矫正之前模型的预测结果。也就是说，之后的模型依赖于之前的模型。

其基本思想是：增加前一个基学习器在训练训练过程中预测错误样本的权重，使得后续基学习器更加关注这些打标错误的训练样本，尽可能纠正这些错误，一直向下串行直至产生需要的T个基学习器，Boosting最终对这T个学习器进行加权结合，产生学习器委员会。

Boosting训练过程：

• 基于原始数据集构造子集
• 初始的时候，所有的数据点都给相同的权重
• 基于这个子集创建一个基模型
• 使用这个模型在整个数据集上进行预测
• 基于真实值和预测值计算误差
• 被预测错的观测值会赋予更大的权重
• 再构造一个模型基于之前预测的误差进行预测，这个模型会尝试矫正之前的模型
• 类似地，构造多个模型，每一个都会矫正之前的误差
• 最终的模型（strong learner）是所有弱学习器的加权融合

7、损失函数,注意不同类别的权重（使用F1_loss、Hamming Loss、数据类别分布不均，如何解决长尾分布（加权损失、先验权重））

相关论文: sigmoidF1: A Smooth F1 Score Surrogate Loss for Multilabel Classification

平时我们在做多标签分类，或者是多分类的时候，经常使用的loss函数一般是binary_crossentropy（也就是log_loss)或者是categorical_crossentropy,不过交叉熵其实还是有点问题的,在多标签分类的问题里，交叉熵并非是最合理的损失函数。在多标签分类的问题中，我们最终评价往往会选择F1分数作为评价指标，那么是否能直接将F1-score制作成为一个loss函数呢？当然是可以的。

在多分类/多标签分类中，F1-score有两种衍生格式，分别是micro-F1和macro-F1。是两种不同的计算方式。

micro-F1是先计算先拿总体样本来计算出TP、TN、FP、FN的值，再使用这些值计算出percision和recall，再来计算出F1值。

macro-F1则是先对每一种分类，视作二分类，计算其F1值，最后再对每一个分类进行简单平均。

简单的记的话其实是这样的，micro（微观）与macro(宏观)的含义其实是，micro-F1是在样本的等级上做平均，是最小颗粒度上的平均了，所以是微观。macro-F1是在每一个分类的层面上做平均，每一个分类都包含很多样本，所以相对是宏观。

作为loss函数的F1

F1-score改造成loss函数相对较为简单，F1是范围在0~1之间的指标，越大代表性能越好，在作为loss时只需要取（1-F1）即可。

一下是keras中的实现：

（这里的K就是keras的后端，一般来说就是tensorflow）

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

K = keras.backend def f1_loss(y_true, y_pred): #计算tp、tn、fp、fn tp = K.sum(K.cast(y_true*y_pred, ‘float’), axis=0) tn = K.sum(K.cast((1-y_true)*(1-y_pred), ‘float’), axis=0) fp = K.sum(K.cast((1-y_true)*y_pred, ‘float’), axis=0) fn = K.sum(K.cast(y_true*(1-y_pred), ‘float’), axis=0) #percision与recall，这里的K.epsilon代表一个小正数，用来避免分母为零 p = tp / (tp + fp + K.epsilon()) r = tp / (tp + fn + K.epsilon()) #计算f1 f1 = 2*p*r / (p+r+K.epsilon()) f1 = tf.where(tf.is_nan(f1), tf.zeros_like(f1), f1)#其实就是把nan换成0 return 1 – K.mean(f1)

这个函数可以直接在keras模型编译时使用，如下：

1 2 3 4

# 类似这样 model.compile(optimizer=tf.train.AdamOptimizer(0.003), loss=f1_loss, metrics=[‘acc’,’mae’])

 
def f1_loss(predict, target):
    predict = torch.sigmoid(predict)
    predict = torch.clamp(predict * (1-target), min=0.01) + predict * target
    tp = predict * target
    tp = tp.sum(dim=0)
    precision = tp / (predict.sum(dim=0) + 1e-8)
    recall = tp / (target.sum(dim=0) + 1e-8)
    f1 = 2 * (precision * recall / (precision + recall + 1e-8))
    return 1 - f1.mean()

8、考虑将多分类 变成多个二分类任务

9、除了bert模型，还可以尝试Performer、ernie-health

Performer 是ICLR 2021的新paper，在处理长序列预测方面有非常不错的结果，速度快，内存小，在LRA（long range arena 一个统一的benchmark）上综合得分不错。

论文：https://arxiv.org/pdf/2009.14794.pdf

ernie-health ：Building Chinese Biomedical Language Models via Multi-Level Text Discrimination
中文题目：基于多层次文本辨析构建中文生物医学语言模型
论文地址：https://arxiv.org/pdf/2110.07244.pdf
领域：自然语言处理，生物医学
发表时间：2021
作者：Quan Wang等，百度
模型下载：https://huggingface.co/nghuyong/ernie-health-zh
模型介绍：https://github.com/PaddlePaddle/Research/tree/master/KG/eHealth
模型代码：https://github.com/PaddlePaddle/PaddleNLP/tree/develop/model_zoo/ernie-health

10、NLP中的对抗训练 （添加的扰动是微小）

1. 提高模型应对恶意对抗样本时的鲁棒性；
2. 作为一种regularization，减少overfitting，提高泛化能力。

对抗训练其实是“对抗”家族中防御的一种方式，其基本的原理呢，就是通过添加扰动构造一些对抗样本，放给模型去训练，以攻为守，提高模型在遇到对抗样本时的鲁棒性，同时一定程度也能提高模型的表现和泛化能力。

那么，什么样的样本才是好的对抗样本呢？对抗样本一般需要具有两个特点：

1. 相对于原始输入，所添加的扰动是微小的；
2. 能使模型犯错。

NLP中的两种对抗训练 + PyTorch实现

a. Fast Gradient Method（FGM）

上面我们提到，Goodfellow在15年的ICLR [7] 中提出了Fast Gradient Sign Method（FGSM），随后，在17年的ICLR [9]中，Goodfellow对FGSM中计算扰动的部分做了一点简单的修改。假设输入的文本序列的embedding vectors [v1,v2,…,vT] 为 x ，embedding的扰动为：

实际上就是取消了符号函数，用二范式做了一个scale，需要注意的是：这里的norm计算的是，每个样本的输入序列中出现过的词组成的矩阵的梯度norm。原作者提供了一个TensorFlow的实现 [10]，在他的实现中，公式里的 x 是embedding后的中间结果（batch_size, timesteps, hidden_dim），对其梯度 g 的后面两维计算norm，得到的是一个(batch_size, 1, 1)的向量 ||g||2 。为了实现插件式的调用，笔者将一个batch抽象成一个样本，一个batch统一用一个norm，由于本来norm也只是一个scale的作用，影响不大。实现如下：

import torch
class FGM():
    def __init__(self, model):
        self.model = model
        self.backup = {}

    def attack(self, epsilon=1., emb_name='emb.'):
        # emb_name这个参数要换成你模型中embedding的参数名
        for name, param in self.model.named_parameters():
            if param.requires_grad and emb_name in name:
                self.backup[name] = param.data.clone()
                norm = torch.norm(param.grad)
                if norm != 0 and not torch.isnan(norm):
                    r_at = epsilon * param.grad / norm
                    param.data.add_(r_at)

    def restore(self, emb_name='emb.'):
        # emb_name这个参数要换成你模型中embedding的参数名
        for name, param in self.model.named_parameters():
            if param.requires_grad and emb_name in name: 
                assert name in self.backup
                param.data = self.backup[name]
        self.backup = {}

需要使用对抗训练的时候，只需要添加五行代码：

# 初始化
fgm = FGM(model)
for batch_input, batch_label in data:
    # 正常训练
    loss = model(batch_input, batch_label)
    loss.backward() # 反向传播，得到正常的grad
    # 对抗训练
    fgm.attack() # 在embedding上添加对抗扰动
    loss_adv = model(batch_input, batch_label)
    loss_adv.backward() # 反向传播，并在正常的grad基础上，累加对抗训练的梯度
    fgm.restore() # 恢复embedding参数
    # 梯度下降，更新参数
    optimizer.step()
    model.zero_grad()

PyTorch为了节约内存，在backward的时候并不保存中间变量的梯度。因此，如果需要完全照搬原作的实现，需要用register_hook接口[11]将embedding后的中间变量的梯度保存成全局变量，norm后面两维，计算出扰动后，在对抗训练forward时传入扰动，累加到embedding后的中间变量上，得到新的loss，再进行梯度下降。

b. Projected Gradient Descent（PGD）

内部max的过程，本质上是一个非凹的约束优化问题，FGM解决的思路其实就是梯度上升，那么FGM简单粗暴的“一步到位”，是不是有可能并不能走到约束内的最优点呢？当然是有可能的。于是，一个很intuitive的改进诞生了：Madry在18年的ICLR中[8]，提出了用Projected Gradient Descent（PGD）的方法，简单的说，就是“小步走，多走几步”，如果走出了扰动半径为 ϵ 的空间，就映射回“球面”上，以保证扰动不要过大：

import torch
class PGD():
    def __init__(self, model):
        self.model = model
        self.emb_backup = {}
        self.grad_backup = {}

    def attack(self, epsilon=1., alpha=0.3, emb_name='emb.', is_first_attack=False):
        # emb_name这个参数要换成你模型中embedding的参数名
        for name, param in self.model.named_parameters():
            if param.requires_grad and emb_name in name:
                if is_first_attack:
                    self.emb_backup[name] = param.data.clone()
                norm = torch.norm(param.grad)
                if norm != 0 and not torch.isnan(norm):
                    r_at = alpha * param.grad / norm
                    param.data.add_(r_at)
                    param.data = self.project(name, param.data, epsilon)

    def restore(self, emb_name='emb.'):
        # emb_name这个参数要换成你模型中embedding的参数名
        for name, param in self.model.named_parameters():
            if param.requires_grad and emb_name in name: 
                assert name in self.emb_backup
                param.data = self.emb_backup[name]
        self.emb_backup = {}

    def project(self, param_name, param_data, epsilon):
        r = param_data - self.emb_backup[param_name]
        if torch.norm(r) > epsilon:
            r = epsilon * r / torch.norm(r)
        return self.emb_backup[param_name] + r

    def backup_grad(self):
        for name, param in self.model.named_parameters():
            if param.requires_grad:
                self.grad_backup[name] = param.grad.clone()

    def restore_grad(self):
        for name, param in self.model.named_parameters():
            if param.requires_grad:
                param.grad = self.grad_backup[name]

使用的时候，要麻烦一点：

pgd = PGD(model)
K = 3
for batch_input, batch_label in data:
    # 正常训练
    loss = model(batch_input, batch_label)
    loss.backward() # 反向传播，得到正常的grad
    pgd.backup_grad()
    # 对抗训练
    for t in range(K):
        pgd.attack(is_first_attack=(t==0)) # 在embedding上添加对抗扰动, first attack时备份param.data
        if t != K-1:
            model.zero_grad()
        else:
            pgd.restore_grad()
        loss_adv = model(batch_input, batch_label)
        loss_adv.backward() # 反向传播，并在正常的grad基础上，累加对抗训练的梯度
    pgd.restore() # 恢复embedding参数
    # 梯度下降，更新参数
    optimizer.step()
    model.zero_grad()

实验对照

为了说明对抗训练的作用，笔者选了四个GLUE中的任务进行了对照试验。实验代码是用的Huggingface的transfomers/examples/run_glue.py [12]，超参都是默认的，对抗训练用的也是相同的超参。

除了监督训练，对抗训练还可以用在半监督任务中，尤其对于NLP任务来说，很多时候输入的无监督文本多的很，但是很难大规模地进行标注，Distributional Smoothing with Virtual Adversarial Training. https://arxiv.org/abs/1507.00677 提到的 Virtual Adversarial Training进行半监督训练。

11、Pseudo Labeling（伪标签）提高模型的分类效果

简而言之，Pseudo Labeling将测试集中判断结果正确的置信度高的样本加入到训练集中，从而模拟一部分人类对新对象进行判断推演的过程。效果比不上人脑那么好，但是在监督学习问题中，Pseudo Labeling几乎是万金油，几乎能够让你模型各个方面的表现都得到提升。

1. 使用原始训练集训练并建立模型
2. 使用训练好的模型对测试集进行分类
3. 将预测正确置信度高的样本加入到训练集中
4. 使用结合了部分测试集样本的新训练集再次训练模型
5. 使用新模型再次进行预测

总之：提分点很多，但能否有效以及能否实现又是另一个事情了，毕竟有时候是否有效也取决于数据集，毕竟缘分，妙不可言~，后续我会抽时间将上面的tricks都尝试尝试。

最近参加一个NLP关于医学电子病历的疾病多标签分类比赛，因为之前比较少去做NLP方向，所以，参赛纯粹是为了了解了解NLP方向，好在nlp做文本分类算是比较简单的下游任务，但在参赛过程中，会发现，其实对于文本分类来说，基本的bert-base的效果不是很好，但其实感觉不是出在模型架构方面，对于简单的分类任务，一个12层的bert应该适足以胜任了，因此需要将注意力看向数据预处理、数据清洗、数据增强。以及数据类别分布不均匀，也可以尝试使用不同的损失函数。另外，不可否认，输入的文本长度越长，效果应该会更好一些，但奈何没有“钞”能力。此外，还可以尝试模型集成、交叉验证（五折交叉验证，即：将训练集分为五部分，一部分做验证集，剩下四部分做训练集，相当于得到五个模型。验证集组合起来就是训练集。五个模型对测试集的预测取均值得到最终的预测结果。）这块的思路还挺多的，算是做个记录，方便后面在处理类似文本分类任务时候的一个参考。

言归正传：今天来总结下NLP中的数据处理。

1、数据清洗

什么是数据清洗：

数据清洗是指发现并纠正数据文件中可识别的错误的最后一道程序，包括检查数据一致性，处理无效值和缺失值等。与问卷审核不同，录入后的数据清理一般是由计算机而不是人工完成。数据清洗从名字上也看的出就是把“脏”的“洗掉”，指发现并纠正数据文件中可识别的错误的最后一道程序，包括检查数据一致性，处理无效值和缺失值等。

为什么要进行数据清洗

因为数据仓库中的数据是面向某一主题的数据的集合，这些数据从多个业务系统中抽取而来而且包含历史数据，这样就避免不了有的数据是错误数据、有的数据相互之间有冲突，这些错误的或有冲突的数据显然是我们不想要的，称为“脏数据”。我们要按照一定的规则把“脏数据”“洗掉”，这就是数据清洗。

清洗后，一个数据集应该与系统中其他类似的数据集保持一致。 检测到或删除的不一致可能最初是由用户输入错误、传输或存储中的损坏或不同存储中类似实体的不同数据字典定义引起的。 数据清理与数据确认(data validation)的不同之处在于，数据确认几乎总是意味着数据在输入时被系统拒绝，并在输入时执行，而不是执行于批量数据。

数据清洗不仅仅更正错误，同样加强来自各个单独信息系统不同数据间的一致性。专门的数据清洗软件能够自动检测数据文件，更正错误数据，并用全企业一致的格式整合数据。

数据清洗流程：

（1）中文首先需要分词，可以采用结巴分词、HanNLP、刨丁解牛等分词工具;

（2）数据规范化处理（Normalization）：比如通常会把文本中的大写转成小写，清除文本中的句号、问号、感叹号等特殊字符，并且仅保留字母表中的字母和数字。小写转换和标点移除是两个最常见的文本 Normalization 步骤。是否需要以及在哪个阶段使用这两个步骤取决于你的最终目标。

去除一些停用词。而停用词是文本中一些高频的代词、连词、介词等对文本分类无意义的词，通常维护一个停用词表，特征提取过程中删除停用表中出现的词，本质上属于特征选择的一部分。具体可参考Hanlp的停用词表https://github.com/hankcs/HanLP

（3）Tokenization，Token 是“符号”的高级表达。一般指具有某种意义，无法再分拆的符号。在英文自然语言处理中，Tokens 通常是单独的词。因此，Tokenization 就是将每个句子分拆成一系列词。可以使用NLTK工具箱来完成相关操作。

（4）Stop Word 是无含义的词，例如 ‘is’/‘our’/‘the’/‘in’/‘at’ 等。它们不会给句子增加太多含义，单停止词是频率非常多的词。 为了减少我们要处理的词汇量，从而降低后续程序的复杂度，需要清除停止词。

（5）Part-of-Speech Tagging：还记得在学校学过的词性吗？名词、代词、动词、副词等等。识别词在句子中的用途有助于我们更好理解句子内容。并且，标注词性还可以明确词之间的关系，并识别出交叉引用。同样地，NLTK 给我们带来了很多便利。你可以将词传入 PoS tag 函数。然后对每个词返回一个标签，并注明不同的词性。

（6）Named Entity 一般是名词短语，又来指代某些特定对象、人、或地点 可以使用 ne_chunk()方法标注文本中的命名实体。在进行这一步前，必须先进行 Tokenization 并进行 PoS Tagging。

（7）Stemming and Lemmatization：为了进一步简化文本数据，我们可以将词的不同变化和变形标准化。Stemming 提取是将词还原成词干或词根的过程。

（8）一些词在句首句尾句中出现的概率不一样，统计N-GRAM特征的时候要在句首加上BOS，句尾加上EOS作标记。

（9）把长文本分成句子和单词这些fine granularity会比较有用。

（10） 一般会有一个dictionary，不在dictionary以内的单词就用UNK取代。

（11）单词会被转成数字（它对应的index，从0开始，一般0就是UNK）。

（12）做机器翻译的时候会把单词转成subword units。

这块的代码还是比较多

1、A Python toolkit for file processing, text cleaning and data splitting. 文件处理，文本清洗和数据划分的python工具包。

2、基本的文本清洗，主要解决文本数据处理的问题

数据增强

与计算机视觉中使用图像进行数据增强不同，NLP中文本数据增强是非常罕见的。这是因为图像的一些简单操作，如将图像旋转或将其转换为灰度，并不会改变其语义。语义不变变换的存在使增强成为计算机视觉研究中的一个重要工具。

方法

1. 词汇替换

这一类的工作，简单来说，就是去替换原始文本中的某一部分，而不改变句子本身的意思。

1.1 基于同义词典的替换

在这种方法中，我们从句子中随机取出一个单词，将其替换为对应的同义词。例如，我们可以使用英语的 WordNet 数据库来查找同义词，然后进行替换。WordNet 是一个人工维护的数据库，其中包含单词之间的关系。

Zhang 等人在2015年的论文 “Character-level Convolutional Networks for Text Classification” 中使用了这种方法。Mueller 等人也使用类似的方法为他们的句子相似度模型生成额外的 10K 条训练数据。这一方法也被 Wei 等人在他们的 “Easy Data Augmentation” 论文中使用。对于如何使用，NLTK 提供了对 WordNet 的接口；我们还可以使用 TextBlob API。此外，还有一个名为 PPDB 的数据库，其中包含数百万条同义词典，可以通过编程方式下载和使用。

1.2 基于 Word-Embeddings 的替换

在这种方法中，我们采用预先训练好的词向量，如 Word2Vec、GloVe、FastText，用向量空间中距离最近的单词替换原始句子中的单词。Jiao 等人在他们的论文 “TinyBert” 中使用了这种方法，以改进语言模型在下游任务上的泛化性；Wang 等人使用它来对 tweet 语料进行数据增强来学习主题模型。

例如，可以用三个向量空间中距离最近的单词替换原始句子中的单词，可以得到原始句子的三个变体。我们可以使用像 Gensim 包来完成这样的操作。在下面这个例子中，我们通过在 Tweet 语料上训练的词向量找到了单词 “awesome” 的同义词。

1.3 基于 Masked Language Model 的替换

像 BERT、ROBERTA 和 ALBERT 这样基于 Transformer 的模型已经使用 “Masked Language Modeling” 的方式，即模型要根据上下文来预测被 Mask 的词语，通过这种方式在大规模的文本上进行预训练。

Masked Language Modeling 同样可以用来做文本的数据增强。例如，我们可以使用一个预先训练好的 BERT 模型，然后对文本的某些部分进行 Mask，让 BERT 模型预测被 Mask 的词语。我们称这种方法叫 Mask Predictions。和之前的方法相比，这种方法生成的文本在语法上更加通顺，因为模型在进行预测的时候考虑了上下文信息。我们可以很方便的使用 HuggingFace 的 transfomers 库，通过设置要替换的词语并生成预测来做文本的数据增强。

1.4 基于 TF-IDF 的替换

这种数据增强方法是 Xie 等人在 “Unsupervised Data Augmentation” 论文中提出来的。其基本思想是，TF-IDF 分数较低的单词不能提供信息，因此可以在不影响句子的基本真值标签的情况下替换它们。

具体如何计算整个文档中单词的 TF-IDF 分数并选择最低的单词来进行替换，可以参考作者公开的代码。

2. Back Translation（回译）

在这种方法中，我们使用机器翻译的方法来复述生成一段新的文本。Xie 等人使用这种方法来扩充未标注的样本，在 IMDB 数据集上他们只使用了 20 条标注数据，就可以训练得到一个半监督模型，并且他们的模型优于之前在 25000 条标注数据上训练得到的 SOTA 模型。

使用机器翻译来回译的具体流程如下：

• 找一些句子(如英语)，翻译成另一种语言，如法语
• 把法语句子翻译成英语句子
• 检查新句子是否与原来的句子不同。如果是，那么我们使用这个新句子作为原始文本的补充版本。

我们还可以同时使用多种不同的语言来进行回译以生成更多的文本变体。如下图所示，我们将一个英语句子翻译成目标语言，然后再将其翻译成三种目标语言:法语、汉语和意大利语。

这种方法也在 Kaggle 上的 “Toxic Comment Classification Challenge” 的第一名解决方案中使用。获胜者将其用于训练数据扩充和测试，在应用于测试的时候，对英语句子的预测概率以及使用三种语言(法语、德语、西班牙语)的反向翻译进行平均，以得到最终的预测。

对于如何实现回译，可以使用 TextBlob 或者谷歌翻译。

3. Text Surface Transformation

这些是使用正则表达式应用的简单模式匹配变换，Claude Coulombe 在他的论文中介绍了这些变换的方法。

在论文中，他给出了一个将动词由缩写形式转换为非缩写形式的例子，我们可以通过这个简单的方法来做文本的数据增强。

需要注意的是，虽然这样的转换在大部分情况下不会改变句子原本的含义，但有时在扩展模棱两可的动词形式时可能会失败，比如下面这个例子:

为了解决这一问题，论文中也提出允许模糊收缩 (非缩写形式转缩写形式)，但跳过模糊展开的方法 (缩写形式转非缩写形式)。

我们可以在这里找到英语缩写的列表。对于展开，可以使用 Python 中的 contractions 库。

4. Random Noise Injection

这些方法的思想是在文本中注入噪声，来生成新的文本，最后使得训练的模型对扰动具有鲁棒性。

4.1 Spelling error injection

在这种方法中，我们在句子中添加一些随机单词的拼写错误。可以通过编程方式或使用常见拼写错误的映射来添加这些拼写错误，具体可以参考这个链接。

4.2 QWERTY Keyboard Error Injection

这种方法试图模拟在 QWERTY 键盘布局上打字时由于键之间非常接近而发生的常见错误。这种错误通常是在通过键盘输入文本时发生的。

4.3 Unigram Noising

这种方法已经被 Xie 等人和 UDA 的论文所使用，其思想是使用从 unigram 频率分布中采样的单词进行替换。这个频率基本上就是每个单词在训练语料库中出现的次数。

4.4 Blank Noising

该方法由 Xie 等人在他们的论文中提出，其思想是用占位符标记替换一些随机单词。本文使用 “_” 作为占位符标记。在论文中，他们使用它作为一种避免在特定上下文上过度拟合的方法以及语言模型平滑的机制，这项方法可以有效提高生成文本的 Perplexity 和 BLEU 值。

4.5 Sentence Shuffling

这是一种很初级的方法，我们将训练样本中的句子打乱，来创建一个对应的数据增强样本。

4.6 Random Insertion

这个方法是由 Wei 等人在其论文 “Easy Data Augmentation” 中提出的。在该方法中，我们首先从句子中随机选择一个不是停止词的词。然后，我们找到它对应的同义词，并将其插入到句子中的一个随机位置。（也比较 Naive）

4.7 Random Swap

这个方法也由 Wei 等人在其论文 “Easy Data Augmentation” 中提出的。该方法是在句子中随机交换任意两个单词。

4.8 Random Deletion

该方法也由 Wei 等人在其论文 “Easy Data Augmentation” 中提出。在这个方法中，我们以概率 p 随机删除句子中的每个单词。

5. Instance Crossover Augmentation

这种方法由 Luque 在他 TASS 2019 的论文中介绍，灵感来自于遗传学中的染色体交叉操作。

在该方法中，一条 tweet 被分成两半，然后两个相同情绪类别（正/负）的 tweets 各自交换一半的内容。这么做的假设是，即使结果在语法和语义上不健全，新的文本仍将保留原来的情绪类别。

这中方法对准确性没有影响，并且在 F1-score 上还有所提升，这表明它帮助了模型提升了在罕见类别上的判断能力，比如 tweet 中较少的中立类别。

6. Syntax-tree Manipulation

这种方法最先是由 Coulombe 提出的，其思想是解析并生成原始句子的依赖树，使用规则对其进行转换来对原句子做复述生成。

例如，一个不会改变句子意思的转换是句子的主动语态和被动语态的转换。

7. MixUp for Text

Mixup 是 Zhang 等人在 2017 年提出的一种简单有效的图像增强方法。其思想是将两个随机图像按一定比例组合成，以生成用于训练的合成数据。对于图像，这意味着合并两个不同类的图像像素。它在模型训练的时候可以作为的一种正则化的方式。

为了把这个想法带到 NLP 中，Guo 等人修改了 Mixup 来处理文本。他们提出了两种将 Mixup 应用于文本的方法:

7.1 wordMixup

在这种方法中，在一个小批中取两个随机的句子，它们被填充成相同的长度；然后，他们的 word embeddings 按一定比例组合，产生新的 word embeddings 然后传递下游的文本分类流程，交叉熵损失是根据原始文本的两个标签按一定比例计算得到的。

7.2 sentMixup

在这种方法中，两个句子首先也是被填充到相同的长度；然后，通过 LSTM/CNN 编码器传递他们的 word embeddings，我们把最后的隐藏状态作为 sentence embedding。这些 embeddings 按一定的比例组合，然后传递到最终的分类层。交叉熵损失是根据原始文本的两个标签按一定比例计算得到的。

8. 生成式的方法

这一类的工作尝试在生成额外的训练数据的同时保留原始类别的标签。

Conditional Pre-trained Language Models

这种方法最早是由 Anaby-Tavor 等人在他们的论文 “Not Enough Data? Deep Learning to the Rescue!” Kumar 等人最近的一篇论文在多个基于 Transformer 的预训练模型中验证了这一想法。

问题的表述如下:

1. 在训练数据中预先加入类别标签，如下图所示。

2. 在这个修改过的训练数据上 finetune 一个大型的预训练语言模型 (BERT/GPT2/BART) 。对于 GPT2，目标是去做生成任务；而对于 BERT，目标是要去预测被 Mask 的词语。

3. 使用经过 finetune 的语言模型，可以使用类标签和几个初始单词作为模型的提示词来生成新的数据。本文使用每条训练数据的前 3 个初始词来为训练数据做数据增强。

9. 实现过程

nlpaug 和 textattack 等第三方 Python 库提供了简单易用的 API，可以轻松使用上面介绍的 NLP 数据增强方法。

1、 NLP Chinese Data Augmentation 一键中文数据增强工具: https://github.com/425776024/nlpcda

使用：pip install nlpcda

介绍

一键中文数据增强工具，支持：

• 1.随机实体替换
• 2.近义词
• 3.近义近音字替换
• 4.随机字删除（内部细节：数字时间日期片段，内容不会删）
• 5.NER类 BIO 数据增强
• 6.随机置换邻近的字：研表究明，汉字序顺并不定一影响文字的阅读理解<<是乱序的
• 7.中文等价字替换（1 一 壹 ①，2 二 贰 ②）
• 8.翻译互转实现的增强
• 9.使用simbert做生成式相似句生成

2、 TextAttack 是一个可以实行自然语言处理的Python 框架，用于方便快捷地进行对抗攻击，增强数据，以及训练模型。https://github.com/QData/TextAttack/blob/master/README_ZH.md

文档：https://textattack.readthedocs.io/en/latest/0_get_started/basic-Intro.html

3、中文语料的EDA数据增强工具

4、中文谐音词/字库

10. 结论

通过阅读许多 NLP 数据增强方面的论文，我发现大多数方法都是具有很强的任务属性的，并且针对这些方法的实验也只在某些特定的场景进行了验证。可以见得，系统地比较这些方法并且分析它们在其他任务上的表现在未来将是一项有趣的研究。