Bert文本分类和命名实体的模型架构剖析

文章目录

- 介绍
- Bert模型架构
- 损失计算方式
- - BertForSequenceClassification
  - BertForTokenClassification
- Bert 输出结果剖析
- - 例子
- 参考资料

介绍

文本分类：给一句文本分类；
实体识别：从一句文本中，识别出其中的实体；

做命名实体识别，有2种方式：

基于Bert-lstm-crf 的Token分类；
生成式的从序列到序列的文本生成方法。比如：T5、UIE、大模型等；

如果你想体验完整命名实体识别教程请浏览：Huggingface Token 分类官方教程：https://huggingface.co/learn/nlp-course/zh-CN/chapter7/2

若实体识别采取Token分类的做法：
那么文本分类是给一整句话做分类，实体识别是给一整句话中的每个词做分类。从本质上看，两者都是分类任务；

import torch
from transformers import (AutoTokenizer, AutoModel,AutoModelForSequenceClassification,BertForSequenceClassification,AutoModelForTokenClassification,
)

Bert模型架构

基本的Bert模型结构：

model_name = "bert-base-chinese"
bert = AutoModel.from_pretrained(model_name)
bert

Output:

...(output): BertOutput((dense): Linear(in_features=3072, out_features=768, bias=True)(LayerNorm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)(dropout): Dropout(p=0.1, inplace=False)))))(pooler): BertPooler((dense): Linear(in_features=768, out_features=768, bias=True)(activation): Tanh())
)

文本分类模型：

seq_cls_model = AutoModelForSequenceClassification.from_pretrained(model_name)
seq_cls_model

Output:

...(output): BertOutput((dense): Linear(in_features=3072, out_features=768, bias=True)(LayerNorm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)(dropout): Dropout(p=0.1, inplace=False)))))(pooler): BertPooler((dense): Linear(in_features=768, out_features=768, bias=True)(activation): Tanh()))(dropout): Dropout(p=0.1, inplace=False)(classifier): Linear(in_features=768, out_features=2, bias=True)
)

实体识别 token 分类：

token_cls_model = AutoModelForTokenClassification.from_pretrained(model_name)
token_cls_model

Output:

...(output): BertOutput((dense): Linear(in_features=3072, out_features=768, bias=True)(LayerNorm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)(dropout): Dropout(p=0.1, inplace=False))))))(dropout): Dropout(p=0.1, inplace=False)(classifier): Linear(in_features=768, out_features=2, bias=True)
)

经过观察AutoModelForSequenceClassification 和 AutoModelForTokenClassification的模型架构一模一样，即分类与实体识别的模型架构一模一样。两者都是在基础的Bert模型尾部添加 dropout和 classifier层。

Q：它们是一模一样Bert模型架构，为何能实现不同的任务？
A：因为它们选取Bert输出不同，损失值计算也不同。

损失计算方式

BertForSequenceClassification

from transformers import BertForSequenceClassification

按住 Ctrl + 鼠标左键，查看源码

在 forward 函数中可以查看到loss的计算方式。

outputs = self.bert(input_ids,attention_mask=attention_mask,token_type_ids=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,
)pooled_output = outputs[1]pooled_output = self.dropout(pooled_output)
logits = self.classifier(pooled_output)

BertForSequenceClassification 使用 pooled_output = outputs[1]。

BertForTokenClassification

from transformers import BertForTokenClassification

在 forward 函数中可以查看到loss的计算方式。

...
outputs = self.bert(input_ids,attention_mask=attention_mask,token_type_ids=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,
)sequence_output = outputs[0]sequence_output = self.dropout(sequence_output)
logits = self.classifier(sequence_output)

BertForTokenClassification 使用 sequence_output = outputs[0]。

Bert 输出结果剖析

下述是BertModel的输出结果，既可以使用字典访问，也可以通过下标访问:

BaseModelOutputWithPoolingAndCrossAttentions(last_hidden_state=sequence_output,pooler_output=pooled_output,past_key_values=encoder_outputs.past_key_values,hidden_states=encoder_outputs.hidden_states,attentions=encoder_outputs.attentions,cross_attentions=encoder_outputs.cross_attentions,)

outputs[0] 是last_hidden_state， outputs[1]是 pooler_output。

last_hidden_state 是输入到Bert模型每一个token的状态，pooler_output是[CLS]的last_hidden_state经过pooler处理得到的状态。

在这里插入图片描述

在图片上，用红色字标出了 last_hidden_state 和 pooler_output 在模型架构的位置。

例子

接下来使用一个例子帮助各位读者深入理解Bert输出结果中的last_hidden_state和pooler_output的区别。

from transformers import (AutoTokenizer, # BertModel,AutoModel,DataCollatorForTokenClassification
)
model_name = "bert-base-chinese"
tokenizer = AutoTokenizer.from_pretrained(model_name)
seq_cls_model = AutoModel.from_pretrained(model_name)data_collator = DataCollatorForTokenClassification(tokenizer=tokenizer)
batch = data_collator([tokenizer("今天天气真好，咱们出去放风筝吧！"),tokenizer("起风了，还是在家待着吧！"),])

for k, v in batch.items():print(k, v.shape)

Output:

input_ids torch.Size([2, 18])
token_type_ids torch.Size([2, 18])
attention_mask torch.Size([2, 18])

Bert 模型推理

output = bert(**batch)
print(torch.equal(output[0], output["last_hidden_state"]),torch.equal(output[1], output["pooler_output"])
)
last_hidden_state = output["last_hidden_state"]
pooler_output = output["pooler_output"]

Output:

True True
# output[0] == output["last_hidden_state"] 为真
# 这意味着Bert的输出，既可以用下标访问，也可以用字典的键访问

print(f"last_hidden_state.shape: {last_hidden_state.shape}",f"pooler_output.shape: {pooler_output.shape}"
)

Output:

last_hidden_state.shape: torch.Size([2, 18, 768]) pooler_output.shape: torch.Size([2, 768])

仅仅看它们的shape，也能看出它们的区别

last_hidden_state：包括每一个token的状态；（所以用来做命名实体识别）
pooler_output：只有[CLS]的状态；（[CLS]的输出向量被认为是整个序列的聚合表示，故用于分类任务。）

# [CLS] 在第一个token的位置，通过下标获取 `[CLS]`的tensor，再经过pooler处理
# 判断其与output["pooler_output"]是否相等
CLS_tensor = last_hidden_state[:,0,:].reshape(2, 1, -1)
torch.equal(bert.pooler(CLS_tensor),pooler_output
)