数据预处理 Preprocessing data
在transformers中，数据处理的主要工具是文本标记器tokenizer。我们可以使用模型对应的文本标记器类型，也可以直接使用AutoTokenizer自动分类。
文本标记器首先会把文本分割成单词、标点符号等，这些被分割的元素叫作token。然后将token转化为数字，使之能被转化为训练用的张量tensor。除此之外，一些特定的文本标记器还会加上一些模型需要的特殊标记，如BERT中的CLS、SEP。
注意：
如果你要使用预训练模型，你就需要使用该模型对应的文本标记器。因为对应文本标记器转化文本的方式与其模型训练时的方式一致，对应的词汇表也一致。如果文本标记器不对，会对模型预测或微调造成巨大的影响。比如，原来“我”这个词的索引是1，另一个文本标记器中“我”的索引是100，这就导致了模型接收到的数据跟你想的完全不一样。
若要自动下载模型训练或微调时使用的文本标记器，可以使用from_pretrained()方法：
from transformers import AutoTokenizer
tokenizer = AutoTokenizer.from_pretrained('bert-base-cased')
基本用法
预处理
transformers中的文本标记器有很多方法，但进行预处理的方法只有一个，即__call__：你只需要将文本直接送入文本标记器对象。如下：
encoded_input = tokenizer("Hello, I'm a single sentence!")
print(encoded_input)
输出：
{'input_ids': [101, 8667, 117, 146, 112, 182, 170, 1423, 5650, 106, 102],
'token_type_ids': [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
'attention_mask': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]}
此方法会返回一个字典。input_ids是输入文本中每个token的索引。之后会讲到attention_mask和token_type_ids的用途。
解码
除了编码文本，文本标记器也可以对索引进行解码：
print(tokenizer.decode(encoded_input["input_ids"]))
输出：
[CLS] Hello, I'm a single sentence! [SEP]
我们可以看到，文本标记器在预处理时已经自动加上了BERT所需的特殊标记。
并不是所有模型都需要特殊标记，如过我们使用gtp2-medium而不是bert-base-cased，我们在解码时可以得到与原文本一样的结果。
在解码时，我们也可以在方法中加入参数add_special_tokens=False来去掉特殊的标记（有些版本是skip_special_tokens=True）。
多数据
如果你想一次处理多个文本，你可以将它们整合到数组中，一次性出入文本标记器，如下：
batch_sentences = ["Hello I'm a single sentence",
"And another sentence",
"And the very very last one"]
encoded_inputs = tokenizer(batch_sentences)
print(encoded_inputs)
输出：
{'input_ids': [[101, 8667, 146, 112, 182, 170, 1423, 5650, 102],
[101, 1262, 1330, 5650, 102],
[101, 1262, 1103, 1304, 1304, 1314, 1141, 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]],
'attention_mask': [[1, 1, 1, 1, 1, 1, 1, 1, 1],
[1, 1, 1, 1, 1],
[1, 1, 1, 1, 1, 1, 1, 1]]}
填充、截断、返回特定类型
当一次性处理多条语句时，我们可能还会有如下要求：
- 将每个句子填充到批处理的最大长度
- 将每个句子截断到模型可以接收的最大长度
- 返回
tensor类型数据
你可以使用如下操作实现所有要求：
batch = tokenizer(batch_sentences, max_length=7, padding=True, truncation=True, return_tensors="pt", )
print(batch)
结果：
{'input_ids': tensor([
[ 101, 8667, 146, 112, 182, 170, 102],
[ 101, 1262, 1330, 5650, 102, 0, 0],
[ 101, 1262, 1103, 1304, 1304, 1314, 102]]),
'token_type_ids': tensor([
[0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0]]),
'attention_mask': tensor([
[1, 1, 1, 1, 1, 1, 1],
[1, 1, 1, 1, 1, 0, 0],
[1, 1, 1, 1, 1, 1, 1]])}
这次返回了一个字符串到pytorch.tensor类型的字典。我们现在可以根据返回结果看出attention_mask的用途了：它会告诉模型哪些token需要被注意，哪些不要管，因为一些是填充来的无意义token。
需要注意的是，如果使用的模型并没有与之相关的最大长度，则上面的代码在执行时会发出警告。这是没有问题的，可以直接无视，也可以加入参数verbose=False来阻止文本标记器抛出这些异常。
处理句子对
有时可能需要将一对句子送入模型。比如，我们需要判断两个句子是否相似；或我们在使用问答模型，需要将文本和问题送入模型。对于BERT模型，句子对需要转化为如下形式：[CLS] Sequence A [SEP] Sequence B [SEP]
在使用Transformers处理句子对时，我们需要将两个句子以不同的变量传入文本标记器中（注意，并不是像之前那样整合成列表，而是两个分开的变量）。然后我们会得到一个对应的字典，如下例：
encoded_input = tokenizer("How old are you?", "I'm 6 years old")
print(encoded_input)
print(tokenizer.decode(encoded_input["input_ids"]))
for i in encoded_input["input_ids"]:
print(tokenizer.decode(i))
结果：
{'input_ids': [101, 1731, 1385, 1132, 1128, 136, 102, 146, 112, 182, 127, 1201, 1385, 102], 'token_type_ids': [0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1], 'attention_mask': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]}
[CLS] How old are you? [SEP] I'm 6 years old [SEP]
[ C L S ]
H o w
o l d
a r e
y o u
?
[ S E P ]
I
'
m
6
y e a r s
o l d
[ S E P ]
从结果我们可以看出token_type_ids的作用：它们告诉模型输入的那个部分属于第一个句子，那个部分属于第二个句子。需要注意的是，并不是所有模型都需要token_tyoe_ids。默认情况下，文本标记器只会返回与模型相关的期望输入。你可以传入一些如return_token_type_ids或return_length的参数来改变文本标记器的输出。
encoded_input = tokenizer("How old are you?", "I'm 6 years old",
return_token_type_ids=False,
return_length=True,
)
print(encoded_input)
输出：
{'input_ids': [101, 1731, 1385, 1132, 1128, 136, 102, 146, 112, 182, 127, 1201, 1385, 102], 'attention_mask': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'length': 14}
同样，如果你向一次性处理多条语句，你可以分别传入两个文本列表。如下：
batch_sentences = ["Hello I'm a single sentence",
"And another sentence",
"And the very very last one"]
batch_of_second_sentences = ["I'm a sentence that goes with the first sentence",
"And I should be encoded with the second sentence",
"And I go with the very last one"]
encoded_inputs = tokenizer(batch_sentences, batch_of_second_sentences)
print(encoded_inputs)
结果：
{'input_ids': [[101, 8667, 146, 112, 182, 170, 1423, 5650, 102, 146, 112, 182, 170, 5650, 1115, 2947, 1114, 1103, 1148, 5650, 102],
[101, 1262, 1330, 5650, 102, 1262, 146, 1431, 1129, 12544, 1114, 1103, 1248, 5650, 102],
[101, 1262, 1103, 1304, 1304, 1314, 1141, 102, 1262, 146, 1301, 1114, 1103, 1304, 1314, 1141, 102]],
'token_type_ids': [[0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
[0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
[0, 0, 0, 0, 0, 0, 0, 0, 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]]}
我们可以通过循环解码input_ids列表来检查我们的输入，如下：
for ids in encoded_inputs["input_ids"]:
print(tokenizer.decode(ids))
结果：
[CLS] Hello I'm a single sentence [SEP] I'm a sentence that goes with the first sentence [SEP]
[CLS] And another sentence [SEP] And I should be encoded with the second sentence [SEP]
[CLS] And the very very last one [SEP] And I go with the very last one [SEP]
并且你仍然可以在编码时输入一些参数来填充或截取文本，或将其转化为特定类型，如下：
batch = tokenizer(batch_sentences, batch_of_second_sentences, padding=True, truncation=True, return_tensors="pt")
一些关于填充和截断的东西
在上面已经介绍了大部分情况下适用的指令。但Transformers也提供了更多的方法，这些方法围绕三个参数padding、truncation、max_length展开。
padding用来控制填充。它可以是布尔类型也可以是字符串类型，如下：
True或”longest”来将所有句子填充至序列列表中的最大长度，如果你只提供一个句子则什么也不做。“max_length”用来将序列填充到参数max_length的长度，若没有提供max_length参数（max_length=None），则填充到模型能接受的最大长度。并且在你只提供了一个句子的时候也会起作用。False或”do_not_pad”来设置为不填充。且这是参数的默认值。
truncation用来控制截断。可以是布尔型或者字符串。
True或“only_first”来讲句子截断到max_length参数长度，若未提供max_length参数（max_length=None），则将句子截取到模型可以接受的最大长度。如果提供的数据为句子对或一批句子对，那么只会对第一个句子进行截断。“only_sceond”将句子截断到max_length参数长度，若未提供max_length参数（max_length=None），则截取到模型可以接受的最大长度。当输入数据为句子对时，只会截断第二条数据。False或”do_not_truncate”表示不对句子进行截取。且这是参数的默认值。
max_length用来控制填充或截断的长度。可以是整数或None，默认值是模型可以接受的最大程度。如果模型没有特定的最大输入长度，则会被截断或填充到max_length。
一些用法总结
如果在下面例子中，输入的是句子对，你可以将**truncation=True替换为STRATEGY，选择如下：['only_first', 'only_second', 'longest_first']**。
- 不截断
- 不填充：
**tokenizer(batch_sentences)** - 填充至当前批次的最大长度：
**tokenizer(batch_sentences, padding=True)**或 **tokenizer(batch_sentences, padding=’longest’)** - 填充到模型可接受的最大长度：
**tokenizer(batch_sentences, padding='max_length')** - 填充到一个特定长度：
**tokenizer(batch_sentences, padding='max_length', max_length=42)**
- 截断到模型输入的最大长度
- 不填充：
tokenizer(batch_sentences, truncation=True) 或**tokenizer(batch_sentences, padding=True, truncation=STRATEGY)** - 填充到当前批次的最大长度：
tokenizer(batch_sentences, padding=True, truncation=True)或tokenizer(batch_sentences, padding=True, truncation=STRATEGY) - 填充到模型可接受的最大长度：
tokenizer(batch_sentences, padding='max_length', truncation=True)或tokenizer(batch_sentences, padding='max_length', truncation=STRATEGY) - 填充到特定长度：做不到，因为加了
max_length参数就无法填充截断到最大输入了。
- 截断到特定长度
- 不填充：
tokenizer(batch_sentences, truncation=True, max_length=42)
或 tokenizer(batch_sentences, truncation=STRATEGY, max_length=42) - 填充到当前批次最大长度：
tokenizer(batch_sentences, padding=True, truncation=True, max_length=42)
或 tokenizer(batch_sentences, padding=True, truncation=STRATEGY, max_length=42) - 填充到模型可接受的最大长度：做不到
- 填充到特定长度：
tokenizer(batch_sentences, padding='max_length', truncation=True, max_length=42)
或 tokenizer(batch_sentences, padding='max_length', truncation=STRATEGY, max_length=42)
预标记输入
标记器也可以接受预标记输入。这在命名实体识别（Named Entity Recognition）和词性标注（Part-Of-Speech Tagging）任务中很重要。
需要注意的是：预标记输入并不是以及索引化的输入，只是将单词进行分割，
若想使用预标记输入，只需将参数设置为is_split_into_words=True即可。例子如下：
encoded_input = tokenizer(["Hello", "I'm", "a", "single", "sentence"], is_split_into_words=True)
print(encoded_input)
结果：
{'input_ids': [101, 8667, 146, 112, 182, 170, 1423, 5650, 102],
'token_type_ids': [0, 0, 0, 0, 0, 0, 0, 0, 0],
'attention_mask': [1, 1, 1, 1, 1, 1, 1, 1, 1]}
注意：预标记输入也会添加模型相关的特殊标记，除非将属性参数为add_special_tokens=False。
输入多个句子
预标记输入多个句子与之前的形式完全一样，你可以想下面这样编码多个句子：
batch_sentences = [["Hello", "I'm", "a", "single", "sentence"],
["And", "another", "sentence"],
["And", "the", "very", "very", "last", "one"]]
encoded_inputs = tokenizer(batch_sentences, is_split_into_words=True)
输入句子对
也可以像这样输入句子对：
batch_of_second_sentences = [["I'm", "a", "sentence", "that", "goes", "with", "the", "first", "sentence"],
["And", "I", "should", "be", "encoded", "with", "the", "second", "sentence"],
["And", "I", "go", "with", "the", "very", "last", "one"]]
encoded_inputs = tokenizer(batch_sentences, batch_of_second_sentences, is_split_into_words=True)
填充和截断
也可以像之前一样填充和截断：
batch = tokenizer(batch_sentences,
batch_of_second_sentences,
is_split_into_words=True,
padding=True,
truncation=True,
return_tensors="pt")
|