深度学习入门系列（七）之Bert实战文本情感分类项目

本次实战利用Bert模型进行下游文字分类，即对一类文本进行类别标签的预测，所用数据集为某外卖评论数据集。

与前面实战不同，本次实战对数据处理，模型定义与训练和验证三个过程进行了封装，将功能模块化，使代码更加简洁，易于维护。

1.数据处理

如何得到Bert的输入

读取数据，将其划分为训练集和验证集，并获得相应数据加载器。
一句话在输入时要经过分词器tokenizer，会将该句话转化为三个部分，且每个输入前加一个cls token，和seq token，不足位则末尾padding补齐。

三者可以让模型知道输入了哪些字，需要考虑处理哪几位字，以及句子编码。
input_id：每个字在21128个字的词语表中对应的数值下标是什么，用于生成独热编码,可以让模型能够知道输入的是哪个字。input_id经过linear（21128，768）后变为Bert的词Embeddings

Mask:告诉模型输入的这句话有多长。在NLP自然语言处理任务中，模型的输入应该固定，即输入语句的长度一致，当句子过短时padding补上，过长则截断。所以商务大床房，加cls和seq，对应7个1，后面的0表示补齐输入规定长度的padding。1表示有用的，0表示无用的，在模型输出时用每个字的mask值×对应字的输出，得到有效输出。

seq_ids:句子编码用于表示输入的语句中每个字同属一句话还是两句话。一般只有这两种，用0，1标识，经过linear(2，768）变为segment embeddings
而位置编码则根据模型规定的每次输入的最大长度（假设为512字）来默认从0开始编序号，即linear(512,768)生成Bert的position embeddings
将这三个embedding相加作为Bert输入

下游训练

本次实战，因为是下游任务，所以从hugging face网站中下载好预训练完成的bert-base-chinese作为模型
1）导入读取数据所必要的包，本次的训练集和验证集需要自己进行划分

#  data负责产生两个dataloader，训练集和验证集
from torch.utils.data import DataLoader, Dataset
from sklearn.model_selection import train_test_split   #给X,Y 和分割比例， 分割出来一个训练集和验证机的X, Y
import torch

2）读取评价文本

def read_file(path):
    data = []
    label = []

    with open(path, "r", encoding="utf-8") as f:
        for i, line in enumerate(f):
            if i == 0:
                continue
           # if i > 200 and i< 7500:
             #   continue
            line = line.strip("\n")
            line = line.split(",", 1)  #把这句话按照逗号分割， 1表示分割次数，即只分割一次
            data.append(line[1])
            label.append(line[0])
    print("读了%d的数据"%len(data))
    return data, label

（3）数据集类：三个函数与前两个实战类似，但需注意两点。第一，读文件函数得到了数据和标签，在数据集类的初始化函数中可直接赋值存储；第二，读文件函数中label列表里存储的是字符型数据，而通常进行训练验证的标签为整型，需进行转换。

class jdDataset(Dataset):
    def __init__(self, data, label):
        self.X = data
        self.Y = torch.LongTensor([int(i) for i in label])

    def __getitem__(self, item):
        return self.X[item], self.Y[item]

    def __len__(self):
        return len(self.Y)

（4）获得数据加载器：
选择将4/5作为训练集，1/5作为验证集，通过在主函数中调用来创建数据加载器

def get_data_loader(path, batchsize, val_size=0.2):
#读入数据，分割数据,val_size=0.2代表五分之一的数据当作验证
    data, label = read_file(path)        #调用读文件函数
    train_x, val_x, train_y, val_y = train_test_split(data, label, test_size=val_size,shuffle=True, stratify=label)
    #stratify=label表示按标签的比例分割数据集
    train_set = jdDataset(train_x, train_y)
    val_set = jdDataset(val_x, val_y)
    train_loader = DataLoader(train_set, batchsize, shuffle=True)
    val_loader = DataLoader(val_set, batchsize, shuffle=True)
 
    return train_loader, val_loader

2.定义模型

1）导入必要的包

import torch
import torch.nn as nn
from transformers import BertModel, BertTokenizer, BertConfig

2)创建模型导入下载的Bert模型
因为利用训练好的Bert进行分类，所以实际上model模块只需要两部分，导入BERT以及自己的分类头
self.bert = BertModel.from_pretrained(bert_path)
self.cls_head = nn.Linear(768, num_class) 输入768维特征，输出分类至自己的分类结果

class myBertModel(nn.Module):
    def __init__(self, bert_path, num_class, device):#传入bert路径和自己的分类数
        super(myBertModel, self).__init__()
 
        self.bert = BertModel.from_pretrained(bert_path)      #加载预训练的bert模型（设置和参数）
        '''
        config = BertConfig.from_pretrained(bert_path)        #只加载设置
        self.bert = BertModel(config)        #根据设置建立模型
        '''
 
        self.device = device
        self.cls_head = nn.Linear(768, num_class)    #添加一个全连接层，映射到指定的类别数
        self.tokenizer = BertTokenizer.from_pretrained(bert_path)    #分词器也来自于下载的Bert模型
 
    

前向过程：
第一步：先让文本（text为一个批次的评论，如16个评论）经过分词器，将其生成的input_id和attention_mask以及token_type_ids(句子标识）存入input中，分词器仅生成ID，并不直接输出向量。得到Bert的输入
第二步 从input中分别提取出他们让其通过模型，在进入模型的时候会由其嵌入层Embedding Layer完成向量化，最终得到Bert的输出
第三步：Bert的输出有两个，分别为sequence_out和pooler_out，用pool_out通过分类头进行分类，得到预测结果

def forward(self, text):
        input = self.tokenizer(text, return_tensors="pt", truncation=True, padding="max_length", max_length=128)
#对输入文本进行分词和编码，指定返回类型为pytorch张量，保证输入序列长度与给定的最大长度相同（填充加截断）
        #ps：调用大佬模型，以下代码定义不确定可以调试看分词后包括什么部分
        input_ids = input["input_ids"].to(self.device)   #分词后的Token ID列表
        token_type_ids = input['token_type_ids'].to(self.device)  #区分不同句子的标识符
        attention_mask = input['attention_mask'].to(self.device)  #屏蔽填充的注意力掩码，即padding 0的部分生成的掩码不参与特征生成
 
        sequence_out, pooler_out = self.bert(input_ids=input_ids,
                        token_type_ids=token_type_ids,
                        attention_mask=attention_mask,
                        return_dict=False)     #return_dict=False，返回一个元组（True为字典）
 
        pred = self.cls_head(pooler_out)      #获得预测值
        return pred

3.训练和验证

与前面实战项目的训练代码基本一致，多了几句代码进行了一点优化。
多的代码如下：
scheduler.step() ：用于每次优化器进行模型更新后，调整一下学习率；
在本次项目中，采用了学习率衰减策略，“余弦退火”,使得学习率在一个周期内缓慢降低，避免了陷入局部最优解。
torch.nn.utils.clip_grad_norm_：每次发现梯度过大时进行裁切至指定范围，如1.0，防止梯度爆炸

scheduler.step()              #调整优化器学习率
 
torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)       #梯度裁切，设置阈值防止梯度爆炸

完整训练和验证代码如下：

import torch
import time
import matplotlib.pyplot as plt
import numpy as np
from tqdm import tqdm



def train_val(para):

########################################################
    model = para['model']
    train_loader =para['train_loader']
    val_loader = para['val_loader']
    scheduler = para['scheduler']
    optimizer = para['optimizer']
    loss = para['loss']
    epoch = para['epoch']
    device = para['device']
    save_path = para['save_path']
    max_acc = para['max_acc']
    val_epoch = para['val_epoch']


#################################################
    plt_train_loss = []
    plt_train_acc = []
    plt_val_loss = []
    plt_val_acc = []
    val_rel = []

    for i in range(epoch):
        start_time = time.time()
        model.train()
        train_loss = 0.0
        train_acc = 0.0
        val_acc = 0.0
        val_loss = 0.0
        for batch in tqdm(train_loader):
            model.zero_grad()
            text, labels = batch[0], batch[1].to(device)
            pred = model(text)
            bat_loss = loss(pred, labels)
            bat_loss.backward()
            optimizer.step()
            scheduler.step()              #scheduler     调整学习率
            optimizer.zero_grad()
            torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)       #梯度裁切，防止梯度爆炸
            train_loss += bat_loss.item()    #.detach 表示去掉梯度
            train_acc += np.sum(np.argmax(pred.cpu().data.numpy(),axis=1)== labels.cpu().numpy())
        plt_train_loss . append(train_loss/train_loader.dataset.__len__())
        plt_train_acc.append(train_acc/train_loader.dataset.__len__())
        if i % val_epoch == 0:
            model.eval()
            with torch.no_grad():
                for batch in tqdm(val_loader):
                    val_text, val_labels = batch[0], batch[1].to(device)
                    val_pred = model(val_text)
                    val_bat_loss = loss(val_pred, val_labels)
                    val_loss += val_bat_loss.cpu().item()

                    val_acc += np.sum(np.argmax(val_pred.cpu().data.numpy(), axis=1) == val_labels.cpu().numpy())
                    val_rel.append(val_pred)

            if val_acc > max_acc:
                torch.save(model, save_path+str(epoch)+"ckpt")
                max_acc = val_acc
            plt_val_loss.append(val_loss/val_loader.dataset.__len__())
            plt_val_acc.append(val_acc/val_loader.dataset.__len__())
            print('[%03d/%03d] %2.2f sec(s) TrainAcc : %3.6f TrainLoss : %3.6f | valAcc: %3.6f valLoss: %3.6f  ' % \
                  (i, epoch, time.time()-start_time, plt_train_acc[-1], plt_train_loss[-1], plt_val_acc[-1], plt_val_loss[-1])
                  )
            if i % 50 == 0:
                torch.save(model, save_path+'-epoch:'+str(i)+ '-%.2f'%plt_val_acc[-1])
        else:
            plt_val_loss.append(plt_val_loss[-1])
            plt_val_acc.append(plt_val_acc[-1])
            print('[%03d/%03d] %2.2f sec(s) TrainAcc : %3.6f TrainLoss : %3.6f   ' % \
                  (i, epoch, time.time()-start_time, plt_train_acc[-1], plt_train_loss[-1])
                  )
    plt.plot(plt_train_loss)
    plt.plot(plt_val_loss)
    plt.title('loss')
    plt.legend(['train', 'val'])
    plt.show()

    plt.plot(plt_train_acc)
    plt.plot(plt_val_acc)
    plt.title('Accuracy')
    plt.legend(['train', 'val'])
    plt.savefig('acc.png')
    plt.show()

4.主函数调用与配置

由于数据处理，模型定义，以及训练验证流程都已在上述三个模块内完成，主函数模块只需要定义超参数开始训练即可

导入各模块以及常用包

import random
import torch
import torch.nn as nn
import numpy as np
import os

from model_utils.data import get_data_loader
from model_utils.model import myBertModel
from model_utils.train import train_val

定义随机种子

#随机种子
def seed_everything(seed):
    torch.manual_seed(seed)
    torch.cuda.manual_seed(seed)
    torch.cuda.manual_seed_all(seed)
    torch.backends.cudnn.benchmark = False
    torch.backends.cudnn.deterministic = True
    random.seed(seed)
    np.random.seed(seed)
    os.environ['PYTHONHASHSEED'] = str(seed)
#################################################################
seed_everything(0)
###############################################

定义超参数：
采用adamw优化器，交叉熵损失函数

lr = 0.0001    #学习率
batchsize = 16    #批次大小
loss = nn.CrossEntropyLoss()       #由于是分类任务依旧采用交叉熵损失函数
bert_path = "bert-base-chinese"    #模型地址
num_class = 2      #标签类别数
device = "cuda" if torch.cuda.is_available() else "cpu"   #设备
max_acc = 0.6      #最大准确率
val_epoch = 1  #设置为每训练一轮验证一次
 
model = myBertModel(bert_path, num_class, device).to(device)    #模型实例化
optimizer = torch.optim.AdamW(model.parameters(), lr=lr, weight_decay=0.00001)   #优化器
 
data_path = "waimai.txt"       #初始数据集地址
train_loader, val_loader = get_data_loader(data_path, batchsize)#创建数据加载器
 
epochs = 5         #轮次数
save_path = "model_save/best_model.pth"       #最优模型保存地址
 
scheduler = torch.optim.lr_scheduler.CosineAnnealingWarmRestarts(optimizer, T_0=20, eta_min=1e-9)
#改变学习率，定义了一个学习率调度器，在一个周期内，学习率会按照余弦函数的形式从初始值逐渐降低到最小值，T_0为重启周期长度，eta_min为最小学习率，不能低于eta_min
#可以有效避免学习率过早降低导致模型陷入局部最优，
 
para = {
    "model": model,
    "train_loader": train_loader,
    "val_loader": val_loader,
    "scheduler": scheduler,
    "optimizer": optimizer,
    "loss": loss,
    "epoch": epochs,
    "device": device,
    "save_path": save_path,
    "max_acc": max_acc,
    "val_epoch": val_epoch      #训练多少轮验证一次
 
}     #用字典集中存储参数

调用训练模块，开始训练：

train_val(para)       #调用训练和验证模块

训练结果

验证准确率高达88%


出现了一些过拟合现象，慢慢调参修正训练即可。