Token 分类为句子中的每个标记分配一个标签。最常见的 Token 分类任务之一是命名实体识别(NER)。NER 试图为句子中的每个实体找到一个标签(如人物、地点或组织)。
本指南将向您展示如何:
ALBERT, BERT, BigBird, BioGpt, BLOOM, CamemBERT, CANINE, ConvBERT, Data2VecText, DeBERTa, DeBERTa-v2, DistilBERT, ELECTRA, ERNIE, ErnieM, ESM, Falcon, FlauBERT, FNet, Funnel Transformer, GPT-Sw3, OpenAI GPT-2, GPTBigCode, GPT Neo, GPT NeoX, I-BERT, LayoutLM, LayoutLMv2, LayoutLMv3, LiLT, Longformer, LUKE, MarkupLM, MEGA, Megatron-BERT, MobileBERT, MPNet, MRA, Nezha, Nyströmformer, QDQBert, RemBERT, RoBERTa, RoBERTa-PreLayerNorm, RoCBert, RoFormer, SqueezeBERT, XLM, XLM-RoBERTa, XLM-RoBERTa-XL, XLNet, X-MOD, YOSO
在开始之前,请确保您已安装所有必要的库:
pip install transformers datasets evaluate seqeval
我们鼓励您登录您的 Hugging Face 帐户,这样您就可以上传和与社区共享您的模型。当提示时,输入您的账户信息进行登录:
>>> from huggingface_hub import notebook_login
>>> notebook_login()
首先从 🤗 Datasets 库中加载 WNUT 17 数据集:
>>> from datasets import load_dataset
>>> wnut = load_dataset("wnut_17")
然后查看数据集里面的一个样例:
>>> wnut["train"][0]
{'id': '0',
'ner_tags': [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 8, 8, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0],
'tokens': ['@paulwalk', 'It', "'s", 'the', 'view', 'from', 'where', 'I', "'m", 'living', 'for', 'two', 'weeks', '.', 'Empire', 'State', 'Building', '=', 'ESB', '.', 'Pretty', 'bad', 'storm', 'here', 'last', 'evening', '.']
}
ner_tags
中的每个数字表示一个实体。通过将数字转换为其标签名称,可以了解实体是什么:
>>> label_list = wnut["train"].features[f"ner_tags"].feature.names
>>> label_list
[
"O",
"B-corporation",
"I-corporation",
"B-creative-work",
"I-creative-work",
"B-group",
"I-group",
"B-location",
"I-location",
"B-person",
"I-person",
"B-product",
"I-product",
]
ner_tag
前缀的字母表示实体的标记位置:
B-
表示实体的开头。I-
表示标记包含在同一实体中(例如,“State” 标记是像“Empire State Building” 这样的实体的一部分)。0
表示该标记不对应任何实体。下一步是加载 DistilBERT 分词器以预处理 tokens
字段:
>>> from transformers import AutoTokenizer
>>> tokenizer = AutoTokenizer.from_pretrained("distilbert-base-uncased")
如上例所示,tokens
字段看起来像已经被分词了的输入。但实际上,输入还没有被分词,您需要将 is_split_into_words=True
设置为将单词分词为子词。例如:
>>> example = wnut["train"][0]
>>> tokenized_input = tokenizer(example["tokens"], is_split_into_words=True)
>>> tokens = tokenizer.convert_ids_to_tokens(tokenized_input["input_ids"])
>>> tokens
['[CLS]', '@', 'paul', '##walk', 'it', "'", 's', 'the', 'view', 'from', 'where', 'i', "'", 'm', 'living', 'for', 'two', 'weeks', '.', 'empire', 'state', 'building', '=', 'es', '##b', '.', 'pretty', 'bad', 'storm', 'here', 'last', 'evening', '.', '[SEP]']
然而,这会添加一些特殊的标记 [CLS]
和 [SEP]
,子词分词会导致输入与标签之间不匹配。一个对应单个标签的单词现在可能被分为两个子词。您需要通过以下方式重新对齐标记和标签:
word_ids
方法将所有标记映射到其对应的单词。[CLS]
和 [SEP]
的标签设置为 -100
,以便它们在 PyTorch 损失函数中被忽略(参见 CrossEntropyLoss )。-100
。下面是如何创建一个函数来对齐标记和标签,并截断序列以不超过 DistilBERT 的最大输入长度:
>>> def tokenize_and_align_labels(examples):
... tokenized_inputs = tokenizer(examples["tokens"], truncation=True, is_split_into_words=True)
... labels = []
... for i, label in enumerate(examples[f"ner_tags"]):
... word_ids = tokenized_inputs.word_ids(batch_index=i) # 将标记映射到它们相应的单词。
... previous_word_idx = None
... label_ids = []
... for word_idx in word_ids: # 将特殊 token 的标签设置为 -100。
... if word_idx is None:
... label_ids.append(-100)
... elif word_idx != previous_word_idx: # 仅为给定词的第一个标记分配标签。
... label_ids.append(label[word_idx])
... else:
... label_ids.append(-100)
... previous_word_idx = word_idx
... labels.append(label_ids)
... tokenized_inputs["labels"] = labels
... return tokenized_inputs
要在整个数据集上应用预处理函数,使用 🤗 Datasets 的 map
函数。通过将 batched=True
设置为一次处理数据集的多个元素,你可以加快 map
函数的速度:
>>> tokenized_wnut = wnut.map(tokenize_and_align_labels, batched=True)
接下来,使用 DataCollatorWithPadding
创建一个示例批次。在整理过程中,将句子动态填充到批次中最长的长度,而不是填充整个数据集。
>>> from transformers import DataCollatorForTokenClassification
>>> data_collator = DataCollatorForTokenClassification(tokenizer=tokenizer)
>>> from transformers import DataCollatorForTokenClassification
>>> data_collator = DataCollatorForTokenClassification(tokenizer=tokenizer, return_tensors="tf")
在训练过程中包含一个评估指标通常有助于评估模型的表现。你可以使用 🤗 Evaluate 库来快速加载一个评估方法。在这个任务中,加载 seqeval 框架 (查看🤗Evaluate quick tour 了解如何加载和计算指标的更多信息)。Seqeval实际上生成了几个分数:准确率、召回率、F1值和准确度。
>>> import evaluate
>>> seqeval = evaluate.load("seqeval")
首先获取NER标签,然后创建一个函数,将您的真实预测和真实标签传递给 compute
来计算分数:
>>> import numpy as np
>>> labels = [label_list[i] for i in example[f"ner_tags"]]
>>> def compute_metrics(p):
... predictions, labels = p
... predictions = np.argmax(predictions, axis=2)
... true_predictions = [
... [label_list[p] for (p, l) in zip(prediction, label) if l != -100]
... for prediction, label in zip(predictions, labels)
... ]
... true_labels = [
... [label_list[l] for (p, l) in zip(prediction, label) if l != -100]
... for prediction, label in zip(predictions, labels)
... ]
... results = seqeval.compute(predictions=true_predictions, references=true_labels)
... return {
... "precision": results["overall_precision"],
... "recall": results["overall_recall"],
... "f1": results["overall_f1"],
... "accuracy": results["overall_accuracy"],
... }
现在,您的compute_metrics
函数已经准备就绪,在设置训练参数时将用到它。
在开始训练模型之前,使用id2label
和label2id
为预期的标识符创建一个标签映射的映射表:
>>> id2label = {
... 0: "O",
... 1: "B-corporation",
... 2: "I-corporation",
... 3: "B-creative-work",
... 4: "I-creative-work",
... 5: "B-group",
... 6: "I-group",
... 7: "B-location",
... 8: "I-location",
... 9: "B-person",
... 10: "I-person",
... 11: "B-product",
... 12: "I-product",
... }
>>> label2id = {
... "O": 0,
... "B-corporation": 1,
... "I-corporation": 2,
... "B-creative-work": 3,
... "I-creative-work": 4,
... "B-group": 5,
... "I-group": 6,
... "B-location": 7,
... "I-location": 8,
... "B-person": 9,
... "I-person": 10,
... "B-product": 11,
... "I-product": 12,
... }
如果您不熟悉使用 Trainer
进行微调模型,请查看这里的 基础教程 !
现在您可以开始训练模型了!使用 AutoModelForTokenClassification
加载DistilBERT模型,同时提供预期标签数和标签映射:
>>> from transformers import AutoModelForTokenClassification, TrainingArguments, Trainer
>>> model = AutoModelForTokenClassification.from_pretrained(
... "distilbert-base-uncased", num_labels=13, id2label=id2label, label2id=label2id
... )
目前为止,只剩下三个步骤:
TrainingArguments
定义训练超参数。唯一必需的参数是output_dir
,用于指定保存模型的位置。您可以通过设置push_to_hub=True
将该模型推送到Hub(您需要登录Hugging Face才能上传模型)。在每个epoch结束时,Trainer
会评估 seqeval 分数并保存训练的检查点。compute_metrics
函数传递给Trainer
。train()
来微调您的模型。>>> training_args = TrainingArguments(
... output_dir="my_awesome_wnut_model",
... learning_rate=2e-5,
... per_device_train_batch_size=16,
... per_device_eval_batch_size=16,
... num_train_epochs=2,
... weight_decay=0.01,
... evaluation_strategy="epoch",
... save_strategy="epoch",
... load_best_model_at_end=True,
... push_to_hub=True,
... )
>>> trainer = Trainer(
... model=model,
... args=training_args,
... train_dataset=tokenized_wnut["train"],
... eval_dataset=tokenized_wnut["test"],
... tokenizer=tokenizer,
... data_collator=data_collator,
... compute_metrics=compute_metrics,
... )
>>> trainer.train()
训练完成后,使用push_to_hub()
方法将模型共享到Hub,以便每个人都可以使用您的模型:
>>> trainer.push_to_hub()
如果您不熟悉使用Keras进行微调模型,请查看这里的 基础教程 !
要在 TensorFlow 中微调模型,请首先设置优化器函数、学习率和一些训练超参数:
>>> from transformers import create_optimizer
>>> batch_size = 16
>>> num_train_epochs = 3
>>> num_train_steps = (len(tokenized_wnut["train"]) // batch_size) * num_train_epochs
>>> optimizer, lr_schedule = create_optimizer(
... init_lr=2e-5,
... num_train_steps=num_train_steps,
... weight_decay_rate=0.01,
... num_warmup_steps=0,
... )
然后使用 TFAutoModelForTokenClassification
加载 DistilBERT 模型,同时提供预期标签数和标签映射:
>>> from transformers import TFAutoModelForTokenClassification
>>> model = TFAutoModelForTokenClassification.from_pretrained(
... "distilbert-base-uncased", num_labels=13, id2label=id2label, label2id=label2id
... )
使用 prepare_tf_dataset()
将您的数据集转换为 tf.data.Dataset
格式:
>>> tf_train_set = model.prepare_tf_dataset(
... tokenized_wnut["train"],
... shuffle=True,
... batch_size=16,
... collate_fn=data_collator,
... )
>>> tf_validation_set = model.prepare_tf_dataset(
... tokenized_wnut["validation"],
... shuffle=False,
... batch_size=16,
... collate_fn=data_collator,
... )
使用 compile
配置您的模型进行训练。请注意,Transformer模型都有默认的任务相关损失函数,所以您不需要指定损失函数,除非您想自定义:
>>> import tensorflow as tf
>>> model.compile(optimizer=optimizer) # 不需要损失参数!
在您开始训练之前,最后两个设置是从预测中计算seqeval分数,并提供一种将模型上传到Hub的方式。这两个都可以通过使用 Keras callbacks 来完成。
将 compute_metrics
函数传递给 KerasMetricCallback
:
>>> from transformers.keras_callbacks import KerasMetricCallback
>>> metric_callback = KerasMetricCallback(metric_fn=compute_metrics, eval_dataset=tf_validation_set)
使用 PushToHubCallback
指定要将模型和分词器推送到的位置:
>>> from transformers.keras_callbacks import PushToHubCallback
>>> push_to_hub_callback = PushToHubCallback(
... output_dir="my_awesome_wnut_model",
... tokenizer=tokenizer,
... )
然后将您的回调函数组合在一起:
>>> callbacks = [metric_callback, push_to_hub_callback]
最后,您准备好开始微调模型了!使用训练和验证数据集、训练的epochs数量以及回调函数来调用 fit
以微调模型:
>>> model.fit(x=tf_train_set, validation_data=tf_validation_set, epochs=3, callbacks=callbacks)
训练完成后,您的模型将自动上传到Hub,这样每个人都可以使用它!
为了进行标记分类的模型微调的更加深入的例子,请参考相应的 PyTorch笔记本 或 TensorFlow笔记本 。
太棒了,现在您已经对模型进行了微调,可以用它进行推理了!
选择一些您想要进行推理的文本:
>>> text = "The Golden State Warriors are an American professional basketball team based in San Francisco."
尝试使用微调后的模型进行推理的最简单方法是在pipeline()
中使用它。通过实例化NER的pipeline
,选择您的模型,并将文本传递给它:
>>> from transformers import pipeline
>>> classifier = pipeline("ner", model="stevhliu/my_awesome_wnut_model")
>>> classifier(text)
[{'entity': 'B-location',
'score': 0.42658573,
'index': 2,
'word': 'golden',
'start': 4,
'end': 10},
{'entity': 'I-location',
'score': 0.35856336,
'index': 3,
'word': 'state',
'start': 11,
'end': 16},
{'entity': 'B-group',
'score': 0.3064001,
'index': 4,
'word': 'warriors',
'start': 17,
'end': 25},
{'entity': 'B-location',
'score': 0.65523505,
'index': 13,
'word': 'san',
'start': 80,
'end': 83},
{'entity': 'B-location',
'score': 0.4668663,
'index': 14,
'word': 'francisco',
'start': 84,
'end': 93}]
您也可以自己手动实现 pipeline
并得到一致的结果:
将文本标记化并返回PyTorch张量:
>>> from transformers import AutoTokenizer
>>> tokenizer = AutoTokenizer.from_pretrained("stevhliu/my_awesome_wnut_model")
>>> inputs = tokenizer(text, return_tensors="pt")
将输入传递给模型并返回logits
:
>>> from transformers import AutoModelForTokenClassification
>>> model = AutoModelForTokenClassification.from_pretrained("stevhliu/my_awesome_wnut_model")
>>> with torch.no_grad():
... logits = model(**inputs).logits
获取具有最高概率的类别,并使用模型的id2label
映射将其转换为文本标签:
>>> predictions = torch.argmax(logits, dim=2)
>>> predicted_token_class = [model.config.id2label[t.item()] for t in predictions[0]]
>>> predicted_token_class
['O',
'O',
'B-location',
'I-location',
'B-group',
'O',
'O',
'O',
'O',
'O',
'O',
'O',
'O',
'B-location',
'B-location',
'O',
'O']
对文本进行 tokenize 并返回 TensorFlow 张量:
>>> from transformers import AutoTokenizer
>>> tokenizer = AutoTokenizer.from_pretrained("stevhliu/my_awesome_wnut_model")
>>> inputs = tokenizer(text, return_tensors="tf")
将输入传递给模型并返回logits
:
>>> from transformers import TFAutoModelForTokenClassification
>>> model = TFAutoModelForTokenClassification.from_pretrained("stevhliu/my_awesome_wnut_model")
>>> logits = model(**inputs).logits
获取具有最高概率的类别,并使用模型的id2label
映射将其转换为文本标签:
>>> predicted_token_class_ids = tf.math.argmax(logits, axis=-1)
>>> predicted_token_class = [model.config.id2label[t] for t in predicted_token_class_ids[0].numpy().tolist()]
>>> predicted_token_class
['O',
'O',
'B-location',
'I-location',
'B-group',
'O',
'O',
'O',
'O',
'O',
'O',
'O',
'O',
'B-location',
'B-location',
'O',
'O']