[ehealth] fix problems in sequence classification

Author: LemonNoel

examples/biomedical/cblue/README.md

@@ -0,0 +1,85 @@
+# 使用医疗领域预训练模型Fine-tune完成中文医疗语言理解任务
+
+近年来，预训练语言模型（Pre-trained Language Model，PLM）逐渐成为自然语言处理（Natural Language Processing，NLP）的主流方法。这类模型可以利用大规模的未标注语料进行训练，得到的模型在下游NLP任务上效果明显提升，在通用领域和特定领域均有广泛应用。在医疗领域，早期的做法是在预先训练好的通用语言模型上进行Fine-tune。后来的研究发现直接使用医疗相关语料学习到的预训练语言模型在医疗文本任务上的效果更好，采用的模型结构也从早期的BERT演变为更新的RoBERTa、ALBERT和ELECTRA。
+
+本示例展示了中文医疗预训练模型eHealth（[Building Chinese Biomedical Language Models via Multi-Level Text Discrimination](https://arxiv.org/abs/2110.07244)）如何Fine-tune完成中文医疗语言理解任务。
+
+## 模型介绍
+
+本项目针对中文医疗语言理解任务，开源了中文医疗预训练模型eHealth（简写`chinese-ehealth`）。eHealth使用了医患对话、科普文章、病历档案、临床病理学教材等脱敏中文语料进行预训练，通过预训练任务设计来学习词级别和句级别的文本信息。该模型的整体结构与ELECTRA相似，包括生成器和判别器两部分。 而Fine-tune过程只用到了判别器模块，由12层Transformer网络组成。
+
+## 数据集介绍
+
+本项目使用了中文医学语言理解测评（[Chinese Biomedical Language Understanding Evaluation，CBLUE](https://github.com/CBLUEbenchmark/CBLUE)）数据集，[<sup>[1]</sup>](#refer-anchor-cblue)其包括医学文本信息抽取（实体识别、关系抽取）、医学术语归一化、医学文本分类、医学句子关系判定和医学问答共5大类任务8个子任务。
+
+* CMeEE：中文医学命名实体识别
+* CMeIE：中文医学文本实体关系抽取
+* CHIP-CDN：临床术语标准化任务
+* CHIP-CTC：临床试验筛选标准短文本分类
+* CHIP-STS：平安医疗科技疾病问答迁移学习
+* KUAKE-QIC：医疗搜索检索词意图分类
+* KUAKE-QTR：医疗搜索查询词-页面标题相关性
+* KUAKE-QQR：医疗搜索查询词-查询词相关性
+
+更多信息可参考CBLUE的[github](https://github.com/CBLUEbenchmark/CBLUE/blob/main/README_ZH.md)。其中对于临床术语标准化任务（CHIP-CDN），我们按照eHealth中的方法通过检索将原多分类任务转换为了二分类任务，即给定一诊断原词和一诊断标准词，要求判定后者是否是前者对应的诊断标准词。本项目提供了检索处理后的CHIP-CDN数据集（简写`CHIP-CDN-2C`），且构建了基于该数据集的example代码。
+
+## 快速开始
+
+### 代码结构说明
+
+以下是本项目主要代码结构及说明：
+
+```text
+cblue/
+├── README.md # 使用说明
+└── train_classification.py # 分类任务训练评估脚本
+```
+
+### 模型训练
+
+我们按照任务类别划分，同时提供了8个任务的样例代码。可以运行下边的命令，在训练集上进行训练，并在开发集上进行验证。
+
+```shell
+$ unset CUDA_VISIBLE_DEVICES
+$ python -m paddle.distributed.launch --gpus "0,1,2,3" train.py --dataset CHIP-CDN-2C --batch_size 256 --max_seq_length 32 --learning_rate 3e-5 --epochs 16
+```
+
+### 训练参数设置（Training setup）及结果
+
+| Task      | epochs | batch_size | learning_rate | max_seq_length | results |
+| --------- | :----: | :--------: | :-----------: | :------------: | :-----: |
+| CHIP-STS  |   16   |     32     |      1e-4     |       96       | 0.88550 |
+| CHIP-CTC  |   16   |     32     |      3e-5     |      160       | 0.82790 |
+| CHIP-CDN  |   16   |    256     |      3e-5     |       32       | 0.76979 |
+| KUAKE-QQR |   16   |     32     |      6e-5     |       64       | 0.82364 |
+| KUAKE-QTR |   12   |     32     |      6e-5     |       64       | 0.69653 |
+| KUAKE-QIC |    4   |     32     |      6e-5     |      128       | 0.81176 |
+
+
+可支持配置的参数：
+
+* `save_dir`：可选，保存训练模型的目录；默认保存在当前目录checkpoints文件夹下。
+* `dataset`：可选，CHIP-CDN-2C CHIP-CTC CHIP-STS KUAKE-QIC KUAKE-QTR KUAKE-QQR，默认为KUAKE-QIC数据集。
+* `max_seq_length`：可选，ELECTRA模型使用的最大序列长度，最大不能超过512, 若出现显存不足，请适当调低这一参数；默认为128。
+* `batch_size`：可选，批处理大小，请结合显存情况进行调整，若出现显存不足，请适当调低这一参数；默认为32。
+* `learning_rate`：可选，Fine-tune的最大学习率；默认为6e-5。
+* `weight_decay`：可选，控制正则项力度的参数，用于防止过拟合，默认为0.01。
+* `epochs`: 训练轮次，默认为3。
+* `valid_steps`: evaluate的间隔steps数，默认100。
+* `save_steps`: 保存checkpoints的间隔steps数，默认100。
+* `logging_steps`: 日志打印的间隔steps数，默认10。
+* `warmup_proption`：可选，学习率warmup策略的比例，如果0.1，则学习率会在前10%训练step的过程中从0慢慢增长到learning_rate, 而后再缓慢衰减，默认为0.1。
+* `init_from_ckpt`：可选，模型参数路径，热启动模型训练；默认为None。
+* `seed`：可选，随机种子，默认为1000.
+* `device`: 选用什么设备进行训练，可选cpu或gpu。如使用gpu训练则参数gpus指定GPU卡号。
+* `use_amp`: 是否使用混合精度训练，默认为False。
+* `use_ema`: 是否使用Exponential Moving Average预测，默认为False。
+
+### 依赖安装
+
+```shell
+pip install xlrd==1.2.0
+```
+
+<div id="refer-anchor-cblue"></div>
+- [1] CBLUE: A Chinese Biomedical Language Understanding Evaluation Benchmark [pdf](https://arxiv.org/abs/2106.08087) [git](https://github.com/CBLUEbenchmark/CBLUE) [web](https://tianchi.aliyun.com/specials/promotion/2021chinesemedicalnlpleaderboardchallenge)

examples/biomedical/cblue/sequence_classification/README.md

@@ -27,7 +27,7 @@
 from paddlenlp.data import Stack, Tuple, Pad
 from paddlenlp.datasets import load_dataset
 from paddlenlp.transformers import LinearDecayWithWarmup
-from paddlenlp.metrics import MultiLabelsMetric
+from paddlenlp.metrics import MultiLabelsMetric, AccuracyAndF1
 from paddlenlp.ops.optimizer import ExponentialMovingAverage
 
 from utils import convert_example
@@ -36,30 +36,27 @@
     'KUAKE-QIC': Accuracy,
     'KUAKE-QQR': Accuracy,
     'KUAKE-QTR': Accuracy,
-    'CHIP-CTC': partial(
-        MultiLabelsMetric, name='macro'),
-    'CHIP-STS': partial(
-        MultiLabelsMetric, name='macro'),
-    'CHIP-CDN-2C': partial(
-        MultiLabelsMetric, name='micro')
+    'CHIP-CTC': MultiLabelsMetric,
+    'CHIP-STS': MultiLabelsMetric,
+    'CHIP-CDN-2C': AccuracyAndF1
 }
 
 # yapf: disable
 parser = argparse.ArgumentParser()
 parser.add_argument('--dataset', choices=['KUAKE-QIC', 'KUAKE-QQR', 'KUAKE-QTR', 'CHIP-STS', 'CHIP-CTC', 'CHIP-CDN-2C'],
-                                 default='KUAKE-QIC', type=str, help='Dataset for token classfication tasks.')
+                                 default='KUAKE-QIC', type=str, help='Dataset for sequence classfication tasks.')
 parser.add_argument('--seed', default=1000, type=int, help='Random seed for initialization.')
 parser.add_argument('--device', choices=['cpu', 'gpu', 'xpu', 'npu'], default='gpu', help='Select which device to train model, default to gpu.')
-parser.add_argument('--epochs', default=3, type=int, help='Total number of training epochs to perform.')
+parser.add_argument('--epochs', default=3, type=int, help='Total number of training epochs.')
 parser.add_argument('--batch_size', default=32, type=int, help='Batch size per GPU/CPU for training.')
 parser.add_argument('--learning_rate', default=6e-5, type=float, help='Learning rate for fine-tuning sequence classification task.')
-parser.add_argument('--weight_decay', default=0.01, type=float, help="Weight decay if we apply some.")
-parser.add_argument('--warmup_proportion', default=0.1, type=float, help='Linear warmup proportion over the training process.')
+parser.add_argument('--weight_decay', default=0.01, type=float, help="Weight decay of optimizer if we apply some.")
+parser.add_argument('--warmup_proportion', default=0.1, type=float, help='Linear warmup proportion of learning rate over the training process.')
 parser.add_argument('--max_seq_length', default=128, type=int, help='The maximum total input sequence length after tokenization.')
 parser.add_argument('--init_from_ckpt', default=None, type=str, help='The path of checkpoint to be loaded.')
 parser.add_argument('--logging_steps', default=10, type=int, help='The interval steps to logging.')
 parser.add_argument('--save_dir', default='./checkpoint', type=str, help='The output directory where the model checkpoints will be written.')
-parser.add_argument('--save_steps', default=100, type=int, help='The interval steps to save checkppoints.')
+parser.add_argument('--save_steps', default=100, type=int, help='The interval steps to save checkpoints.')
 parser.add_argument('--valid_steps', default=100, type=int, help='The interval steps to evaluate model performance.')
 parser.add_argument('--use_ema', default=False, type=bool, help='Use exponential moving average for evaluation.')
 parser.add_argument('--use_amp', default=False, type=distutils.util.strtobool, help='Enable mixed precision training.')
@@ -100,9 +97,13 @@ def evaluate(model, criterion, metric, data_loader):
     if isinstance(metric, Accuracy):
         metric_name = 'accuracy'
         result = metric.accumulate()
+    elif isinstance(metric, MultiLabelsMetric):
+        metric_name = 'macro f1'
+        _, _, result = metric.accumulate('macro')
     else:
-        metric_name = metric._name + ' f1'
-        _, _, result = metric.accumulate(metric._name)
+        metric_name = 'micro f1'
+        _, _, _, result, _ = metric.accumulate()
+
     print('eval loss: %.5f, %s: %.5f' % (np.mean(losses), metric_name, result))
     model.train()
     metric.reset()
@@ -143,7 +144,10 @@ def do_train():
         'cblue', args.dataset, splits=['train', 'dev', 'test'])
 
     model = ppnlp.transformers.ElectraForSequenceClassification.from_pretrained(
-        'chinese-ehealth', num_classes=len(train_ds.label_list))
+        'chinese-ehealth',
+        num_classes=len(train_ds.label_list),
+        activation='tanh',
+        layer_norm_eps=1e-5)
     tokenizer = ppnlp.transformers.ElectraTokenizer.from_pretrained(
         'chinese-ehealth')
 
@@ -152,9 +156,9 @@ def do_train():
         tokenizer=tokenizer,
         max_seq_length=args.max_seq_length)
     batchify_fn = lambda samples, fn=Tuple(
-        Pad(axis=0, pad_val=tokenizer.pad_token_id),  # input
-        Pad(axis=0, pad_val=tokenizer.pad_token_type_id),  # segment
-        Pad(axis=0, pad_val=args.max_seq_length - 1),  # position
+        Pad(axis=0, pad_val=tokenizer.pad_token_id, dtype='int64'),  # input
+        Pad(axis=0, pad_val=tokenizer.pad_token_type_id, dtype='int64'),  # segment
+        Pad(axis=0, pad_val=args.max_seq_length - 1, dtype='int64'),  # position
         Stack(dtype='int64')): [data for data in fn(samples)]
     train_data_loader = create_dataloader(
         train_ds,
@@ -172,7 +176,8 @@ def do_train():
     if args.init_from_ckpt and os.path.isfile(args.init_from_ckpt):
         state_dict = paddle.load(args.init_from_ckpt)
         model.set_dict(state_dict)
-    model = paddle.DataParallel(model)
+    if paddle.distributed.get_world_size() > 1:
+        model = paddle.DataParallel(model)
 
     num_training_steps = len(train_data_loader) * args.epochs
 
@@ -196,10 +201,13 @@ def do_train():
     if METRIC_CLASSES[args.dataset] is Accuracy:
         metric = METRIC_CLASSES[args.dataset]()
         metric_name = 'accuracy'
-    else:
+    elif METRIC_CLASSES[args.dataset] is MultiLabelsMetric:
         metric = METRIC_CLASSES[args.dataset](
             num_labels=len(train_ds.label_list))
-        metric_name = metric._name + ' f1'
+        metric_name = 'macro f1'
+    else:
+        metric = METRIC_CLASSES[args.dataset]()
+        metric_name = 'micro f1'
     if args.use_amp:
         scaler = paddle.amp.GradScaler(init_loss_scaling=args.scale_loss)
     if args.use_ema and rank == 0:
@@ -222,8 +230,10 @@ def do_train():
 
             if isinstance(metric, Accuracy):
                 result = metric.accumulate()
+            elif isinstance(metric, MultiLabelsMetric):
+                _, _, result = metric.accumulate('macro')
             else:
-                _, _, result = metric.accumulate(metric._name)
+                _, _, _, result, _ = metric.accumulate()
 
             if args.use_amp:
                 scaler.scale(loss).backward()
@@ -259,11 +269,14 @@ def do_train():
                 save_dir = os.path.join(args.save_dir, 'model_%d' % global_step)
                 if not os.path.exists(save_dir):
                     os.makedirs(save_dir)
-                model._layers.save_pretrained(save_dir)
+                if paddle.distributed.get_world_size() > 1:
+                    model._layers.save_pretrained(save_dir)
+                else:
+                    model.save_pretrained(save_dir)
                 tokenizer.save_pretrained(save_dir)
                 tic_train = time.time()
-
-    print('Speed: %.2f steps/s' % (global_step / total_train_time))
+    if rank == 0:
+        print('Speed: %.2f steps/s' % (global_step / total_train_time))
 
 
 if __name__ == "__main__":