二、Data Collator

发布于 2023-07-17 23:38:23 字数 12339 浏览 0 评论 0 收藏 0

data collator 是一个对象，它将数据集元素的一个列表作为输入从而构建成一个 batch 。为了能够构建 batch，data collator 可能会应用一些处理（如 padding 或截断）。其中，某些 data collator （如 DataCollatorForLanguageModeling）还在构成的 batch 上应用一些随机数据增强（如，random masking）。

2.1 API

class transformers.DefaultDataCollator(return_tensors: str = 'pt' )：非常简单的 data collator，它简单地处理一组 dict-like 对象，并以下的 key 进行特殊处理：

label：为每个 dict-like 对象处理一个 single value。
label_ids：为每个 dict-like 对象处理一个 list of values。

参数：

return_tensors：一个字符串，指定返回的 batch 数据的类型。

示例：

x
import transformers


collator = transformers.DefaultDataCollator()


result = []
for num in range(0,5):
    element = {"xxxx": [num,num+1],
               # "label": num%2,
               "label_ids": [num]} # label_ids 和 label 只能存在一个, 如果有两个则只有第一个会生效
    result.append(element)


print(collator(result)) # 注意, "label_ids" 键被替换为 "labels"
# {'labels': tensor([[0],
#         [1],
#         [2],
#         [3],
#         [4]]), 'xxxx': tensor([[0, 1],
#         [1, 2],
#         [2, 3],
#         [3, 4],
#         [4, 5]])}

transformers.default_data_collator(features: typing.List[InputDataClass], return_tensors = 'pt')：非常简单的 data collator，是 DefaultDataCollator 的函数式方式。
class transformers.DataCollatorWithPadding：对 input 进行动态填充的 data collator。
```
xxxxxxxxxx
class transformers.DataCollatorWithPadding(tokenizer: PreTrainedTokenizerBase,
           padding: typing.Union[bool, str, transformers.utils.generic.PaddingStrategy] = True,
           max_length: typing.Optional[int] = None,
           pad_to_multiple_of: typing.Optional[int] = None,
           return_tensors: str = 'pt' 
)
```
参数：
- tokenizer：一个 PreTrainedTokenizerBase 对象，指定用于 data encoding 的 tokenizer 。
- padding：一个布尔值、字符串、或者 PaddingStrategy，参考 PreTrainedTokenizerBase.__call__() 方法。
- max_length：一个整数，参考 PreTrainedTokenizerBase.__call__() 方法。
- pad_to_multiple_of：一个整数，参考 PreTrainedTokenizerBase.__call__() 方法。
- return_tensors：一个字符串，参考 DefaultDataCollator 。

class transformers.DataCollatorForTokenClassification：对 input 和 label 进行动态填充的 data collator。


xxxxxxxxxx
class transformers.DataCollatorForTokenClassification(tokenizer: PreTrainedTokenizerBase,
           padding: typing.Union[bool, str, transformers.utils.generic.PaddingStrategy] = True,
           max_length: typing.Optional[int] = None,
           pad_to_multiple_of: typing.Optional[int] = None,
           label_pad_token_id: int = -100,
           return_tensors: str = 'pt' 
)

参数：

label_pad_token_id：一个整数，指定填充 label 的 token id。-100 将被 PyTorch 损失函数自动忽略。
其它参数参考 DataCollatorWithPadding 。

class transformers.DataCollatorForSeq2Seq：对 input 和 label 进行动态填充的 data collator。


xxxxxxxxxx
class transformers.DataCollatorForSeq2Seq(
           tokenizer: PreTrainedTokenizerBasemodel: typing.Optional[typing.Any] = None,
           padding: typing.Union[bool, str, transformers.utils.generic.PaddingStrategy] = True,
           max_length: typing.Optional[int] = None,
           pad_to_multiple_of: typing.Optional[int] = None,
           label_pad_token_id: int = -100,
           return_tensors: str = 'pt' 
)

参数：参考 DataCollatorForTokenClassification 。

class transformers.DataCollatorForLanguageModeling：用于语言模型的 data collator 。input 被动态填充到 batch 内的最大长度（如果序列长度不是一样长）。
```
xxxxxxxxxx
class transformers.DataCollatorForLanguageModeling(
           tokenizer: PreTrainedTokenizerBase,
           mlm: bool = True,
           mlm_probability: float = 0.15,
           pad_to_multiple_of: typing.Optional[int] = None,
           tf_experimental_compile: bool = False,
           return_tensors: str = 'pt'
)
```
参数：
- mlm：一个布尔值，指定是否使用 masked language modeling 。
  - 如果为 False，那么 label 和 input 完全相同，其中 padding token 被忽略（将它们的 label 设置为 -100）。
  - 如果为 True，那么将 non-masked token 的 label 设置为 -100（从而忽略它们的损失），而 masked token 的 label 设置为 original value 。
- mlm_probability：一个浮点数，指定 input 中 mask token 的概率，仅当 mlm = True 时有效。
- tf_experimental_compile：一个布尔值，如果为 True，则基于 tensorflow 来编译。
- 其它参数参考 DataCollatorForTokenClassification 。
为了获得最佳性能，这个应该与一个数据集一起使用，该数据集的item 是带有 "special_tokens_mask" 键的字典或 BatchEncoding （由 PreTrainedTokenizerBase 以参数 return_special_tokens_mask=True 来调用时的返回结果）。
方法：
- numpy_mask_tokens(inputs: Any, special_tokens_mask: Optional[Any] = None) -> Tuple[Any, Any]：为掩码语言模型准备 masked inputs/labels，其中 80% MASK、10% random、10% original 。用于 numpy。
- tf_mask_tokens(inputs: typing.Any, vocab_size, mask_token_id, special_tokens_mask: typing.Optional[typing.Any] = None) -> Tuple[Any, Any]：为掩码语言模型准备 masked inputs/labels，其中 80% MASK、10% random、10% original 。用于 TensorFlow。
- torch_mask_tokens(inputs: Any, special_tokens_mask: Optional[Any] = None) -> Tuple[Any, Any]：为掩码语言模型准备 masked inputs/labels，其中 80% MASK、10% random、10% original 。用于 PyTorch。
class transformers.DataCollatorForWholeWordMask：用于语言模型的 data collator ，其中执行全词掩码 whole word masking 。
```
xxxxxxxxxx
class transformers.DataCollatorForWholeWordMask(tokenizer: PreTrainedTokenizerBase,
           mlm: bool = True,
           mlm_probability: float = 0.15,
           pad_to_multiple_of: typing.Optional[int] = None,
           tf_experimental_compile: bool = False,
           return_tensors: str = 'pt'
)
```
参数：参考 DataCollatorForLanguageModeling。
注意：该 data collator 依赖于 BertTokenizer 的 subword tokenization，尤其是以 ## 为前缀的 subword token 。如果你的 tokenizer 不是这种方案，那么该 data collator 将得到等价于 DataCollatorForLanguageModeling 的结果。
方法：
- numpy_mask_tokens(inputs: typing.Any, mask_labels: typing.Any) -> Tuple[Any, Any]：为掩码语言模型准备 masked inputs/labels，其中 80% MASK、10% random、10% original 。用于 numpy。
  mask_labels 由人工指定哪些索引处的 token 需要被掩码。因为它是由人工指定的 mask，因此被称作 mask_labels。
- tf_mask_tokens(inputs: typing.Any, mask_labels: typing.Any) -> Tuple[Any, Any]：为掩码语言模型准备 masked inputs/labels，其中 80% MASK、10% random、10% original 。用于 TensorFlow。
- torch_mask_tokens(inputs: typing.Any, mask_labels: typing.Any) -> Tuple[Any, Any]：为掩码语言模型准备 masked inputs/labels，其中 80% MASK、10% random、10% original 。用于 Pytorch。
class transformers.DataCollatorForPermutationLanguageModeling：用于排列语言建模 permutation language modeling （如，XLNet）的 data collator。
```
xxxxxxxxxx
class transformers.DataCollatorForPermutationLanguageModeling(tokenizer: PreTrainedTokenizerBase,
           plm_probability: float = 0.16666666666666666,
           max_span_length: int = 5,
           return_tensors: str = 'pt' 
)
```
参数：
- plm_probability：一个浮点数，指定掩码率。
- max_span_length：一个整数，指定 span of masked token 的最大长度。
- 其它参数参考 DataCollatorForLanguageModeling。
方法：
- numpy_mask_tokens(inputs: typing.Any) -> Tuple[Any, Any, Any, Any]：为排列语言模型准备 masked inputs。用于 numpy。
  对于一个特定的序列，要预测的 masked token 是由以下算法决定的：
  - step 0：通过设置 cur_len = 0 （它指定已经处理的 token 数量）来从序列的 beginning 开始。
  - step 1：从区间 [1, max_span_length] 中随机采样一个 span_length （要掩码的 token 的 span 长度）。
  - step 2：保留一个长度为 context_length = span_length / plm_probability 的上下文，从而包围 masked span 。
  - step 3：从区间 [cur_len, cur_len + context_length - span_length] 之间采样一个 start_index，然后掩码 start_index: start_index + span_length 之间的 token 。
  - step 4：设置 cur_len = cur_len + context_length。如果 cur_len < max_len（即，序列中还有剩余的 token 需要被处理），那么从 step 1 开始重复执行。
- tf_mask_tokens(inputs: typing.Any) -> Tuple[Any, Any, Any, Any]：为排列语言模型准备 masked inputs。用于 Tensorflow。
- torch_mask_tokens(inputs: typing.Any) -> Tuple[Any, Any, Any, Any]：为排列语言模型准备 masked inputs。用于 PyTorch。