预训练过程训练数据分析1

最新推荐文章于 2024-06-10 10:39:48 发布
最新推荐文章于 2024-06-10 10:39:48 发布
阅读量1.7k 收藏 4
点赞数
分类专栏： bert源码解读
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/znevegiveup1/article/details/118527599
版权

源代码地址
大佬预训练代码地址
模型结构之前已经进行分析过了，这里从训练过程开始分析

training_args = TrainingArguments(
    output_dir='record',
    num_train_epochs=num_train_epochs,
    learning_rate=learning_rate,
    per_device_train_batch_size=batch_size,
    save_steps=save_steps,
    logging_steps=500,
    save_total_limit=5,
    prediction_loss_only=True,
    seed=seed
)

得到对应的training_args

training_args = 
output_dir:record
overwrite_output_dir:False
do_train:False
do_eval:False
do_predict:False
evaluation_strategy:IntervalStrategy.NO
prediction_loss_only:True
per_device_train_batch_size:32
per_device_eval_batch_size:8
per_gpu_train_batch_size:None
per_gpu_eval_batch_size:None
gradient_accumulation_steps:1

接着定义Trainer的内容

trainer = Trainer(
    model=model,
    args=training_args,
    data_collator=data_collator,
    train_dataset=dataset
)

然后调用trainer.train()进入训练的过程
这里首先调用data_collator.py之中的mask_tokens的内容
首先分析DataCollatorForLanguageModeling类之中的内容

class DataCollatorForLanguageModeling:
	tokenizer: PreTrainedTokenizerBase
	mlm: bool = True
	mlm_probability: float = 0.15
	pad_to_multiple_of: Optional[int] = None
	def __post_init__(self):
		if self.mlm and self.tokenizer.mask_token is None:
            raise ValueError(
                "This tokenizer does not have a mask token which is necessary for masked language modeling. "
                "You should pass `mlm=False` to train on causal language modeling instead."
            )

这是初始化之中的一些参数，之前初始化过了，这里直接调用DataCollatorForLanguageModeling之中的__call__函数

    def __call__(
        self, examples: List[Union[List[int], torch.Tensor, Dict[str, torch.Tensor]]]
    ) -> Dict[str, torch.Tensor]:
        if isinstance(examples[0], (dict, BatchEncoding)):
            batch = self.tokenizer.pad(examples, return_tensors="pt", pad_to_multiple_of=self.pad_to_multiple_of)
        else:
            batch = {"input_ids": _collate_batch(examples, self.tokenizer, pad_to_multiple_of=self.pad_to_multiple_of)}
        # If special token mask has been preprocessed, pop it from the dict.
        special_tokens_mask = batch.pop("special_tokens_mask", None)
        #special_tokens_mask = None
        if self.mlm:
            #special_tokens_mask = None
            batch["input_ids"], batch["labels"] = self.mask_tokens(
                batch["input_ids"], special_tokens_mask=special_tokens_mask
            )
        else:
            labels = batch["input_ids"].clone()
            if self.tokenizer.pad_token_id is not None:
                labels[labels == self.tokenizer.pad_token_id] = -100
            batch["labels"] = labels
        return batch

这里对应的放入的内容为：

[{'input_ids': tensor([  101,   169,   107, 10539,   142,  8231,   107,   131,   107,   146,
                       8189,  8168,  9402,  8156,  8177,  8660,  8154,  8408,  8921,  8148,
                       ............
                        100,   100,   107,   171,   117,   169,   107, 10539,   107,   102])},
                       ............
{'input_ids': tensor([  101,   169,   107, 10539,   142,  8231,   107,   131,   107,  8424,
                       8161, 12540, 12675,  8154, 10696,  9647,  8168,  8849,  8139,  9355,
                       ............
                        100,  8123,   118,  8143,   100,   100,   100,   100,   100,   102])},
                       ............]

接着调用对应的pad函数

batch = self.tokenizer.pad(examples,return_tensors="pt,pad_to_multiple_of=self.pad_to_multiple_of)

这里发现上面的数据有很多100的对应数值，联想到之前数据分词的时候可能有所操作。
回看之前LineByLineTextDataset的分词部分操作的内容

batch_encoding = tokenizer(lines, add_special_tokens=True, truncation=True, max_length=block_size)

对应初始化操作之中

tokenizer:PreTrainedTokenizer

所以这里的self.tokenizer.pad要去PreTrainedTokenizer中的pad函数之中去查看
进入到PreTrainedTokenizer之中，也就是说直接使用PreTrainedTokenizer(…)的内容去进行相应的分词操作。

真实的tokenizer定义在main()的对应定义之中

tokenizer = BertTokenizer.from_pretrained(vocab_file)

经过的相应输出之后，发现这里的内容仍然为PreTrainedTokenizer的内容

tokenizer = 
PreTrainedTokenizer(name_or_path=
'/home/xiaoguzai/数据/nezha-chinese-base/vocab.txt', vocab_size=21128, 
model_max_len=1000000000000000019884624838656, is_fast=False, 
padding_side='right', special_tokens={'unk_token': '[UNK]', 
'sep_token': '[SEP]', 'pad_token': '[PAD]', 
'cls_token': '[CLS]', 'mask_token': '[MASK]'})

所以这里调用的DataCollatorForWholeWordMask的对应函数内容
这里面调用函数的过程如下：

PreTrainedTokenizer tokenize
PreTrainedTokenizer split_on_tokens
PreTrainedTokenizer split_on_token
PreTrainedTokenizer split_on_token
PreTrainedTokenizer split_on_token
PreTrainedTokenizer split_on_token
PreTrainedTokenizer split_on_token
PreTrainedTokenizer convert_tokens_to_ids
PreTrainedTokenizer _convert_token_to_id_with_added_voc
PreTrainedTokenizer _convert_token_to_id_with_added_voc
PreTrainedTokenizer _convert_token_to_id_with_added_voc
PreTrainedTokenizer _convert_token_to_id_with_added_voc
PreTrainedTokenizer _convert_token_to_id_with_added_voc
......

下一波又进入了这种调用函数的运行状态之中：

PreTrainedTokenizer tokenize
PreTrainedTokenizer split_on_tokens
PreTrainedTokenizer split_on_token
PreTrainedTokenizer split_on_token
PreTrainedTokenizer split_on_token
PreTrainedTokenizer split_on_token
PreTrainedTokenizer split_on_token
PreTrainedTokenizer convert_tokens_to_ids
PreTrainedTokenizer _convert_token_to_id_with_added_voc
PreTrainedTokenizer _convert_token_to_id_with_added_voc
PreTrainedTokenizer _convert_token_to_id_with_added_voc
PreTrainedTokenizer _convert_token_to_id_with_added_voc
PreTrainedTokenizer _convert_token_to_id_with_added_voc
......

这里有一个相应的疑点，就是直接调用的时候为什么就调用到了PreTrainedTokenizer tokenize函数之中了，猜想大概是因为在初始化过程之中绑定了tokenize函数，使得调用了对应的tokenize的函数内容。
这里的实现应该类似于建立模型之后使用model(input_ids)直接找到对应的输出内容。
进入PreTrainedTokenizer的tokenize函数之中去查看调用的过程：

def tokenize(self, text: TextInput, **kwargs) -> List[str]:

这里输入的text =

{"text_id": "e225b9fd36b8914f42c188fc92e8918f", "query": "河南省巩义市新华路街道办事处桐和街6号钢苑新区3号楼一单元", "candidate": [{"text": "巩义市桐和街", "label": "不匹配"}, 
{"text": "桐和街依家小店", "label": "不匹配"}, {"text": "桐和街CHANG六LIULIU", "label": "不匹配"}, {"text": "桐和街佳乐钢琴", "label": "不匹配"}, 
{"text": "世博领秀城南门桐和街囍饭食堂", "label": "不匹配"}]}

接着运行对应的all_special_tokens_extended内容

all_special_tokens_extended = dict(
            (str(t), t) for t in self.all_special_tokens_extended if isinstance(t, AddedToken)
        )

输出对应的all_special_tokens_extended

all_special_tokens_extended = {}

接下来调用prepare_for_tokenization函数内容

text, kwargs = self.prepare_for_tokenization(text,**kwargs)

得到的text和kwargs没有变化，kwargs = {}仍然不变。
接下来

if hasattr(self,"do_lower_case") and self.do_lower_case:
	......

这里由于都是中文，所以不会运行这一句
接下来调用split_on_token函数和split_on_tokens函数内容

no_split_token = self.unique_no_split_tokens
tokenized_text = split_on_tokens(no_split_token,text)

进入split_on_tokens之中
这里放入我修改过之后的split_on_tokens函数

def split_on_tokens(tok_list, text):
    print('PreTrainedTokenizer split_on_tokens')
    if not text.strip():
        return []
    if not tok_list:
        return self._tokenize(text)

    tokenized_text = []
    text_list = [text]
    for tok in tok_list:
        tokenized_text = []
        for sub_text in text_list:
            if sub_text not in self.unique_no_split_tokens:
                tokenized_text.extend(split_on_token(tok, sub_text))
            else:
                tokenized_text.append(sub_text)
        text_list = tokenized_text

    return list(
        itertools.chain.from_iterable(
            (
                self._tokenize(token) if token not in self.unique_no_split_tokens else [token]
                for token in tokenized_text
            )
        )
    )

这中间的内容都没有改变，关键在于最后return这一部分的内容

return list(
   	   itertools.chain.from_iterable(
   	   (
       		self._tokenize(token) if token not in self.unique_no_split_tokens else [token] for token in tokenized_text
       )
   )
)

这里的

self.unique_no_split_tokens = ['[CLS]','[MASK]','[PAD]','[SEP]','[UNK]']

处理完之后，对应的字符串内容为

['{', '"', 'text', '_', 'id', '"', ':', '"', 'e2', '##25', '##b', '##9', '##f', '##d', '##36', '##b', '##89', '##14', '##f', '##42', '##c', '##18', '##8', '##fc', '##92', '##e', '##89', '##18', '##f', '"', ',', '"', 'q', '##ue', '##ry', '"', ':', '"', '[UNK]', '[UNK]', '[UNK]', '[UNK]', '[UNK]', '[UNK]', 
'[UNK]', '[UNK]', '[UNK]', '[UNK]', '[UNK]', '[UNK]', '[UNK]', '[UNK]', '[UNK]', '[UNK]', '[UNK]', '6', '[UNK]', '[UNK]', '[UNK]', '[UNK]', '[UNK]', '3', '[UNK]', '[UNK]', '[UNK]', '[UNK]', '[UNK]', 
'"', ',', '"', 'can', '##di', '##da', '##te', '"', ':', '[', '{', '"', 'text', '"', ':', '"', '[UNK]', '[UNK]', '[UNK]', '[UNK]', '[UNK]', '[UNK]', '"', ',', '"', 'lab', '##el', '"', ':', '"', '[UNK]', '[UNK]', '[UNK]', '"', '}', ',', '{', '"', 'text', '"', ':', '"', 
'[UNK]', '[UNK]', '[UNK]', '[UNK]', '[UNK]', '[UNK]', '[UNK]', '"', ',', '"', 'lab', '##el', '"', ':', '"', '[UNK]', '[UNK]', '[UNK]', '"', '}', ',', '{', '"', 'text', '"', ':', '"', '[UNK]', '[UNK]', '[UNK]', 'chang', '[UNK]', 'liu', '##li', '##u', '"', ',', '"', 'lab', '##el', '"', ':', '"', '[UNK]', '[UNK]', '[UNK]', '"', '}', ',', 
'{', '"', 'text', '"', ':', '"', '[UNK]', '[UNK]', '[UNK]', '[UNK]', '[UNK]', '[UNK]', '[UNK]', '"', ',', '"', 'lab', '##el', '"', ':', '"', '[UNK]', '[UNK]', '[UNK]', '"', '}', ',',
'{', '"', 'text', '"', ':', '"', '[UNK]', '[UNK]', '[UNK]', '[UNK]', '[UNK]', '[UNK]', '[UNK]', '[UNK]', '[UNK]', '[UNK]', '[UNK]', '[UNK]', '[UNK]', '[UNK]', '"', ',', '"', 'lab', '##el', '"', ':', '"', '[UNK]', '[UNK]', '[UNK]', '"', '}', ']', '}']

可以看出，所有的中文汉字都被替换成为了标志’[UNK]'的内容
比如传入的字符串为

['{"text_id": "e225b9fd36b8914f42c188fc92e8918f", 
   "query": "河南省巩义市新华路街道办事处桐和街6号钢苑新区3号楼一单元", 
   "candidate": [{"text": "巩义市桐和街", "label": "不匹配"}, {"text": "桐和街依家小店", "label": "不匹配"}, 
   {"text": "桐和街chang六liuliu", "label": "不匹配"}, {"text": "桐和街佳乐钢琴", "label": "不匹配"}, 
   {"text": "世博领秀城南门桐和街囍饭食堂", "label": "不匹配"}]}']

得到对应的list数组内容为

PreTrainedTokenizer split_on_tokens
['{', '"', 'text', '_', 'id', '"', ':', '"', 'e2', '##25', '##b', '##9', '##f', '##d', '##36', '##b', '##89', '##14', '##f', '##42', '##c', '##18', '##8', '##fc', '##92', '##e', '##89', '##18', '##f', '"', ',', '"', 'q', '##ue', '##ry', '"', ':', '"', '[UNK]',
'[UNK]', '[UNK]', '[UNK]', '[UNK]', '[UNK]', '[UNK]', '[UNK]', '[UNK]', '[UNK]', '[UNK]', '[UNK]', '[UNK]', '[UNK]', '[UNK]', '[UNK]', '[UNK]', '6', '[UNK]', '[UNK]', '[UNK]', '[UNK]', '[UNK]', '3', '[UNK]', '[UNK]', 
'[UNK]', '[UNK]', '[UNK]', '"', ',', '"', 'can', '##di', '##da', '##te', '"', ':', '[', '{', '"', 'text', '"', ':', '"', '[UNK]', '[UNK]', '[UNK]', '[UNK]', '[UNK]', '[UNK]', '"', ',', '"', 'lab', '##el', '"', ':', '"', '[UNK]', '[UNK]', '[UNK]', '"', '}', ',', '{', '"', 
'text', '"', ':', '"', '[UNK]', '[UNK]', '[UNK]', '[UNK]', '[UNK]', '[UNK]', '[UNK]', '"', ',', '"', 'lab', '##el', '"', ':', '"', '[UNK]', '[UNK]', '[UNK]', '"', '}', ',', '{', '"', 'text', '"', ':', '"', '[UNK]', '[UNK]', '[UNK]', 'chang', '[UNK]', 'liu', 
'##li', '##u', '"', ',', '"', 'lab', '##el', '"', ':', '"', '[UNK]', '[UNK]', '[UNK]', '"', '}', ',', '{', '"', 'text', '"', ':', '"', '[UNK]', '[UNK]', '[UNK]', '[UNK]', '[UNK]', '[UNK]', '[UNK]', '"', ',', '"', 'lab', '##el', '"', ':', '"', '[UNK]', '[UNK]', '[UNK]', 
'"', '}', ',', '{', '"', 'text', '"', ':', '"', '[UNK]', '[UNK]', '[UNK]', '[UNK]', '[UNK]', '[UNK]', '[UNK]', '[UNK]', '[UNK]', '[UNK]', '[UNK]', '[UNK]', '[UNK]', '[UNK]', '"', ',', '"', 'lab', '##el', '"', ':', '"', '[UNK]', '[UNK]', '[UNK]', '"', '}', ']', '}']
ids = 
[169, 107, 10539, 142, 8231, 107, 131, 107, 12357, 8743, 8204, 8160, 8189, 8168, 9159, 8204, 9402, 8717, 8189, 9240, 8177, 8662, 8156, 9717, 9595, 8154, 9402, 8662, 8189, 107, 117, 
107, 159, 8803, 8449, 107, 131, 107, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 127, 100, 100, 100, 100, 100, 124, 100, 100, 100, 100, 100, 107, 117, 
107, 9109, 9172, 8521, 8299, 107, 131, 138, 169, 107, 10539, 107, 131, 107, 100, 100, 100, 100, 100, 100, 107, 117, 107, 11441, 8472, 107, 131, 107, 100, 100, 100, 107, 171, 117, 169, 107, 
10539, 107, 131, 107, 100, 100, 100, 100, 100, 100, 100, 107, 117, 107, 11441, 8472, 107, 131, 107, 100, 100, 100, 107, 171, 117, 169, 107, 10539, 107, 131, 107, 100, 100, 100, 11680, 100, 
12306, 8636, 8207, 107, 117, 107, 11441, 8472, 107, 131, 107, 100, 100, 100, 107, 171, 117, 169, 107, 10539, 107, 131, 107, 100, 100, 100, 100, 100, 100, 100, 107, 117, 107, 11441, 8472, 107, 
131, 107, 100, 100, 100, 107, 171, 117, 169, 107, 10539, 107, 131, 107, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 107, 117, 107, 11441, 8472, 107, 131, 107, 100, 100, 100, 107, 171, 140, 171]

从上面的内容可以看出，中文的内容全被使用[UNK]遮盖住了，而英文的内容则被保留了下来。
接下来查看训练数据的过程

trainer = Trainer(
	model=model,
	args=training_args,
	data_collator=data_collator,
	train_dataset=dataset
)

这里面首先调用的是DataCollatorForLanguageModeling类的调用__call__函数的过程

def __call__(
    self, examples: List[Union[List[int], torch.Tensor, Dict[str, torch.Tensor]]]
) -> Dict[str, torch.Tensor]:
    print('data/data_collator.py __call__')
    # Handle dict or lists with proper padding and conversion to tensor.
    print('data_collator examples = ')
    print(examples)
    print('#########################')
    if isinstance(examples[0], (dict, BatchEncoding)):
        #运行第一个对应的if语句
        batch = self.tokenizer.pad(examples, return_tensors="pt", pad_to_multiple_of=self.pad_to_multiple_of)
        #这里的tokenizer使用的是PreTrainedTokenizerBase
        print('|||self.tokenizer = |||')
        print(self.tokenizer)
        print('---self.pad_to_multiple_of---')
        print(self.pad_to_multiple_of)
        r"""
        self.tokenizer = PreTrainedTokenizer(name_or_path='/home/...vocab.txt',
        special_tokens={'unk_token':'[UNK]','sep_token':'[SEP]',...'mask_token':'[MASK]'}
        """
    else:
        print('situation2')
        batch = {"input_ids": _collate_batch(examples, self.tokenizer, pad_to_multiple_of=self.pad_to_multiple_of)}
    print('999batch = 999')
    print(batch)
    r"""
    batch = 
    {'input_ids':tensor(
    [[101,169,...102],
     ................
     [101,169,...102]]),
     'attention_mask':tensor(
    [[1,1,...1,1]
    """
    #batch['input_ids'].shape = ([32,90])
    #batch['attention_mask'].shape = ([32,90])
    print('99999999999999')
    r"""
    batch = 
    {'input_ids': tensor(
    [[  101,   169,   107,  ..., 10539,   107,   102],
    [  101,   169,   107,  ...,   100,   100,   102],
    [  101,   169,   107,  ...,   100,   100,   102],
    ...,
    [  101,   169,   107,  ...,   100,   100,   102],
    [  101,   169,   107,  ...,   100,   100,   102],
    [  101,   169,   107,  ...,   117,   169,   102]]), 
    'attention_mask': tensor(
    [[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]])}
    """
    # If special token mask has been preprocessed, pop it from the dict.
    special_tokens_mask = batch.pop("special_tokens_mask", None)
    #special_tokens_mask = None
    r"""
    special_tokens_mask = 
    [[1,0,0,...0,0,1],
     [1,0,0,...1,1,1],
     ...............
     [1,0,0,...0,0,1]]
    """
    if self.mlm:
        #special_tokens_mask = None
        batch["input_ids"], batch["labels"] = self.mask_tokens(
            batch["input_ids"], special_tokens_mask=special_tokens_mask
        )
        r"""
        ***batch = ***
        {'input_ids': tensor(
        [[  101,   169,   107,  ..., 10539,   107,   102],
        [  101,   169,   107,  ...,   100,   100,   102],
        [  101,   169,   107,  ...,   100,   100,   102],
        ...,
        [  101,   169,   107,  ...,   100,   100,   102],
        [  101,   169,   107,  ...,   100,   100,   102],
        [  101,   169,   107,  ...,   103,   169,   102]]), 
        'attention_mask': tensor(
        [[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]]), 
        'labels': tensor(
        [[-100, -100, -100,  ..., -100,  107, -100],
        [-100, -100, -100,  ..., -100, -100, -100],
        [-100, -100, -100,  ..., -100, -100, -100],
        ...,
        [-100, -100, -100,  ..., -100, -100, -100],
        [-100, -100, -100,  ..., -100, -100, -100],
        [-100, -100, -100,  ...,  117, -100, -100]])}
        """
    else:
        labels = batch["input_ids"].clone()
        if self.tokenizer.pad_token_id is not None:
            labels[labels == self.tokenizer.pad_token_id] = -100
        batch["labels"] = labels
    return batch

首先输出

data_collator examples =
[{'input_ids': tensor([  101,   169,   107, 10539,   142,  8231,   107,   131,   107,  8360,
         8717,  8139,  9099,  8168,  9267,  8157,  8177,  9446,  8177,  9419,
         8510, 10340, 10696,  8129, 11008,  8160,  8204,  8849,  8152,  8139,
         ...........
         107, 10539,   107,   131,   107,   100,   100,   100,   100,   102])},
         ......
 {'input_ids': tensor([  101,   169,   107, 10539,   142,  8231,   107,   131,   107,  9226,
                          9102,  9039,  8854,  8748,  8159,  9717,  8204,  8189,  9242,  8168,
                          8189, 11219, 11414,  8148,  8154,  9102,  9410,  8157,  8139,   107,
                           117,   107,   159,  8803,  8449,   107,   131,   107,   100,   100,
                           100,   100,   100,   100,   100,   100,   100,   100,   100,   100,
                           100,   100,   100,   100,   100,   100,   100,   100,   100,   127,
                           100,   100,   100,   100,   100,   107,   117,   107,  9109,  9172,
                          8521,  8299,   107,   131,   138,   169,   107, 10539,   107,   131,
                           107,   100,   100,   100,   100,   100,   100,   107,   171,   102])}]

接着输出对应的内容

self.pad_to_multiple_of = None

这里得到对应的attention_mask的内容

batch = 
{'input_ids': tensor(
	   [[  101,   169,   107,  ..., 10539,   107,   102],
        [  101,   169,   107,  ...,   100,   100,   102],
        [  101,   169,   107,  ...,   100,   100,   102],
        ...,
        [  101,   169,   107,  ...,   100,   100,   102],
        [  101,   169,   107,  ...,   100,   100,   102],
        [  101,   169,   107,  ...,   117,   169,   102]]), 
 'attention_mask': tensor(
       [[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]])}

接着调用对应的语句

special_tokens_mask = batch.pop("special_tokens_mask",None)

由于上面的batch之中没有对应的special_tokens_mask的属性，所以得到对应的special_tokens_mask的对应值为None

special_tokens_mask = None

接着进入调用语句

if self.mlm:
    #special_tokens_mask = None
    batch["input_ids"], batch["labels"] = self.mask_tokens(
        batch["input_ids"], special_tokens_mask=special_tokens_mask
    )

这里面需要进入self.mask_tokens去调用

    def mask_tokens(
        self, inputs: torch.Tensor, special_tokens_mask: Optional[torch.Tensor] = None
    ) -> Tuple[torch.Tensor, torch.Tensor]:
        print('data/data_collator.py mask_tokens')
        """
        Prepare masked tokens inputs/labels for masked language modeling: 80% MASK, 10% random, 10% original.
        """
        labels = inputs.clone()
        # We sample a few tokens in each sequence for MLM training (with probability `self.mlm_probability`)
        r"""
        labels = tensor(
       [[  101,   169,   107,  ..., 10539,   107,   102],
        [  101,   169,   107,  ...,   100,   100,   102],
        [  101,   169,   107,  ...,   100,   100,   102],
        ...,
        [  101,   169,   107,  ...,   100,   100,   102],
        [  101,   169,   107,  ...,   100,   100,   102],
        [  101,   169,   107,  ...,   117,   169,   102]])
        """
        probability_matrix = torch.full(labels.shape, self.mlm_probability)
        r"""
        probability_matrix = 
        tensor([[0.1500,0.1500,...],
                [0.1500,0.1500,...],
                ..................
            
        """
        if special_tokens_mask is None:
            special_tokens_mask = [
                self.tokenizer.get_special_tokens_mask(val, already_has_special_tokens=True) for val in labels.tolist()
            ]
            special_tokens_mask = torch.tensor(special_tokens_mask, dtype=torch.bool)
        else:
            special_tokens_mask = special_tokens_mask.bool()

        probability_matrix.masked_fill_(special_tokens_mask, value=0.0)
        masked_indices = torch.bernoulli(probability_matrix).bool()
        labels[~masked_indices] = -100  # We only compute loss on masked tokens

        # 80% of the time, we replace masked input tokens with tokenizer.mask_token ([MASK])
        indices_replaced = torch.bernoulli(torch.full(labels.shape, 0.8)).bool() & masked_indices
        inputs[indices_replaced] = self.tokenizer.convert_tokens_to_ids(self.tokenizer.mask_token)

        # 10% of the time, we replace masked input tokens with random word
        indices_random = torch.bernoulli(torch.full(labels.shape, 0.5)).bool() & masked_indices & ~indices_replaced
        random_words = torch.randint(len(self.tokenizer), labels.shape, dtype=torch.long)
        inputs[indices_random] = random_words[indices_random]

        # The rest of the time (10% of the time) we keep the masked input tokens unchanged
        return inputs, labels

首先复制一下对应的labels的值

labels = inputs.clone()

labels = tensor(
	   [[  101,   169,   107,  ..., 10539,   107,   102],
        [  101,   169,   107,  ...,   100,   100,   102],
        [  101,   169,   107,  ...,   100,   100,   102],
        ...,
        [  101,   169,   107,  ...,   100,   100,   102],
        [  101,   169,   107,  ...,   100,   100,   102],
        [  101,   169,   107,  ...,   117,   169,   102]]
)

接着调用对应的probability_matrix矩阵

probability_matrix = torch.full(labels.shape,self.mlm_probability)

得到的对应的probability_matrix矩阵

probability_matrix = 
tensor([[0.1500,0.1500,...],
        [0.1500,0.1500,...],
        ..................
        [0.1500,0.1500,...]])

接下来查看对于masked_indices的调用

if special_tokens_mask is None:
    special_tokens_mask = [
        self.tokenizer.get_special_tokens_mask(val, already_has_special_tokens=True) for val in labels.tolist()
    ]
    print('special_tokens_mask1 = ')
    print(special_tokens_mask)
    special_tokens_mask = torch.tensor(special_tokens_mask, dtype=torch.bool)
    print('special_tokens_mask2 = ')
    print(special_tokens_mask)
else:
    special_tokens_mask = special_tokens_mask.bool()

得到对应的内容为

special_tokens_mask1 = 
[[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1],
.....................
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1]]

对应的special_tokens_mask2的内容为

special_tokens_mask2 = 
tensor([[ True, False, False,  ..., False, False,  True],
        ...,
        [ True, False, False,  ..., False, False,  True]])

这里调用special_tokens_mask1需要调用get_special_tokens_mask的函数内容

special_tokens_mask = [
	self.tokenizer.get_special_tokens_mask(val,already_head_special_tokens=True) for valu in labels.tolist()
]

下一篇博客继续解读相应的代码内容

唐僧爱吃唐僧肉
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
imdb自然语言处理bert预训练数据
01-27
标题"imdb自然语言处理bert预训练数据"指的是将BERT模型应用于IMDb数据集进行预训练的过程。IMDb是一个大型电影和电视节目的数据库，包含了观众和评论者的评价，这些评价构成了丰富的文本资源，适合用于情感分析任务...
ChatGLM 官方ptuning2训练参数解析
人工智能曾小健
06-30 2099
这是一个环境变量，代表序列的预设长度为128。LR=2e-2： 另一个环境变量，代表学习率为0.02。：此环境变量用于设置哪些GPU可见，这里设置为只有第0个GPU可见。--do_train：此参数指示程序进行训练。：用于训练的文件路径。：用于验证的文件路径。：在输入数据中，用于作为输入的列名是“content”。：在输入数据中，用于作为目标的列名是“summary”。：此参数指示如果缓存存在，将覆盖它。：预训练模型的名称或路径。：输出目录的路径。：此参数指示如果输出目录存在，将覆盖它。
用了这个技术，我让模型训练和推理快了好几倍
算法码上来
09-07 1017
❤️点击上方，选择星标或置顶，每天给你送上干货❤️作者 | godweiyang出品 | 公众号：算法码上来（ID：GodNLP）- BEGIN-什么技术呢？就是量化，别激动，不是量化交易，这里是指模型精度上的int8量化。Transformer系列模型都在用吧？Hugging Face都在用吧？Fairseq都在用吧？那你们训练和推理的时候没有觉得很慢吗？之前教过你们怎么用LightSeq来加...
怎么看TRAIN_BATCH_SIZE是多少？
最新发布
qq_34425255的博客
06-10 275
所以86乘以2刚好等于172，这就对应上了train_coco.json里面的images字段。分析：这里的86表示的意思是总共有86个batch，每个batch是2。由于TRAIN_BATCH_SIZE = 2。
5分钟NLP：使用 HuggingFace 微调BERT 并使用 TensorBoard 可视化
deephub
03-10 7208
上篇文章我们已经介绍了Hugging Face的主要类，在本文中将介绍如何使用Hugging Face进行BERT的微调进行评论的分类。其中包含：AutoTokenizer、AutoModel、Trainer、TensorBoard、数据集和指标的使用方法。 在本文中，我们将只关注训练和测试拆分。每个数据集都由一个文本特征（评论的文本）和一个标签特征（表示评论的好坏）组成。 from datasets import load_dataset, load_metric task = "imdb" data
大模型ChatGLM Lora微调的参数详探- 多卡版本
人工智能曾小健
07-04 3061
但是，如果你想要尝试提高模型的精度，可能需要试验不同的batch size。不同的深度学习框架可能会有不同的命名规则，一般来说，xxit/s是每秒钟处理的批次（batch）数量，而不是每秒处理的数据条数。比如，如果我们有1000个样本的数据集，我们可以设置batch size为100，那么我们就会将数据集分成10批，每批包含100个样本，然后逐一将这10批数据输入到模型中进行训练。：这是一个标志，表示如果你的缓存中已经存在预处理过的数据集，那么这个标志会让你的程序忽略这些数据，重新预处理数据。
用自己的数据增量训练预训练语言模型
qq_22472047的博客
04-08 4898
预训练模型给各类NLP任务的性能带来了巨大的提升，预训练模型通常是在通用领域的大规模文本上进行训练的。而很多场景下，使用预训练语言模型的下游任务是某些特定场景，如金融，法律等。这是如果可以用这些垂直领域的语料继续训练原始的预训练模型，对于下游任务往往会有更大的提升。 以BERT为例，利用huggingface的tranformers介绍一下再训练的方式： 1. 定义tokenizer bert的预训练模式一般分为，Masked language model (MLM)与 next sentence p
用于各类文本的BERT二次预训练.zip
01-07
在二次预训练过程中，我们可以针对特定领域的文本调整掩码策略，或者优化损失函数，以使模型更适应新的任务需求。 接下来是**P-tuning任务**，这是近年来提出的一种增强BERT的方法，它引入了prompt（提示）的概念。...
基于python的中文预训练RoBERTa模型型
03-21
RoBERTa在BERT的基础上进行了优化，特别是在预训练阶段的数据量、训练时长以及学习率策略等方面进行了调整，使得模型在多项NLP任务上表现出更优的性能。而Python作为最流行的编程语言之一，为开发和应用这些模型提供...
基于预训练模型的文本情感分析
02-06
这个过程展示了如何将预训练模型应用于实际任务，通过少量的调整和训练，即可将模型的能力应用到新的数据集上，实现高效的情感分析。在实际应用中，还可以考虑优化模型参数、增加多类情感分类、集成学习等策略来...
情感分析评论训练数据
09-21
本文将深入探讨一种特别针对情感分析训练的数据集——"情感分析评论训练数据"，并结合深度学习技术，解析其在训练模型过程中的关键作用。 "情感分析评论训练数据"主要包含大量带有标注的评论文本，这些文本主要来源...
小样本学习分类任务：在文心ERNIE3.0应用（提示学习），提速提效快用起来！
m0_63642362的博客
09-04 2103
小样本学习在文心模型多分类任务应用（提示学习）
如何使用transformers的trainer.train()函数如何训练自定义Bert的下游模型，并进行评估
weixin_44002458的博客
04-13 4948
训练模型：使用 Trainer.train() 函数训练模型。准备数据集：将原始数据集转换为适合 BERT 模型训练的格式，例如使用 tokenizer 对文本进行编码，将标签转换为数字等。定义数据加载器：使用 Dataset 和 DataLoader 对数据集进行加载和处理，以便在训练期间以批量的方式输入模型。创建 Trainer 对象：使用自定义的模型、数据加载器、训练参数和评估指标创建 Trainer 对象。定义模型：定义一个自定义的 BERT 模型，并根据任务类型添加相应的输出层。
预训练模型transformers综合总结（三）
yingdajun的博客
02-05 6224
这就是最后的部分，关于语言建模、多选、问答系统、文本分类、命名实体识别等任务的模型微调，这一块我也是直接看人家笔记本总结的。按照这三个部分，这个库基本就弄熟了 语言建模 主要有这两种方式进行建模 因果语言建模：模型必须预测句子中的下一个标记（因此标签与向右移动的输入相同）。为确保模型不作弊，当尝试预测句子中的标记i + 1时，它将获得一个注意掩码，以防止其访问标记i之后的标记。 屏蔽语言建模：模型必须预测输入中被屏蔽的一些标记。它仍然可以访问整个句子，因此它可以在屏蔽标记之前和之后使用标记来预测其值
大语言模型占显存的计算和优化
weixin_72100405的博客
01-04 865
gradient_accumulation_steps（per_device_train_batch_size*gradient_accumulation_steps=计算梯度的数据数）gradient_checkpointing（前项激活值里面有很多是不需要存的，可以在反向传播再次计算的）per_device_train_batch_size（相当于batch size，越小显存占的越小）optim（可以改为adafactor）冻结参数（只训练下游任务的参数）将max_length减小。
NLP文档挖宝(3)——能够快速设计参数的TrainingArguments类
天才小呵呵的博客
05-29 7554
整个任务中的调参“源泉”就是这个TrainingArguments类，这个类是使用dataclass装饰器进行包装，然后再利用HfArgumentParser进行参数的解析，最后获得了对应的内容。这个包可以调的参数有很多，有用的也有很多，所以还是有必要一起看一下的。
一本读懂BERT(实践篇)
热门推荐
程序猿废柴的博客
04-18 4万+
目录 一、什么是BERT？ 二、BERT安装 三、预训练模型 四、运行Fine-Tuning 五、数据读取源码阅读 （一） DataProcessor （二） MrpcProcessor 六、分词源码阅读 （一）FullTokenizer （二） WordpieceTokenizer 七、run_classifier.py的main函数 八、BertModel类 九、自己...
训练BERT，我只花了一半的时间
算法码上来
07-14 1459
相信很多人都知道Hugging Face，也都用过它的Transformers预训练语言模型，但你们有没有觉得它训练的有点太慢了呢？这时候，字节第二快的男人要站出来了（第一快是我mentor），手把手教你怎么让训练时间缩短一半。训练BERT首先我们要安装Transformers库，这很简单：pip install transformers然后我们直接把官方的例子拷贝下来，这里我们用的是GLUE任务...
一、train_epochs及batch_size的理解
weixin_53262883的博客
12-01 4131
batch_size：每次使用训练的样本数量 epochs:跑完所有的训练数据
预训练模型实现词性分析
05-31
预训练模型实现词性分析的一种方法是使用BERT等预训练语言模型。具体而言，我们可以首先使用大规模文本数据对BERT进行预训练，然后使用Fine-tuning技术对BERT进行微调，从而得到一个针对特定任务（如词性分析）的模型。 在微调过程中，我们可以采用一些技巧来提高模型的性能，比如在输入中加入特殊的标记以指示每个词的位置、引入注意力机制等。此外，在微调时，我们需要准备一个包含已标注词性信息的数据集，然后使用该数据集对模型进行训练。 在实际应用中，我们可以使用该模型对输入文本进行词性分析。具体而言，我们将待分析的文本输入到模型中，模型会输出每个单词对应的词性标签。这样，我们就可以通过模型来自动进行词性分析。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值