【NLP】bertorch: 基于 pytorch 的 bert 实现和下游任务微调

最新推荐文章于 2024-08-20 11:43:56 发布
最新推荐文章于 2024-08-20 11:43:56 发布
阅读量2.2k 收藏 1
点赞数
文章标签： 人工智能 python 机器学习 深度学习 tensorflow
原文链接：https://mp.weixin.qq.com/s?__biz=MzIwODI2NDkxNQ==&mid=2247503331&idx=3&sn=3fda9c3691dee92aa39f0691b04445c6&chksm=9707465fa070cf49b2cc6abf4315e2a43cf3c7532faa6c331a47a697a6b28d8e5253c42a18a8&scene=126&&sessionid=0
版权

bertorch ( https://github.com/zejunwang1/bertorch ) 是一个基于 pytorch 进行 bert 实现和下游任务微调的工具，支持常用的自然语言处理任务，包括文本分类、文本匹配、语义理解和序列标注等。

  • 1. 依赖环境

  • 2. 文本分类

  • 3. 文本匹配

  • 4. 语义理解

    • 4.1 SimCSE

    • 4.2 In-Batch Negatives

  • 5. 序列标注

1. 依赖环境

  • Python >= 3.6

  • torch >= 1.1

  • argparse

  • json

  • loguru

  • numpy

  • packaging

  • re

2. 文本分类

本项目展示了以 BERT 为代表的预训练模型如何 Finetune 完成文本分类任务。我们以中文情感分类公开数据集 ChnSentiCorp 为例，运行如下的命令，基于 DistributedDataParallel 进行单机多卡分布式训练，在训练集 (train.tsv) 上进行模型训练，并在验证集 (dev.tsv) 上进行评估：

CUDA_VISIBLE_DEVICES=0,1 python -m torch.distributed.launch --nproc_per_node=2 run_classifier.py --train_data_file ./data/ChnSentiCorp/train.tsv --dev_data_file ./data/ChnSentiCorp/dev.tsv --label_file ./data/ChnSentiCorp/labels.txt --save_best_model --epochs 3 --batch_size 32

可支持的配置参数：

usage: run_classifier.py [-h] [--local_rank LOCAL_RANK]
                         [--pretrained_model_name_or_path PRETRAINED_MODEL_NAME_OR_PATH]
                         [--init_from_ckpt INIT_FROM_CKPT] --train_data_file
                         TRAIN_DATA_FILE [--dev_data_file DEV_DATA_FILE]
                         --label_file LABEL_FILE [--batch_size BATCH_SIZE]
                         [--scheduler {linear,cosine,cosine_with_restarts,polynomial,constant,constant_with_warmup}]
                         [--learning_rate LEARNING_RATE]
                         [--warmup_proportion WARMUP_PROPORTION] [--seed SEED]
                         [--save_steps SAVE_STEPS]
                         [--logging_steps LOGGING_STEPS]
                         [--weight_decay WEIGHT_DECAY] [--epochs EPOCHS]
                         [--max_seq_length MAX_SEQ_LENGTH]
                         [--saved_dir SAVED_DIR]
                         [--max_grad_norm MAX_GRAD_NORM] [--save_best_model]
                         [--is_text_pair]

  • local_rank: 可选，分布式训练的节点编号，默认为 -1。

  • pretrained_model_name_or_path: 可选，huggingface 中的预训练模型名称或路径，默认为 bert-base-chinese。

  • train_data_file: 必选，训练集数据文件路径。

  • dev_data_file: 可选，验证集数据文件路径，默认为 None。

  • label_file: 必选，类别标签文件路径。

  • batch_size: 可选，批处理大小，请结合显存情况进行调整，若出现显存不足，请适当调低这一参数。默认为 32。

  • init_from_ckpt: 可选，要加载的模型参数路径，热启动模型训练。默认为None。

  • scheduler: 可选，优化器学习率变化策略，默认为 linear。

  • learning_rate: 可选，优化器的最大学习率，默认为 5e-5。

  • warmup_proportion: 可选，学习率 warmup 策略的比例，如果为 0.1，则学习率会在前 10% 训练 step 的过程中从 0 慢慢增长到 learning_rate，而后再缓慢衰减。默认为 0。

  • weight_decay: 可选，控制正则项力度的参数，用于防止过拟合，默认为 0.0。

  • seed: 可选，随机种子，默认为1000。

  • logging_steps: 可选，日志打印的间隔 steps，默认为 20。

  • save_steps: 可选，保存模型参数的间隔 steps，默认为 100。

  • epochs: 可选，训练轮次，默认为 3。

  • max_seq_length: 可选，输入到预训练模型中的最大序列长度，最大不能超过 512，默认为 128。

  • saved_dir: 可选，保存训练模型的文件夹路径，默认保存在当前目录的 checkpoint 文件夹下。

  • max_grad_norm: 可选，训练过程中梯度裁剪的 max_norm 参数，默认为 1.0。

  • save_best_model: 可选，是否在最佳验证集指标上保存模型，当训练命令中加入

    --save_best_model 时，save_best_model 为 True，否则为 False。

  • is_text_pair: 可选，是否进行文本对分类，当训练命令中加入 --is_text_pair 时，进行文本对的分类，否则进行普通文本分类。

模型训练的中间日志如下：

2022-05-25 07:22:29.403 | INFO     | __main__:train:301 - global step: 20, epoch: 1, batch: 20, loss: 0.23227, accuracy: 0.87500, speed: 2.12 step/s
2022-05-25 07:22:39.131 | INFO     | __main__:train:301 - global step: 40, epoch: 1, batch: 40, loss: 0.30054, accuracy: 0.87500, speed: 2.06 step/s
2022-05-25 07:22:49.010 | INFO     | __main__:train:301 - global step: 60, epoch: 1, batch: 60, loss: 0.23514, accuracy: 0.93750, speed: 2.02 step/s
2022-05-25 07:22:58.909 | INFO     | __main__:train:301 - global step: 80, epoch: 1, batch: 80, loss: 0.12026, accuracy: 0.96875, speed: 2.02 step/s
2022-05-25 07:23:08.804 | INFO     | __main__:train:301 - global step: 100, epoch: 1, batch: 100, loss: 0.21955, accuracy: 0.90625, speed: 2.02 step/s
2022-05-25 07:23:13.534 | INFO     | __main__:train:307 - eval loss: 0.22564, accuracy: 0.91750
2022-05-25 07:23:25.222 | INFO     | __main__:train:301 - global step: 120, epoch: 1, batch: 120, loss: 0.32157, accuracy: 0.90625, speed: 2.03 step/s
2022-05-25 07:23:35.104 | INFO     | __main__:train:301 - global step: 140, epoch: 1, batch: 140, loss: 0.20107, accuracy: 0.87500, speed: 2.02 step/s
2022-05-25 07:23:44.978 | INFO     | __main__:train:301 - global step: 160, epoch: 2, batch: 10, loss: 0.08750, accuracy: 0.96875, speed: 2.03 step/s
2022-05-25 07:23:54.869 | INFO     | __main__:train:301 - global step: 180, epoch: 2, batch: 30, loss: 0.08308, accuracy: 1.00000, speed: 2.02 step/s
2022-05-25 07:24:04.754 | INFO     | __main__:train:301 - global step: 200, epoch: 2, batch: 50, loss: 0.10256, accuracy: 0.93750, speed: 2.02 step/s
2022-05-25 07:24:09.480 | INFO     | __main__:train:307 - eval loss: 0.22497, accuracy: 0.93083
2022-05-25 07:24:21.020 | INFO     | __main__:train:301 - global step: 220, epoch: 2, batch: 70, loss: 0.23989, accuracy: 0.93750, speed: 2.03 step/s
2022-05-25 07:24:30.919 | INFO     | __main__:train:301 - global step: 240, epoch: 2, batch: 90, loss: 0.00897, accuracy: 1.00000, speed: 2.02 step/s
2022-05-25 07:24:40.777 | INFO     | __main__:train:301 - global step: 260, epoch: 2, batch: 110, loss: 0.13605, accuracy: 0.93750, speed: 2.03 step/s
2022-05-25 07:24:50.640 | INFO     | __main__:train:301 - global step: 280, epoch: 2, batch: 130, loss: 0.14508, accuracy: 0.93750, speed: 2.03 step/s
2022-05-25 07:25:00.529 | INFO     | __main__:train:301 - global step: 300, epoch: 2, batch: 150, loss: 0.04770, accuracy: 0.96875, speed: 2.02 step/s
2022-05-25 07:25:05.256 | INFO     | __main__:train:307 - eval loss: 0.23039, accuracy: 0.93500
2022-05-25 07:25:16.818 | INFO     | __main__:train:301 - global step: 320, epoch: 3, batch: 20, loss: 0.04312, accuracy: 0.96875, speed: 2.04 step/s
2022-05-25 07:25:26.700 | INFO     | __main__:train:301 - global step: 340, epoch: 3, batch: 40, loss: 0.05103, accuracy: 0.96875, speed: 2.02 step/s
2022-05-25 07:25:36.588 | INFO     | __main__:train:301 - global step: 360, epoch: 3, batch: 60, loss: 0.12114, accuracy: 0.87500, speed: 2.02 step/s
2022-05-25 07:25:46.443 | INFO     | __main__:train:301 - global step: 380, epoch: 3, batch: 80, loss: 0.01080, accuracy: 1.00000, speed: 2.03 step/s
2022-05-25 07:25:56.228 | INFO     | __main__:train:301 - global step: 400, epoch: 3, batch: 100, loss: 0.14839, accuracy: 0.96875, speed: 2.04 step/s
2022-05-25 07:26:00.953 | INFO     | __main__:train:307 - eval loss: 0.22589, accuracy: 0.94083
2022-05-25 07:26:12.483 | INFO     | __main__:train:301 - global step: 420, epoch: 3, batch: 120, loss: 0.14986, accuracy: 0.96875, speed: 2.05 step/s
2022-05-25 07:26:22.289 | INFO     | __main__:train:301 - global step: 440, epoch: 3, batch: 140, loss: 0.00687, accuracy: 1.00000, speed: 2.04 step/s

当需要进行文本对分类时，仅需设置 is_text_pair 为 True。以 CLUEbenchmark 中的 AFQMC 蚂蚁金融语义相似度数据集为例，可以运行如下的命令进行训练：

CUDA_VISIBLE_DEVICES=0,1 python -m torch.distributed.launch --nproc_per_node=2 run_classifier.py --train_data_file ./data/AFQMC/train.txt --dev_data_file ./data/AFQMC/dev.txt --label_file ./data/AFQMC/labels.txt --is_text_pair --save_best_model --epochs 3 --batch_size 32

在不同数据集上进行训练，验证集上的效果如下：

TaskChnSentiCorpAFQMCTNEWS
dev-acc0.940830.743050.56990

TNEWS 为 CLUEbenchmark 中的今日头条新闻分类数据集。

CLUEbenchmark 数据集链接：https://github.com/CLUEbenchmark/CLUE

3. 文本匹配

本项目展示了如何基于 Sentence-BERT 结构 Finetune 完成中文文本匹配任务。Sentence BERT 采用了双塔 (Siamese) 的网络结构。Query 和 Title 分别输入到两个共享参数的 bert encoder 中，得到各自的 token embedding 特征。然后对 token embedding 进行 pooling (论文中使用 mean pooling 操作)，输出分别记作 u 和 v。最后将三个向量 (u,v,|u-v|) 拼接起来输入到线性分类器中进行分类。网络结构如下图所示：

86c6d4456c5f52c3e2add912c2724d1a.png

更多关于 Sentence-BERT 的信息可以参考论文：https://arxiv.org/abs/1908.10084

我们以中文文本匹配数据集 LCQMC 为例，运行下面的命令，基于 DistributedDataParallel 进行单机多卡分布式训练，在训练集上进行模型训练，在验证集上进行评估：

CUDA_VISIBLE_DEVICES=0,1 python -m torch.distributed.launch --nproc_per_node=2 run_sentencebert.py --train_data_file ./data/LCQMC/train.txt --dev_data_file ./data/LCQMC/dev.txt --save_best_model --epochs 3 --batch_size 32

可支持的配置参数：

usage: run_sentencebert.py [-h] [--local_rank LOCAL_RANK]
                           [--pretrained_model_name_or_path PRETRAINED_MODEL_NAME_OR_PATH]
                           [--init_from_ckpt INIT_FROM_CKPT] --train_data_file
                           TRAIN_DATA_FILE [--dev_data_file DEV_DATA_FILE]
                           [--label_file LABEL_FILE] [--batch_size BATCH_SIZE]
                           [--scheduler {linear,cosine,cosine_with_restarts,polynomial,constant,constant_with_warmup}]
                           [--learning_rate LEARNING_RATE]
                           [--warmup_proportion WARMUP_PROPORTION]
                           [--seed SEED] [--save_steps SAVE_STEPS]
                           [--logging_steps LOGGING_STEPS]
                           [--weight_decay WEIGHT_DECAY] [--epochs EPOCHS]
                           [--max_seq_length MAX_SEQ_LENGTH]
                           [--saved_dir SAVED_DIR]
                           [--max_grad_norm MAX_GRAD_NORM] [--save_best_model]
                           [--is_nli] [--pooling_mode {linear,cls,mean}]
                           [--concat_multiply]
                           [--output_emb_size OUTPUT_EMB_SIZE]

其中大部分参数与文本分类中介绍的相同，如下为特有的参数：

  • is_nli: 可选，当训练命令中加入 --is_nli 时，使用 NLI 自然语言推断数据集进行模型训练。

  • pooling_mode: 可选，当为 linear 时，使用 cls 向量经过 linear pooler 后的输出作为 encoder 编码的句子向量；当为 cls 时，使用 cls 向量作为 encoder 编码的句子向量；当为 mean 时，使用所有 token 向量的平均值作为 encoder 编码的句子向量。默认为 linear。

  • concat_multiply: 可选，当训练命令中加入 --concat_multiply 时，使用 (u, v, |u-v|, u*v) 作为分类器的输入特征；否则使用 (u, v, |u-v|) 作为分类器的输入特征。

  • output_emb_size: 可选，encoder 输出的句子向量维度，当为 None 时，输出句子向量的维度为 encoder 的 hidden_size。默认为 None。

模型训练的部分中间日志如下：

......
2022-05-24 17:07:26.672 | INFO     | __main__:train:308 - global step: 9620, epoch: 3, batch: 2158, loss: 0.16183, accuracy: 0.90625, speed: 3.38 step/s
2022-05-24 17:07:32.407 | INFO     | __main__:train:308 - global step: 9640, epoch: 3, batch: 2178, loss: 0.09866, accuracy: 0.96875, speed: 3.49 step/s
2022-05-24 17:07:38.177 | INFO     | __main__:train:308 - global step: 9660, epoch: 3, batch: 2198, loss: 0.38715, accuracy: 0.90625, speed: 3.47 step/s
2022-05-24 17:07:43.796 | INFO     | __main__:train:308 - global step: 9680, epoch: 3, batch: 2218, loss: 0.12515, accuracy: 0.93750, speed: 3.56 step/s
2022-05-24 17:07:49.740 | INFO     | __main__:train:308 - global step: 9700, epoch: 3, batch: 2238, loss: 0.03231, accuracy: 1.00000, speed: 3.37 step/s
2022-05-24 17:08:04.752 | INFO     | __main__:train:314 - eval loss: 0.38621, accuracy: 0.86549
2022-05-24 17:08:12.245 | INFO     | __main__:train:308 - global step: 9720, epoch: 3, batch: 2258, loss: 0.08337, accuracy: 0.96875, speed: 3.45 step/s
2022-05-24 17:08:18.112 | INFO     | __main__:train:308 - global step: 9740, epoch: 3, batch: 2278, loss: 0.15085, accuracy: 0.93750, speed: 3.41 step/s
2022-05-24 17:08:23.895 | INFO     | __main__:train:308 - global step: 9760, epoch: 3, batch: 2298, loss: 0.11466, accuracy: 0.93750, speed: 3.46 step/s
2022-05-24 17:08:29.703 | INFO     | __main__:train:308 - global step: 9780, epoch: 3, batch: 2318, loss: 0.04269, accuracy: 1.00000, speed: 3.44 step/s
2022-05-24 17:08:35.658 | INFO     | __main__:train:308 - global step: 9800, epoch: 3, batch: 2338, loss: 0.28312, accuracy: 0.90625, speed: 3.36 step/s
2022-05-24 17:08:50.674 | INFO     | __main__:train:314 - eval loss: 0.39262, accuracy: 0.86424
2022-05-24 17:08:56.609 | INFO     | __main__:train:308 - global step: 9820, epoch: 3, batch: 2358, loss: 0.13456, accuracy: 0.96875, speed: 3.37 step/s
2022-05-24 17:09:02.259 | INFO     | __main__:train:308 - global step: 9840, epoch: 3, batch: 2378, loss: 0.06361, accuracy: 1.00000, speed: 3.54 step/s
2022-05-24 17:09:08.120 | INFO     | __main__:train:308 - global step: 9860, epoch: 3, batch: 2398, loss: 0.09087, accuracy: 0.96875, speed: 3.41 step/s
2022-05-24 17:09:13.834 | INFO     | __main__:train:308 - global step: 9880, epoch: 3, batch: 2418, loss: 0.19537, accuracy: 0.90625, speed: 3.50 step/s
2022-05-24 17:09:19.531 | INFO     | __main__:train:308 - global step: 9900, epoch: 3, batch: 2438, loss: 0.05254, accuracy: 1.00000, speed: 3.51 step/s
2022-05-24 17:09:34.531 | INFO     | __main__:train:314 - eval loss: 0.39561, accuracy: 0.86560
2022-05-24 17:09:42.084 | INFO     | __main__:train:308 - global step: 9920, epoch: 3, batch: 2458, loss: 0.05342, accuracy: 1.00000, speed: 3.41 step/s
2022-05-24 17:09:47.781 | INFO     | __main__:train:308 - global step: 9940, epoch: 3, batch: 2478, loss: 0.22660, accuracy: 0.87500, speed: 3.51 step/s
2022-05-24 17:09:53.496 | INFO     | __main__:train:308 - global step: 9960, epoch: 3, batch: 2498, loss: 0.14745, accuracy: 0.93750, speed: 3.50 step/s
2022-05-24 17:09:59.350 | INFO     | __main__:train:308 - global step: 9980, epoch: 3, batch: 2518, loss: 0.06218, accuracy: 0.96875, speed: 3.42 step/s
2022-05-24 17:10:05.157 | INFO     | __main__:train:308 - global step: 10000, epoch: 3, batch: 2538, loss: 0.15225, accuracy: 0.96875, speed: 3.44 step/s
2022-05-24 17:10:20.159 | INFO     | __main__:train:314 - eval loss: 0.39152, accuracy: 0.86730
......

当使用 NLI 数据进行训练时，需要加入 --is_nli 选项和 --label_file LABEL_FILE，训练命令如下：

CUDA_VISIBLE_DEVICES=0,1 python -m torch.distributed.launch --nproc_per_node=2 run_sentencebert.py --train_data_file ./data/CMNLI/train.txt --dev_data_file ./data/CMNLI/dev.txt --label_file ./data/CMNLI/labels.txt --is_nli --save_best_model --epochs 3 --batch_size 32

在不同数据集上进行训练，验证集上的效果如下：

TaskLCQMCChinese-MNLIChinese-SNLI
dev-acc0.867300.711050.80567

Chinese-MNLI 和 Chinese-SNLI 链接：https://github.com/zejunwang1/CSTS

4. 语义理解

4.1 SimCSE

SimCSE 模型适合缺乏监督数据，但是又有大量无监督数据的匹配和检索场景。本项目实现了 SimCSE 无监督方法，并在中文维基百科句子数据上进行句向量表示模型的训练。

更多关于 SimCSE 的信息可以参考论文：https://arxiv.org/abs/2104.08821

从中文维基百科中抽取 15 万条句子数据，保存于 data/zhwiki/ 文件夹下的 wiki_sents.txt 文件中，运行下面的命令，基于腾讯 uer 开源的预训练语言模型 uer/chinese_roberta_L-6_H-128 (https://huggingface.co/uer/chinese_roberta_L-6_H-128) ，使用 SimCSE 无监督方法进行训练，并在 Chinese-STS-B 验证集 ( https://github.com/zejunwang1/CSTS ) 上进行评估：

CUDA_VISIBLE_DEVICES=0,1 python -m torch.distributed.launch --nproc_per_node=2 run_simcse.py --pretrained_model_name_or_path uer/chinese_roberta_L-6_H-128 --train_data_file ./data/zhwiki/wiki_sents.txt --dev_data_file ./data/STS-B/sts-b-dev.txt --learning_rate 5e-5 --epochs 1 --dropout 0.1 --margin 0.2 --scale 20 --batch_size 32

可支持的配置参数：

usage: run_simcse.py [-h] [--local_rank LOCAL_RANK]
                     [--pretrained_model_name_or_path PRETRAINED_MODEL_NAME_OR_PATH]
                     [--init_from_ckpt INIT_FROM_CKPT] --train_data_file
                     TRAIN_DATA_FILE [--dev_data_file DEV_DATA_FILE]
                     [--batch_size BATCH_SIZE]
                     [--scheduler {linear,cosine,cosine_with_restarts,polynomial,constant,constant_with_warmup}]
                     [--learning_rate LEARNING_RATE]
                     [--warmup_proportion WARMUP_PROPORTION] [--seed SEED]
                     [--save_steps SAVE_STEPS] [--logging_steps LOGGING_STEPS]
                     [--weight_decay WEIGHT_DECAY] [--epochs EPOCHS]
                     [--max_seq_length MAX_SEQ_LENGTH] [--saved_dir SAVED_DIR]
                     [--max_grad_norm MAX_GRAD_NORM] [--save_best_model]
                     [--margin MARGIN] [--scale SCALE] [--dropout DROPOUT]
                     [--pooling_mode {linear,cls,mean}]
                     [--output_emb_size OUTPUT_EMB_SIZE]

其中大部分参数与文本分类中介绍的相同，如下为特有的参数：

  • margin: 可选，正样本相似度与负样本之间的目标 Gap，默认为 0.2。

  • dropout: 可选，SimCSE 网络中 encoder 部分使用的 dropout 取值，默认为 0.1。

  • scale: 可选，在计算交叉熵损失之前，对余弦相似度进行缩放的因子，默认为 20。

  • pooling_mode: 可选，当为 linear 时，使用 cls 向量经过 linear pooler 后的输出作为 encoder 编码的句子向量；当为 cls 时，使用 cls 向量作为 encoder 编码的句子向量；当为 mean 时，使用所有 token 向量的平均值作为 encoder 编码的句子向量。默认为 linear。

  • output_emb_size: 可选，encoder 输出的句子向量维度，当为 None 时，输出句子向量的维度为 encoder 的 hidden_size。默认为 None。

模型训练的部分中间日志如下：

2022-05-27 09:14:58.471 | INFO     | __main__:train:315 - global step: 20, epoch: 1, batch: 20, loss: 1.04241, speed: 8.45 step/s
2022-05-27 09:15:01.063 | INFO     | __main__:train:315 - global step: 40, epoch: 1, batch: 40, loss: 0.15792, speed: 7.72 step/s
2022-05-27 09:15:03.700 | INFO     | __main__:train:315 - global step: 60, epoch: 1, batch: 60, loss: 0.18357, speed: 7.58 step/s
2022-05-27 09:15:06.365 | INFO     | __main__:train:315 - global step: 80, epoch: 1, batch: 80, loss: 0.13284, speed: 7.51 step/s
2022-05-27 09:15:09.000 | INFO     | __main__:train:315 - global step: 100, epoch: 1, batch: 100, loss: 0.14146, speed: 7.59 step/s
2022-05-27 09:15:09.847 | INFO     | __main__:train:321 - spearman corr: 0.6048, pearson corr: 0.5870
2022-05-27 09:15:12.507 | INFO     | __main__:train:315 - global step: 120, epoch: 1, batch: 120, loss: 0.03073, speed: 7.74 step/s
2022-05-27 09:15:15.110 | INFO     | __main__:train:315 - global step: 140, epoch: 1, batch: 140, loss: 0.09425, speed: 7.69 step/s
2022-05-27 09:15:17.749 | INFO     | __main__:train:315 - global step: 160, epoch: 1, batch: 160, loss: 0.08629, speed: 7.58 step/s
2022-05-27 09:15:20.386 | INFO     | __main__:train:315 - global step: 180, epoch: 1, batch: 180, loss: 0.03206, speed: 7.59 step/s
2022-05-27 09:15:23.052 | INFO     | __main__:train:315 - global step: 200, epoch: 1, batch: 200, loss: 0.11463, speed: 7.50 step/s
2022-05-27 09:15:24.023 | INFO     | __main__:train:321 - spearman corr: 0.5954, pearson corr: 0.5807
......

隐藏层数 num_hidden_layers=6，维度 hidden_size=128 的 SimCSE 句向量预训练模型 simcse_tiny_chinese_wiki 可以从如下链接获取：

model_namelink
WangZeJun/simcse-tiny-chinese-wikihttps://huggingface.co/WangZeJun/simcse-tiny-chinese-wiki

4.2 In-Batch Negatives

从哈工大 LCQMC 数据集、谷歌 PAWS-X 数据集、北大文本复述 PKU-Paraphrase-Bank 数据集 (https://github.com/zejunwang1/CSTS) 中抽取出所有语义相似的文本 Pair 作为训练集，保存于：data/batchneg/paraphrase_lcqmc_semantic_pairs.txt

运行下面的命令，基于腾讯 uer 开源的预训练语言模型 uer/chinese_roberta_L-6_H-128，采用 In-batch negatives 策略，在 GPU 0,1,2,3 四张卡上训练句向量表示模型，并在 Chinese-STS-B 验证集上进行评估：

CUDA_VISIBLE_DEVICES=0,1,2,3 python -m torch.distributed.launch --nproc_per_node=4 run_batchneg.py --pretrained_model_name_or_path uer/chinese_roberta_L-6_H-128 --train_data_file ./data/batchneg/paraphrase_lcqmc_semantic_pairs.txt --dev_data_file ./data/STS-B/sts-b-dev.txt --learning_rate 5e-5 --epochs 3 --margin 0.2 --scale 20 --batch_size 64 --mean_loss

可支持的配置参数：

usage: run_batchneg.py [-h] [--local_rank LOCAL_RANK]
                       [--pretrained_model_name_or_path PRETRAINED_MODEL_NAME_OR_PATH]
                       [--init_from_ckpt INIT_FROM_CKPT] --train_data_file
                       TRAIN_DATA_FILE [--dev_data_file DEV_DATA_FILE]
                       [--batch_size BATCH_SIZE]
                       [--scheduler {linear,cosine,cosine_with_restarts,polynomial,constant,constant_with_warmup}]
                       [--learning_rate LEARNING_RATE]
                       [--warmup_proportion WARMUP_PROPORTION] [--seed SEED]
                       [--save_steps SAVE_STEPS]
                       [--logging_steps LOGGING_STEPS]
                       [--weight_decay WEIGHT_DECAY] [--epochs EPOCHS]
                       [--max_seq_length MAX_SEQ_LENGTH]
                       [--saved_dir SAVED_DIR] [--max_grad_norm MAX_GRAD_NORM]
                       [--save_best_model] [--margin MARGIN] [--scale SCALE]
                       [--pooling_mode {linear,cls,mean}]
                       [--output_emb_size OUTPUT_EMB_SIZE] [--mean_loss]

各参数的介绍与 SimCSE 中相同，模型训练的部分中间日志如下：

......
2022-05-27 13:20:48.428 | INFO     | __main__:train:318 - global step: 7220, epoch: 3, batch: 1888, loss: 0.73655, speed: 6.70 step/s
2022-05-27 13:20:51.454 | INFO     | __main__:train:318 - global step: 7240, epoch: 3, batch: 1908, loss: 0.70207, speed: 6.61 step/s
2022-05-27 13:20:54.308 | INFO     | __main__:train:318 - global step: 7260, epoch: 3, batch: 1928, loss: 1.10231, speed: 7.01 step/s
2022-05-27 13:20:57.107 | INFO     | __main__:train:318 - global step: 7280, epoch: 3, batch: 1948, loss: 0.94975, speed: 7.15 step/s
2022-05-27 13:20:59.898 | INFO     | __main__:train:318 - global step: 7300, epoch: 3, batch: 1968, loss: 0.34252, speed: 7.17 step/s
2022-05-27 13:21:00.322 | INFO     | __main__:train:324 - spearman corr: 0.6950, pearson corr: 0.6801
2022-05-27 13:21:03.168 | INFO     | __main__:train:318 - global step: 7320, epoch: 3, batch: 1988, loss: 1.10022, speed: 7.20 step/s
2022-05-27 13:21:05.929 | INFO     | __main__:train:318 - global step: 7340, epoch: 3, batch: 2008, loss: 1.00207, speed: 7.25 step/s
2022-05-27 13:21:08.687 | INFO     | __main__:train:318 - global step: 7360, epoch: 3, batch: 2028, loss: 0.72985, speed: 7.25 step/s
2022-05-27 13:21:11.372 | INFO     | __main__:train:318 - global step: 7380, epoch: 3, batch: 2048, loss: 0.88964, speed: 7.45 step/s
2022-05-27 13:21:14.090 | INFO     | __main__:train:318 - global step: 7400, epoch: 3, batch: 2068, loss: 0.70836, speed: 7.36 step/s
2022-05-27 13:21:14.520 | INFO     | __main__:train:324 - spearman corr: 0.6922, pearson corr: 0.6764
......

以上面得到的模型为热启，在句子数据集 data/batchneg/domain_finetune.txt 上继续进行 In-batch negatives 训练：

CUDA_VISIBLE_DEVICES=0,1 python -m torch.distributed.launch --nproc_per_node=2 run_batchneg.py --pretrained_model_name_or_path uer/chinese_roberta_L-6_H-128 --init_from_ckpt ./checkpoint/pytorch_model.bin --train_data_file ./data/batchneg/domain_finetune.txt --dev_data_file ./data/STS-B/sts-b-dev.txt --learning_rate 1e-5 --epochs 1 --margin 0.2 --scale 20 --batch_size 32 --mean_loss

可以得到隐藏层数 num_hidden_layers=6，维度 hidden_size=128 的句向量预训练模型：

model_namelink
WangZeJun/batchneg-tiny-chinesehttps://huggingface.co/WangZeJun/batchneg-tiny-chinese

5. 序列标注

本项目展示了以 BERT 为代表的预训练模型如何 Finetune 完成序列标注任务。以中文命名实体识别任务为例，分别在 msra、ontonote4、resume 和 weibo 四个数据集上进行训练和测试。每个数据集的训练集和验证集均被预处理为如下的格式，每一行为文本和标签组成的 json 字符串。

{"text": ["我", "们", "的", "藏", "品", "中", "有", "几", "十", "册", "为", "北", "京", "图", "书", "馆", "等", "国", "家", "级", "藏", "馆", "所", "未", "藏", "。"], "label": ["O", "O", "O", "O", "O", "O", "O", "O", "O", "O", "O", "B-NS", "I-NS", "I-NS", "I-NS", "I-NS", "O", "O", "O", "O", "O", "O", "O", "O", "O", "O"]}
{"text": ["由", "于", "这", "一", "时", "期", "战", "争", "频", "繁", "，", "条", "件", "艰", "苦", "，", "又", "遭", "国", "民", "党", "毁", "禁", "，", "传", "世", "量", "稀", "少", "，", "购", "藏", "不", "易", "。"], "label": ["O", "O", "O", "O", "O", "O", "O", "O", "O", "O", "O", "O", "O", "O", "O", "O", "O", "O", "B-NT", "I-NT", "I-NT", "O", "O", "O", "O", "O", "O", "O", "O", "O", "O", "O", "O", "O", "O"]}

运行下面的命令，在 msra 数据集上使用 BERT+Linear 结构进行单机多卡分布式训练，并在验证集上进行评估：

CUDA_VISIBLE_DEVICES=0,1 python -m torch.distributed.launch --nproc_per_node=2 run_ner.py --train_data_file ./data/ner/msra/train.json --dev_data_file ./data/ner/msra/dev.json --label_file ./data/ner/msra/labels.txt --tag bios --learning_rate 5e-5 --save_best_model --batch_size 32

可支持的配置参数：

usage: run_ner.py [-h] [--local_rank LOCAL_RANK]
                  [--pretrained_model_name_or_path PRETRAINED_MODEL_NAME_OR_PATH]
                  [--init_from_ckpt INIT_FROM_CKPT] --train_data_file
                  TRAIN_DATA_FILE [--dev_data_file DEV_DATA_FILE] --label_file
                  LABEL_FILE [--tag {bios,bio}] [--batch_size BATCH_SIZE]
                  [--scheduler {linear,cosine,cosine_with_restarts,polynomial,constant,constant_with_warmup}]
                  [--learning_rate LEARNING_RATE]
                  [--crf_learning_rate CRF_LEARNING_RATE]
                  [--warmup_proportion WARMUP_PROPORTION] [--seed SEED]
                  [--save_steps SAVE_STEPS] [--logging_steps LOGGING_STEPS]
                  [--weight_decay WEIGHT_DECAY] [--epochs EPOCHS]
                  [--max_seq_length MAX_SEQ_LENGTH] [--saved_dir SAVED_DIR]
                  [--max_grad_norm MAX_GRAD_NORM] [--save_best_model]
                  [--use_crf]

大部分参数与文本分类中介绍的相同，如下为特有的参数：

  • tag: 可选，实体标记方法，支持 bios 和 bio 的标注方法，默认为 bios。

  • use_crf: 可选，是否使用 CRF 结构，当训练命令中加入 --use_crf 时，使用 BERT+CRF 模型结构；否则使用 BERT+Linear 模型结构。

  • crf_learning_rate: 可选，CRF 模型参数的初始学习率，默认为 5e-5。

模型训练的部分中间日志如下：

2022-05-27 15:56:59.043 | INFO     | __main__:train:355 - global step: 20, epoch: 1, batch: 20, loss: 0.20780, speed: 2.10 step/s
2022-05-27 15:57:08.723 | INFO     | __main__:train:355 - global step: 40, epoch: 1, batch: 40, loss: 0.09440, speed: 2.07 step/s
2022-05-27 15:57:18.001 | INFO     | __main__:train:355 - global step: 60, epoch: 1, batch: 60, loss: 0.05570, speed: 2.16 step/s
2022-05-27 15:57:27.357 | INFO     | __main__:train:355 - global step: 80, epoch: 1, batch: 80, loss: 0.02468, speed: 2.14 step/s
2022-05-27 15:57:36.994 | INFO     | __main__:train:355 - global step: 100, epoch: 1, batch: 100, loss: 0.05032, speed: 2.08 step/s
2022-05-27 15:57:53.299 | INFO     | __main__:train:362 - eval loss: 0.03203, F1: 0.86481
2022-05-27 15:58:03.264 | INFO     | __main__:train:355 - global step: 120, epoch: 1, batch: 120, loss: 0.04150, speed: 2.16 step/s
2022-05-27 15:58:12.712 | INFO     | __main__:train:355 - global step: 140, epoch: 1, batch: 140, loss: 0.04907, speed: 2.12 step/s
2022-05-27 15:58:21.959 | INFO     | __main__:train:355 - global step: 160, epoch: 1, batch: 160, loss: 0.01224, speed: 2.16 step/s
2022-05-27 15:58:31.039 | INFO     | __main__:train:355 - global step: 180, epoch: 1, batch: 180, loss: 0.01846, speed: 2.20 step/s
2022-05-27 15:58:40.542 | INFO     | __main__:train:355 - global step: 200, epoch: 1, batch: 200, loss: 0.06604, speed: 2.10 step/s
2022-05-27 15:58:56.831 | INFO     | __main__:train:362 - eval loss: 0.02589, F1: 0.89128
2022-05-27 15:59:07.813 | INFO     | __main__:train:355 - global step: 220, epoch: 1, batch: 220, loss: 0.07066, speed: 2.15 step/s
2022-05-27 15:59:16.857 | INFO     | __main__:train:355 - global step: 240, epoch: 1, batch: 240, loss: 0.03061, speed: 2.21 step/s
2022-05-27 15:59:26.240 | INFO     | __main__:train:355 - global step: 260, epoch: 1, batch: 260, loss: 0.01680, speed: 2.13 step/s
2022-05-27 15:59:35.568 | INFO     | __main__:train:355 - global step: 280, epoch: 1, batch: 280, loss: 0.01245, speed: 2.14 step/s
2022-05-27 15:59:44.684 | INFO     | __main__:train:355 - global step: 300, epoch: 1, batch: 300, loss: 0.02699, speed: 2.19 step/s
2022-05-27 16:00:00.977 | INFO     | __main__:train:362 - eval loss: 0.01928, F1: 0.92157

当使用 BERT+CRF 结构进行训练时，运行下面的命令：

CUDA_VISIBLE_DEVICES=0,1 python -m torch.distributed.launch --nproc_per_node=2 run_ner.py --train_data_file ./data/ner/msra/train.json --dev_data_file ./data/ner/msra/dev.json --label_file ./data/ner/msra/labels.txt --tag bios --learning_rate 5e-5 --save_best_model --batch_size 32 --use_crf --crf_learning_rate 1e-4

模型在不同验证集上的 F1 指标：

模型MsraResumeOntonoteWeibo
BERT+Linear0.941790.956430.802060.70588
BERT+CRF0.942650.958180.802570.72215

其中 Msra、Resume 和 Ontonote 训练了 3 个 epochs，Weibo 训练了 5 个 epochs，Resume、Ontonote 和 Weibo 的 logging_steps 和 save_steps 均设置为 10，所有数据集的 BERT 参数初始学习率设置为 5e-5，CRF 参数初始学习率设置为 1e-4，batch_size 设置为 32。

 
 
 
 
 
 
 
 
 
 
往期精彩回顾




适合初学者入门人工智能的路线及资料下载(图文+视频)机器学习入门系列下载中国大学慕课《机器学习》（黄海广主讲）机器学习及深度学习笔记等资料打印《统计学习方法》的代码复现专辑机器学习交流qq群955171419，加入微信群请扫码
 
 
349c0bf41fce894622517884cb61cbdd.png
 


                

        

        

    

  


    

      

        

            

              
                
                  风度78
                
              
            

            

                关注
              
            

        

        

          
      

      









                



	

		

			

				
					
Python-PyTorch实现的BERT多标签文本分类

				
			

			

				

					08-10
				

			

		

		

			
				
This repo contains a PyTorch implementation of a pretrained BERT model for multi-label text classification.

			
		

	



                

            
              



	

		

			

				
					
【动手学习pytorch笔记】37.5 BERT微调

				
			

			

				

					ymk1998的博客
				

				

					05-08
					
					1624
					
				

			

		

		

			
				
BERT微调
import json
import multiprocessing
import os
import torch
from torch import nn
from d2l import torch as d2l

bert.base和bert.small地址
d2l.DATA_HUB['bert.base'] = (d2l.DATA_URL + 'bert.base.torch.zip',
                             '225d66f04cae318b841a

			
		

	



              


  
              

                


	

		

			

				
					
【HuggingFace Transformers】BertModel源码解析

					
最新发布

				
			

			

				

					AI小白的学习记录，欢迎交流~
				

				

					08-20
					
					1137
					
				

			

		

		

			
				
BertModel是transformers 库中的核心模型之一，它实现了BERT模型的架构。BERT是基于Transformer 编码器的堆叠模块来构建的。以下是 BertModel 内部包含的主要模块和组件的详细介绍

			
		

	





	

		

			

				
					
pytorch实现Bert

				
			

			

				

					m0_61688615的博客
				

				

					02-23
					
					938
					
				

			

		

		

			
				
pytorch实现Bert，详细

			
		

	



		

			
		



	

		

			

				
					
Pytorch实现Bert模型

				
			

			

				

					敷衍zgf的博客
				

				

					10-27
					
					3178
					
				

			

		

		

			
				
Pytorch实现Bert模型

			
		

	





	

		

			

				
					
NLP-了解BERT下游任务

				
			

			

				

					weixin_44077556的博客
				

				

					11-30
					
					2万+
					
				

			

		

		

			
				
MNLI：大规模分类任务，目标是预测第二个句子相对于第一个句子是包含，矛盾还是中立。QQP：二分类任务，预测Quora在两个语义问题上是否等效。STS-B：语义文本相似性基准，从新闻头条或者其他来源提取句子对的集合。然后按分值标注，表示两个句子在语义上多相似。MRPC：自动从在线新闻源中提取句子对组成，并带有人工标注，以说明句子对中的句子在语义上是否等效。SWAG: 对抗生成的情境数据集包含113k个句子对完整示例，用于评估扎实的常识推理。给定一个句子，任务是在四个选择中选择最合理的连续性。

			
		

	





	

		

			

				
					
基于 pytorch 的 bert 实现和下游任务微调【100011822】

				
			

			

				

					04-11
				

			

		

		

			
				
**基于PyTorch的BERT实现和下游任务微调**  BERT（Bidirectional Encoder Representations from Transformers）是由Google在2018年提出的预训练语言模型，它在多项自然语言处理任务中取得了突破性的成绩。PyTorch是...

			
		

	





	

		

			

				
					
基于pytorch的谷歌自然语言处理模型BERT代码实现

				
			

			

				

					03-25
				

			

		

		

			
				
在自然语言处理领域，BERT（Bidirectional Encoder Representations from Transformers）是由谷歌研发的一种预训练语言模型，它在多项自然语言理解任务上取得了显著的性能提升。本篇文章将聚焦于如何使用PyTorch这一...

			
		

	





	

		

			

				
					
BERT_Pytorch下游任务-萌新向

				
			

			

				

					LinkList____的博客
				

				

					07-04
					
					856
					
				

			

		

		

			
				
Paper：BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding



			
		

	





	

		

			

				
					
利用pytorch实现BERT模型及下游任务微调

				
			

			

				

					
				

			

		

		

			
				
资源摘要信息:"本文将详细介绍基于 PyTorch 的 BERT（Bidirectional ...通过本文的介绍，我们可以了解到 BERT 在自然语言处理中的强大能力，以及如何利用 PyTorch 这一工具进行BERT的实现和对下游任务的有效微调。

			
		

	





	

		

			

				
					
#最全面# 使用 Bert 解决下游 NLP 实际任务

				
			

			

				

					lch551218的博客
				

				

					04-16
					
					4020
					
				

			

		

		

			
				
文章目录1 四大NLP下游任务1 句子对分类任务1.1 MNLI1.2 QQP1.3 QNLI1.4 STS-B1.5 MRPC1.6 RTE1.7 SWAG2 单句子分类任务2.1 SST-22.2 CoLA3 问答任务3.1 SQuAD v1.14 单句子标注任务2 使用Bert实现自动文本摘要
1 四大NLP下游任务
BERT在概念上很简单，在经验上也很强大。它推动了11项自然语言处理任务的最新技术成果，而这11项NLP任务可分类为四大自然语言处理下游任务。这四类任务分别是：句子对分类任务、单句子分类

			
		

	





	

		

			

				
					
BERT 的 PyTorch 实现（超详细）

					
热门推荐

				
			

			

				

					mathor的博客
				

				

					09-28
					
					3万+
					
				

			

		

		

			
				
B站视频讲解
本文主要介绍一下如何使用 PyTorch 复现BERT。请先花上 10 分钟阅读我的这篇文章 BERT详解（附带ELMo、GPT介绍），再来看本文，方能达到醍醐灌顶，事半功倍的效果
准备数据集
这里我并没有用什么大型的数据集，而是手动输入了两个人的对话，主要是为了降低代码阅读难度，我希望读者能更关注模型实现的部分
'''
  code by Tae Hwan Jung(Jeff Jung) @graykode, modify by wmathor
  Reference : https://g

			
		

	





	

		

			

				
					
pytorch--从零实现一个BERT模型

				
			

			

				

					与或
				

				

					12-11
					
					7670
					
				

			

		

		

			
				
本文主要从代码的角度一步步来讲解一下BERT模型是如何实现的。(后附完整代码)
关于BERT的理论解析现在随便一搜就可以找到很多，在这里就不在赘述。有需要补一下理论知识的，可以看一下下面的文章：
图解BERT模型：从零开始构建BERT

...

			
		

	





	

		

			

				
					
BERT从零详细解读：如何微调BERT，提升BERT在下游任务中的效果

				
			

			

				

					weixin_40064300的博客
				

				

					04-24
					
					4835
					
				

			

		

		

			
				
a)是句子对的分类任务
b)是单个句子的分类任务
c) 是问答任务
d)是序列标注任务
首先我自己最常用的就是：文本分类、序列标注和文本匹配。
这四个都是比较简单的，我们来看d)序列标注，其实就是把所有的token输出，做了一个softmax，去看它属于实体中的哪一个。对于单个样本，它的一个文本分类就是使用CLS这边，第一个CLS的输出，去做一个微调，做一个二分类，或者是多分类。
a)这个其实本质是一个文本匹配的一个任务，文本匹配就是把两个句子拼接起来，去判断它是否相似。左上角也是用CLS输出判断，0不相.

			
		

	





	

		

			

				
					
PyTorch预训练Bert模型的示例

				
			

			

				

					12-16
				

			

		

		

			
				
本文介绍以下内容：
1. 使用transformers框架做预训练的bert-base模型；
2. 开发平台使用Google的Colab平台，白嫖GPU加速；
3. 使用datasets模块下载IMDB影评数据作为训练数据。
transformers模块简介
transformers框架为Huggingface开源的深度学习框架，支持几乎所有的Transformer架构的预训练模型。使用非常的方便，本文基于此框架，尝试一下预训练模型的使用，简单易用。
本来打算预训练bert-large模型，发现colab上GPU显存不够用，只能使用base版本了。打开colab，并且设置好GPU加速，接下来开

			
		

	





	

		

			

				
					
【BERT下游任务】意图分类：1. 数据处理与加载

				
			

			

				

					尊新必威的博客
				

				

					09-06
					
					1753
					
				

			

		

		

			
				
目录一、数据形式二、标签集：将所有出现的意图标签统计出来三、样本读取为样本实例四、将数据处理成可以喂给模型的特征

任务简介：
学习一个简单的bert意图分类项目，了解bert进行nlp任务时的流程。
任务说明：


标签类别收集


训练样本读取


样本转化为符合BERT模型的特征



一、数据形式
使用的atis数据集已经将训练集、验证集和测试集区分好

label文件保存了意图识别的标签
seq.in文件每行保存了一句输入样本
seq.out文件每行保存了样本的NER标签序列，以空格隔开(ner任

			
		

	





	

		

			

				
					
AI大模型应用：自定义Pytorch Bert预训练模型微调教程

				
			

			

				

					
				

			

		

		

			
				
在当前的人工智能领域，尤其是自然语言处理（NLP）领域，Bert（Bidirectional Encoder Representations from Transformers）模型已经成为一种主流的技术。Bert模型是基于Transformer的深度双向预训练模型，它在2018...

			
		

	





	

		

			

				
					
【NLP】(task5)BERT应用到下游任务、训练和优化

				
			

			

				

					发现问题，并解决问题，批判性思维
				

				

					08-24
					
					3543
					
				

			

		

		

			
				
文章目录前言三、BERT-based Models3.1 BertForPreTraining3.2 BertForSequenceClassification3.3 BertForMultipleChoice3.4 BertForTokenClassification3.5 BertForQuestionAnswering四、BERT训练和优化4.1 Pre-Training4.2 Fine-Tuning4.2.1 AdamW4.2.2 WarmupReference
前言
接着上一小节，我们对Huggi

			
		

	





	

		

			

				
					
Pytorch环境下微调BERT以及调参教程

				
			

			

				

					sinat_20829389的博客
				

				

					03-18
					
					9035
					
				

			

		

		

			
				
使用Hugginface的Transformers库快速微调BERT等预训练模型，使其适应下游任务，本文以Quora问题对为例，对两问题表意是否一致进行预测

介绍
之前写了个微调BERT的入门教程，步骤比较多，我后来把它都封装成函数了，但用起来还是比较麻烦，而且有时候Transformer库里一些函数方法会改动，这就还要对代码进行调整。最近看Transformers的文档，发现它自己封装了一个trainer()函数，很好用，分享一下
本文相应的jupyter notebook地址为：https://gi.

			
		

	





	

		

			

				
					
如何使用BERT进行下游任务 - Transformer教程

				
			

			

				

					shandianfk_com的博客
				

				

					08-14
					
					431
					
				

			

		

		

			
				
BERT是一种强大的预训练语言模型，通过预训练和微调两个阶段，它在自然语言处理的多种任务上表现出色。本文详细介绍了如何使用BERT进行下游任务，尤其是文本分类任务，包括安装必要库、加载模型和数据、数据预处理、微调模型以及评估和预测等步骤。此外，BERT还在问答系统、命名实体识别等其他任务中有广泛应用。

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值