跳转至

BERT

模型概述

BERT(Bidirectional Encoder Representations from Transformers)是NLP领域的一种新型预训练模型。本案例中,基于论文BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding实现了BERT模型的OneFlow版本。

模型架构

Model Hidden layers Hidden unit size Attention heads Feedforward filter size Max sequence length Parameters
BERTBASE 12 encoder 768 12 4 x 768 512 110M

BERT在实际应用中往往分为两步:

  • 首先,预训练得到BERT语言模型;

  • 然后,为满足下游应用,在得到的BERT语言模型的基础上,多加一层网络,并进行微调,得到下游应用。

快速开始

获取相关数据集

我们提供了完成BERT预训练及SQuAD微调的OFRecord数据集及相关数据文件,可以通过以下命令下载并解压:

wget https://oneflow-static.oss-cn-beijing.aliyuncs.com/oneflow-tutorial-attachments/bert_squad_dataset.zip
unzip bert_squad_dataset.zip
解压后的文件目录清单如下:

  • bert_config.json、vocab.txt:制作prediction json文件需要的文件,来自google bert

  • dev-v1.1/、dev-v1.1.json:SQuAD检验集,用于打分

  • part-0:预训练集样本(40个样本)

  • train-v1.1:SQuAD训练集,已经转为ofrecord数据集格式

以上各个文件将在下文的预训练任务、SQuAD微调中使用到。

训练BERT模型

首先,克隆OneFlow-Benchmark仓库。

git clone https://github.com/Oneflow-Inc/OneFlow-Benchmark.git
cd OneFlow-Benchmark/LanguageModeling/BERT/

然后,通过以下命令,使用我们预训练好的pretrain模型以及小型样本集合,开始BERT预训练查看效果:

python ./run_pretraining.py\
    --gpu_num_per_node=1 \
    --learning_rate=3e-5 \
    --batch_size_per_device=1 \
    --iter_num=3 \
    --loss_print_every_n_iter=50 \
    --seq_length=128 \
    --max_predictions_per_seq=20 \
    --num_hidden_layers=12 \
    --num_attention_heads=12 \
    --max_position_embeddings=512 \
    --type_vocab_size=2 \
    --vocab_size=30522 \
    --attention_probs_dropout_prob=0.0 \
    --hidden_dropout_prob=0.0 \
    --hidden_size_per_head=64 \
    --use_boxing_v2=True \
    --data_dir=./dataset/ \
    --data_part_num=1 \
    --log_dir=./bert_regresssioin_test/of \
    --loss_print_every_n_iter=5 \
    --model_save_dir=./bert_regresssioin_test/of \
    --warmup_batches 831 \
    --save_last_snapshot True 
我们将获得类似以下输出:
==================================================================
Running bert: num_gpu_per_node = 1, num_nodes = 1.
==================================================================
gpu_num_per_node = 1
node_num = 1
node_list = None
learning_rate = 3e-05
weight_decay_rate = 0.01
batch_size_per_device = 1
iter_num = 20
warmup_batches = 831
log_every_n_iter = 1
data_dir = ./dataset/
data_part_num = 1
use_fp16 = None
use_boxing_v2 = True
loss_print_every_n_iter = 5
model_save_every_n_iter = 10000
model_save_dir = ./bert_regresssioin_test/of
save_last_snapshot = True
model_load_dir = None
log_dir = ./bert_regresssioin_test/of
seq_length = 128
max_predictions_per_seq = 20
num_hidden_layers = 12
num_attention_heads = 12
max_position_embeddings = 512
type_vocab_size = 2
vocab_size = 30522
attention_probs_dropout_prob = 0.0
hidden_dropout_prob = 0.0
hidden_size_per_head = 64
------------------------------------------------------------------
Time stamp: 2020-07-06-19:09:29
I0706 19:09:29.605840639   34801 ev_epoll_linux.c:82]        Use of signals is disabled. Epoll engine will not be used
Init model on demand
iter 4, total_loss: 11.032, mlm_loss: 10.281, nsp_loss: 0.751, speed: 33.086(sec/batch), 0.151(sentences/sec)
iter 9, total_loss: 11.548, mlm_loss: 10.584, nsp_loss: 0.965, speed: 0.861(sec/batch), 5.806(sentences/sec)
iter 14, total_loss: 10.697, mlm_loss: 10.249, nsp_loss: 0.448, speed: 0.915(sec/batch), 5.463(sentences/sec)
iter 19, total_loss: 10.685, mlm_loss: 10.266, nsp_loss: 0.419, speed: 1.087(sec/batch), 4.602(sentences/sec)
Saving model to ./bert_regresssioin_test/of/last_snapshot.
------------------------------------------------------------------
average speed: 0.556(sentences/sec)
------------------------------------------------------------------

详细说明

脚本说明

分类 说明 所属
pretrain.py、bert.py 定义了BERT网络模型; BERT
run_pretraining.py 启动BERT训练的用户脚本,用户通过命令行参数进行BERT训练的训练环境及超参配置,各个参数的具体作用将在下文 脚本参数 中说明。 BERT
squad.py 定义了squad网络; SQuAD
run_squad.py 用于启动SQuAD的训练 SQuAD
run_squad_predict.py 使用训练好的SQuAD模型进行预测 SQuAD
npy2json.py 将OneFlow的预测结果转化为prediction json格式的必要脚本 SQuAD
convert_tf_ckpt_to_of.py 将TensorFlow模型转为OneFlow个模型格式 BERT/SQuAD

脚本参数

run_pretraining.py通过命令行参数配置包括超参在内的训练环境,可以通过 run_pretraining.py --help查看,以下是这些参数作用的具体说明:

  • gpu_num_per_node: 每个节点上GPU的数目,OneFlow要求每个节点的GPU数目必须一致

  • node_num: 节点数目,即分布式训练时的主机数目

  • node_list: 节点列表,如果节点数大于1,则需要通过node_list指定节点列表,节点列表为字符串形式,采用逗号分隔,如--node_num=2 --node_list="192.168.1.12,192.168.1.14"

  • learning_rate: Learning rate

  • weight_decay_rate:设置权重衰减率

  • batch_size_per_device: 分布式训练时每个设备上的batch大小

  • iter_num ITER_NUM: 训练的总轮数

  • warmup_batches: 预热轮数,默认值为10000

  • data_dir: OFRecord数据集的路径

  • data_part_num:OFRecord数据集目录下的数据文件数目

  • use_fp16: 是否使用fp16

  • use_boxing_v2: 是否使用boxing v2

  • loss_print_every_n_iter:训练中每隔多少轮打印一次训练信息(loss信息)

  • model_save_every_n_iter: 训练中每隔多少轮保存一次模型

  • model_save_dir: 模型存储路径

  • save_last_snapshot:指定最后一轮训练完成后,模型保存路径

  • model_load_dir:指定模型加载路径

  • log_dir LOG_DIR:指定日志路径

  • seq_length: 指定BERT句子长度,默认值为512

  • max_predictions_per_seq: 默认值为80

  • num_hidden_layers:隐藏层数目,默认值为24

  • num_attention_heads: Attention头数目,默认值为16

  • max_position_embeddings:

  • type_vocab_size

  • vocab_size

  • attention_probs_dropout_prob

  • hidden_dropout_prob

  • hidden_size_per_head

使用完整的Wikipedia + BookCorpus数据集

如果需要无到有进行BERT的pretrain训练,则需要使用较大的训练集。

如果感兴趣,可以通过google-research BERT的页面,下载tfrecord格式的数据集。再根据加载与准备OFRecord数据集中的方法,将TFRecord数据转为OFRecord数据集使用。

将Tensorflow的BERT模型转为OneFlow模型格式

如果想直接使用已经训练好的pretrained模型做fine-tune任务(如以下将展示的SQuAD),可以考虑直接从google-research BERT页面下载已经训练好的BERT模型。

再利用我们提供的convert_tf_ckpt_to_of.py脚本,将其转为OneFlow模型格式。转换过程如下:

首先,下载并解压某个版本的BERT模型,如uncased_L-12_H-768_A-12

wget https://storage.googleapis.com/bert_models/2020_02_20/uncased_L-12_H-768_A-12.zip
unzip uncased_L-12_H-768_A-12.zip -d uncased_L-12_H-768_A-12

然后,运行以下命令:

cd uncased_L-12_H-768_A-12/
cat > checkpoint <<ONEFLOW
model_checkpoint_path: "bert_model.ckpt" 
all_model_checkpoint_paths: "bert_model.ckpt" 
ONEFLOW

该命令将在解压目录下创建一个checkpoint文件,并写入以下内容:

model_checkpoint_path: "bert_model.ckpt" 
all_model_checkpoint_paths: "bert_model.ckpt" 

此时,已经准备好待转化的tensorflow模型目录,整个模型目录的结构如下:

uncased_L-12_H-768_A-12
├── bert_config.json
├── bert_model.ckpt.data-00000-of-00001
├── bert_model.ckpt.index
├── checkpoint
└── vocab.txt

我们接着使用convert_tf_ckpt_to_of.py将tensorflow模型转为OneFlow模型:

python convert_tf_ckpt_to_of.py \
  --tf_checkpoint_path ./uncased_L-12_H-768_A-12 \
  --of_dump_path ./uncased_L-12_H-768_A-12-oneflow
以上命令,将转化好的OneFlow格式的模型保存在./uncased_L-12_H-768_A-12-oneflow目录下,供后续微调训练(如SQuAD)使用。

微调:SQuAD问答任务

将pretrained模型修改为SQuAD模型

我们只需要在BERT的backbone基础上,加上一层output层,并修改loss的表达式即可,完整的代码可以查看squad.py脚本,以下是几处关键修改:

def SQuADTrain():
    #...
    backbone = bert_util.BertBackbone()

    #在BERT的基础上加上一个全连接层
    with flow.name_scope("cls-squad"):
        final_hidden = backbone.sequence_output()
        final_hidden_matrix = flow.reshape(final_hidden, [-1, hidden_size])
        logits = bert_util._FullyConnected(
                    final_hidden_matrix,
                    hidden_size,
                    units=2,
                    weight_initializer=bert_util.CreateInitializer(initializer_range),
                    name='output')
        logits = flow.reshape(logits, [-1, seq_length, 2])

        start_logits = flow.slice(logits, [None, None, 0], [None, None, 1])
        end_logits = flow.slice(logits, [None, None, 1], [None, None, 1])

    #重新定义SQuAD任务的loss
        start_loss = _ComputeLoss(start_logits, start_positions_blob, seq_length)
        end_loss = _ComputeLoss(end_logits, end_positions_blob, seq_length)

        total_loss = 0.5*(start_loss + end_loss)

    return total_loss

为了得到一个初始化的squad模型,我们通过以下脚本启动squad训练,并保存模型。

python ./run_squad.py\
    --gpu_num_per_node=1\
    --learning_rate=3e-5\
    --batch_size_per_device=2\
    --iter_num=50\
    --loss_print_every_n_iter=50\
    --seq_length=384\
    --max_predictions_per_seq=20\
    --num_hidden_layers=12\
    --num_attention_heads=12\
    --max_position_embeddings=512\
    --type_vocab_size=2\
    --vocab_size=30522\
    --attention_probs_dropout_prob=0.0\
    --hidden_dropout_prob=0.0\
    --hidden_size_per_head=64\
    --use_boxing_v2=True\
    --data_dir=./dataset/train-v1.1\
    --data_part_num=1\
    --log_dir=./bert_regresssioin_test/of\
    --model_save_dir=./bert_regresssioin_test/of\
    --warmup_batches 831\
    --save_last_snapshot True
完成训练后,在./bert_regresssioin_test/of/last_snapshot中保存有初始化的SQuAD模型,我们将其与训练好的SQuAD合并后,进行微调(fine-tune)训练。

合并pretrained模型为SQuAD模型

SQuAD模型是在pretrained模型基础上的扩充,我们需要参照模型的加载与保存中的“模型部分初始化和部分导入”方法,将训练好的BERT pretrained模型与初始化的SQuAD模型合并。

cp -R ./bert_regresssioin_test/of/last_snapshot ./squadModel
cp -R --remove-destination ./dataset/uncased_L-12_H-768_A-12_oneflow/* ./squadModel/

OneFlow预训练模型的训练次数问题

OneFlow生成的模型目录中,会有一个名为System-Train-TrainStep-xxx的子目录(xxx为作业函数的函数名),该子目录下的out文件中,保存有训练总迭代数,并且这个迭代数会用于动态调节训练过程的learning rate

为了防止保存的迭代数影响到微调的训练,应该将out文件中的二进制数据清零:

cd System-Train-TrainStep-xxx
xxd -r > out <<ONEFLOW
00000000: 0000 0000 0000 0000
ONEFLOW

如果你使用的是由TensorFlow转过来的预训练模型,则可以省去这个步骤。

开始SQuAD训练

通过run_suqad.py脚本,开始训练SQuAD模型,主要配置如下:

  • 使用以上合并得到的SQuAD模型./squadModel

  • 采用SQuAD v1.1作为训练集

  • epoch = 3 (iternum = 88641*3/(4*8) = 8310)

  • learning rate = 3e-5

python ./run_squad.py\
    --gpu_num_per_node=4\
    --learning_rate=3e-5\
    --batch_size_per_device=8\
    --iter_num=8310\
    --loss_print_every_n_iter=50\
    --seq_length=384\
    --max_predictions_per_seq=20\
    --num_hidden_layers=12\
    --num_attention_heads=12\
    --max_position_embeddings=512\
    --type_vocab_size=2\
    --vocab_size=30522\
    --attention_probs_dropout_prob=0.0\
    --hidden_dropout_prob=0.0\
    --hidden_size_per_head=64\
    --use_boxing_v2=True\
    --data_dir=./dataset/train-v1.1\
    --data_part_num=8\
    --log_dir=./bert_regresssioin_test/of\
    --model_save_dir=./bert_regresssioin_test/of\
    --warmup_batches 831\
    --save_last_snapshot True\
    --model_load_dir=./squadModel

预测及打分

生成为了生成Preidiction File格式的json文件,我们先将预测结果保存为npy文件,再使用google BERT的run_squad.py中的write_predictions函数,转化为json格式。

利用run_squad_predict.py生成all_results.npy文件:

python run_squad_predict.py \
  --gpu_num_per_node=1 \
  --batch_size_per_device=4 \
  --iter_num=2709 \
  --seq_length=384 \
  --max_predictions_per_seq=20 \
  --num_hidden_layers=12 \
  --num_attention_heads=12 \
  --max_position_embeddings=512 \
  --type_vocab_size=2 \
  --vocab_size=30522 \
  --attention_probs_dropout_prob=0.0 \
  --hidden_dropout_prob=0.0 \
  --hidden_size_per_head=64 \
  --use_boxing_v2=True \
  --data_part_num=1 \
  --data_dir=./dataset/dev-v1.1 \
  --log_dir=./bert_regresssioin_test/of \
  --model_load_dir=path/to/squadModel \
  --warmup_batches 831
注意将以上model_load_dir修改为 训练好的 squadModel。

得到all_results.npy文件后,在google bert仓库目录下(注意该仓库的tensorflow版本为 tensorflow v1 ),运行我们提供的npy2json.py(由google bert中的run_squand.py修改得来):

python npy2json.py\
  --vocab_file=./dataset/vocab.txt \
  --bert_config_file=./dataset/bert_config.json \
  --do_train=False \
  --do_predict=True \
  --all_results_file=./all_results.npy \
  --predict_file=./dataset/dev-v1.1.json \
  --max_seq_length=384 \
  --doc_stride=128 \
  --output_dir=./squad_base/

注意将all_results_file修改为上一步得到的all_results.npy的路径。

最终,得到predictions.json文件,可以使用evaluate-v1.1.py进行打分。

python evaluate-v1.1.py \
./dataset/dev-v1.1.json \
path/to/squad_base/predictions.json 

分布式训练

如之前介绍脚本参数时描述:进行分布式训练,只需要在启动训练脚本式加入node_num选项指定主机数目及 node_list选项即可:

python run_squad_predict.py \
  --gpu_num_per_node=1 \
  --batch_size_per_device=4 \
  --iter_num=2709 \
  --seq_length=384 \
  --max_predictions_per_seq=20 \
  --num_hidden_layers=12 \
  --num_attention_heads=12 \
  --max_position_embeddings=512 \
  --type_vocab_size=2 \
  --vocab_size=30522 \
  --attention_probs_dropout_prob=0.0 \
  --hidden_dropout_prob=0.0 \
  --hidden_size_per_head=64 \
  --use_boxing_v2=True \
  --data_part_num=1 \
  --data_dir=./dataset/dev-v1.1 \
  --log_dir=./bert_regresssioin_test/of \
  --model_load_dir=path/to/squadModel \
  --warmup_batches 831 \
  --node_num=2 \
  --node_list="192.168.1.12,192.168.1.14"