全网最详细的Bert4torch入门教程

简介: 全网最详细的Bert4torch入门教程

本人经常会阅读苏神的科学空间网站,里面有很多对前言paper浅显易懂的解释,以及很多苏神自己的创新实践;并且基于bert4keras框架都有了相应的代码实现。但是由于本人主要用pytorch开发,因此参考bert4keras开发了bert4torch项目,实现了bert4keras的主要功能。


简介


bert4torch是一个基于pytorch的训练框架,前期以效仿和实现bert4keras的主要功能为主,方便加载多类预训练模型进行finetune,提供了中文注释方便用户理解模型结构。主要是期望应对新项目时,可以直接调用不同的预训练模型直接finetune,或方便用户基于bert进行魔改,快速验证自己的idea;节省在github上clone各种项目耗时耗力,且本地文件各种copy的问题。


  • pip安装

pip install bert4torch


github链接

https://github.com/Tongjilibo/bert4torch


主要功能


1、加载预训练权重(bert、roberta、albert、nezha、bart、RoFormer、ELECTRA、GPT、GPT2、T5)继续进行finetune

fd71209cd2fb26e4b09e64c424ab0583.png


目前支持的预训练模型一览

2、在bert基础上灵活定义自己模型:主要是可以接在bert的[btz, seq_len, hdsz]的隐含层向量后做各种魔改

3、调用方式和bert4keras基本一致,简洁高效

    model.fit(
        train_dataloader,
        steps_per_epoch=1000,
        epochs=epochs,
        callbacks=[evaluator]
    )

4、实现基于keras的训练进度条动态展示


fa1ceb7cc918c533c88fc62b9ce4d181.jpg

仿照keras的模型训练进度条

5、配合torchinfo,实现打印各层参数量功能

6b11a9724814cfb57da48cde31a3fb35.jpg


打印参数

6、结合logger,或者tensorboard可以在后台打印日志

支持在训练开始/结束,batch开始/结束,epoch的开始/结束,记录日志,写tensorboard等

class Callback(object):
    '''Callback基类    '''
    def __init__(self):
        pass
    def on_train_begin(self, logs=None):
        pass
    def on_train_end(self, logs=None):
        pass
    def on_epoch_begin(self, global_step, epoch, logs=None):
        pass
    def on_epoch_end(self, global_step, epoch, logs=None):
        pass
    def on_batch_begin(self, global_step, batch, logs=None):
        pass
    def on_batch_end(self, global_step, batch, logs=None):
        pass


7、集成多个example,可以作为自己的训练框架,方便在同一个数据集上尝试多种解决方案


7022683fbf70c6cd63653ee447eec4e2.jpg


实现多个example可供参考

支持的预训练权重(bert4torch)

b76545505c05db9c325813a3bd2dd17a.png

实战

1. 建模流程示例

# 建立分词器
tokenizer = Tokenizer(dict_path, do_lower_case=True)# 加载数据集,可以自己继承Dataset来定义
class MyDataset(ListDataset):
    @staticmethod
    def load_data(filenames):
        """读取文本文件,整理成需要的格式        """
        D = []
        return Ddef collate_fn(batch):
    '''处理上述load_data得到的batch数据,整理成对应device上的Tensor    注意:返回值分为feature和label, feature可整理成list或tuple    '''
    batch_token_ids, batch_segment_ids, batch_labels = [], [], []
    return [batch_token_ids, batch_segment_ids], batch_labels.flatten()# 加载数据集train_dataloader = DataLoader(MyDataset('file_path'), batch_size=batch_size, shuffle=True, collate_fn=collate_fn) # 定义bert上的模型结构,以文本二分类为例class Model(BaseModel):
    def __init__(self) -> None:
        super().__init__()
        self.bert = build_transformer_model(config_path, checkpoint_path, with_pool=True)
        self.dropout = nn.Dropout(0.1)
        self.dense = nn.Linear(768, 2)
    def forward(self, token_ids, segment_ids):
        # build_transformer_model得到的模型仅接受list/tuple传参,因此入参只有一个时候包装成[token_ids]
        hidden_states, pooled_output = self.bert([token_ids, segment_ids])
        output = self.dropout(pooled_output)
        output = self.dense(output)
        return outputmodel = Model().to(device)# 定义使用的loss和optimizer,这里支持自定义model.compile(
    loss=nn.CrossEntropyLoss(), # 可以自定义Loss
    optimizer=optim.Adam(model.parameters(), lr=2e-5),  # 可以自定义优化器
    scheduler=None, # 可以自定义scheduler
    metrics=['accuracy'])# 定义评价函数def evaluate(data):
    total, right = 0., 0.
    for x_true, y_true in data:
        y_pred = model.predict(x_true).argmax(axis=1)
        total += len(y_true)
        right += (y_true == y_pred).sum().item()
    return right / totalclass Evaluator(Callback):
    """评估与保存,这里定义仅在epoch结束后调用    """
    def __init__(self):
        self.best_val_acc = 0.
    def on_epoch_end(self, global_step, epoch, logs=None):
        val_acc = evaluate(valid_dataloader)
        if val_acc > self.best_val_acc:
            self.best_val_acc = val_acc
            model.save_weights('best_model.pt')
        print(f'val_acc: {val_acc:.5f}, best_val_acc: {self.best_val_acc:.5f}\n')
if __name__ == '__main__':
    evaluator = Evaluator()
    model.fit(train_dataloader, epochs=20, steps_per_epoch=100, grad_accumulation_steps=2, callbacks=[evaluator])

2. 主要模块讲解

1) 数据处理部分

a. 精简词表,并建立分词器

token_dict, keep_tokens = load_vocab(
    dict_path=dict_path,  # 词典文件路径
    simplified=True,  # 过滤冗余部分token,如[unused1]
    startswith=['[PAD]', '[UNK]', '[CLS]', '[SEP]'],  # 指定起始的token,如[UNK]从bert默认的103位置调整到1
)
tokenizer = Tokenizer(token_dict, do_lower_case=True)  # 若无需精简,仅使用当前行定义tokenizer即可


b. 好用的小函数


  • text_segmentate(): 截断总长度至不超过maxlen, 接受多个sequence输入,每次截断最长的句子,indices表示删除的token位置
  • tokenizer.encode(): 把text转成token_ids,默认句首添加[CLS],句尾添加[SEP],返回token_ids和segment_ids,相当于同时调用tokenizer.tokenize()和tokenizer.tokens_to_ids()
  • tokenizer.decode(): 把token_ids转成text,默认会删除[CLS], [SEP], [UNK]等特殊字符,相当于调用tokenizer.ids_to_tokens()并做了一些后处理
  • sequence_padding: 将序列padding到同一长度, 传入一个元素为list, ndarray, tensor的list,返回ndarry或tensor


2) 模型定义部分


  • 模型创建
'''调用模型后,若设置with_pool, with_nsp, with_mlm,则返回值依次为[hidden_states, pool_emb/nsp_emb, mlm_scores],否则只返回hidden_states'''
build_transformer_model(
    config_path=config_path, # 模型的config文件地址
    checkpoint_path=checkpoint_path, # 模型文件地址,默认值None表示不加载预训练模型
    model='bert', # 加载的模型结构,这里Model也可以基于nn.Module自定义后传入
    application='encoder',  # 模型应用,支持encoder,lm和unilm格式
    segment_vocab_size=2,  # type_token_ids数量,默认为2,如不传入segment_ids则需设置为0
    with_pool=False,  # 是否包含Pool部分
    with_nsp=False,  # 是否包含NSP部分
    with_mlm=False,  # 是否包含MLM部分
    return_model_config=False,  # 是否返回模型配置参数
    output_all_encoded_layers=False,  # 是否返回所有hidden_state层)
  • 定义loss,optimizer,scheduler等
'''定义使用的loss和optimizer,这里支持自定义'''
model.compile(
    loss=nn.CrossEntropyLoss(), # 可以自定义Loss
    optimizer=optim.Adam(model.parameters(), lr=2e-5),  # 可以自定义优化器
    scheduler=None, # 可以自定义scheduler
    adversarial_train={'name': 'fgm'},  # 训练trick方案设置,支持fgm, pgd, gradient_penalty, vat
    metrics=['accuracy']  # loss等默认打印的字段无需设置
)


  • 自定义模型


'''基于bert上层的各类魔改,如last2layer_average, token_first_last_average'''
class Model(BaseModel):
    # 需要继承BaseModel
    def __init__(self):
        super().__init__()
        self.bert = build_transformer_model(config_path, checkpoint_path)
    def forward(self):
        pass


  • 自定义训练过程
'''自定义fit过程,适用于自带fit()不满足需求时'''
class Model(BaseModel):
    def fit(self, train_dataloader, steps_per_epoch, epochs):   
        train_dataloader = cycle(train_dataloader)
        self.train()
        for epoch in range(epochs):
            for bti in range(steps_per_epoch):
                train_X, train_y = next(train_dataloader)
                output = self.forward(*train_X)
                loss = self.criterion(output, train_y)
                loss.backward()
                self.optimizer.step()
                self.optimizer.zero_grad()


  • 模型保存和加载
'''prefix: 是否以原始的key来保存,如word_embedding原始key为bert.embeddings.word_embeddings.weight默认为None表示不启用, 若基于BaseModel自定义模型,需指定为bert模型对应的成员变量名,直接使用设置为''主要是为了别的训练框架容易加载'''
model.save_weights(save_path, prefix=None)
model.load_weights(load_path, strict=True, prefix=None)
  • 加载transformers模型进行训练
from transformers import AutoModelForSequenceClassificationclass Model(BaseModel):
    def __init__(self):
        super().__init__()
        self.bert = AutoModelForSequenceClassification.from_pretrained("file_path", num_labels=2)
    def forward(self, token_ids, attention_mask, segment_ids):
        output = self.bert(input_ids=token_ids, attention_mask=attention_mask, token_type_ids=segment_ids)
        return output.logits

3) 模型评估部分


'''支持在多个位置执行'''
class Evaluator(Callback):
    """评估与保存    """
    def __init__(self):
        self.best_val_acc = 0.
    def on_train_begin(self, logs=None):  # 训练开始时候
        pass
    def on_train_end(self, logs=None):  # 训练结束时候
        pass
    def on_batch_begin(self, global_step, batch, logs=None):  # batch开始时候
        pass
    def on_batch_end(self, global_step, batch, logs=None):  # batch结束时候
        # 可以设置每隔多少个step,后台记录log,写tensorboard等
        # 尽量不要在batch_begin和batch_end中print,防止打断进度条功能
        pass
    def on_epoch_begin(self, global_step, epoch, logs=None):  # epoch开始时候
        pass
    def on_epoch_end(self, global_step, epoch, logs=None):  # epoch结束时候
        val_acc = evaluate(valid_dataloader)
        if val_acc > self.best_val_acc:
            self.best_val_acc = val_acc
            model.save_weights('best_model.pt')
        print(f'val_acc: {val_acc:.5f}, best_val_acc: {self.best_val_acc:.5f}\n')


3. 其他特性讲解

1) 单机多卡训练

a. 使用DataParallel

'''DP有两种方式,第一种是forward只计算logit,第二种是forward直接计算loss建议使用第二种,可以部分缓解负载不均衡的问题'''
from bert4torch.models import BaseModelDP
# ===========处理数据和定义model===========
model = BaseModelDP(model)  # 指定DP模式使用多gpu
model.compile(
    loss=lambda x, _: x.mean(),  # 多个gpu计算的loss的均值
    optimizer=optim.Adam(model.parameters(), lr=2e-5),  # 用足够小的学习率
)

b. 使用DistributedDataParallel


'''DDP使用torch.distributed.launch,从命令行启动'''
# 需要定义命令行参数
parser = argparse.ArgumentParser()
parser.add_argument("--local_rank", type=int, default=-1)
args = parser.parse_args()
torch.cuda.set_device(args.local_rank)
device = torch.device('cuda', args.local_rank)
torch.distributed.init_process_group(backend='nccl')
# ===========处理数据和定义model===========
# 指定DDP模型使用多gpu, master_rank为指定用于打印训练过程的local_rank
model = BaseModelDDP(
    model, master_rank=0, 
    device_ids=[args.local_rank], 
    output_device=args.local_rank, 
    find_unused_parameters=False
  )# 定义使用的loss和optimizer,这里支持自定义model.compile(
loss=lambda x, _: x,  # 直接把forward计算的loss传出来
optimizer=optim.Adam(model.parameters(), lr=2e-5),  # 用足够小的学习率)

2) tensorboard保存训练过程

from tensorboardX import SummaryWriterclass Evaluator(Callback):
    """每隔多少个step评估并记录tensorboard    """
    def on_batch_end(self, global_step, batch, logs=None):
        if global_step % 100 == 0:
            writer.add_scalar(f"train/loss", logs['loss'], global_step)
            val_acc = evaluate(valid_dataloader)
            writer.add_scalar(f"valid/acc", val_acc, global_step)


3) 打印训练参数

from torchinfo import summary
summary(model, input_data=next(iter(train_dataloader))[0])


相关文章
|
18天前
|
机器学习/深度学习 自然语言处理 PyTorch
Transformers入门指南:从零开始理解Transformer模型
【10月更文挑战第29天】作为一名机器学习爱好者,我深知在自然语言处理(NLP)领域,Transformer模型的重要性。自从2017年Google的研究团队提出Transformer以来,它迅速成为NLP领域的主流模型,广泛应用于机器翻译、文本生成、情感分析等多个任务。本文旨在为初学者提供一个全面的Transformers入门指南,介绍Transformer模型的基本概念、结构组成及其相对于传统RNN和CNN模型的优势。
44 1
|
6月前
|
机器学习/深度学习 PyTorch 算法框架/工具
详解Batch Normalization并基于PyTorch实操(附代码)
详解Batch Normalization并基于PyTorch实操(附代码)
168 2
|
机器学习/深度学习 数据采集 存储
基于PaddlePaddle的词向量实战 | 深度学习基础任务教程系列
基于PaddlePaddle的词向量实战 | 深度学习基础任务教程系列
|
机器学习/深度学习 PyTorch 算法框架/工具
PyTorch学习笔记(六):PyTorch进阶训练技巧
在源数据集上预训练一个神经网络模型,即源模型 创建一个新的神经网络模型,即目标模型,该模型复制了源模型上除输出层外的所有模型设计和参数 给目标模型添加一个输出大小为目标数据集类别个数的输出层,并随机初始化改成的模型参数
256 0
PyTorch学习笔记(六):PyTorch进阶训练技巧
|
数据挖掘 TensorFlow 算法框架/工具
TensorFlow教程(4)-Attention机制
TensorFlow教程(4)-Attention机制
419 0
TensorFlow教程(4)-Attention机制
|
机器学习/深度学习 编解码 PyTorch
PyTorch 零基础入门 GAN 模型之 cGAN
最早提出 cGAN 的是论文 《Conditional Generative Adversarial Nets》,为了达到条件生成的目的,我们在输入给生成器网络 G 的噪声 z 上 concat 一个标签向量 y, 告诉生成网络生成标签所指定的数据。对于输入给判别器 D 的数据,也 concat 这样的一个标签,告诉判别网络判断输入是否为真实的该类别数据。
757 0
PyTorch 零基础入门 GAN 模型之 cGAN
|
搜索推荐 算法 PyTorch
【Pytorch基础教程27】DeepFM推荐算法
DeepFM模型架构图 (出自论文 DeepFM: A Factorization-Machine based Neural Network for CTR Prediction) 由上图的DeepFM架构图看出:
1234 0
【Pytorch基础教程27】DeepFM推荐算法
|
机器学习/深度学习 PyTorch API
【PyTorch基础教程13】GoogleNet和ResNet
上节课主要讲了CNN的架构(如下图的LetNet5), 定义一个卷积层:输入通道数、输出通道数、卷积核的大小(长和宽)。卷积层要求输入输出是四维张量(B,C,W,H),全连接层的输入与输出都是二维张量(B,Input_feature)。
312 0
【PyTorch基础教程13】GoogleNet和ResNet
|
PyTorch 算法框架/工具
【PyTorch基础教程6】逻辑斯蒂回归
(1)和上一讲的模型训练是类似的,只是在线性模型的基础上加个sigmoid,然后loss函数改为交叉熵BCE函数(当然也可以用其他函数),另外一开始的数据y_data也从数值改为类别0和1(本例为二分类,注意x_data和y_data这里也是矩阵的形式)。 文章目录
228 0
【PyTorch基础教程6】逻辑斯蒂回归
|
算法框架/工具 Python
Py之keras-resnet:keras-resnet的简介、安装、使用方法之详细攻略
Py之keras-resnet:keras-resnet的简介、安装、使用方法之详细攻略
Py之keras-resnet:keras-resnet的简介、安装、使用方法之详细攻略