HugginFace 中文情感分类(学习笔记)

• HugginFace 中文情感分类(学习笔记)
  • 数据集介绍
  • 模型架构
  • 实现代码
    • 环境设置
    • 准备数据集
      • 使用编码工具
      • 定义数据集
      • 定义数据整理函数
      • 定义数据整理函数
      • 定义数据集加载器
    • 定义模型
      • 加载预训练模型
      • 定义下游任务类型
    • 训练预测
      • 训练
      • 测试

数据集介绍

本章使用的是lansinuote/ChnSentiCorp数据集，这是一个情感分类数据集，每条数据中包括一句购物评价和标识(好评或差评)。

模型架构

RNN的主要功能是能把自然语言的句子抽取成特征向量，有了特征向量之后入全连接神经网络做分类或者回归就水到渠成了。
RNN把一个自然语言处理的任务换成了全连接神经网络任务。
对于类似RNN能把抽象数据类型转换成具体的特征向量的网络层，被统称为backbone，中文一般译为特征抽取层。
本章的情感分类任务中也将使用BERT中文模型作为backbone层。
相对于backbone的网络，后续的处理神经网络被称为下游任务模型，它往往会对backbone输出的特征向量进行再计算，得到业务上需要的计算结果，这往往是分类或者回归的结果。整合backbone和下游任务模型的架构如下图所示。

网络的计算过程先把一句自然语言输入backbone网络中进行特征抽取，特征是一个向量，再把特征向量输入下游任务模型中进行计算，得出最终业务需要的结果。
对于应用了预训练的backbone的网络，训练时可以选择继续训练backbone层，也可以不训练backbone层，因为backbone的参数量往往非常巨大。如果要对backbone进行再训练，则往往会消耗掉更多的计算资源；如果不对backbone进行再训练二模型的性能已经达到业务需求，也可以选择节省这些计算资源，接下来将进行演示。

实现代码

环境设置

%pip install torch torchvision torchaudio -f https://download.pytorch.org/whl/cpu/torch_stable.html
%pip install -q transformers==4.18 datasets==2.4.0 torchtext

准备数据集

使用编码工具

加载编码工具，把文字转数字。

from transformers import BertTokenizer
token = BertTokenizer.from_pretrained('bert-base-chinese')
token

这里加载的编码工具为bert-base-chinese，编码工具和预训练模型往往是成对使用的，后续啊讲使用同名的预训练模型作为backbone，运行结果如下：

从输出可以看出，bert-base-chinese模型中的字典有21128个，编码器编码句子的最大长度为512个词，并且能看到bert-base-chinese模型所使用的一些特殊符号。
加载编码工具之后，不妨进行一次试算，以便更清晰地观察到编码工具的输入和输出，代码如下：

out = token.batch_encode_plus(
    batch_text_or_text_pairs=['从明天起，做一个幸福的人。', '喂马，劈柴，周游世界。'],
    truncation=True,
    padding='max_length',
    max_length=17,
    return_tensors='pt',
    return_length=True)
#查看编码输出
for k, v in out.items():
    print(k, v.shape)
#把编码还原为句子
print(token.decode(out['input_ids'][0]))

从上面的代码中的参数max_length=17的说明可以看出，超过长度的会被夹断。

定义数据集

我们将一个情感分类数据集进行模型的训练和测试，这里我们加载lansinuote/ChnSentiCorp数据集。

import torch
from datasets import load_dataset
class Dataset(torch.utils.data.Dataset):
    def __init__(self,split):
        self.dataset = load_dataset('lansinuote/ChnSentiCorp')[split]
    def __len__(self):
        return len(self.dataset)
    def __getitem__(self, i):
        text = self.dataset[i]['text']
        label = self.dataset[i]['label']
        return text, label
dataset = Dataset('train')
len(dataset), dataset[20]

定义了一个Dataset类初始化时加载lansinuote/ChnSentiCorp的train训练数据集。
__len__获取长度。
__getitem__定义了每条数据，包括text和label两个字段，最后初始化训练数据集，并查看训练集的长度和一条数据采样。
结果如下：

可见训练数据集包括9600条数据。

定义数据整理函数

再CUDA计算平台上进行计算比在CPU上要快。
但不一定准，我们可以通过如下代码来确认系统是否支持GPU。

device = 'cpu'
if torch.cuda.is_available():
    device = 'cuda'
device

这里我使用的显卡是V100,所以输出的是GUDA。

定义数据整理函数

接下来我们需要定义个数据整理函数，它具有批量编码一批文本数据的功能。
代码如下：

def collate_fn(data):
    sents = [i[0] for i in data]
    labels = [i[1] for i in data]
    #编码
    data = token.batch_encode_plus(batch_text_or_text_pairs=sents,
                                   truncation=True,
                                   padding='max_length',
                                   max_length=500,
                                   return_tensors='pt',
                                   return_length=True)
    #input_ids:编码之后的数字
    #attention_mask:是补零的位置是0,其他位置是1
    input_ids = data['input_ids']
    attention_mask = data['attention_mask']
    token_type_ids = data['token_type_ids']
    labels = torch.LongTensor(labels)
    #把数据移动到计算设备上
    input_ids = input_ids.to(device)
    attention_mask = attention_mask.to(device)
    token_type_ids = token_type_ids.to(device)
    labels = labels.to(device)
    return input_ids, attention_mask, token_type_ids, labels

入参的data表示每一批数据，在参数中将编码后的结果指定为确定的500个词，超过500个词的句子将被截断，而不足500个词的句子将被补充PAD，直到500个词。
取出的编码也转换为PyTorch的Tensor格式。
接下来我们将模拟一组数据进行试算。

#第7章/数据整理函数试算
#模拟一批数据
data = [
    ('你站在桥上看风景', 1),
    ('看风景的人在楼上看你', 0),
    ('明月装饰了你的窗子', 1),
    ('你装饰了别人的梦', 0),
]
#试算
input_ids, attention_mask, token_type_ids, labels = collate_fn(data)
input_ids.shape, attention_mask.shape, token_type_ids.shape, labels

输出到结果4个句子每个500个词。

定义数据集加载器

数据集加载器可以将数据整理函数来成批地处理数据集中的数据，代码如下：

loader = torch.utils.data.DataLoader(dataset=dataset,
                                     batch_size=16,
                                     collate_fn=collate_fn,
                                     shuffle=True,
                                     drop_last=True)
len(loader)

运行的结果获取加载器一共有多少个批次，运行结果如下：

我们来进行一次数据样本的示例，代码如下：

for i, (input_ids, attention_mask, token_type_ids,
        labels) in enumerate(loader):
    break
input_ids.shape, attention_mask.shape, token_type_ids.shape, labels

定义模型

加载预训练模型

完成以上准备工作，现在数据数据的机构已经准备好，可以输入模型进行计算了，即可加载预训练了，代码如下：

from transformers import BertModel
pretrained = BertModel.from_pretrained('bert-base-chinese')
#统计参数量
sum(i.numel() for i in pretrained.parameters()) / 10000

此处加载的模型为bert-base-chinese模型，和编码工具的名字一致，注意模型和其编码工具往往配套使用。
模型的参数量，运行结果如下：

可见bert-base-chinese模型的参数量约为1亿个。
由于bert-base-chinese的体量比较大所以我们不需要对于本次的二分类任务进行训练。
代码如下：

# 不训练预训练模型,不需要计算梯度
for param in pretrained.parameters():
    param.requires_grad_(False)

定义好预训练模型之后，可以进行一次试算，观察模型的输入和输出，代码如下：

#设定计算设备
pretrained.to(device)
#模型试算
out = pretrained(input_ids=input_ids,
                 attention_mask=attention_mask,
                 token_type_ids=token_type_ids)
out.last_hidden_state.shape

在这段代码中，首先把预训练模型移动到计算设备上，如果模型和数据不在同一个设备上，则无法计算。
之后把之前得到的样例数据输入预训练模型中，得到的计算结果为一个BaseModelOutputWithPoolingAndCrossAttentions对象，其中包括last_hidden_state和pooler_output两个字段，此处只关心last_hidden_state字段，取出该字段并输出其形状，运行结果如下：

16句话，每句话包括500个词，每个词被抽象成768维的向量。
接着我们接入下游任务模型做分类或者回归任务。

定义下游任务类型

下游任务模型的任务是对backbone抽取的特征进行进一步计算，得到符合业务需求的计算结果。
代码如下：

#第7章/定义下游任务模型
class Model(torch.nn.Module):
    def __init__(self):
        super().__init__()
        self.fc = torch.nn.Linear(in_features=768, out_features=2)
    def forward(self, input_ids, attention_mask, token_type_ids):
        #使用预训练模型抽取数据特征
        with torch.no_grad():
            out = pretrained(input_ids=input_ids,
                             attention_mask=attention_mask,
                             token_type_ids=token_type_ids)
        #对抽取的特征只取第一个字的结果做分类即可
        out = self.fc(out.last_hidden_state[:, 0])
        out = out.softmax(dim=1)
        return out
model = Model()
#设定计算设备
model.to(device)
#试算
model(input_ids=input_ids,
      attention_mask=attention_mask,
      token_type_ids=token_type_ids).shape

在这段代码中，定义了下游任务模型，该模型只包括一个全连接的神经网络，权重矩阵768x2，所以它能够把一个768维度的向量转换到二维空间中。
下游任务模型的计算过程为，获取了一批数据之后，使用backbone将这批数据抽取成特征矩阵，抽取的特征矩阵的形状应该是16x500x768，这在之前预训练模型的试算中已经看到。这三个维度分别代表了16句话、500个词、768维度的特征向量。
之后下游任务模型丢弃了499个词的特征，只取得第一个词（索引为0）的特征向量，对应编码结果中的[CLS]，把特征向量矩阵变成了16x768。相当于把每句话变成了一个768维度的向量。

之后再使用自己的全连接线性神经网络把16x768特征矩阵转换到16x2,即为要求的分类结果。
运行结果如下：

这是16句话的二分类结果。

训练预测

训练

from transformers import AdamW
from transformers.optimization import get_scheduler
def train():
    #定义优化器
    optimizer = AdamW(model.parameters(), lr=5e-4)
    #定义loss函数
    criterion = torch.nn.CrossEntropyLoss()
    #定义学习率调节器
    scheduler = get_scheduler(name='linear',
                              num_warmup_steps=0,
                              num_training_steps=len(loader),
                              optimizer=optimizer)
    #模型切换到训练模式
    model.train()
    #按批次遍历训练集中的数据
    for i, (input_ids, attention_mask, token_type_ids,
            labels) in enumerate(loader):
        #模型计算
        out = model(input_ids=input_ids,
                    attention_mask=attention_mask,
                    token_type_ids=token_type_ids)
        #计算loss并使用梯度下降法优化模型参数
        loss = criterion(out, labels)
        loss.backward()
        optimizer.step()
        scheduler.step()
        optimizer.zero_grad()
        #输出各项数据的情况，便于观察
        if i % 10 == 0:
            out = out.argmax(dim=1)
            accuracy = (out == labels).sum().item() / len(labels)
            lr = optimizer.state_dict()['param_groups'][0]['lr']
            print(i, loss.item(), lr, accuracy)
train()

首先定于了优化器、loss计算函数、学习率调节器，其中优化器使用了HuggingFace提供的AdamW优化，这是传统的Adam优化器改进版本，在自然语言处理任务中，该优化器往往能取得比Adam优化器更好的成绩，并且计算效率更高。
学习率调节器也使用了HuggingFace提供的线性学习率调节器，它能在训练的过程中，让学习率缓慢地下降，而不是使用始终如一的学习率，因为在训练的后期阶段，需要更小的学习率来微调参数，这有利于loss 下降到更低的点。
由于本章的任务为分类任务，所以使用的loss计算函数为CrossEntropyLoss，即交叉熵计算函数。
之后把下游任务模型切换到训练模式，即可开始训练。训练的过程为不断地从数据集加载器中获取一批一批的数据，让模型进行计算，用模型计算的结果和真实的labels 计算 loss,根据 loss计算模型中所有参数的梯度，并执行梯度下降优化参数。
最后，每优化10次模型参数，就计算一次当前模型预测结果的正确率，并输出模型的 loss 和优化器的学习率，最终训练完毕后，输出的观察数据图表。
从图表可以看出，在训练到大约580个steps时，模型已经能够达到大约87%和100%的正确率，并且能够观察到loss是随着训练的进程在不断地下降，学习率也如预期的一样，也在缓慢地下降

测试

def test():
    #定义测试数据集加载器
    loader_test = torch.utils.data.DataLoader(dataset=Dataset('test'),
                                              batch_size=32,
                                              collate_fn=collate_fn,
                                              shuffle=True,
                                              drop_last=True)
    #下游任务模型切换到运行模式
    model.eval()
    correct = 0
    total = 0
    #按批次遍历测试集中的数据
    for i, (input_ids, attention_mask, token_type_ids,
            labels) in enumerate(loader_test):
        #计算5个批次即可，不需要全部遍历
        if i == 5:
            break
        print(i)
        #计算
        with torch.no_grad():
            out = model(input_ids=input_ids,
                        attention_mask=attention_mask,
                        token_type_ids=token_type_ids)
        #统计正确率
        out = out.argmax(dim=1)
        correct += (out == labels).sum().item()
        total += len(labels)
    print(correct / total)
test()

首先定义了测试数据集和加载器，并取出5个批次的数据让模型进行预测，最后统计正确率并输出，如下图所示：