Classificação de tokens
A classificação de tokens atribui um rótulo a tokens individuais em uma frase. Uma das tarefas de classificação de tokens mais comuns é o Reconhecimento de Entidade Nomeada, também chamada de NER (sigla em inglês para Named Entity Recognition). O NER tenta encontrar um rótulo para cada entidade em uma frase, como uma pessoa, local ou organização.
Este guia mostrará como realizar o fine-tuning do DistilBERT no conjunto de dados WNUT 17 para detectar novas entidades.
Consulte a página de tarefas de classificação de tokens para obter mais informações sobre outras formas de classificação de tokens e seus modelos, conjuntos de dados e métricas associadas.
Carregando o conjunto de dados WNUT 17
Carregue o conjunto de dados WNUT 17 da biblioteca 🤗 Datasets:
>>> from datasets import load_dataset
>>> wnut = load_dataset("wnut_17")
E dê uma olhada em um exemplo:
>>> 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', '.']
}
Cada número em ner_tags
representa uma entidade. Converta o número em um rótulo para obter mais informações:
>>> 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",
]
O ner_tag
descreve uma entidade, como uma organização, local ou pessoa. A letra que prefixa cada ner_tag
indica a posição do token da entidade:
B-
indica o início de uma entidade.I-
indica que um token está contido dentro da mesma entidade (por exemplo, o tokenState
pode fazer parte de uma entidade comoEmpire State Building
).0
indica que o token não corresponde a nenhuma entidade.
Pré-processamento
Carregue o tokenizer do DistilBERT para processar os tokens
:
>>> from transformers import AutoTokenizer
>>> tokenizer = AutoTokenizer.from_pretrained("distilbert-base-uncased")
Como a entrada já foi dividida em palavras, defina is_split_into_words=True
para tokenizar as palavras em subpalavras:
>>> 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]']
Ao adicionar os tokens especiais [CLS]
e [SEP]
e a tokenização de subpalavras uma incompatibilidade é gerada entre a entrada e os rótulos. Uma única palavra correspondente a um único rótulo pode ser dividida em duas subpalavras. Você precisará realinhar os tokens e os rótulos da seguinte forma:
- Mapeie todos os tokens para a palavra correspondente com o método
word_ids
. - Atribuindo o rótulo
-100
aos tokens especiais[CLS]
e[SEP]
para que a função de loss do PyTorch ignore eles. - Rotular apenas o primeiro token de uma determinada palavra. Atribuindo
-100
a outros subtokens da mesma palavra.
Aqui está como você pode criar uma função para realinhar os tokens e rótulos e truncar sequências para não serem maiores que o comprimento máximo de entrada do 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) # Map tokens to their respective word.
... previous_word_idx = None
... label_ids = []
... for word_idx in word_ids: # Set the special tokens to -100.
... if word_idx is None:
... label_ids.append(-100)
... elif word_idx != previous_word_idx: # Only label the first token of a given word.
... 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
Use a função map
do 🤗 Datasets para tokenizar e alinhar os rótulos em todo o conjunto de dados. Você pode acelerar a função map
configurando batched=True
para processar vários elementos do conjunto de dados de uma só vez:
>>> tokenized_wnut = wnut.map(tokenize_and_align_labels, batched=True)
Use o DataCollatorForTokenClassification
para criar um batch de exemplos. Ele também preencherá dinamicamente seu texto e rótulos para o comprimento do elemento mais longo em seu batch, para que tenham um comprimento uniforme. Embora seja possível preencher seu texto na função tokenizer
configurando padding=True
, o preenchimento dinâmico é mais eficiente.
>>> from transformers import DataCollatorForTokenClassification
>>> data_collator = DataCollatorForTokenClassification(tokenizer=tokenizer)
>>> from transformers import DataCollatorForTokenClassification
>>> data_collator = DataCollatorForTokenClassification(tokenizer=tokenizer, return_tensors="tf")
Treinamento
Carregue o DistilBERT com o AutoModelForTokenClassification
junto com o número de rótulos esperados:
>>> from transformers import AutoModelForTokenClassification, TrainingArguments, Trainer
>>> model = AutoModelForTokenClassification.from_pretrained("distilbert-base-uncased", num_labels=14)
Se você não estiver familiarizado com o fine-tuning de um modelo com o Trainer
, dê uma olhada no tutorial básico aqui!
Nesse ponto, restam apenas três passos:
- Definir seus hiperparâmetros de treinamento em
TrainingArguments
. - Passar os argumentos de treinamento para o
Trainer
junto com o modelo, conjunto de dados, tokenizador e o data collator. - Chamar a função
train()
para executar o fine-tuning do seu modelo.
>>> training_args = TrainingArguments(
... output_dir="./results",
... evaluation_strategy="epoch",
... learning_rate=2e-5,
... per_device_train_batch_size=16,
... per_device_eval_batch_size=16,
... num_train_epochs=3,
... weight_decay=0.01,
... )
>>> trainer = Trainer(
... model=model,
... args=training_args,
... train_dataset=tokenized_wnut["train"],
... eval_dataset=tokenized_wnut["test"],
... tokenizer=tokenizer,
... data_collator=data_collator,
... )
>>> trainer.train()
Para executar o fine-tuning de um modelo no TensorFlow, comece convertendo seu conjunto de dados para o formato tf.data.Dataset
com to_tf_dataset
. Nessa execução você deverá especificar as entradas e rótulos (no parâmetro columns
), se deseja embaralhar o conjunto de dados, o tamanho do batch e o data collator:
>>> tf_train_set = tokenized_wnut["train"].to_tf_dataset(
... columns=["attention_mask", "input_ids", "labels"],
... shuffle=True,
... batch_size=16,
... collate_fn=data_collator,
... )
>>> tf_validation_set = tokenized_wnut["validation"].to_tf_dataset(
... columns=["attention_mask", "input_ids", "labels"],
... shuffle=False,
... batch_size=16,
... collate_fn=data_collator,
... )
Se você não estiver familiarizado com o fine-tuning de um modelo com o Keras, dê uma olhada no tutorial básico aqui!
Configure o otimizador e alguns hiperparâmetros de treinamento:
>>> 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,
... )
Carregue o DistilBERT com o TFAutoModelForTokenClassification
junto com o número de rótulos esperados:
>>> from transformers import TFAutoModelForTokenClassification
>>> model = TFAutoModelForTokenClassification.from_pretrained("distilbert-base-uncased", num_labels=2)
Configure o modelo para treinamento com o método compile
:
>>> import tensorflow as tf
>>> model.compile(optimizer=optimizer)
Chame o método fit
para executar o fine-tuning do modelo:
>>> model.fit(x=tf_train_set, validation_data=tf_validation_set, epochs=3)
Para obter um exemplo mais aprofundado de como executar o fine-tuning de um modelo para classificação de tokens, dê uma olhada nesse notebook utilizando PyTorch ou nesse notebook utilizando TensorFlow.