Awesome pre-trained models toolkit based on PaddlePaddle. (400+ models including Image, Text, Audio, Video and Cross-Modal with Easy Inference & Serving)
Traceback (most recent call last):
File "sequence_label.py", line 187, in <module>
main()
File "sequence_label.py", line 159, in main
seq_label_task.finetune_and_eval()
File "/home/gaolu/miniconda3/envs/paddlehub_env3/lib/python3.6/site-packages/paddlehub/finetune/task/base_task.py", line 945, in finetune_and_eval
return self.finetune(do_eval=True)
File "/home/gaolu/miniconda3/envs/paddlehub_env3/lib/python3.6/site-packages/paddlehub/finetune/task/base_task.py", line 960, in finetune
self.init_if_necessary()
File "/home/gaolu/miniconda3/envs/paddlehub_env3/lib/python3.6/site-packages/paddlehub/finetune/task/base_task.py", line 384, in init_if_necessary
if not self.load_checkpoint():
File "/home/gaolu/miniconda3/envs/paddlehub_env3/lib/python3.6/site-packages/paddlehub/finetune/task/base_task.py", line 911, in load_checkpoint
main_program=self.main_program)
File "/home/gaolu/miniconda3/envs/paddlehub_env3/lib/python3.6/site-packages/paddlehub/finetune/task/base_task.py", line 545, in main_program
self._build_env()
File "/home/gaolu/miniconda3/envs/paddlehub_env3/lib/python3.6/site-packages/paddlehub/finetune/task/base_task.py", line 462, in _build_env
self.loss, self.max_train_steps)
File "/home/gaolu/miniconda3/envs/paddlehub_env3/lib/python3.6/site-packages/paddlehub/finetune/strategy.py", line 471, in execute
scheduled_lr = self.scheduler_handler(max_train_steps)
File "/home/gaolu/miniconda3/envs/paddlehub_env3/lib/python3.6/site-packages/paddlehub/finetune/strategy.py", line 361, in scheduler_handler
cycle=False)
File "/home/gaolu/miniconda3/envs/paddlehub_env3/lib/python3.6/site-packages/paddle/fluid/layers/learning_rate_scheduler.py", line 347, in polynomial_decay
((1 - global_step / decay_steps) ** power) + end_learning_rate
File "/home/gaolu/miniconda3/envs/paddlehub_env3/lib/python3.6/site-packages/paddle/fluid/layers/math_op_patch.py", line 201, in __impl__
return scalar_method(self, float(other_var))
File "/home/gaolu/miniconda3/envs/paddlehub_env3/lib/python3.6/site-packages/paddle/fluid/layers/math_op_patch.py", line 183, in _scalar_elementwise_div_
return _scalar_elementwise_op_(var, 1.0 / value, 0.0)
ZeroDivisionError: float division by zero
调用finetune部分代码如下：
import argparse
import ast
import json
import numpy as np
import paddle.fluid as fluid
import paddlehub as hub
from paddlehub.dataset.base_nlp_dataset import BaseNLPDataset
from paddlehub.dataset import InputExample
from data_process import data_process
from data_process import schema_process
from data_process import write_by_lines
import sys
import csv
import codecs
csv.field_size_limit(sys.maxsize)
# yapf: disable
parser = argparse.ArgumentParser(__doc__)
parser.add_argument("--num_epoch", type=int, default=3, help="Number of epoches for fine-tuning.")
parser.add_argument("--use_gpu", type=ast.literal_eval, default=True, help="Whether use GPU for finetuning, input should be True or False")
parser.add_argument("--learning_rate", type=float, default=5e-5, help="Learning rate used to train with warmup.")
parser.add_argument("--data_dir", type=str, default=None, help="data save dir")
parser.add_argument("--schema_path", type=str, default=None, help="schema path")
parser.add_argument("--train_data", type=str, default=None, help="train data")
parser.add_argument("--dev_data", type=str, default=None, help="dev data")
parser.add_argument("--test_data", type=str, default=None, help="test data")
parser.add_argument("--predict_data", type=str, default=None, help="predict data")
parser.add_argument("--do_train", type=ast.literal_eval, default=False, help="do train")
parser.add_argument("--do_predict", type=ast.literal_eval, default=True, help="do predict")
parser.add_argument("--do_model", type=str, default="trigger", choices=["trigger", "role"], help="trigger or role")
parser.add_argument("--weight_decay", type=float, default=0.01, help="Weight decay rate for L2 regularizer.")
parser.add_argument("--warmup_proportion", type=float, default=0.1, help="Warmup proportion params for warmup strategy")
parser.add_argument("--max_seq_len", type=int, default=512, help="Number of words of the longest seqence.")
parser.add_argument("--eval_step", type=int, default=200, help="eval step")
parser.add_argument("--model_save_step", type=int, default=3000, help="model save step")
parser.add_argument("--batch_size", type=int, default=32, help="Total examples' number in batch for training.")
parser.add_argument("--add_crf", type=ast.literal_eval, default=True, help="add crf")
parser.add_argument("--checkpoint_dir", type=str, default=None, help="Directory to model checkpoint")
parser.add_argument("--use_data_parallel", type=ast.literal_eval, default=False, help="Whether use data parallel.")
args = parser.parse_args()
# yapf: enable.
# 先把数据处理好保存下来
train_data = data_process(args.train_data, args.do_model) # 处理训练数据
dev_data = data_process(args.dev_data, args.do_model) # 处理dev数据
test_data = data_process(args.test_data, args.do_model)
predict_sents, predict_data = data_process(args.predict_data, args.do_model, is_predict=True)
write_by_lines("{}/{}_train.tsv".format(args.data_dir, args.do_model), train_data)
write_by_lines("{}/{}_dev.tsv".format(args.data_dir, args.do_model), dev_data)
write_by_lines("{}/{}_test.tsv".format(args.data_dir, args.do_model), test_data)
write_by_lines("{}/{}_predict.tsv".format(args.data_dir, args.do_model), predict_data)
schema_labels = schema_process(args.schema_path, args.do_model)
class EEDataset(BaseNLPDataset):
"""EEDataset"""
def __init__(self, data_dir, labels, tokenizer=None,max_seq_len=None,model="trigger"):
# 数据集存放位置
self.base_path = data_dir
super(EEDataset, self).__init__(
base_path=self.base_path,
train_file="{}_train.tsv".format(model),
dev_file="{}_dev.tsv".format(model),
test_file="{}_test.tsv".format(model),
tokenizer= tokenizer,
max_seq_len=max_seq_len,
# 如果还有预测数据（不需要文本类别label），可以放在predict.tsv
predict_file="{}_predict.tsv".format(model),
train_file_with_header=True,
dev_file_with_header=True,
test_file_with_header=True,
predict_file_with_header=True,
# 数据集类别集合
label_list=labels)
def main():
# Load Paddlehub pretrained model
#model_name = "ernie_tiny"
model_name = "chinese-roberta-wwm-ext-large"
module = hub.Module(name=model_name)
inputs, outputs, program = module.context(
trainable=True, max_seq_len=args.max_seq_len)
# Download dataset and use SequenceLabelReader to read dataset
tokenizer = hub.BertTokenizer(vocab_file=module.get_vocab_path())
dataset = EEDataset(data_dir=args.data_dir, labels=schema_labels, tokenizer=tokenizer,
max_seq_len=args.max_seq_len,model=args.do_model)
reader = hub.reader.SequenceLabelReader(
dataset=dataset,
vocab_path=module.get_vocab_path(),
max_seq_len=args.max_seq_len,
sp_model_path=module.get_spm_path(),
word_dict_path=module.get_word_dict_path())
# Construct transfer learning network
# Use "sequence_output" for token-level output.
sequence_output = outputs["sequence_output"]
# Setup feed list for data feeder
# Must feed all the tensor of module need
feed_list = [
inputs["input_ids"].name, inputs["position_ids"].name,
inputs["segment_ids"].name, inputs["input_mask"].name
]
# Select a finetune strategy
strategy = hub.AdamWeightDecayStrategy(
warmup_proportion=args.warmup_proportion,
weight_decay=args.weight_decay,
learning_rate=args.learning_rate)
# Setup runing config for PaddleHub Finetune API
config = hub.RunConfig(
eval_interval=args.eval_step,
save_ckpt_interval=args.model_save_step,
use_data_parallel=args.use_data_parallel,
use_cuda=args.use_gpu,
num_epoch=args.num_epoch,
batch_size=args.batch_size,
checkpoint_dir=args.checkpoint_dir,
strategy=strategy)
# Define a sequence labeling finetune task by PaddleHub's API
# If add crf, the network use crf as decoder
seq_label_task = hub.SequenceLabelTask(
dataset=dataset,
feature=sequence_output,
# feed_list=feed_list,
max_seq_len=args.max_seq_len,
num_classes=dataset.num_labels,
config=config,
add_crf=args.add_crf)
# Finetune and evaluate model by PaddleHub's API
# will finish training, evaluation, testing, save model automatically
if args.do_train:
print("start finetune and eval process")
seq_label_task.finetune_and_eval()
if args.do_predict:
print("start predict process")
ret = []
id2label = {val: key for key, val in reader.label_map.items()}
input_data = [[d] for d in predict_data]
run_states = seq_label_task.predict(data=input_data[1:])
results = []
for batch_states in run_states:
batch_results = batch_states.run_results
batch_infers = batch_results[0].reshape([-1]).astype(np.int32).tolist()
seq_lens = batch_results[1].reshape([-1]).astype(np.int32).tolist()
current_id = 0
for length in seq_lens:
seq_infers = batch_infers[current_id:current_id + length]
seq_result = list(map(id2label.get, seq_infers[1: -1]))
current_id += length if args.add_crf else args.max_seq_len
results.append(seq_result)
ret = []
for sent, r_label in zip(predict_sents, results):
sent["labels"] = r_label
ret.append(json.dumps(sent, ensure_ascii=False))
write_by_lines("{}.{}.pred".format(args.predict_data, args.do_model), ret)
if __name__ == "__main__":
main()
KPatr1ck
commented
3 years ago
@Steffy-zxf
在使用paddle1.8进行finetune时，系统自动下载的数据集没问题，切换到自定义数据集finetune时，报错，错误如下：
调用finetune部分代码如下：