transformers库使用--tokenizer

在我使用transformers进行预训练模型学习及微调的时候，需要先对数据进行预处理，然后经过处理过的数据才能送进bert模型里，这个过程中使用的主要的工具就是tokenizer。通过与相关预训练模型相关的tokenizer类建立tokenizer，例如，对于Roberta，我们可以使用与之相关的RobertaTokenizer,或者直接通过AutoTokenizer类，这个类能自动的识别所建立的tokenizer是与哪个bert模型相对应。通过tokenizer，它会将一个给定的文本分词成一个token序列，然后它会映射这些tokens成tokenizer的词汇表中token所对应的下标，在这个过程中，tokenizer还会增加一些预训练模型输入格式所要求的额外的符号，如，‘[CLS]’，'[SEP]'等。经过这个预处理后，就可以直接地“喂”进我们的预训练模型里面。

1. tokenizer的初始化及入门

1.1 初始化

通常初始化有两种，一种是通过 from_pretrained 方法，另一种是直接实例化RobertaTokenizer类，并在其中指定词表的路径。

• from_pretrained

  from transformers import BertTokenizer
  TOKENIZER_PATH = "../input/huggingface-bert/bert-base-chinese"
  tokenizer = BertTokenizer.from_pretrained(TOKENIZER_PATH)
  

  TOKENIZER_PATH 是包含vocab.txt文件的目录

• 直接实例化类

  from transformers import BertTokenizer
  tokenizer = BertTokenizer(vocab_file="./pretrain_model/bert-base-chinese/vocab.txt")
  

  该方法必须指定vocab_file

1.2 入门使用

• tokenizer.tokenize(text:str): 分词，只能输入字符串
• tokenizer.convert_tokens_to_ids(tokens:list): 将词转换成id
• tokenizer.convert_ids_to_tokens(token_id: list): 将id转换成词

from transformers import BertTokenizer
tokenizer = BertTokenizer(vocab_file="./pretrain_model/bert-base-chinese/vocab.txt")

examples = ["我爱北京天安门", "天安门广场吃炸鸡"]

res = tokenizer.tokenize(examples[0])
print(res)

token_id = tokenizer.convert_tokens_to_ids(res)
print(token_id)

id2token = tokenizer.convert_ids_to_tokens(token_id)
print(id2token)

输出：

['我', '爱', '北', '京', '天', '安', '门']
[2769, 4263, 1266, 776, 1921, 2128, 7305]
['我', '爱', '北', '京', '天', '安', '门']

tokenizer里面的方encode, batch_encode, encode_plus, batch_encode_plus 将上面的两个步骤(分词、编码)都包含了，使用起来更加方便，不过这些方法在transformers的将来的版本中，会被遗弃，它们的全部的功能都集成到了__call__方法里，所以下一节重点讲解__call__方法

2. 更方便的使用tokenizer

第一节中需要先分词，再将token转换成id，此外输入到模型中还需要手工进行padding等操作，并且第一节中的方法只能处理单条数据。该章节将介绍如何一步到位，直接输入到模型。在此之前需要了解__call__方法中的一些参数

__call__( 
	text: typing.Union[str, typing.List[str], typing.List[typing.List[str]]],
	text_pair: typing.Union[str, typing.List[str], typing.List[typing.List[str]], NoneType] = None
	add_special_tokens: bool = True
	padding: typing.Union[bool, str, transformers.utils.generic.PaddingStrategy] = False
	truncation: typing.Union[bool, str, transformers.tokenization_utils_base.TruncationStrategy] = False
	max_length: typing.Optional[int] = None
	stride: int = 0
	is_split_into_words: bool = False
	pad_to_multiple_of: typing.Optional[int] = None
	return_tensors: typing.Union[str, transformers.utils.generic.TensorType, NoneType] = None
	return_token_type_ids: typing.Optional[bool] = None
	return_attention_mask: typing.Optional[bool] = Nonereturn_overflowing_tokens: bool = False
	return_special_tokens_mask: bool = False
	return_offsets_mapping: bool = False
	return_length: bool = Falseverbose: bool = True**kwargs 
	) → BatchEncoding

下面介绍几个经常用到的参数：

• text: 需要被编码的文本，可以是一维或二维list
• padding: 是否需要padding，可选如下几个值
  • True or 'longest'，padding到一个batch中最长序列的长度
  • 'max_length'， padding到由max_length参数指定的长度，如果没有指定max_length则padding到模型所能接受的最大长度
  • False or 'do_not_pad'， 不进行padding
• truncation: 是否要进行截断
  • True or 'longest_first'，保留由max_length指定的长度，或者当max_length没有指定时，截取保留模型最大能接受的长度，对于sentence pair，截取长度最大的句子
  • False or 'do_not_truncate (default) 不截取
  • only_first，截取到max_length, 但是只截取sentence pair中的第一个句子
  • 'only_second'，同理，只截取pair中第二个句子
• max_length，句子最大长度，和padding及truncation相关
• is_split_into_words 输入的句子是否已经分词好了，比如已经用空格分隔开
• return_tensors 返回类型，默认是list类型，可选pt返回torch 的 tensor，tf返回tensorflow的tensor， npnumpy类型
• return_length，是否返回编码的序列长度，default=False

from transformers import BertTokenizer
tokenizer = BertTokenizer(vocab_file="./pretrain_model/bert-base-chinese/vocab.txt")

examples = ["我爱北京天安门", "天安门广场吃炸鸡"]
res = tokenizer(examples, 
                padding="max_length", 
                truncation=True, 
                max_length=7, 
                return_tensors="pt",
                return_length=True)

print(res)
print(res["input_ids"].shape)

输出: 返回一个字典

{'input_ids': tensor([[ 101, 2769, 4263, 1266,  776, 1921,  102],
        			[ 101, 1921, 2128, 7305, 2408, 1767,  102]]),
 'token_type_ids': tensor([[0, 0, 0, 0, 0, 0, 0],
       					 [0, 0, 0, 0, 0, 0, 0]]), 
 'length': tensor([7, 7]), 
 'attention_mask': tensor([[1, 1, 1, 1, 1, 1, 1],
       					 [1, 1, 1, 1, 1, 1, 1]])}
       					 
torch.Size([2, 7])

2.1 最常用的方法

• 每一个batch只padding到batch中最大长度，如果超过模型接受的最大长度，就截取到模型能接受最大长度

input_text = ["我爱北京天安门", "广场吃炸鸡"]
tok_res = tokenizer(input_text, 
                padding=True, 
                truncation=True, 
                max_length=512, 
                return_tensors="pt")

这样的好处是能够根据batch动态调整句子padding后长度，没必要每个batch都padding成相同的长度，比如第一个batch中最大长度为7，那第一batch最后每个句子都会padding到7，第二个batch中最大长度为10，最后第二batch中每个句子长度都会padding到10；但是每个batch句子的长度会不同，在某些情况下可能会有问题

• 指定句子最大长度，每个batch都使用相同的句子长度

examples = ["我爱北京天安门", "广场吃炸鸡"]
res = tokenizer(examples, 
                padding="max_length", 
                truncation=True, 
                max_length=7, 
                return_tensors="pt",
                return_length=True)

这样无论第一个batch和第二个batch中最大长度为多少，都会padding或truncate到7

参考

transformers中，关于PreTrainedTokenizer的使用
hugging face call