Transformers实战（二）快速入门文本相似度、检索式对话机器人

Transformers实战（二）快速入门文本相似度、检索式对话机器人

1、文本相似度

1.1 文本相似度简介

• 文本匹配是一个较为宽泛的概念，基本上只要涉及到两段文本之间关系的，都可以被看作是一种文本匹配的任务，

• 只是在具体的场景下，不同的任务对匹配二字的定义可能是存在差异的，具体的任务场景包括文本相似度计算、问答匹配、对话匹配、文本推理等等，另外，如之前介绍的多项选择，本质上也是文本匹配

• 本次重点关注文本相似度任务，即判断两段文本是不是表达了同样的语义

• 文本相似度本质上是一个分类任务。

Sentence A	Sentence B	Label
找一部小时候的动画片	求一部小时候的动画片。谢了	1
别急呀，我的朋友。	你一定要看我一下	0
明天多少度啊	明天气温多少度啊	1
可怕的事情终于发生	你到底想说什么?	0

1.2 最直接的解决方案—交互策略

交互策略，就是输入句子对，对是否相似进行学习。

数据预处理方式如下：

交互策略的实现比较简单，类似于情感分析。

1.2.1 数据集预处理

数据集：https://github.com/CLUEbenchmark/SimCLUE/tree/main

预训练模型依然是哈工大开源的chinese-macbert-base

from transformers import AutoTokenizer, AutoModelForSequenceClassification, Trainer, TrainingArguments
from datasets import load_datasetdataset = load_dataset("json", data_files="./train_pair_1w.json", split="train")
dataset[0:2]

{'sentence1': ['找一部小时候的动画片','我不可能是一个有鉴赏能力的行家，小姐我把我的时间都花在书写上；象这样豪华的舞会，我还是头一次见到。'],'sentence2': ['求一部小时候的动画片。谢了', '蜡烛没熄就好了，夜黑得瘆人，情绪压抑。'],'label': ['1', '0']}

# 划分数据集
datasets = dataset.train_test_split(test_size=0.2)# tokenizer = AutoTokenizer.from_pretrained("hfl/chinese-macbert-base")# 离线加载
model_path = '/root/autodl-fs/models/chinese-macbert-base'
tokenizer = AutoTokenizer.from_pretrained(model_path)def process_function(examples):tokenized_examples = tokenizer(examples["sentence1"], examples["sentence2"], max_length=128, truncation=True)tokenized_examples["labels"] = [float(label) for label in examples["label"]]return tokenized_examplestokenized_datasets = datasets.map(process_function, batched=True, remove_columns=datasets["train"].column_names)
tokenized_datasets

DatasetDict({train: Dataset({features: ['input_ids', 'token_type_ids', 'attention_mask', 'labels'],num_rows: 8000})test: Dataset({features: ['input_ids', 'token_type_ids', 'attention_mask', 'labels'],num_rows: 2000})
})

print(tokenized_datasets["train"][0])

{
'input_ids': [101, 1062, 4265, 1920, 782, 8024, 1963, 3362, 2769, 1762, 6878, 1168, 2600, 1385, 808, 1184, 6878, 1168, 4640, 2370, 7363, 678, 8024, 6929, 6421, 2582, 720, 1215, 8043, 102, 800, 2697, 6230, 2533, 800, 2190, 6821, 5439, 1928, 2094, 3683, 2190, 800, 1520, 1520, 6820, 779, 8024, 4507, 754, 800, 2190, 6821, 702, 782, 772, 4495, 4638, 3946, 2658, 679, 4881, 2544, 5010, 6629, 3341, 511, 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, 0, 0, 0, 0, 0, 0, 0, 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, 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, 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], 
'labels': 0.0
}

1.2.2 加载模型、创建评估函数

import evaluate# 离线加载模型
model = AutoModelForSequenceClassification.from_pretrained(model_path, num_labels=1)# 这里采用离线加载
accuracy_path = '/root/autodl-tmp/transformers-code/metrics/accuracy'
f1_path = '/root/autodl-tmp/transformers-code/metrics/f1'acc_metric = evaluate.load(accuracy_path)
f1_metirc = evaluate.load(f1_path)def eval_metric(eval_predict):predictions, labels = eval_predictpredictions = [int(p > 0.5) for p in predictions]labels = [int(l) for l in labels]acc = acc_metric.compute(predictions=predictions, references=labels)f1 = f1_metirc.compute(predictions=predictions, references=labels)acc.update(f1)return acc

1.2.3 创建TrainingArguments及Trainer

train_args = TrainingArguments(output_dir="./cross_model",      # 输出文件夹per_device_train_batch_size=16,  # 训练时的batch_sizeper_device_eval_batch_size=16,  # 验证时的batch_sizelogging_steps=10,                # log 打印的频率evaluation_strategy="epoch",     # 评估策略save_strategy="epoch",           # 保存策略save_total_limit=3,              # 最大保存数learning_rate=2e-5,              # 学习率weight_decay=0.01,               # weight_decaymetric_for_best_model="f1",      # 设定评估指标load_best_model_at_end=True)     # 训练完成后加载最优模型

from transformers import DataCollatorWithPadding
trainer = Trainer(model=model, args=train_args, train_dataset=tokenized_datasets["train"], eval_dataset=tokenized_datasets["test"], data_collator=DataCollatorWithPadding(tokenizer=tokenizer),compute_metrics=eval_metric)

trainer.train()

1.2.4 模型预测

from transformers import pipelinemodel.config.id2label = {0: "不相似", 1: "相似"}
pipe = pipeline("text-classification", model=model, tokenizer=tokenizer, device=0)result = pipe({"text": "我喜欢北京", "text_pair": "天气怎样"}, function_to_apply="none")
result["label"] = "相似" if result["score"] > 0.5 else "不相似"
result

{'label': '不相似', 'score': 0.054742373526096344}

1.3 基于向量匹配的解决方案

如果从多个文本中，找到最相似的文本，应该如何做呢？

基于交互策略，我们可以借鉴之前多项选择，用相同的处理方式(如下图)。

但是这样效率极低，因为每次都需要与全量数据进行模型推理，数据量较大时很难满足时延要求。

基于向量匹配的方案可以解决。

我们可以将候选文本经过训练好的模型进行向量化，然后存到向量数据库中(如faiss)。然后将问题也同样向量化，去向量库中进行向量匹配。(这也是检索式机器人的思路，我们将在检索机器人中，将本章节训练好的向量模型作为预训练模型，对文本进行向量化，并将向量集合存到faiss中，进行向量匹配，这里仅仅训练出向量模型。)

那么，这个向量模型该如何进行训练呢？

向量匹配训练，分别对句子进行编码，目标是让两个相似句子的相似度分数尽可能接近1。

数据预处理与多项选择类似

注意：此时没有预定义模型，需要我们自己实现模型。

模型中的损失，我们可以用pytorch提供的余弦损失函数 torch.nn.CosineEmbeddingLoss

• 余弦损失函数，常常用于评估两个向量的相似性，两个向量的余弦值越高，则相似性越高。

• x：包括x1和x2，即需要计算相似度的prediction和GT；

• y：相当于人为给定的flag，决定按哪种方式计算得到loss的结果。

• 注意：此时label应该为正负1

• 如果需要约束使x1和x2尽可能的相似，那么就使用y=1，prediction和GT完全一致时，loss为0

input1 = torch.randn(100, 128)
input2 = torch.randn(100, 128)
cos = nn.CosineEmbeddingLoss(reduction='mean')# # 需要初始化一个N维的1或-1
loss_flag = torch.ones([100]) 
output = cos(input1, input2, loss_flag)print(output)	# tensor(1.0003)

1.3.1 数据预处理

数据集：https://github.com/CLUEbenchmark/SimCLUE/tree/main

预训练模型依然是哈工大开源的chinese-macbert-base

from transformers import AutoTokenizer, AutoModelForSequenceClassification, Trainer, TrainingArguments
from datasets import load_dataset
import torch# 离线加载数据
dataset = load_dataset("json", data_files="./train_pair_1w.json", split="train")# 数据集划分
datasets = dataset.train_test_split(test_size=0.2)# 和多项选择相似的处理方式
model_path = '/root/autodl-fs/models/chinese-macbert-base'
tokenizer = AutoTokenizer.from_pretrained(model_path)def process_function(examples):sentences = []labels = []for sen1, sen2, label in zip(examples["sentence1"], examples["sentence2"], examples["label"]):sentences.append(sen1)sentences.append(sen2)# 这里label处理为1和-1labels.append(1 if int(label) == 1 else -1)# input_ids, attention_mask, token_type_idstokenized_examples = tokenizer(sentences, max_length=128, truncation=True, padding="max_length")tokenized_examples = {k: [v[i: i + 2] for i in range(0, len(v), 2)] for k, v in tokenized_examples.items()}tokenized_examples["labels"] = labelsreturn tokenized_examplestokenized_datasets = datasets.map(process_function, batched=True, remove_columns=datasets["train"].column_names)
tokenized_datasets

DatasetDict({train: Dataset({features: ['input_ids', 'token_type_ids', 'attention_mask', 'labels'],num_rows: 8000})test: Dataset({features: ['input_ids', 'token_type_ids', 'attention_mask', 'labels'],num_rows: 2000})
})

1.3.2 自定义训练模型

from transformers import BertForSequenceClassification, BertPreTrainedModel, BertModel
from typing import Optional
from transformers.configuration_utils import PretrainedConfig
from torch.nn import CosineSimilarity, CosineEmbeddingLossclass DualModel(BertPreTrainedModel):def __init__(self, config: PretrainedConfig, *inputs, **kwargs):super().__init__(config, *inputs, **kwargs)self.bert = BertModel(config)self.post_init()def forward(self,input_ids: Optional[torch.Tensor] = None,attention_mask: Optional[torch.Tensor] = None,token_type_ids: Optional[torch.Tensor] = None,position_ids: Optional[torch.Tensor] = None,head_mask: Optional[torch.Tensor] = None,inputs_embeds: Optional[torch.Tensor] = None,labels: Optional[torch.Tensor] = None,output_attentions: Optional[bool] = None,output_hidden_states: Optional[bool] = None,return_dict: Optional[bool] = None,):return_dict = return_dict if return_dict is not None else self.config.use_return_dict# Step1 分别获取sentenceA 和 sentenceB的输入senA_input_ids, senB_input_ids = input_ids[:, 0], input_ids[:, 1]senA_attention_mask, senB_attention_mask = attention_mask[:, 0], attention_mask[:, 1]senA_token_type_ids, senB_token_type_ids = token_type_ids[:, 0], token_type_ids[:, 1]# Step2 分别获取sentenceA 和 sentenceB的向量表示senA_outputs = self.bert(senA_input_ids,attention_mask=senA_attention_mask,token_type_ids=senA_token_type_ids,position_ids=position_ids,head_mask=head_mask,inputs_embeds=inputs_embeds,output_attentions=output_attentions,output_hidden_states=output_hidden_states,return_dict=return_dict,)senA_pooled_output = senA_outputs[1]    # [batch, hidden]senB_outputs = self.bert(senB_input_ids,attention_mask=senB_attention_mask,token_type_ids=senB_token_type_ids,position_ids=position_ids,head_mask=head_mask,inputs_embeds=inputs_embeds,output_attentions=output_attentions,output_hidden_states=output_hidden_states,return_dict=return_dict,)senB_pooled_output = senB_outputs[1]    # [batch, hidden]# step3 计算相似度cos = CosineSimilarity()(senA_pooled_output, senB_pooled_output)    # [batch, ]# step4 计算lossloss = Noneif labels is not None:loss_fct = CosineEmbeddingLoss(0.3)loss = loss_fct(senA_pooled_output, senB_pooled_output, labels)output = (cos,)return ((loss,) + output) if loss is not None else outputmodel = DualModel.from_pretrained(model_path)

1.3.3 创建评估函数

import evaluate# 这里采用离线加载
accuracy_path = '/root/autodl-tmp/transformers-code/metrics/accuracy'
f1_path = '/root/autodl-tmp/transformers-code/metrics/f1'acc_metric = evaluate.load(accuracy_path)
f1_metirc = evaluate.load(f1_path)def eval_metric(eval_predict):predictions, labels = eval_predictpredictions = [int(p > 0.7) for p in predictions]labels = [int(l > 0) for l in labels]acc = acc_metric.compute(predictions=predictions, references=labels)f1 = f1_metirc.compute(predictions=predictions, references=labels)acc.update(f1)return acc

1.3.4 创建TrainingArguments及Trainer

train_args = TrainingArguments(output_dir="./dual_model",      # 输出文件夹per_device_train_batch_size=32,  # 训练时的batch_sizeper_device_eval_batch_size=32,  # 验证时的batch_sizelogging_steps=10,                # log 打印的频率evaluation_strategy="epoch",     # 评估策略save_strategy="epoch",           # 保存策略save_total_limit=3,              # 最大保存数learning_rate=2e-5,              # 学习率weight_decay=0.01,               # weight_decaymetric_for_best_model="f1",      # 设定评估指标load_best_model_at_end=True)     # 训练完成后加载最优模型

trainer = Trainer(model=model, args=train_args, train_dataset=tokenized_datasets["train"], eval_dataset=tokenized_datasets["test"], compute_metrics=eval_metric)

trainer.train()

1.3.5 自定义pipeline实现模型评估

class SentenceSimilarityPipeline:def __init__(self, model, tokenizer) -> None:self.model = model.bertself.tokenizer = tokenizerself.device = model.devicedef preprocess(self, senA, senB):return self.tokenizer([senA, senB], max_length=128, truncation=True, return_tensors="pt", padding=True)def predict(self, inputs):inputs = {k: v.to(self.device) for k, v in inputs.items()}return self.model(**inputs)[1]  # [2, 768]def postprocess(self, logits):cos = CosineSimilarity()(logits[None, 0, :], logits[None,1, :]).squeeze().cpu().item()return cosdef __call__(self, senA, senB, return_vector=False):inputs = self.preprocess(senA, senB)logits = self.predict(inputs)result = self.postprocess(logits)if return_vector:return result, logitselse:return result

pipe = SentenceSimilarityPipeline(model, tokenizer)pipe("我喜欢北京", "明天不行", return_vector=True)

(0.4414671063423157,tensor([[ 0.8044, -0.7820,  0.9974,  ..., -0.6317, -0.9653, -0.4989],[ 0.3756,  0.0484,  0.9767,  ..., -0.9928, -0.9980, -0.5648]],device='cuda:0', grad_fn=<TanhBackward0>))

注：文本向量化更加便捷有效的工具

• sentence-transformers

https://www.sbert.net/

• text2vec

https://github.com/shibing624/text2vec

• uniem

https://github.com/wangyuxinwhy/uniem

2、检索式对话机器人

2.1 检索式对话机器人简介

• 对话机器人在本质上是一个用来模拟人类对话或聊天的计算机程序，接收人类的自然语言作为输入并给出合适的回复

• 按照任务类型划分，对话机器人简单的可以划分为闲聊机器人、问答机器人、任务型对话机器人

• 按照答案产生的逻辑划分，对话机器人可以划分为检索式对话机器人和生成式对话机器人

如何实现基于检索的问答机器人?

QQ匹配策略

可以利用QQ匹配策略，即取最优结果的Q对应的Answer作为最终结果。

• 但是使用向量匹配的模型效果并不好，很难直接取到最优结果

• 因此引入基于交互策略模型。向量匹配模块又称为召回模块，交互策略的模块又称为排序模块

2.2 向量匹配和交互策略结合实现检索对话机器人

法律知道数据集
https://github.com/SophonPlus/ChineseNlpCorpus预训练模型
1.2章节训练的交互模型
1.3章节训练的匹配模型

2.2.1 加载自己训练的向量匹配模型

import pandas as pddata = pd.read_csv("./law_faq.csv")
data.head()

# dual_model.py文件中是自定义的DualModel
from dual_model import DualModel
from transformers import AutoTokenizer# 加载自己训练好的模型
dual_model = DualModel.from_pretrained("../12-sentence_similarity/dual_model/checkpoint-500/")
dual_model = dual_model.cuda()
dual_model.eval()
print("匹配模型加载成功！")# 加载tokenzier
model_path = '/root/autodl-fs/models/chinese-macbert-base'
tokenzier = AutoTokenizer.from_pretrained(model_path)

2.2.2 将知识库中的问题编码为向量

import torch
from tqdm import tqdmquestions = data["title"].to_list()
vectors = []
with torch.inference_mode():for i in tqdm(range(0, len(questions), 32)):batch_sens = questions[i: i + 32]inputs = tokenzier(batch_sens, return_tensors="pt", padding=True, max_length=128, truncation=True)inputs = {k: v.to(dual_model.device) for k, v in inputs.items()}# 这里拿出[CLS]的向量表示vector = dual_model.bert(**inputs)[1]vectors.append(vector)
vectors = torch.concat(vectors, dim=0).cpu().numpy()
vectors.shape

(18213, 768)

2.2.3 将知识库中的问题向量存入向量库中

# pip install faiss-cpu
import faissindex = faiss.IndexFlatIP(768)
faiss.normalize_L2(vectors)
index.add(vectors)
index

2.2.4 将用户问题编码为向量

quesiton = "寻衅滋事"
with torch.inference_mode():inputs = tokenzier(quesiton, return_tensors="pt", padding=True, max_length=128, truncation=True)inputs = {k: v.to(dual_model.device) for k, v in inputs.items()}vector = dual_model.bert(**inputs)[1]q_vector = vector.cpu().numpy()
q_vector.shape

(1, 768)

2.2.5 向量匹配

faiss.normalize_L2(q_vector)
# 使用faiss进行搜索
scores, indexes = index.search(q_vector, 10)# 将匹配到的相似问题及答案召回
topk_result = data.values[indexes[0].tolist()]# 匹配到的相似问题
topk_result[:, 0]

array(['涉嫌寻衅滋事', '两个轻微伤够寻衅滋事', '敲诈勒索罪', '聚群斗殴', '飞达暴力催收', '打架斗殴','涉嫌犯罪？？？？？', '殴打他人治安处罚', '遵守法律的措施', '十级伤残工伤'], dtype=object)

2.2.6 加载自己训练的交互模型

from transformers import BertForSequenceClassificationcorss_model = BertForSequenceClassification.from_pretrained("../12-sentence_similarity/cross_model/checkpoint-500/")
corss_model = corss_model.cuda()
corss_model.eval()
print("模型加载成功！")

2.2.7 最终的预测结果

# 候选问题集合
canidate = topk_result[:, 0].tolist()
ques = [quesiton] * len(canidate)
inputs = tokenzier(ques, canidate, return_tensors="pt", padding=True, max_length=128, truncation=True)
inputs = {k: v.to(corss_model.device) for k, v in inputs.items()}
with torch.inference_mode():logits = corss_model(**inputs).logits.squeeze()result = torch.argmax(logits, dim=-1)
result

tensor(0, device='cuda:0')

# 候选答案集合
canidate_answer = topk_result[:, 1].tolist()match_quesiton = canidate[result.item()]
final_answer = canidate_answer[result.item()]
match_quesiton, final_answer

('涉嫌寻衅滋事','说明具有寻衅滋事行为，应受到相应的处罚，行为人情形严重或行为恶劣的涉嫌了寻衅滋事罪。寻衅滋事是指行为人结伙斗殴的、追逐、拦截他人的、强拿硬要或者任意损毁、占用公私财物的、其他寻衅滋事的行为。寻衅滋事罪，是指在公共场所无事生非、起哄闹事，造成公共场所秩序严重混乱的，追逐、拦截、辱骂、恐吓他人，强拿硬要或者任意损毁、占用公私财物，破坏社会秩序，情节严重的行为。对于寻衅滋事行为的处罚：1、《中华人*共和国治安管理处罚法》第二十六条规定，有下列行为之一的，处五日以上十日以下拘留，可以并处五百元以下罚款;情节较重的，处十日以上十五日以下拘留，可以并处一千元以下罚款:(一)结伙斗殴的;(二)追逐、拦截他人的;(三)强拿硬要或者任意损毁、占用公私财物的;(四)其他寻衅滋事行为;...)