引言

     借用修仙小说体写的标题，主要目的就是吸引你点进来🤭，客官来都来了，看完再走呗~ 其实实现一个智能的聊天机器人🤖还是有一定难度的。博主就和大家一起尽可能实现一个智能的聊天机器人。计划一周🧭更新一次，如果觉得更新慢的话，就在留言里催更吧，很有可能会响应你们的催更哦。

      本系列文章📓会基于Pytorch实现一个Seq2Seq 带Attention机制的聊天机器人，在本系列文章中，大家会了解到实现聊天机器人的所有知识，欢迎关注哦。

     上篇文章中我们直接加载哈工大的预训练模型得到了句子表示，但是在计算余弦相似度时发现效果一般。因此，本文来针对句子相似问题进行微调。

    主要想法是将句子相似看成一个分类问题，结果就是：相似(1)/不相似(0)。

    本文一步一步介绍如何微调这个分类问题，并对我们上篇文章中的句子进行测试。

使用🤗的Transformers包

pip install transformers datasets

    本文需要的包通过上面的指令安装即可。

数据集

    本文使用的数据集为中文句子对数据集，期望有两个句子，并且带有是否相似的标签。

    博主在HuggingFace的官方数据集中没有找到满足要求的，因此从网上下载了一个数据集，但是过分相信该数据集，导致直接加载各种报错。因此花费了几个小时处理了一下数据集，使它是可用的。

    数据集包含了两个文件：train.csv和dev.csv，其中训练集有9万句子对；开发集有1万句子对。

    该数据集下载地址：https://download.csdn.net/download/yjw123456/24496517

加载数据集到datasets中

    🤗提供的datasets模块导入数据集用起来很方便，因此如果能将我们自己的数据集也通过该工具加载岂不是美滋滋。

    下面一起来实现吧：

from datasets import load_dataset
# 加载本地数据集，指定本地路径即可
raw_datasets = load_dataset('csv', data_files={'train': './data/train.csv','dev': './data/dev.csv'})

    由于🤗引入了进度条工具，加载这些数据集的时候还会有一个进度条，等起来就不觉得久了。

    尤其是在jupyter上看起来更舒服。

    加载完成后，我们看下它的结构：

print(raw_datasets)

DatasetDict({
    train: Dataset({
        features: ['sentence1', 'sentence2', 'label'],
        num_rows: 88975
    })
    dev: Dataset({
        features: ['sentence1', 'sentence2', 'label'],
        num_rows: 10000
    })
})

    现在我们已经加载好了原始的数据集，接下来需要对数据集中的每个句子进行分词、转换为ID、增加特殊标记等操作。好在🤗已经帮我们把这些封装到了分词器Tokenizer里面了，不用每次做一些重复工作。

下载并加载Tokenizer

    与上篇文章一样，我们还是采用哈工大的BERT数据集，这里介绍一种比较简单的方式，可以不需要自己手动下载，不过可能你需要有网络?

from transformers import AutoTokenizer
tokenizer = AutoTokenizer.from_pretrained("hfl/chinese-bert-wwm-ext")

    这里我们使用🤗transformers中的AutoTokenizer模块，它会根据我们传入的路径自动帮我们分析需要创建什么分词器，每个模型的分词器是不同的。还有一个好处时，我们可以把路径封装成一个变量，如果需要不同的预训练模型，只要改变该变量的内容即可，主要代码可以不变。

    这里的hfl/chinese-bert-wwm-ext代表https://huggingface.co/hfl/chinese-bert-wwm-ext

    并不是随意输入的，像我们的代码可以传到github一样，我们使用🤗做的模型也可以上传到他们提供的模型hub。hfl是哈工大的用户名，后面就是哈工大上传的模型名称。

    等待片刻，下载好了之后，我们先看一下我们数据，并使用该分词进行预处理。

dataset_train = raw_datasets['train']
dataset_train[6]

{'label': 0, 'sentence1': '为什么我每次都提前还款了最后却不给我贷款了', 'sentence2': '30号我一次性还清可以不'}

    可以通过datasets的feature属性查看有哪些字段：

dataset_train.features

{'label': Value(dtype='int64', id=None),
 'sentence1': Value(dtype='string', id=None),
 'sentence2': Value(dtype='string', id=None)}

    然后我们使用加载的分词器对这两个句子进行处理。

inputs = tokenizer(dataset_train[6]['sentence1'],dataset_train[6]['sentence2'])
inputs

{
'input_ids': [101, 711, 784, 720, 2769, 3680, 3613, 6963, 2990, 1184, 6820, 3621, 749, 3297, 1400, 1316, 679, 5314, 2769, 6587, 3621, 749, 102, 8114, 1384, 2769, 671, 3613, 2595, 6820, 3926, 1377, 809, 679, 102],
 'token_type_ids': [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
 'attention_mask': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
}

    可以看到，已经帮我们把句子分词并转换为ID，同时返回了标记类型ID和注意力掩码。

    我们也可以把input_ids转换回文字：

tokenizer.convert_ids_to_tokens(inputs["input_ids"])

['[CLS]',
 '为',
 '什',
 '么',
 '我',
 '每',
 '次',
 '都',
 '提',
 '前',
 '还',
 '款',
 '了',
 '最',
 '后',
 '却',
 '不',
 '给',
 '我',
 '贷',
 '款',
 '了',
 '[SEP]',
 '30',
 '号',
 '我',
 '一',
 '次',
 '性',
 '还',
 '清',
 '可',
 '以',
 '不',
 '[SEP]']

    嗯，增加了特殊标记。

处理数据集

    下面我们来看下如何处理我们的数据集，如果想一次性处理整个数据集并加载到内存的话，不是土豪就是天真。

    官方提供的datasets.map 可以分批加载数据，而不是一次加载整个数据集。

    首先需要定义一个分词函数：

def tokenize_function(example):
    '''
    example可以是一个样本，也是一个一批样本
    
    注意根据指定的最大长度填充是非常低效的，最好的方法是按照该批次内最大长度进行填充。
    '''
 return tokenizer(example['sentence1'], example['sentence2'],truncation=True)

    我们可以在上面的例子中实验这个函数：

tokenize_function(dataset_train[6])

{'input_ids': [101, 711, 784, 720, 2769, 3680, 3613, 6963, 2990, 1184, 6820, 3621, 749, 3297, 1400, 1316, 679, 5314, 2769, 6587, 3621, 749, 102, 8114, 1384, 2769, 671, 3613, 2595, 6820, 3926, 1377, 809, 679, 102], 'token_type_ids': [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'attention_mask': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]}

    下面就可以利用map方法传入该函数来处理整个数据集了：

# batched=True一次可以处理一批数据
tokenized_datasets = raw_datasets.map(tokenize_function, batched=True)

    我们来看一下返回的数据集：

print(tokenized_datasets)

DatasetDict({
    train: Dataset({
        features: ['attention_mask', 'input_ids', 'label', 'sentence1', 'sentence2', 'token_type_ids'],
        num_rows: 88975
    })
    dev: Dataset({
        features: ['attention_mask', 'input_ids', 'label', 'sentence1', 'sentence2', 'token_type_ids'],
        num_rows: 10000
    })
})

    注意由于句子已经标记化了，因此里面的原始字符串不再需要了，我们可以删除它们(什么？你说我过河拆桥？)。

tokenized_datasets = tokenized_datasets.remove_columns(
 ["sentence1", "sentence2"]
)

    下面我们需要创建批数据，这里要注意的是，我们根据这批数据内最长的句子长度进行填充，而不是默认的最大长度512。

数据批量化

    剩下的工作是根据批数据内最大长度，动态填充批内数据。

    在PyTorch中，负责将批内的样本放在一起的函数称为整理函数(collate function)

    Transformers帮我们实现了这样的一个函数。

from transformers import DataCollatorWithPadding
data_collator = DataCollatorWithPadding(tokenizer=tokenizer)

    我们取一些样本，来测试这个函数。

samples = tokenized_datasets["train"][:8]
samples = {
    k: v for k, v in samples.items()
}
# 查看该批次内每个样本的长度
print([len(x) for x in samples["input_ids"]])

[27, 16, 39, 38, 25, 35, 35, 37]

    现在我们就使用data_collator来创建一个批数据，并根据该批数据内最大长度(39)进行填充

batch = data_collator(samples)
{k: v.shape for k, v in batch.items()}

{'attention_mask': torch.Size([8, 39]),
 'input_ids': torch.Size([8, 39]),
 'labels': torch.Size([8]),
 'token_type_ids': torch.Size([8, 39])}

    可以看到，第二个维度都是39。

定义训练器

    训练🤗的模型最简单的方法是使用他们提供的训练器(Trainer)。

    它主要是通过TrainingArguments来控制训练器的参数。

from transformers import TrainingArguments
# 指定训练过程中模型参数保存的路径以及批大小
training_args = TrainingArguments(output_dir="saved",per_device_train_batch_size=8)

    里面有很多默认的参数，可以根据自己的需要进行调整，官方文档链接→https://huggingface.co/transformers/main_classes/trainer.html#transformers.TrainingArguments

定义模型

     万事具备，只差模型了。我们这里使用的还是哈工大的bert预训练模型。

      加载也很简单：

# 定义模型
from transformers import AutoModelForSequenceClassification
# 基于哈工大的bert预训练模型
model = AutoModelForSequenceClassification.from_pretrained("hfl/chinese-bert-wwm-ext", num_labels=2)

Some weights of the model checkpoint at hfl/chinese-bert-wwm-ext were not used when initializing BertForSequenceClassification: ['cls.predictions.decoder.weight', 'cls.seq_relationship.weight', 'cls.predictions.transform.LayerNorm.weight', 'cls.seq_relationship.bias', 'cls.predictions.bias', 'cls.predictions.transform.dense.weight', 'cls.predictions.transform.dense.bias', 'cls.predictions.transform.LayerNorm.bias']
- This IS expected if you are initializing BertForSequenceClassification from the checkpoint of a model trained on another task or with another architecture (e.g. initializing a BertForSequenceClassification model from a BertForPreTraining model).
- This IS NOT expected if you are initializing BertForSequenceClassification from the checkpoint of a model that you expect to be exactly identical (initializing a BertForSequenceClassification model from a BertForSequenceClassification model).
Some weights of BertForSequenceClassification were not initialized from the model checkpoint at hfl/chinese-bert-wwm-ext and are newly initialized: ['classifier.weight', 'classifier.bias']
You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.

      下载完了之后它会打印一些提示⚠️，由于我们要做分类任务，因此选择AutoModelForSequenceClassification，它相当于在预训练的BERT模型上，加了一个输出头，这个提示或者警告的意思是让我们注意，这个新加的用于句子分类的输出头是随机初始化的，需要你去微调，真是贴心❤️啊。

      好了，那下面我们就来微调吧。

定义评估指标

      差点忘说了，在进行训练之前，需要先定义评估指标。因为训练比较耗时，定义评估指标应用在开发集上，以便你可以看到一轮迭代完成之后的效果。

from datasets import load_metric

def compute_metrics(eval_preds):
    metric = load_metric("accuracy")
    logits, labels = eval_preds
    predictions = np.argmax(logits, axis=-1)
    return metric.compute(predictions=predictions, references=labels)

      这里采用准确率作为评估指标，你也可以替换为f1/recall/precision等。

进行训练

      传入要训练的模型实例，配置的training_args和训练数据集、验证数据集等。

# 实例化训练器
from transformers import Trainer
trainer = Trainer(
    model,
    training_args,
    train_dataset=tokenized_datasets['train'],
    data_collator=data_collator, 
    eval_dataset=tokenized_datasets["dev"],
    tokenizer=tokenizer,
    compute_metrics=compute_metrics
)

      然后执行

trainer.train()
# 别忘记保存模型
trainer.save_model()

      就可以开始训练了。

     在GeForce RTX 3090上面跑了一个小时才训练完。

      训练完了之后，它会输出：

Configuration saved in saved/config.json
Model weights saved in saved/pytorch_model.bin
tokenizer config file saved in saved/tokenizer_config.json
Special tokens file saved in saved/special_tokens_map.json

      博主已经上传了训练好的模型，同时基于RoBERTa和BERT进行了微调，本文中微调的是BERT版的。

• BERT
• RoBERTa

加载微调好的模型

      最后也是比较重要的一步是，我们要如何加载微调好的模型，不可能每次都训练一次吧。

      其实很简单，报我们上面最终保存的文件统一放到一个目录下面，这里放到当前路径的saved文件下，如下所示：

      下面编写加载代码：

from transformers import AutoTokenizer, AutoModelForSequenceClassification

tokenizer = AutoTokenizer.from_pretrained("./saved")
model = AutoModelForSequenceClassification.from_pretrained("./saved")
model.eval()

      是不是也很简单，注意我们除了要加载未调好的模型，还要加载对应的分词器。

进行测试

      还是采用上篇文章的测试句子：

sentences = [
    '今天的月亮又大又圆',
    '十五的月亮十六圆',
    '今天去看电影吧',
]

     然后看前两句话的相似度：

def compute_similarity(sentence1, sentence2):
    batch = tokenizer(sentence1, sentence2, truncation=True, return_tensors="pt")

    output = model(**batch)
    softmax = torch.nn.Softmax(dim=1)
    logits = output[0].view(1, -1, 2)
    out = softmax(logits[:, -1])
    result = out[0].detach().cpu().numpy()
    print(f'The similarity of {sentence1} and {sentence2} is: {result[1]:.2f}')

compute_similarity(sentences[0], sentences[1])
compute_similarity(sentences[0], sentences[2])
compute_similarity(sentences[1], sentences[2])

The similarity of 今天的月亮又大又圆 and 十五的月亮十六圆 is: 0.99
The similarity of 今天的月亮又大又圆 and 今天去看电影吧 is: 0.00
The similarity of 十五的月亮十六圆 and 今天去看电影吧 is: 0.00

      可以看到，我们随意输入的几个句子，之间的相似度判断还比较准确，当然，更严谨的做法是对测试集使用f1/recall/precision等评估指标进行评估。