使用 bert-base-chinese-ner 模型实现中文NER

已于 2024-04-11 20:16:08 修改
阅读量2.2k 收藏 8
点赞数 12
分类专栏： # NLP 文章标签： bert ner 中文 transformer
于 2024-04-11 19:58:54 首次发布
我们不生产知识，我们只是互联网的搬运工
本文链接：https://blog.csdn.net/itnerd/article/details/137650663
版权

TokenClassification

from transformers import AutoTokenizer, AutoModelForTokenClassification
from transformers import pipeline

tokenizer = BertTokenizerFast.from_pretrained('models/bert-base-chinese')
model = AutoModelForTokenClassification.from_pretrained('models/bert-base-chinese-ner')

nlp = pipeline("ner", model=model, tokenizer=tokenizer)
example = "我叫王大，喜欢去旺角餐厅吃牛角包, 今年买了阿里巴巴的股票，亏得舅老爷的裤衩都没了，我的手机号是13587677888"
ner_results = nlp(example)

输出结果是按token进行分类，恰如其名：AutoModel For TokenClassification

[{'entity': 'B-PERSON',
  'score': 0.999997,
  'index': 3,
  'word': '王',
  'start': 2,
  'end': 3},
 {'entity': 'E-PERSON',
  'score': 0.999998,
  'index': 4,
  'word': '大',
  'start': 3,
  'end': 4},
 {'entity': 'B-FAC',
  'score': 0.99907553,
  'index': 9,
  'word': '旺',
  'start': 8,
  'end': 9},
 {'entity': 'I-FAC',
  'score': 0.9980399,
  'index': 10,
  'word': '角',
  'start': 9,
  'end': 10},
 {'entity': 'I-FAC',
  'score': 0.99831957,
  'index': 11,
  'word': '餐',
  'start': 10,
  'end': 11},
 {'entity': 'E-FAC',
  'score': 0.99899906,
  'index': 12,
  'word': '厅',
  'start': 11,
  'end': 12},
 {'entity': 'B-DATE',
  'score': 0.9999993,
  'index': 18,
  'word': '今',
  'start': 18,
  'end': 19},
 {'entity': 'E-DATE',
  'score': 0.99999917,
  'index': 19,
  'word': '年',
  'start': 19,
  'end': 20},
 {'entity': 'B-PERSON',
  'score': 0.99988663,
  'index': 22,
  'word': '阿',
  'start': 22,
  'end': 23},
 {'entity': 'I-PERSON',
  'score': 0.99996257,
  'index': 23,
  'word': '里',
  'start': 23,
  'end': 24},
 {'entity': 'I-PERSON',
  'score': 0.9999058,
  'index': 24,
  'word': '巴',
  'start': 24,
  'end': 25},
 {'entity': 'E-PERSON',
  'score': 0.99996555,
  'index': 25,
  'word': '巴',
  'start': 25,
  'end': 26},
 {'entity': 'B-CARDINAL',
  'score': 0.99999297,
  'index': 48,
  'word': '135',
  'start': 48,
  'end': 51},
 {'entity': 'I-CARDINAL',
  'score': 0.9999881,
  'index': 49,
  'word': '##87',
  'start': 51,
  'end': 53},
 {'entity': 'I-CARDINAL',
  'score': 0.99998856,
  'index': 50,
  'word': '##67',
  'start': 53,
  'end': 55},
 {'entity': 'I-CARDINAL',
  'score': 0.9999887,
  'index': 51,
  'word': '##78',
  'start': 55,
  'end': 57},
 {'entity': 'E-CARDINAL',
  'score': 0.99999154,
  'index': 52,
  'word': '##88',
  'start': 57,
  'end': 59}]

如果不想用 pipeline，也可以用如下方式：

def token_classify(example):
    inputs = tokenizer([example], return_tensors='pt')
    with torch.no_grad():
        logits = model(**inputs).logits
    predictions = torch.argmax(logits, dim=2)
    predicted_token_class = [model.config.id2label[t.item()] for t in predictions[0]]
    input_tokens = [tokenizer.decode(i) for i in tokenizer(example).input_ids]
    return [{"word":i,"entity":j} for i,j in zip(input_tokens, predicted_token_class)]

[{'word': '[CLS]', 'entity': 'O'},
 {'word': '我', 'entity': 'O'},
 {'word': '叫', 'entity': 'O'},
 {'word': '王', 'entity': 'B-PERSON'},
 {'word': '大', 'entity': 'E-PERSON'},
 {'word': '，', 'entity': 'O'},
 {'word': '喜', 'entity': 'O'},
 {'word': '欢', 'entity': 'O'},
 {'word': '去', 'entity': 'O'},
 {'word': '旺', 'entity': 'B-FAC'},
 {'word': '角', 'entity': 'I-FAC'},
 {'word': '餐', 'entity': 'I-FAC'},
 {'word': '厅', 'entity': 'E-FAC'},
 {'word': '吃', 'entity': 'O'},
 {'word': '牛', 'entity': 'O'},
 {'word': '角', 'entity': 'O'},
 {'word': '包', 'entity': 'O'},
 {'word': ',', 'entity': 'O'},
 {'word': '今', 'entity': 'B-DATE'},
 {'word': '年', 'entity': 'E-DATE'},
 {'word': '买', 'entity': 'O'},
 {'word': '了', 'entity': 'O'},
 {'word': '阿', 'entity': 'B-PERSON'},
 {'word': '里', 'entity': 'I-PERSON'},
 {'word': '巴', 'entity': 'I-PERSON'},
 {'word': '巴', 'entity': 'E-PERSON'},
 {'word': '的', 'entity': 'O'},
 {'word': '股', 'entity': 'O'},
 {'word': '票', 'entity': 'O'},
 {'word': '，', 'entity': 'O'},
 {'word': '亏', 'entity': 'O'},
 {'word': '得', 'entity': 'O'},
 {'word': '舅', 'entity': 'O'},
 {'word': '老', 'entity': 'O'},
 {'word': '爷', 'entity': 'O'},
 {'word': '的', 'entity': 'O'},
 {'word': '裤', 'entity': 'O'},
 {'word': '衩', 'entity': 'O'},
 {'word': '都', 'entity': 'O'},
 {'word': '没', 'entity': 'O'},
 {'word': '了', 'entity': 'O'},
 {'word': '，', 'entity': 'O'},
 {'word': '我', 'entity': 'O'},
 {'word': '的', 'entity': 'O'},
 {'word': '手', 'entity': 'O'},
 {'word': '机', 'entity': 'O'},
 {'word': '号', 'entity': 'O'},
 {'word': '是', 'entity': 'O'},
 {'word': '135', 'entity': 'B-CARDINAL'},
 {'word': '##87', 'entity': 'I-CARDINAL'},
 {'word': '##67', 'entity': 'I-CARDINAL'},
 {'word': '##78', 'entity': 'I-CARDINAL'},
 {'word': '##88', 'entity': 'E-CARDINAL'},
 {'word': '[SEP]', 'entity': 'O'}]

实体识别

为了得到正常的NER识别结果，需要把token聚合成实体。朕用如下代码实现，仅供参考：

def allow_merge(a, b):
    a_flag, a_type = a.split('-')
    b_flag, b_type = b.split('-')
    if b_flag == 'B' or a_flag == 'E':
        return False
    if a_type != b_type:
        return False
    if (a_flag, b_flag) in [
        ("B", "I"),
        ("B", "E"),
        ("I", "I"),
        ("I", "E")
    ]:
        return True
    return False

def divide_entities(ner_results):
    divided_entities = []
    current_entity = []

    for item in sorted(ner_results, key=lambda x: x['index']):
        if not current_entity:
            current_entity.append(item)
        elif allow_merge(current_entity[-1]['entity'], item['entity']):
            current_entity.append(item)
        else:
            divided_entities.append(current_entity)
            current_entity = [item]
    divided_entities.append(current_entity)
    return divided_entities

def merge_entities(same_entities):
    def avg(scores):
        return sum(scores)/len(scores)
    return {
        'entity': same_entities[0]['entity'].split("-")[1],
        'score': avg([e['score'] for e in same_entities]),
        'word': ''.join(e['word'].replace('##', '') for e in same_entities),
        'start': same_entities[0]['start'],
        'end': same_entities[-1]['end']
    }

def post_process(ner_results):
    return [merge_entities(i) for i in divide_entities(ner_results)]

[{'entity': 'PERSON',
  'score': 0.9999974966049194,
  'word': '王大',
  'start': 2,
  'end': 4},
 {'entity': 'FAC',
  'score': 0.9986085146665573,
  'word': '旺角餐厅',
  'start': 8,
  'end': 12},
 {'entity': 'DATE',
  'score': 0.9999992251396179,
  'word': '今年',
  'start': 18,
  'end': 20},
 {'entity': 'PERSON',
  'score': 0.9999301433563232,
  'word': '阿里巴巴',
  'start': 22,
  'end': 26},
 {'entity': 'CARDINAL',
  'score': 0.9999899625778198,
  'word': '13587677888',
  'start': 48,
  'end': 59}]

参考：

  • https://huggingface.co/docs/transformers/tasks/token_classification
  • https://huggingface.co/google-bert/bert-base-chinese
  • https://hf-mirror.com/ckiplab/bert-base-chinese-ner
使用bert-base-chinese模型进行中文自然语言处理任务的部署与微调
WELL_CODER的博客
09-14 2383
使用bert-base-chinese模型进行中文自然语言处理任务的部署与微调自然语言处理（Natural Language Processing，简称NLP）是人工智能领域中的一个重要研究方向，涉及到对人类语言的理解和生成。近年来，基于深度学习的模型在NLP任务中取得了巨大的成功，其中BERT（Bidirectional Encoder Representations from Transformers）是一种非常流行的预训练语言模型。
Bert中文预训练模型（Bert-base-chinese）
ldk的博客
07-15 4442
该模型的主要作用是获取每个汉字的向量表示，后续通过微调可应用于各种简体和繁体中文任务。
深度学习速通系列:如何使用bert进行超长中文文本命名实体识别
Ven%的博客
10-29 734
要将超长中文文本按最大 BERT 输入长度进行分割，并使用 bert-chinese-ner 模型进行命名实体识别，可以遵循以下步骤。以下是一个 Python 代码示例，利用 Hugging Face 的 transformers 库来实现：安装必要的库代码示例。
BERT 模型是什么
一览无遗
01-08 1648
BERT（代表 Bidirectional Encoder Representations from Transformers）是 Google 于 2018 年开发的开源模型。这是一项雄心勃勃的实验，旨在测试所谓的 Transformers（一种创新的神经架构，由谷歌研究人员在 2017 年的著名论文《注意力是你所需要的一切》中提出）在自然语言 （NLP） 任务上的性能。BERT成功的关键在于其变压器架构。在 Transformer 出现之前，对自然语言进行建模是一项非常具有挑战性的任务。
自然语言处理基础
最新发布
m0_68837470的博客
02-28 544
又称独热编码，将每个词表示成具有n个元素的向量，这个词向量中只有一个元素是1，其他元素都是0，不同词汇元素为0的位置不同，其中n的大小是整个语料中不同词汇的总数.[pair('我', 'r'), pair('爱', 'v'), pair('大唐', 'nz'), pair('不夜城', 'i')]将文本表示成张量(矩阵)形式，能够使语言文本可以作为计算机处理程序的输入，进行接下来一系列的解析工作。tagger(['我'"的”，'希望''是''希望''和平'])["人生”，"该’，"如何"，"起头”]
基于Bert-base-chinese训练多分类文本模型(代码详解）
m0_58700887的博客
09-03 4180
BERT（Bidirectional Encoder Representations from Transformers）是基于深度学习在自然语言处理（NLP）领域近几年出现的、影响深远的创新模型之一。在BERT之前，已经有许多预训练语言模型，如ELMO和GPT，它们展示了预训练模型在NLP任务中的强大性能。然而，这些模型通常基于单向的上下文信息，即只考虑文本中的前向或后向信息，这限制了它们对文本的全局理解。BERT旨在通过引入双向上下文信息来解决这一问题，从而更准确地表示文本中的语义信息。
bert预训练模型
weixin_63512304的博客
09-29 222
models--bert-base-chinese` 通常指的是一个预训练好的 BERT（Bidirectional Encoder Representations from Transformers）模型，它是专门针对中文语料库进行训练的。- `bert-base`: 这表示模型的大小是基础的，即 "Base" 版本的 BERT 模型，它有 12 层（transformer block），768 个隐藏单元，以及 12 个自注意力头。- 命名实体识别（NER）
BERT-CRF 微调中文 NER 模型
颹蕭蕭
04-23 1212
pytorch BERT CRF NER
中文小样本NER模型方法总结和实战
zenRRan的博客
08-18 1359
作者：Erinlp（知乎同名）方向：信息抽取一、简介在UIE出来以前，小样本NER主要针对的是英文数据集，目前主流的小样本NER方法大多是基于prompt，在英文上效果好的方法，在中文上不一定适用，其主要原因可能是：中文长实体相对英文较多，英文是按word进行切割，很多实体就是一个词；边界相对来说更清晰；生成方法对于长实体来说更加困难。但是随着UIE的出现，中文小样本NER 的效果得到了突破。二、...
bert-chinese-ner：使用预训练语言模型BERT做中文NER
02-06
伯特·中国人 前言 使用预训练语言模型BERT做中文NER尝试，微调BERT模型 PS：移步最新模型 代码参考 使用方法 从下载bert源代码，存放在路径下bert文件夹中 从下载模型，放置在checkpoint文件夹下 使用BIO数据标注模式，使用人民日报经典数据 培养： python BERT_NER.py --data_dir=data/ --bert_config_file=checkpoint/bert_config.json --init_checkpoint=checkpoint/bert_model.ckpt --vocab_file=vocab.txt --output_d
BERT 微调中文 NER 模型
颹蕭蕭
04-16 724
BERT 微调 NER 模型
bert-base-chinese.rar
11-10
pytorch实现的中文bert预训练模型bert-base-chinese，可用于中文短文本分类，问答系统等各种NLP任务（网盘链接）
Python-使用预训练语言模型BERT做中文NER
08-10
使用预训练语言模型BERT做中文NER
人工智能-项目实践-预训练-使用预训练语言模型BERT做中文NER.zip
01-06
使用方法 从BERT-TF下载bert源代码，存放在路径下bert文件夹中 从BERT-Base Chinese下载模型，存放在checkpoint文件夹下 使用BIO数据标注模式，使用人民日报经典数据
bert-base-chinese模型文件，深度学习，自然语言处理
02-02
bert-base-chinese模型文件是基于深度学习的自然语言处理工具，它能够支持中文语言的理解和处理。该模型文件是Google推出的一系列语言模型中的中文版本，其基础模型为BERT（Bidirectional Encoder Representations ...
bert-base-chinese.zip
12-03
BERT-base-Chinese模型广泛应用于中文NLP的各种任务，如情感分析、命名实体识别（NER）、文本分类、问答系统、机器翻译等。由于其强大的语义理解能力，它通常能显著提高这些任务的性能。 4. **使用方式**： 在...
transformers 框架使用详解，bert-base-chinese
猛犸象
11-01 1377
transformers 框架使用详解，bert-base-chinese
bert-base-chinese中文分类模型使用流程
weixin_51196635的博客
01-02 1267
本文章详细描述实现了bert-base-chinese中文分类模型使用流程，包括jupyter环境配置和代码修改
帮我写一个bert-bilstm-crf-ner模型用于中文命名实体识别
05-27
好的，下面是bert-bilstm-crf-ner模型的代码实现（Python）： ```python import torch import torch.nn as nn from transformers import BertModel class BertBilstmCrfNer(nn.Module): def __init__(self, num_tags, hidden_dim=768, bert_model_name='bert-base-chinese'): super(BertBilstmCrfNer, self).__init__() self.bert = BertModel.from_pretrained(bert_model_name) self.dropout = nn.Dropout(0.5) self.bilstm = nn.LSTM(hidden_dim, hidden_dim // 2, num_layers=2, bidirectional=True, batch_first=True) self.fc = nn.Linear(hidden_dim, num_tags) self.crf = nn.CRF(num_tags, batch_first=True) def forward(self, input_ids, attention_mask, labels=None): bert_output = self.bert(input_ids=input_ids, attention_mask=attention_mask)[0] bert_output = self.dropout(bert_output) lstm_output, _ = self.bilstm(bert_output) logits = self.fc(lstm_output) if labels is not None: loss = -self.crf(logits, labels, mask=attention_mask.byte(), reduction='mean') return loss else: pred_labels = self.crf.decode(logits, mask=attention_mask.byte()) return pred_labels ``` 该模型使用了BERT作为预训练模型，使用了BiLSTM作为特征提取器，并使用CRF作为序列标注器。在模型中，我们首先使用BERT模型对输入进行编码，然后通过BiLSTM提取特征，最后通过全连接层将提取的特征映射到标签空间。在训练时，我们使用CRF计算损失，并通过反向传播更新模型参数。在推理时，我们使用CRF进行解码，得到最终的标签序列。 模型的输入是一个batch的文本序列，每个文本序列已经使用BERT进行编码，因此输入是一个二维张量，形状为(batch_size, sequence_length, hidden_dim)。另外，我们还需要提供一个attention_mask张量，用于指示输入中的实际文本序列部分。标签序列是一个二维张量，形状为(batch_size, sequence_length)，每个元素代表一个标签。在训练时，我们需要提供标签序列，用于计算损失；在推理时，我们不需要提供标签序列，而是通过CRF进行解码，得到最终的标签序列。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

颹蕭蕭

白嫖？

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值