手把手教利用Bert实现知识库问答（详细注释）

跟着DataFountain学的，加了一些代码注释，DataFountain有数据集，链接：个人工作平台https://work.datafountain.cn/forum?id=121&type=2&source=1

一、数据处理

1、数据分析

数据格式如下：这个题目的意思就是判断Question和Sentence是否匹配，如果匹配label就是1

# 统一导入工具包
import csv
import transformers
import torch
import warnings
warnings.filterwarnings('ignore')

"""
1.数据说明
"""
# pd_table = pd.read_csv('./datasets/raw/WikiQA-train.tsv', encoding="utf-8", sep='\t')
"""
每条数据为以下6个字段：
    QuestionID: 问题id
    Question: 问题文本
    DocumentID: 检索到的作为答案来源的文档ID
    Document: 检索到的作为答案来源的文档标题
    SentenceID: 对于文档摘要中的每个句子的id
    Sentence: 文档中摘要中的句子
    label: 判断句子是否是答案的标签
"""

"""

2、数据加载处理

接下来加载有用的数据，将数据加载为这样的三元组，如果answer是question的正确答案，则lable为1，每个三元组用一个字典来存储。

def load(filename):
    result = []  
    with open(filename, mode='r', encoding="utf-8") as csvfile:
        spamreader = csv.reader(csvfile, delimiter='\t', quotechar='"')  # 这里的spamreader装了csv中每一行的
        next(spamreader, None)  # 这里自动迭代了一次，就跳过了第一行（第一行是标题），否则会读取到第一行
        for row in spamreader:  # 对每一行进行遍历
            res = {}  # 每一行的三元组用这个字典来存储
            res['question'] = str(row[1])  # 将Question赋值给字典的question
            res['answer'] = str(row[5])  # 将Sentence赋值给字典的answer
            res['label'] = int(row[6])  # 将label赋值给字典的label
            result.append(res)  # 这里的res就是装了每一行需要用到的信息的字典，然后把这个字典放到result这个列表中，每一行对应的字典都添加给这个列表
    return result
train_file = load('./datasets/raw/WikiQA-train.tsv')
valid_file = load('./datasets/raw/WikiQA-dev.tsv')
test_file = load('./datasets/raw/WikiQA-test.tsv')

train_file中的数据如下：

[{'question': 'how are glacier caves formed?', 'answer': 'A partly submerged glacier cave on Perito Moreno Glacier .', 'label': 0},[......],[.....]....]

3、数据标准化

读入数据后，要分词、将自然语言转换为one-hot向量，将文本对齐或者截断为相同长度等。同时需要将数据处理为Bert需要的输入形式。

#  3.1 max_length就是自己设定的文本最大长度，然后需要对小于max_length的文本长度进行补齐,对于长度不足的序列，在右边补padding
def padding(squence, max_length, pad_token=0):
    # squence就是需要需要处理的文本，pad_token就是padding的token，默认为0
    # padding_length如果大于0，就代表需要补padding_length个pad_token，如果小于0，代表需要截断多少个token
    padding_length = max_length - len(squence)
    return squence + [pad_token] * padding_length
#  3.2 Bert的标准输入，Bert的输入主要由input_ids, input_mask, token_type_ids三部分构成
# input_ids:Bert的输入通常需要两个句子，句子A前由[CLS]开始，以[SEP]结束，后面再连接句子B
# input_mask: 由于不同批次的数据长度不同，因此会对数据进行补全。但补全的信息对于网络是无用的，这个主要是输入的句子可能存在填0的操作，attention模块不需要把填0的无意义的信息算进来，所以使用mask操作。
# token_type_ids:用于标记一个input_ids序列中哪些位置是第一句话，哪些位置是第二句话。

将文本转换为可运行的数据集:

def tokenize(data, max_length, device):
    # 下面使用transformer中的BertTokenizer进行处理，tokenizer需要指定预训练模型位置，读取使用的词表vocab用于文本转换。
    model_path = './datasets/models/bert-pretrain'
    tokenizer = transformers.BertTokenizer.from_pretrained(model_path, do_lower_case=True)
    res = []
    for triple in data:
        # 这里将问题和答案两句话作为输入，使用[sep]将两句话链接， 同时转化为one-hot向量
        # tokenizer的encode_plus方法除了可以对文本进行分词外，还可以将输入序列转换为上面描述的标准形式
        inputs = tokenizer.encode_plus(
            triple['question'],  # 输入bert的第一句话,在sep前面
            triple['answer'],  # 输入bert的第二句话，在sep后面，注意这句话的结尾还有个sep
            add_special_tokens=True,  # 设为True就可以将句子专为Bert对应的输入形式
            max_length=max_length,  # 指定序列的最大长度，超过长度会截断
            truncation=True
        )
        # 注意上面的inputs已经将每个词根据词表转换为数字了
        input_ids, token_type_ids = inputs["input_ids"], inputs["token_type_ids"]
        # 这里的attention_mask和input_mask是一个意思，先初始化为每个位置都是1
        attention_mask = [1] * len(input_ids)
        # 下面进行长度补全或截断
        input_ids = padding(input_ids, max_length, pad_token=0)
        attention_mask = padding(attention_mask, max_length, pad_token=0)
        token_type_ids = padding(token_type_ids, max_length, pad_token=0)
        label = triple['label']
        res.append((input_ids, attention_mask, token_type_ids, label))
        # 上面的(input_ids, attention_mask, token_type_ids, label)元组就是Bert的输入了
        
    # 下面把所有数据转换为tensor形式，并且让代表单词的数字确定为int型
    all_input_ids = torch.tensor([x[0] for x in res], dtype=torch.int64, device=device)
    all_attention_mask = torch.tensor([x[1] for x in res], dtype=torch.int64, device=device)
    all_token_type_ids = torch.tensor([x[2] for x in res], dtype=torch.int64, device=device)
    all_labels = torch.tensor([x[3] for x in res], dtype=torch.int64, device=device)
    # 将Bert的输入用pytorch的工具打包
    return torch.utils.data.TensorDataset(all_input_ids, all_attention_mask, all_token_type_ids, all_labels)

二、模型搭建

import transformers
import torch
from transformers import BertPreTrainedModel, BertModel
from torch import nn
import warnings
warnings.filterwarnings('ignore')

device = torch.device('cuda:0')
"""
使用bert来计算两个语句之间的匹配度，将问题和答案作为一个序列输入后，最后全连接层输出的特征向量转换为1维的分类输出，来判断是否匹配
"""
# config为预训练模型的参数
config = transformers.BertConfig.from_pretrained('./datasets/models/bert-pretrain')
# 可以尝试用requires_grad冻结bert部分的参数，在Fine-tunning时只训练全连接的参数，这样训练会快一些
class BertQA(BertPreTrainedModel):
    def __init__(self, config):
        super(BertQA, self).__init__(config)
        self.num_labels = config.num_labels  # 分类数
        self.bert = BertModel(config)  # BertModel也是transformers库中的一个类
        # 冻结bert参数,只fine-tuning后面层的参数
        for p in self.parameters():  # 应该是因为继承了父类，所以直接self.parameters()就好了
            p.requires_grad = False
        # Linear是将CLS的输出的最后一个维度变成2，这是一个二分类问题
        self.qa_outputs = nn.Linear(config.hidden_size, 2)
        self.loss_fn = nn.CrossEntropyLoss(reduction='mean')
        self.init_weights()  # 初始化全连接层的权重

    def forward(self, input_ids=None, attention_mask=None,
                token_type_ids=None, position_ids=None,
                head_mask=None, inputs_embeds=None, labels=None):
        # 将数据输入Bert模型，得到Bert的输出
        outputs = self.bert(input_ids=input_ids, attention_mask=attention_mask, token_type_ids=token_type_ids,
                            position_ids=position_ids, head_mask=head_mask, inputs_embeds=inputs_embeds)
        # 注意bert的输出是个元组，是以下四个输出
        """
            last_hidden_state：shape是(batch_size, sequence_length, hidden_size)，hidden_size=768,它是模型最后一层输出的隐藏状态
            pooler_output：shape是(batch_size, hidden_size)，这是序列的第一个token(classification token)的最后一层的隐藏状态，它是由线性层和Tanh激活函数进一步处理的，这个输出不是对输入的语义内容的一个很好的总结，对于整个输入序列的隐藏状态序列的平均化或池化通常更好。
            hidden_states：这是输出的一个可选项，如果输出，需要指定config.output_hidden_states=True,它也是一个元组，它的第一个元素是embedding，其余元素是各层的输出，每个元素的形状是(batch_size, sequence_length, hidden_size)
            attentions：这也是输出的一个可选项，如果输出，需要指定config.output_attentions=True,它也是一个元组，它的元素是每一层的注意力权重，用于计算self-attention heads的加权平均值
        """
        # 通过全连接网络，将特征转换为一个二维向量，可以看做标签0和1的得分情况
        # output[0]就是last_hidden_state, 然后[:, 0, :]的意思是每个样本只取第一个位置，也就是CLS的输出,然后用squeeze在中间加一个维度支撑
        logits = self.qa_outputs(outputs[0][:, 0, :]).squeeze()  # 这里只选取第一列是只把第一列当做输出
        # 选择得分大的标签作为预测值
        predicted = nn.functional.softmax(logits, dim=-1)
        if labels is not None:
            loss = self.loss_fn(predicted, labels)
            return loss, predicted
        else:
            return predicted
#模型实例化

def model_real():
    model = BertQA.from_pretrained('./datasets/models/bert-pretrain', config=config)
    model.to(device)
    return model

三、模型训练

#Dataset
train_dataset = pre.tokenize(train_file, max_length, device=device)
train_dataloader = torch.utils.data.DataLoader(train_dataset, shuffle=True, batch_size=batch_size)


# 使用filter选择模型中未冻结的层，就可以只训练全连接层，而冻结bert层
optimizer = transformers.AdamW(filter(lambda p: p.requires_grad, model.parameters()), lr=lr, eps=adam_epsilon)
train_loss = []
for epoch in range(epoch):
    print("Training epoch {}".format(epoch+1))
    for step, batch in enumerate(train_dataloader):
        model.train()
        model.zero_grad()
        inputs = {
            'input_ids':      batch[0],
            'attention_mask': batch[1],
            'token_type_ids': batch[2],
            'labels':         batch[3]
        }
        outputs = model(**inputs)  # 如果使用**前缀，多余的参数会被认为是字典
        loss, results = outputs
        loss.backward()
        optimizer.step()
        train_loss.append(loss.item())