Skip to content

E
ERNIE

PaddlePaddle / ERNIE
大约 1 年 前同步成功

通知 108
Star 5997
Fork 1270
E
ERNIE

体验新版 GitCode，发现更多精彩内容 >>

提交 9ef7e866 编写于 作者: K Kennycao123
浏览文件
操作

fix readme

上级 085424c4
隐藏空白更改
内联 并排
Showing with 1516 addition and 0 deletion
README_ENV.md 0 → 100644
浏览文件 @ 9ef7e866
# 环境安装与配置
# 1、环境版本要求
- 环境主要安装Python和Paddle对应版本要求的环境，中间建议使用pip安装方式进行安装。
- Python3版本要求：python3.7及以上版本，参考https://www.python.org/
- PaddlePaddle版本要求：paddlepaddle2.0+版本，参考https://www.paddlepaddle.org.cn/documentation/docs/zh/install/pip/macos-pip.html
- Paddle环境的安装，需要确认Python和pip是64bit，并且处理器架构是x86_64（或称作x64、Intel 64、AMD64）架构，目前PaddlePaddle不支持arm64架构（mac M1除外，paddle 已支持Mac M1 芯片）。下面的第一行输出的是”64bit”，第二行输出的是”x86_64”、”x64”或”AMD64”即可：
```java
python -c "import platform;print(platform.architecture()[0]);print(platform.machine())"
```
# 2、CPU机器和GPU机器的安装
## 2.1 CPU机器的安装
- 请参考1，完成Paddle和Python3的安装即可
## 2.2 GPU机器的安装
- 使用GPU机器时，比CPU机器的安装多了GPU相关驱动的配置安装
**1、 GPU环境及示例**
- 需要您确认自己的GPU机器的安装情况，包括：**nvidia驱动、cuda版本、cudnn版本、nccl版本。**
- 以下是文心ERNIE开发套件在GPU机器上运行的环境配置示例：
**环境示例**
- Tesla V100上nvidia驱动、cuda版本、cudnn版本、nccl版本、python版本以及PaddlePaddle版本
- NVIDIA Driver Version: 418.67
- CUDA Version: 10.1
- CUDNN Version：7.6.0
- NCCL Version: 2.3.5
- Python 3.7.1及以上
- PaddlePaddle 2.2
- Tesla K40上nvidia驱动、cuda版本、cudnn版本、nccl版本、python版本以及PaddlePaddle版本
- NVIDIA Driver Version: 418.39
- CUDA Version: 10.1
- CUDNN Version：7.0.3
- NCCL Version: 2.3.5
- Python 3.7.1及以上
- PaddlePaddle 2.2
**2、** **配置环境变量：**
- 上述环境配置完成以后，可以参考以下方式进行运行时环境变量的配置。
- 如果您的开发机上已经配置好文心ERNIE开发套件需要的环境，可以参考以下命令设置您的运行环境，配置如下：
```plain
set -x
#在LD_LIBRARY_PATH中添加cuda库的路径
export LD_LIBRARY_PATH=/home/work/cuda-10.1/lib64:$LD_LIBRARY_PATH
export LD_LIBRARY_PATH=/home/work/cuda-10.1/extras/CUPTI/lib64:$LD_LIBRARY_PATH
#在LD_LIBRARY_PATH中添加cudnn库的路径
export LD_LIBRARY_PATH=/home/work/cudnn/cudnn7.6.5/lib64:$LD_LIBRARY_PATH
#如果需要多卡并行训练，需要先下载NCCL，下载地址：http://bj.bcebos.com/wenxin-models/nccl.tar.gz，然后在LD_LIBRARY_PATH中添加NCCL库的路径
export LD_LIBRARY_PATH=/home/work/nccl_2.3.5/lib:$LD_LIBRARY_PATH
#如果FLAGS_sync_nccl_allreduce为1，则会在allreduce_op_handle中调用cudaStreamSynchronize（nccl_stream），这种模式在某些情况下可以获得更好的性能
export FLAGS_sync_nccl_allreduce=1
#是否是分布式训练，0标识是分布式，1标识是单机
export PADDLE_IS_LOCAL=1
export PADDLE_USE_GPU=1
#表示分配的显存块占GPU总可用显存大小的比例，范围[0,1]
export FLAGS_fraction_of_gpu_memory_to_use=0.5
#选择要使用的GPU
#export CUDA_VISIBLE_DEVICES=0,1,2,3,4,5,6,7
export CUDA_VISIBLE_DEVICES=0
#表示是否使用垃圾回收策略来优化网络的内存使用，<0表示禁用，>=0表示启用
export FLAGS_eager_delete_tensor_gb=1.0
#是否使用快速垃圾回收策略
export FLAGS_fast_eager_deletion_mode=1
#垃圾回收策略释放变量的内存大小百分比，范围为[0.0, 1.0]
export FLAGS_memory_fraction_of_eager_deletion=1
#设置python
#alias python= your python path
#alias pip= your pip path
```
- 注意：如果需要多卡并行训练，需要先下载NCCL，下载地址：http://bj.bcebos.com/wenxin-models/nccl.tar.gz，然后在LD_LIBRARY_PATH中添加NCCL库的路径
\ No newline at end of file
Research/README.md 0 → 100644
浏览文件 @ 9ef7e866
- 多粒度语言知识模型[ERNIE-Gram](https://github.com/PaddlePaddle/ERNIE/blob/develop/ernie-gram)
- 超长文本双向建模预训练模型 [ERNIE-Doc](https://github.com/PaddlePaddle/ERNIE/tree/repro/ernie-doc)
- 融合场景图知识的跨模态预训练模型教程 [ERNIE-ViL](https://github.com/PaddlePaddle/ERNIE/tree/repro/ernie-vil)
- 语言与视觉一体的预训练模型 [ERNIE-UNIMO](https://github.com/PaddlePaddle/ERNIE/tree/repro/ernie-unimo)
- 新增语音-语言跨模态模型ERNIE-SAT（链接待补充）
\ No newline at end of file
nlp-ernie/wenxin_appzoo/wenxin_appzoo/tasks/information_extraction_many_to_many/README.md 0 → 100644
浏览文件 @ 9ef7e866
# 多对多信息抽取
- 实体关系，实体属性抽取是信息抽取的关键任务；实体关系抽取是指从一段文本中抽取关系三元组，实体属性抽取是指从一段文本中抽取属性三元组；信息抽取一般分以下几种情况一对一，一对多，多对一，多对多的情况：
- 一对一：“张三男汉族硕士学历”含有一对一的属性三元组（张三，民族，汉族）。
- 一对多：“华扬联众数字技术股份有限公司于2017年8月2日在上海证券交易所上市”，含有一对多的属性三元组（华扬联众数字技术股份有限公司，上市时间，2017年8月2日）和（华扬联众数字技术股份有限公司，上市地点，上海证券交易所上市）
- 多对一：“上海森焱软件有限公司和上海欧提软件有限公司的注册资本均为100万人民币”，含有多对一的属性三元组（上海森焱软件有限公司，注册资本，100万人民币）和（上海欧提软件有限公司，注册资本，100万人民币）
- 多对多：“大华种业稻麦种子加工36.29万吨、销售37.5万吨；苏垦米业大米加工22.02万吨、销售24.86万吨”，含有多对多的属性三元组（大华种业，稻麦种子产量，36.29万吨）和（苏垦米业，大米加工产量，22.02万吨）
## 代码结构
- 多对多信息抽取任务位于 ./wenxin_appzoo/tasks/information_extraction_many_to_many
```plain
information_extraction_many_to_many/
├── data
│ ├── DuIE2.0
│ │ └── convert_data.py
│ ├── entity_attribute_data
│ │ ├── dev_data
│ │ │ └── dev.json
│ │ ├── predict_data
│ │ │ └── predict.json
│ │ ├── test_data
│ │ │ └── test.json
│ │ └── train_data
│ │ └── train.json
│ └── entity_relation_data
│ ├── dev_data
│ │ └── dev.json
│ ├── predict_data
│ │ └── predict.json
│ ├── test_data
│ │ └── test.json
│ └── train_data
│ └── train.json
├── data_set_reader
│ └── ie_data_set_reader.py
├── dict
│ ├── entity_attribute_label_map.json
│ └── entity_relation_label_map.json
├── examples
│ ├── many_to_many_ie_attribute_ernie_fc_ch_infer.json
│ ├── many_to_many_ie_attribute_ernie_fc_ch.json
│ ├── many_to_many_ie_relation_ernie_fc_ch_infer.json
│ └── many_to_many_ie_relation_ernie_fc_ch.json
├── inference
│ ├── custom_inference.py
│ └── __init__.py
├── model
│ ├── ernie_fc_ie_many_to_many.py
│ └── __init__.py
├── run_infer.py
├── run_trainer.py
└── trainer
├── custom_dynamic_trainer.py
├── custom_trainer.py
└── __init__.py
```
## 准备工作：数据准备、网络（模型）选择、ERNIE预训练模型选择
#### 数据准备
- 这里我们提供三份已标注的数据集：属性抽取数据集（demo示例数据集）、关系抽取数据集（demo示例数据集）、[DuIE2.0](https://www.luge.ai/#/luge/dataDetail?id=5)（全量数据集）。
- 属性抽取训练集、测试集、验证集和预测集分别存放在./data/entity_attribute_data目录下的train_data、test_data、dev_data和predict_data文件夹下，对应的示例标签词表存放在./dict目录下。
- 关系抽取训练集、测试集、验证集和预测集分别存放在./data/entity_relation_data目录下的train_data、test_data、dev_data和predict_data文件夹下，对应的示例标签词表存放在./dict目录下。
- DuIE2.0需要去官网下载，下载链接：https://www.luge.ai/#/luge/dataDetail?id=5
- 注：数据集（包含词表）均为utf-8格式。
##### Demo示例数据集（属性抽取数据集、关系抽取数据集）
- demo示例数据集中属性抽取数据集与关系抽取数据集的结构一样，他们都只包含少量数据集，可用于快速开始模型的训练与预测。
###### 训练集/测试集/
- 训练集、测试集的数据格式相同，每个样例分为两个部分文本和对应标签
```plain
{"text": "倪金德，1916年生，奉天省营口（今辽宁省营口市）人", "spo_list": [{"predicate": "出生日期", "subject": [0, 3], "object": [4, 9]}, {"predicate": "出生地", "subject": [0, 3], "object": [11, 16]}]}
{"text": "基本介绍克里斯蒂娜·塞寇丽（Christina Sicoli）身高163cm，在加拿大安大略出生和长大，毕业于伦道夫学院", "spo_list": [{"predicate": "毕业院校", "subject": [4, 13], "object": [55, 60]}]}
```
###### 预测集
- 预测集只有一个key（"text"）：
```plain
{"text": "倪金德，1916年生，奉天省营口（今辽宁省营口市）人"}
{"text": "基本介绍克里斯蒂娜·塞寇丽（Christina Sicoli）身高163cm，在加拿大安大略出生和长大，毕业于伦道夫学院"}
```
###### 标签词表
- 标签列表是一个json字符串，key是标签值，value是标签对应id，示例词表采用BIO标注，B表示关系，分为主体（S）与客体（O），如下所示：
```plain
{
"O": 0,
"I": 1,
"B-毕业院校@S": 2,
"B-毕业院校@O": 3,
"B-出生地@S": 4,
"B-出生地@O": 5,
"B-祖籍@S": 6,
"B-祖籍@O": 7,
"B-国籍@S": 8,
"B-国籍@O": 9,
"B-出生日期@S": 10,
"B-出生日期@O": 11
}
```
- 注意：O, I对应的ID必须是0， 1，B-XXX@O对应的id需要必须为B-XXX@S对应的id+1（B-XXX@s须为偶数,B-XXX@O须为奇数）
##### DuIE2.0数据集
- DuIE2.0是业界规模最大的中文关系抽取数据集，其schema在传统简单关系类型基础上添加了多元复杂关系类型，此外其构建语料来自百度百科、百度信息流及百度贴吧文本，全面覆盖书面化表达及口语化表达语料，能充分考察真实业务场景下的关系抽取能力。下载链接：https://www.luge.ai/#/luge/dataDetail?id=5
- DuIE2.0数据集的格式与本框架所需要的文本输入格式不一致，需要进行转化成**demo示例数据集**的格式才能使用，具体转化步骤如下：
- 从链接 https://www.luge.ai/#/luge/dataDetail?id=5 下载数据集到 ./data/DuIE2.0 文件夹中，并解压
- 进入./data/DuIE2.0目录
```json
cd ./data
mkdir DuIE2.0
cd DuIE2.0
#下载DuIE2.0数据并解压，下载地址https://www.luge.ai/#/luge/dataDetail?id=5
```
- - 运行./data/DuIE2.0/convert_data.py 脚本
```json
python convert_data.py
```
### 网络（模型）选择
- 文心预置的可用于生成任务的模型源文件在wenxin_appzoo/wenxin_appzoo/tasks/text_generation/model/目录下
| 网络名称（py文件的类型） | 简介 | 支持类型 | 备注 |
| -------------------------------------- | ------------------------------------------------------------ | ------------------------ | -------- |
| ErnieFcIe(ernie_fc_ie_many_to_many.py) | ErnieFcIe多对多信息抽取任务模型源文件，可加载ERNIE2.0-Base、ERNIE2.0-large、ERNIE3.0-Base、ERNIE3.0-x-Base、ERNIE3.0-Medium | 通用信息抽取Finetune任务 | 信息抽取 |
### ERNIE预训练模型下载
- 文心提供的[ERNIE预训练模型](../../../../../README_MODEL.md)的参数文件和配置文件在 wenxin_appzoo/wenxin_appzoo/models_hub目录下，使用对应的sh脚本，即可拉取对应的模型、字典、必要环境等文件。
| 模型名称 | 下载脚本 | 备注 |
| --------------- | ---------------------------------- | ------------------------------------------ |
| ERNIE2.0-Base | sh download_ernie_2.0_base_ch.sh | 下载并解压后得到对应模型的参数、字典和配置 |
| ERNIE2.0-large | sh download_ernie_2.0_large_ch.sh | |
| ERNIE3.0-Base | sh download_ernie_3.0_base_ch.sh | |
| ERNIE3.0-x-Base | sh download_ernie_3.0_x_base_ch.sh | |
| ERNIE3.0-Medium | sh download_ernie_3.0_medium.sh | |
### 模型评估指标选择
- 采用评估指标：precison、recall、f1
## 开始训练
- 以属性抽取数据集的训练为例，进入指定任务目录./wenxin_appzoo/tasks/information_extraction_many_to_many
```json
cd ./wenxin_appzoo/tasks/information_extraction_many_to_many
```
#### 训练的配置文件
- 配置文件：./examples/many_to_many_ie_attribute_ernie_fc_ch.json
```json
{
"dataset_reader": {
"train_reader": {
"name": "train_reader",
"type": "IEReader",
"fields": [],
"config": {
"data_path": "./data/entity_attribute_data/train_data/",
"shuffle": false,
"batch_size": 2,
"epoch": 5,
"sampling_rate": 1.0,
"need_data_distribute": true,
"need_generate_examples": false,
"extra_params": {
"vocab_path": "../../models_hub/ernie_3.0_base_ch_dir/vocab.txt", #选择对应预训练模型的词典路径，在models_hub路径下
"label_map_config": "./dict/entity_attribute_label_map.json",
"num_labels": 12,
"max_seq_len": 512,
"do_lower_case":true,
"in_tokens":false,
"tokenizer": "FullTokenizer"
}
}
},
"test_reader": {
"name": "test_reader",
"type": "IEReader",
"fields": [],
"config": {
"data_path": "./data/entity_attribute_data/test_data/",
"shuffle": false,
"batch_size": 2,
"epoch": 1,
"sampling_rate": 1.0,
"need_data_distribute": false,
"need_generate_examples": false,
"extra_params": {
"vocab_path": "../../models_hub/ernie_3.0_base_ch_dir/vocab.txt", #选择对应预训练模型的词典路径，在models_hub路径下
"label_map_config": "./dict/entity_attribute_label_map.json",
"num_labels": 12,
"max_seq_len": 512,
"do_lower_case":true,
"in_tokens":false,
"tokenizer": "FullTokenizer"
}
}
}
},
"model": {
"type": "ErnieFcIe",
"is_dygraph":1,
"num_labels":12,
"optimization": {
"learning_rate": 5e-05,
"use_lr_decay": true,
"warmup_steps": 0,
"warmup_proportion": 0.1,
"weight_decay": 0.01,
"use_dynamic_loss_scaling": false,
"init_loss_scaling": 128,
"incr_every_n_steps": 100,
"decr_every_n_nan_or_inf": 2,
"incr_ratio": 2.0,
"decr_ratio": 0.8
},
"embedding": {
"config_path": "../../models_hub/ernie_3.0_base_ch_dir/ernie_config.json" #选择对应预训练模型的配置文件路径，在models_hub路径下
}
},
"trainer": {
"type": "CustomDynamicTrainer",
"PADDLE_PLACE_TYPE": "gpu",
"PADDLE_IS_FLEET": 0,
"train_log_step": 10,
"use_amp": true,
"is_eval_dev": 0,
"is_eval_test": 1,
"eval_step": 50,
"save_model_step": 100,
"load_parameters": "",
"load_checkpoint": "",
"pre_train_model": [
{
"name": "ernie_3.0_base_ch",
"params_path": "../../models_hub/ernie_3.0_base_ch_dir/params" #选择对应预训练模型的参数路径，在models_hub路径下
}
],
"output_path": "./output/ie_attribute_ernie_3.0_base_fc_ch", #输出路径
"extra_param": {
"meta":{
"job_type": "entity_attribute_extraction"
}
}
}
}
```
#### 训练ERNIE模型
- 基于示例的数据集，可以运行以下命令在训练集（train.txt）上进行模型训练，并在测试集（test.txt）上进行验证；
```shell
python run_trainer.py --param_path ./examples/many_to_many_ie_attribute_ernie_fc_ch.json
```
- 训练模型保存于./output/ie_attribute_ernie_3.0_base_fc_ch文件夹下（可在配置文件./examples/many_to_many_ie_attribute_ernie_fc_ch.json中修改输出路径），其中save_inference_model/文件夹会保存用于预测的模型文件，save_checkpoint/文件夹会保存用于热启动的模型文件
- 训练模型的日志文件保存于./log文件夹下
## 开始预测
- 以属性抽取数据集的预测为例
#### 预测的配置文件
- 配置文件：./examples/many_to_many_ie_attribute_ernie_fc_ch_infer.json
- 在配置文件./examples/many_to_many_ie_attribute_ernie_fc_ch_infer.json中需要更改 inference.inference_model_path 为上面训练过程中所保存的**预测模型的路径**
```json
{
"dataset_reader": {
"predict_reader": {
"name": "predict_reader",
"type": "IEReader",
"fields": [],
"config": {
"data_path": "./data/entity_attribute_data/predict_data/",
"shuffle": false,
"batch_size": 2,
"epoch": 1,
"sampling_rate": 1.0,
"extra_params": {
"vocab_path": "../../models_hub/ernie_3.0_base_ch_dir/vocab.txt",
"label_map_config": "./dict/entity_attribute_label_map.json",
"num_labels": 12,
"max_seq_len": 512,
"do_lower_case":true,
"in_tokens":false,
"tokenizer": "FullTokenizer",
"need_data_distribute": false,
"need_generate_examples": true
}
}
}
},
"inference": {
"output_path": "./output/predict_result.txt", #输出文件路径
"label_map_config": "./dict/entity_attribute_label_map.json",
"PADDLE_PLACE_TYPE": "gpu",
"inference_model_path": "./output/ie_attribute_ernie_3.0_base_fc_ch/save_inference_model/inference_step_1000", #加载推理模型
"extra_param": {
"meta": {
"job_type": "information_extraction"
}
}
}
}
```
#### 预测ERNIE模型
```plain
python run_infer.py --param_path ./examples/many_to_many_ie_relation_ernie_fc_ch_infer.json
```
- 预测结果保存于./output/predict_result.txt文件中（可在./examples/many_to_many_ie_attribute_ernie_fc_ch_infer.json中修改输出路径）
\ No newline at end of file
nlp-ernie/wenxin_appzoo/wenxin_appzoo/tasks/text_classification/README_BOW.md 0 → 100644
浏览文件 @ 9ef7e866
# Bow(BowClassification)模型训练、预测
## 开始训练
- 进入分类任务的目录./wenxin_appzoo/tasks/text_classification
```json
cd ./wenxin_appzoo/tasks/text_classification
```
### 训练的配置文件
- 配置文件 ./examples/cls_bow_ch.json
- 文心中的各种参数都是在json文件中进行配置的，您可以通过修改所加载的json文件来进行参数的自定义配置。json配置文件主要分为三个部分：
- dataset_reader
- model
- trainer
```json
{
"dataset_reader": { ## 用于配置模型训练或者预测时的数据相关配置，训练任务的dataset_reader中必须有train_reader、test_reader、dev_reader，预测推理任务的dataset_reader仅需要predict_reader。
"train_reader": { ## 训练、验证、测试各自基于不同的数据集，数据格式也可能不一样，可以在json中配置不同的reader，此处为训练集的reader。
"name": "train_reader",
"type": "BasicDataSetReader", ## 采用BasicDataSetReader，其封装了常见的读取tsv、txt文件、组batch等操作。
"fields": [ ## 域（field）是文心的高阶封装，对于同一个样本存在不同域的时候，不同域有单独的数据类型（文本、数值、整型、浮点型）、单独的词表(vocabulary)等，可以根据不同域进行语义表示，如文本转id等操作，field_reader是实现这些操作的类。
{
"name": "text_a", ## 文本分类只有一个文本特征域，命名为"text_a"。
"data_type": "string", ## data_type定义域的数据类型，文本域的类型为string，整型数值为int，浮点型数值为float。
"reader": {
"type": "CustomTextFieldReader" ## 采用针对文本域的通用reader "CustomTextFieldReader"。数值数组类型域为"ScalarArrayFieldReader"，数值标量类型域为"ScalarFieldReader"，这里的取值是对应FieldReader的类名
},
"tokenizer": {
"type": "CustomTokenizer", ## 指定该文本域的tokenizer为CustomTokenizer，type的取值是对应Tokenizer的类名
"split_char": " ", ## 非Ernie任务需要自己切词，切词之后的明文使用的分隔符在这里设置，默认是通过空格区分不同的token。
"unk_token": "[UNK]", ## unk标记为"[UNK]"， 即词表之外的token所对应的默认id，unk必须是词表文件中存在的token。
"params": null ## 如果需要一些额外的参数传入tokenizer的时候可以使用该字段
},
"need_convert": true, ## "need_convert"为true说明数据格式是明文字符串，需要通过词表转换为id。
"vocab_path": "./data/dict/vocab.txt", ## 指定该文本域的词表，"need_convert"为true时一定要设置
"max_seq_len": 512, ## 设定当前域转为id之后的最大长度
"truncation_type": 0, ## 选择文本超长截断的策略，0为从头开始到最大长度截断，1为从头开始到max_len-1的位置截断，末尾补上最后一个id（词或字），2为保留头和尾两个位置，然后按从头开始到最大长度方式截断。
"padding_id": 0 ## 设定padding时对应的id值，文心内部会按batch中的最长文本大小对整个batch中的数据进行padding补齐。
}, ## 如果每一个样本有多个特征域（文本类型、数值类型均可），可以仿照前面对每个域进行设置，依次增加每个域的配置即可。此时样本的域之间是以\t分隔的。
{
"name": "label", ## 标签也是一个单独的域，在当前例子中命名为"label"。如果多个不同任务体系的标签存在于多个域中，则可实现最基本的多任务学习。
"data_type": "int", ## 标签是整型数值。
"reader": {
"type": "ScalarFieldReader" ## 整型数值域的reader为"ScalarFieldReader"
},
"tokenizer": null, ## 如果你的label是明文文本，且需要分词的话，这里就需要配置对应的tokenizer，规则如上方文本域的tokenizer配置
"need_convert": false, ## "need_convert"为true说明数据格式是明文字符串，需要通过词表转换为id。
"vocab_path": "", ## "need_convert"为true的时候需要填词表路径 。
"max_seq_len": 1, ## 设定每个域的最大长度，当前例子中的label域是一个int数值，所以最大长度是1。
"truncation_type": 0, ## 超过max_seq_len长度之后的截断策略，同上。
"padding_id": 0, ## 设定padding时对应的id值。
"embedding": null ## 历史遗留参数，设置为null即可。
}
],
"config": {
"data_path": "./data/train_data", ## 训练数据train_reader的数据路径，只写到文件夹目录。
"shuffle": false, ## 数据在读取过程中是否需要打乱顺序。
"batch_size": 128, ## 超参数之一，表示每个step训练多少个样本。
"epoch": 5, ## 超参数之一，表示这个数据集中的数据会被重复训练多少轮。
"sampling_rate": 1.0, ## 数据集的采样率，文心预留参数，暂时不起作用，后续版本会升级。
"need_data_distribute": true, ## 表示数据读取过程中是否需要按卡数进行分发，true表示每张卡在同一个step中读取到的数据是不一样的，false表示每张卡在同一个step中读取到的数据是一样的，训练集默认为true，测试集、验证集、预测集都是false。
"need_generate_examples": false, ## 表示在数据读取过程中除了id化好的tensor数据外，是否需要返回原始明文样本，测试集默认取值为true，训练集、验证集为false
"key_tag": false ## 需全部置为false
}
},
"test_reader": { ## 若要评估测试集，需配置test_reader，其配置方式与train_reader类似， 需要注意的是shuffle参数要设置为false，epoch参数必须是1。
"name": "test_reader",
"type": "BasicDataSetReader",
"fields": [
{
"name": "text_a",
"data_type": "string",
"reader": {
"type": "CustomTextFieldReader"
},
"tokenizer": {
"type": "CustomTokenizer",
"split_char": " ",
"unk_token": "[UNK]",
"params": null
},
"need_convert": true,
"vocab_path": "./data/dict/vocab.txt",
"max_seq_len": 512,
"truncation_type": 0,
"padding_id": 0,
"embedding": null
},
{
"name": "label",
"data_type": "int",
"reader": {
"type": "ScalarFieldReader"
},
"tokenizer": null,
"need_convert": false,
"vocab_path": "",
"max_seq_len": 1,
"truncation_type": 0,
"padding_id": 0,
"embedding": null
}
],
"config": {
"data_path": "./data/test_data",
"shuffle": false,
"batch_size": 128,
"epoch": 1,
"sampling_rate": 1.0,
"need_data_distribute": false,
"need_generate_examples": false,
"key_tag": false
}
},
"dev_reader": { ## 若要评估验证集，需配置dev_reader，其配置方式与test_reader类似，需要注意的是shuffle参数要设置为false，epoch参数必须是1。
"name": "dev_reader",
"type": "BasicDataSetReader",
"fields": [
{
"name": "text_a",
"data_type": "string",
"reader": {
"type": "CustomTextFieldReader"
},
"tokenizer": {
"type": "CustomTokenizer",
"split_char": " ",
"unk_token": "[UNK]",
"params": null
},
"need_convert": true,
"vocab_path": "./data/dict/vocab.txt",
"max_seq_len": 512,
"truncation_type": 0,
"padding_id": 0,
"embedding": null
},
{
"name": "label",
"data_type": "int",
"reader": {
"type": "ScalarFieldReader"
},
"tokenizer": null,
"need_convert": false,
"vocab_path": "",
"max_seq_len": 1,
"truncation_type": 0,
"padding_id": 0,
"embedding": null
}
],
"config": {
"data_path": "./data/dev_data",
"shuffle": false,
"batch_size": 128,
"epoch": 1,
"sampling_rate": 1.0,
"need_data_distribute": false,
"need_generate_examples": false,
"key_tag": false
}
}
},
"model": {
"type": "BowClassification", ## 文心采用模型(models)的方式定义神经网络的基本操作，本例采用预置的模型BowClassification实现文本分类，具体网络可参考models目录。
"is_dygraph": 1, ## 区分动态图模型和静态图模型，1表示动态图，0表示静态图
"optimization": {
"learning_rate": 2e-05 ## 预置模型的优化器所需的参数配置，如学习率等。
},
"vocab_size": 33261, ## 该模型（model）使用的词表大小，必填参数。
"num_labels": 2 ## 该分类模型的类别数目是多少，必填参数，不填则默认是二分类
},
"trainer": {
"type": "CustomDynamicTrainer", ## 上面设置为0表示静态图时，此处改为CustomTrainer
"PADDLE_PLACE_TYPE": "cpu", ## 表示运行时的设备类别，取值为cpu和gpu。
"PADDLE_IS_FLEET": 0, ## 表示是否使用fleetrun模式进行训练，gpu多卡情况下必须设置为1，并使用fleetrun命令进行训练。
"train_log_step": 20, ## 训练时打印训练日志的间隔步数，
"is_eval_dev": 0, ## 是否在训练的时候评估开发集，如果取值为1，则一定需要配置dev_reader及其数据路径
"is_eval_test": 1, ## 是否在训练的时候评估测试集，如果取值为1，则一定需要配置test_reader及其数据路径
"eval_step": 100, ## 进行测试集或验证集评估的间隔步数
"save_model_step": 10000, ## 保存模型时的间隔步数，建议设置为eval_step的整数倍
"load_parameters": "", ## 加载包含各op参数值的训练好的模型，用于热启动。此处填写checkpoint路径。不填则表示不使用热启动
"load_checkpoint": "", ## 加载包含学习率等所有参数的训练模型，用于热启动。此处填写checkpoint路径。不填则表示不使用热启动
"pre_train_model": [], ## 加载预训练模型，ERNIE任务的必填参数，非ERNIE任务将当前参数置为[]即可。
"output_path": "./output/cls_bow_ch", ## 保存模型的输出路径，如置空或者不配置则默认输出路径为"./output"
"extra_param": { ## 除核心必要信息之外，需要额外标明的参数信息，比如一些meta信息可以作为日志统计的关键字
"meta":{
"job_type": "text_classification"
}
}
}
}
```
### 训练BOW模型
```json
python run_trainer.py --param_path ./examples/cls_bow_ch.json
```
- 训练模型保存于./output/cls_bow_ch文件夹下（可在配置文件./examples/cls_bow_ch.json中修改输出路径），其中save_inference_model/文件夹会保存用于预测的模型文件，save_checkpoint/文件夹会保存用于热启动的模型文件
- 训练模型的日志文件保存于./log文件夹下
## 开始预测
### 预测的配置文件
- 配置文件 ./examples/cls_bow_ch_infer.json
- 在配置文件./examples/cls_bow_ch_infer.json中需要更改 inference.inference_model_path 为上面训练过程中所保存的**预测模型的路径**
```json
{
"dataset_reader": {
"predict_reader": { ## 如果是预测推理，则必须配置predict_reader，其配置方式与train_reader、test_reader类似，需要注意的是predict_reader不需要label域，shuffle参数必须是false，epoch参数必须是1。
"name": "predict_reader",
"type": "BasicDataSetReader",
"fields": [
{
"name": "text_a",
"data_type": "string",
"reader": {
"type": "CustomTextFieldReader"
},
"tokenizer": {
"type": "CustomTokenizer",
"split_char": " ",
"unk_token": "[UNK]",
"params": null
},
"need_convert": true,
"vocab_path": "./data/dict/vocab.txt",
"max_seq_len": 512,
"truncation_type": 0,
"padding_id": 0,
"embedding": null
}
],
"config": {
"data_path": "./data/predict_data",
"shuffle": false, ## 注意！这里的参数必须关掉，打乱顺序输出之后不方便比对数据看结果
"batch_size": 8,
"epoch": 1, ## 注意！这里的epoch要设置为1，重复多次预测没意义。
"sampling_rate": 1.0,
"need_data_distribute": false,
"need_generate_examples": true,
"key_tag": false
}
}
},
"inference": { ## 用于配置模型预测推理的启动器，包括待预测模型路径、结果输出等参数。
"type": "CustomInference",
"output_path": "./output/predict_result.txt", ## 预测结果的输出路径，如果不填则默认输出路径为"./output/predict_result.txt"
"PADDLE_PLACE_TYPE": "cpu",
"num_labels": 2, ## 必填参数，表示分类模型的类别数目是多少，预测结果解析时会用到
"thread_num": 2,
"inference_model_path": "./output/cls_bow_ch/save_inference_model_0/inference_step_381/", ## 待预测模型的路径
"extra_param": { ## 同trainer，除核心必要信息之外，需要额外标明的参数信息，比如一些meta信息可以作为日志统计的关键字。
"meta":{
"job_type": "text_classification"
}
}
}
}
```
### Bow模型预测
```json
python run_infer.py --param_path ./examples/cls_bow_ch_infer.json
```
- 预测结果保存于./output/predict_result.txt文件中（可在./examples/cls_bow_ch_infer.json中修改输出路径）
\ No newline at end of file
nlp-ernie/wenxin_appzoo/wenxin_appzoo/tasks/text_classification/README_CODE.md 0 → 100644
浏览文件 @ 9ef7e866
# 代码结构、准备工作
## 代码结构
- 分类任务位于wenxin_appzoo/tasks/text_classification
```plain
.
├── data # 训练数据
│ ├── dev_data
│ │ └── dev_1.txt
│ ├── dev_data_one_sent_multilingual
│ │ └── multi_dev.tsv
│ ├── dict
│ │ ├── sentencepiece.bpe.model
│ │ └── vocab.txt
│ ├── download_data.sh
│ ├── multi_label_data
│ │ ├── dev_data
│ │ │ └── dev.txt
│ │ ├── test_data
│ │ │ └── test.txt
│ │ └── train_data
│ │ └── train.txt
│ ├── predict_data
│ │ └── infer.txt
│ ├── predict_data_one_sent_multilingual
│ │ └── multi_predict.tsv
│ ├── test_data
│ │ └── test.txt
│ ├── test_data_one_sent_multilingual
│ │ └── multi_test.tsv
│ ├── train_data
│ │ └── train.txt
│ └── train_data_one_sent_multilingual
│ └── multi_train.tsv
├── data_set_reader # 数据加载相关类
│ ├── dataset_reader_for_ernie_doc_classification.py
│ └── __init__.py
├── examples
│ ├── cls_bow_ch_infer.json
│ ├── cls_bow_ch.json
│ ├── cls_ernie_doc_1.0_one_sent_ch_infer_dy.json
│ ├── cls_ernie_doc_1.0_one_sent_ch.json
│ ├── cls_ernie_fc_ch_infer.json
│ ├── cls_ernie_fc_ch.json
│ ├── cls_ernie_fc_ch_with_data_aug.json
│ ├── cls_ernie_m_1.0_base_one_sent_infer.json
│ ├── cls_ernie_m_1.0_base_one_sent.json
│ ├── cls_ernie_multi_label_ch_infer.json
│ └── cls_ernie_multi_label_ch.json
├── inference # 推理相关类
│ ├── custom_inference.py
│ ├── ernie_doc_inference_dy.py
│ └── __init__.py
├── __init__.py
├── model
│ ├── base_cls.py
│ ├── bow_classification.py
│ ├── ernie_classification.py
│ ├── ernie_doc_classification.py
│ ├── __init__.py
│ └── multi_label_classification.py
├── reader
│ ├── categorical_field_reader.py
│ └── multi_label_field_reader.py
├── run_infer_dy.py #ernie_doc 动态图预测的py文件
├── run_infer.py # 除enrie_doc外的预测文件入口文件，只依靠json进行模型训练的入口脚本
├── run_trainer.py. # 训练文件入口文件，只依靠json进行模型训练的入口脚本
├── run_with_data_aug.sh
└── trainer
├── custom_dynamic_ernie_doc_trainer.py
├── custom_dynamic_trainer.py
├── custom_trainer.py
└── __init__.py
```
## 数据准备
- 在文心中，基于ERNIE的模型都不需要用户自己分词和生成词表文件，非ERNIE的模型需要用户自己提前切好词，词之间以空格分隔，并生成词表文件。切词和词表生成可以使用「[分词工具与词表生成工具](../../tools/data/wordseg/README.md)」进行处理。
- 文心中的所有数据集、包含词表文件、label_map文件等都必须为为utf-8格式，如果你的数据是其他格式，请使用「[编码识别及转换工具](../../tools/data/data_cleaning/README.md)」进行格式转换。
- 文心中的训练集、测试集、验证集、预测集和词表分别存放在./wenxin_appzoo/tasks/text_classification/data目录下的train_data、test_data、dev_data、predict_data、dict文件夹下。
- 在分类任务中，训练集、测试集和验证集的数据格式相同，数据分为两列，列与列之间用**\t**进行分隔。第一列为文本，第二列为标签。以下为示例：
### 单标签分类
- 非ERNIE训练集数据示例：数据分为两列，列与列之间用**\t**进行分隔。第一列为文本，第二列为标签。
```js
房间 太 小 。 其他 的 都 一般 。 。 。 。 。 。 。 。 。 0
LED屏 就是 爽 ， 基本 硬件 配置 都 很 均衡 ， 镜面 考 漆 不错 ， 小黑 ， 我喜欢 。 1
差 得 要命 , 很大 股霉味 , 勉强 住 了 一晚 , 第二天 大早 赶紧 溜。 0
```
- 非ERNIE预测数据集示例：仅一列为文本，不需要标签列
```js
USB接口 只有 2个 ， 太 少 了 点 ， 不能 接 太多 外 接 设备 ！ 表面 容易 留下 污垢 ！
平时 只 用来 工作 ， 上 上网 ， 挺不错 的 ， 没有 冗余 的 功能 ， 样子 也 比较 正式 ！ 还 可以 吧 ， 价格 实惠 宾馆 反馈 2008年4月17日 ： 谢谢 ！ 欢迎 再次 入住 其士 大酒店 。
```
- 非ERNIE模型的词表文件示例：词表分为两列，第一列为词，第二列为id（从0开始），列与列之间用**\t**进行分隔。文心的词表中，[PAD]、[CLS]、[SEP]、[MASK]、[UNK]这5个词是必须要有的，若用户自备词表，需保证这5个词是存在的。部分词表示例如下所示：
```js
[PAD] 0
[CLS] 1
[SEP] 2
[MASK] 3
[UNK] 4
郑重 5
天空 6
工地 7
神圣 8
```
- ERNIE数据集与非ERNIE数据集格式一致，不同之处在于不用分词，如下所示：
```js
选择珠江花园的原因就是方便，有电动扶梯直接到达海边，周围餐馆、食廊、商场、超市、摊位一应俱全。酒店装修一般，但还算整洁。 1
15.4寸笔记本的键盘确实爽，基本跟台式机差不多了，蛮喜欢数字小键盘，输数字特方便，样子也很美观，做工也相当不错 1
房间太小。其他的都一般。。。。。。。。。 0
```
- ERNIE词表文件格式与非ERNIE的格式一致，由文心提供。
```js
[PAD] 0
[CLS] 1
[SEP] 2
[MASK] 3
， 4
的 5
、 6
一 7
人 8
有 9
```
### 多标签分类
- ERNIE训练集数据示例：数据分为两列，列与列之间用**\t**进行分隔。第一列为文本，第二列为标签，当该样本拥有多个标签时，标签之间使用空格进行分隔。比如你的标签有100种，某个样例的标签是第50个标签和第87个标签，其标签列就是“49 86”。像这个情况就是标签的第49和86维是正例1，其他维是负例0。非ERNIE的训练集数据与ERNIE一致，区别就是非ERNIE的文本需要切词，这里不再赘述。
```js
互联网创业就如选秀 需求与服务就是价值 0 1
郭德纲式生存：时代的变与未变 2
快讯！腾讯市值突破10000亿港元 3
```
- ERNIE预测数据集示例：仅一列为文本，不需要标签列，非ERNIE的训练集数据与ERNIE一致，区别就是非ERNIE的文本需要切词，这里不再赘述。
```js
互联网创业就如选秀 需求与服务就是价值
郭德纲式生存：时代的变与未变
快讯！腾讯市值突破10000亿港元
```
- 词表的格式与单标签分类一致，不再赘述
## 网络（模型）选择
文心预置的可用于文本分类的模型源文件在./wenxin_appzoo/tasks/text_classification/model目录下，各个模型的特点如下所示（后面章节会依次展示使用方法）：
| 网络名称（py文件的类名） | 简介 | 支持类型 | 支持预训练模型 | 备注 |
| ------------------------------------------------------- | ------------------------------------------------------------ | ---------- | ------------------------------------------------------------ | ---- |
| BowClassification(bow_classification.py) | 词袋模型，不考虑语法和语序，用一组无序单词来表达一段文本。 | 单标签分类 | 无 | |
| ErnieClassification(ernie_classification.py) | 基于ERNIE预训练模型的最简单的分类模型，在ERNIE的embedding输出层之后直接添加FC（全链接层）降维到标签数量的纬度，loss使用交叉熵。网络结构简单，效果好。 | 单标签分类 | ERNIE2.0-Base、ERNIE2.0-large、ERNIE3.0-Base、ERNIE3.0-x-Base、ERNIE3.0-Medium、ERNIE-M | |
| MultiLabelClassification(multi_label_classification.py) | 处理多标签分类任务的网络结构，在ErnieClassification的基础上，loss由二分类交叉熵更换为 sigmoid cross entropy | 多标签分类 | ERNIE2.0-Base、ERNIE2.0-large、ERNIE3.0-Base、ERNIE3.0-x-Base、ERNIE3.0-Medium、ERNIE-M | |
| ErnieDocClassification(ernie_doc_classification.py) | 长文本分类任务的网络 | 单标签分类 | ERNIE-Doc | |
## ERNIE预训练模型下载
文心提供的ERNIE预训练模型的参数文件和配置文件在./wenxin_appzoo/tasks/models_hub/目录下，由对应的download_xx.sh文件是下载得到。ERNIE部分模型介绍，请详见文档「[ERNIE模型介绍](../../../../../README_MODEL.md)」
## 模型评估指标选择
分类任务常用的指标有：Acc（准确率）、Precision（精确率）、Recall（召回率）、F1。
\ No newline at end of file
nlp-ernie/wenxin_appzoo/wenxin_appzoo/tasks/text_classification/README_ERNIE.md 0 → 100644
浏览文件 @ 9ef7e866
# ERNIE(ErnieClassification)模型训练、预测
# 开始训练
- 进入分类任务的目录./wenxin_appzoo/tasks/text_classification
```json
cd ./wenxin_appzoo/tasks/text_classification
```
## 预训练模型准备
- 模型均存放于wenxin_appzoo/wenxin_appzoo/models_hub文件夹下，进入该文件夹下载对应ERNIE模型
```json
cd ../../models_hub
sh ./download_ernie_xxx.sh
cd ../tasks/text_classification
```
## 训练的配置文件
- 配置文件：./examples/cls_ernie_fc_ch.json
```json
{
"dataset_reader": {
"train_reader": {
"name": "train_reader",
"type": "BasicDataSetReader",
"fields": [
{
"name": "text_a",
"data_type": "string",
"reader": {
"type": "ErnieTextFieldReader"
},
"tokenizer": {
"type": "FullTokenizer",
"split_char": " ",
"unk_token": "[UNK]"
},
"need_convert": true,
"vocab_path": "../../models_hub/ernie_3.0_base_ch_dir/vocab.txt",
"max_seq_len": 512,
"truncation_type": 0,
"padding_id": 0
},
{
"name": "label",
"data_type": "int",
"reader": {
"type": "ScalarFieldReader"
},
"tokenizer": null,
"need_convert": false,
"vocab_path": "",
"max_seq_len": 1,
"truncation_type": 0,
"padding_id": 0,
"embedding": null
}
],
"config": {
"data_path": "./data/train_data",
"shuffle": false,
"batch_size": 8,
"epoch": 5,
"sampling_rate": 1.0,
"need_data_distribute": true,
"need_generate_examples": false
}
},
"test_reader": {
"name": "test_reader",
"type": "BasicDataSetReader",
"fields": [
{
"name": "text_a",
"data_type": "string",
"reader": {
"type": "ErnieTextFieldReader"
},
"tokenizer": {
"type": "FullTokenizer",
"split_char": " ",
"unk_token": "[UNK]"
},
"need_convert": true,
"vocab_path": "../../models_hub/ernie_3.0_base_ch_dir/vocab.txt",
"max_seq_len": 512,
"truncation_type": 0,
"padding_id": 0
},
{
"name": "label",
"data_type": "int",
"need_convert": false,
"reader": {
"type": "ScalarFieldReader"
},
"tokenizer": null,
"vocab_path": "",
"max_seq_len": 1,
"truncation_type": 0,
"padding_id": 0,
"embedding": null
}
],
"config": {
"data_path": "./data/test_data",
"shuffle": false,
"batch_size": 8,
"epoch": 1,
"sampling_rate": 1.0,
"need_data_distribute": false,
"need_generate_examples": false
}
}
},
"model": {
"type": "ErnieClassification",
"is_dygraph": 1,
"optimization": { ## 优化器设置，文心ERNIE推荐的默认设置。
"learning_rate": 5e-05,
"use_lr_decay": true,
"warmup_steps": 0,
"warmup_proportion": 0.1,
"weight_decay": 0.01,
"use_dynamic_loss_scaling": false,
"init_loss_scaling": 128,
"incr_every_n_steps": 100,
"decr_every_n_nan_or_inf": 2,
"incr_ratio": 2.0,
"decr_ratio": 0.8
},
"embedding": {
"config_path": "../../models_hub/ernie_3.0_base_ch_dir/ernie_config.json"
},
"num_labels": 2
},
"trainer": {
"type": "CustomDynamicTrainer",
"PADDLE_PLACE_TYPE": "gpu",
"PADDLE_IS_FLEET": 1,
"train_log_step": 10,
"use_amp": true, # 是否开启混合精度训练，默认开启。
"is_eval_dev": 0,
"is_eval_test": 1,
"eval_step": 100,
"save_model_step": 200,
"load_parameters": "", ## 加载包含各op参数值的训练好的模型，用于热启动。此处填写checkpoint路径。不填则表示不使用热启动。
"load_checkpoint": "", ## 加载包含学习率等所有参数的训练模型，用于热启动。此处填写checkpoint路径。不填则表示不使用热启动。
"pre_train_model": [
{
"name": "ernie_3.0_base_ch",
"params_path": "../../models_hub/ernie_3.0_base_ch_dir/params"
}
],
"output_path": "./output/cls_ernie_3.0_base_fc_ch_dy",
"extra_param": {
"meta":{
"job_type": "text_classification"
}
}
}
}
```
## 训练ERNIE模型
```json
python run_trainer.py --param_path ./examples/cls_ernie_fc_ch.json
```
- 训练模型保存于./output/cls_ernie_3.0_base_fc_ch_dy文件夹下（可在配置文件./examples/cls_ernie_fc_ch.json中修改输出路径），其中save_inference_model/文件夹会保存用于预测的模型文件，save_checkpoint/文件夹会保存用于热启动的模型文件
- 训练模型的日志文件保存于./log文件夹下
# 开始预测
## 预测的配置文件
- 配置文件 ./examples/cls_ernie_fc_ch_infer.json
- 在配置文件./examples/cls_ernie_fc_ch_infer.json中需要更改 inference.inference_model_path 为上面训练过程中所保存的**预测模型的路径**
```json
{
"dataset_reader": {
"predict_reader": {
"name": "predict_reader",
"type": "BasicDataSetReader",
"fields": [
{
"name": "text_a",
"data_type": "string",
"reader": {
"type": "ErnieTextFieldReader"
},
"tokenizer": {
"type": "FullTokenizer",
"split_char": " ",
"unk_token": "[UNK]",
"params": null
},
"need_convert": true,
"vocab_path": "../../models_hub/ernie_3.0_base_ch_dir/vocab.txt",
"max_seq_len": 512,
"truncation_type": 0,
"padding_id": 0,
"embedding": null
}
],
"config": {
"data_path": "./data/predict_data",
"shuffle": false,
"batch_size": 8,
"epoch": 1,
"sampling_rate": 1.0,
"need_data_distribute": false,
"need_generate_examples": true
}
}
},
"inference": {
"type": "CustomInference",
"output_path": "./output/predict_result.txt",
"PADDLE_PLACE_TYPE": "cpu",
"num_labels": 2,
"thread_num": 2,
"inference_model_path": "./output/cls_ernie_3.0_base_fc_ch_dy/save_inference_model/inference_step_126/",
"extra_param": {
"meta":{
"job_type": "text_classification"
}
}
}
}
```
## ERNIE模型预测
```shell
python ./run_infer.py --param_path ./examples/cls_ernie_fc_ch_infer.json
```
- 预测结果保存于./output/predict_result.txt文件中（可在./examples/cls_ernie_fc_ch_infer.json中修改输出路径）。
\ No newline at end of file
nlp-ernie/wenxin_appzoo/wenxin_appzoo/tasks/text_classification/README_GRID.md 0 → 100644
浏览文件 @ 9ef7e866
# 网格搜索
- 网格搜索是指在一份配置文件中，每种超参数都可以配置一到多个值，多种超参数之间会进行排列组合，从而形成N份新的配置文件，真正运行的时候会去串行执行这N个配置文件，生成N组模型，这样能通过一次配置和运行，进行多次训练，产出多个模型，提高开发效率。
## 文心中的网格搜索
这里我们以BOW分类任务为例介绍文心中的网格搜索的使用方式，主要分为以下几个步骤：
1. 数据准备：数据集的准备与通用的BOW分类任务一致，不再赘述，详细信息请移步“[快速使用->实战演练：使用文心进行模型训练](https://ai.baidu.com/ai-doc/ERNIE-Ultimate/Ekmlrorrp)”
2. 参数配置：以wenxin_appzoo/tasks/text_classification/examples/cls_bow_ch.json为例，假如我们需要对学习率这个参数进行网格搜索设置，那么将”model”中的”learning_rate“的值修改为一个数组即可。目前文心的网格搜索的作用范围在optimization和train_reader的config中，用户可设置多个learning_rate、batch_size和epoch等。修改示例如下：
```json
{
"dataset_reader": {
"train_reaer": {
...
"config": {
"data_path": "./data/train_data",
"shuffle": false,
"batch_size": [2, 4, 8], ## 分别以bath_size=2，4，8进行训练
"epoch": [3, 5], ## 分别进行3轮和5轮的训练
"sampling_rate": 1.0
}
}
...
},
"model": {
"type": "BowClassification",
"optimization": {
"learning_rate": [2e-5, 2e-4] ## learning_rate=2e-5， 2e-4 进行训练
},
"vocab_size": 33261,
"num_labels": 2
},
...
}
```
3. 启动训练：使用网格搜索进行训练的启动脚本与普通训练任务不一样，启动脚本为**run_with_preprocess.py**，该脚本的位置在wenxin_appzoo/tools/run_preprocess/目录下，可以拷贝到当前wenxin_appzoo/tasks/text_classification目录下使用，入参为上一步骤配置好的json文件，具体如下所示：
```shell
# BOW 中文文本分类模型
# 基于json实现预置网络训练。其调用了配置文件./examples/cls_bow_ch.json（添加了网格搜索配置的json）
python run_with_preprocess.py --param_path ./examples/cls_bow_ch.json
```
## 运行过程中产生的文件
运行过程：使用**run_with_preprocess.py**启动的添加了网格搜索的任务会产生一些额外的目录，如下所示：
- json_tmp：交叉验证处理完成之后生成的新的待运行配置文件，如下图所示：
![img](http://rte.weiyun.baidu.com/api/imageDownloadAddress?attachId=2c310896927a4aa0a76a8b2331b18a76)
- log：基于交run_with_preprocess.py运行的任务都会生成新的json配置，每个json对应一个独立的trainer，各个trainer按照顺序串行训练，所以日志会分别输出到对应编号的log中。如下图就是串行的4个trainer的日志。日志内容和单独运行run_trainer.py输出到test.log中的日志一样，如下图所示：
![img](http://rte.weiyun.baidu.com/api/imageDownloadAddress?attachId=5188e4fb42bf41c1aaf9cd208aecbe41)
\ No newline at end of file
nlp-ernie/wenxin_appzoo/wenxin_appzoo/tasks/text_classification/README_M.md 0 → 100644
浏览文件 @ 9ef7e866
# ERNIE-M(ErnieClassification)模型训练、预测
## 开始训练
- 进入分类任务的目录./wenxin_appzoo/tasks/text_classification
```json
cd ./wenxin_appzoo/tasks/text_classification
```
### 预训练模型准备
- 模型均存放于wenxin_appzoo/wenxin_appzoo/models_hub文件夹下，进入该文件夹下载对应ERNIE-M模型
```json
cd ../../models_hub
sh download_ernie_m_1.0_base.sh
cd ../tasks/text_classification
```
### 训练的配置文件
- 配置文件：./examples/cls_ernie_m_1.0_base_one_sent.json
```json
{
"dataset_reader": {
"train_reader": {
"name": "train_reader",
"type": "BasicDataSetReader",
"fields": [
{
"name": "text_a",
"data_type": "string",
"reader": {"type":"ErnieTextFieldReaderForMultilingual"},
"tokenizer":{
"type":"FullTokenizerErnieM",
"split_char":" ",
"unk_token":"[UNK]",
"params":{
"do_lower_case": "false",
"spm_model_file": "./data/dict/sentencepiece.bpe.model"
}
},
"need_convert": true,
"vocab_path": "../../models_hub/ernie_m_1.0_base_dir/erniem.vocab.txt",
"max_seq_len": 256,
"truncation_type": 0,
"padding_id": 1,
"embedding": {
"type":"ErnieTokenEmbedding",
"use_reader_emb":false,
"emb_dim":768,
"config_path":"../../models_hub/ernie_m_1.0_base_dir/ernie_m_1.0_base_config.json"
}
},
{
"name": "label",
"data_type": "int",
"reader": {"type":"ScalarFieldReader"},
"tokenizer": null,
"need_convert": false,
"vocab_path": "",
"max_seq_len": 1,
"truncation_type": 0,
"padding_id": 0,
"embedding": null
}
],
"config": {
"data_path": "./data/train_data_one_sent_multilingual",
"shuffle": true,
"batch_size": 32,
"epoch": 3,
"sampling_rate": 1.0,
"key_tag": false,
"need_data_distribute": true,
"need_generate_examples": false
}
},
"test_reader": {
"name": "test_reader",
"type": "BasicDataSetReader",
"fields": [
{
"name": "text_a",
"data_type": "string",
"reader": {"type":"ErnieTextFieldReaderForMultilingual"},
"tokenizer":{
"type":"FullTokenizerErnieM",
"split_char":" ",
"unk_token":"[UNK]",
"params":{
"do_lower_case": false,
"spm_model_file": "./data/dict/sentencepiece.bpe.model"
}
},
"need_convert": true,
"vocab_path": "../../models_hub/ernie_m_1.0_base_dir/erniem.vocab.txt",
"max_seq_len": 512,
"truncation_type": 0,
"padding_id": 0,
"embedding": {
"type":"ErnieTokenEmbedding",
"use_reader_emb":false,
"emb_dim":768,
"config_path":"../../models_hub/ernie_m_1.0_base_dir/ernie_m_1.0_base_config.json",
"other":""
}
},
{
"name": "label",
"data_type": "int",
"reader": {"type":"ScalarFieldReader"},
"tokenizer": null,
"need_convert": false,
"vocab_path": "",
"max_seq_len": 1,
"truncation_type": 0,
"padding_id": 0,
"embedding": null
}
],
"config": {
"data_path": "./data/test_data_one_sent_multilingual",
"shuffle": false,
"batch_size": 8,
"key_tag": false,
"epoch": 1,
"sampling_rate": 1.0,
"need_data_distribute": false,
"need_generate_examples": false
}
},
"dev_reader": {
"name": "dev_reader",
"type": "BasicDataSetReader",
"fields": [
{
"name": "text_a",
"data_type": "string",
"reader": {"type":"ErnieTextFieldReaderForMultilingual"},
"tokenizer":{
"type":"FullTokenizerErnieM",
"split_char":" ",
"unk_token":"[UNK]",
"params":{
"do_lower_case":false,
"spm_model_file": "./data/dict/sentencepiece.bpe.model"
}
},
"need_convert": true,
"vocab_path": "../../models_hub/ernie_m_1.0_base_dir/erniem.vocab.txt",
"max_seq_len": 512,
"truncation_type": 0,
"padding_id": 0,
"embedding": {
"type":"ErnieTokenEmbedding",
"use_reader_emb":false,
"emb_dim":768,
"config_path":"../../models_hub/ernie_m_1.0_base_dir/ernie_m_1.0_base_config.json",
"other":""
}
},
{
"name": "label",
"data_type": "int",
"reader": {"type":"ScalarFieldReader"},
"tokenizer": null,
"need_convert": false,
"vocab_path": "",
"max_seq_len": 1,
"truncation_type": 0,
"padding_id": 0,
"embedding": null
}
],
"config": {
"data_path": "./data/dev_data_one_sent_multilingual",
"shuffle": false,
"key_tag": false,
"batch_size": 8,
"epoch": 1,
"sampling_rate": 1.0,
"need_data_distribute": false,
"need_generate_examples": false
}
}
},
"model": {
"type": "ErnieClassification",
"is_dygraph": 1,
"embedding": {
"type":"ErnieTokenEmbedding",
"emb_dim":768,
"config_path":"../../models_hub/ernie_m_1.0_base_dir/ernie_m_1.0_base_config.json",
"other":""
},
"optimization":{
"learning_rate": 2e-5,
"use_lr_decay": true,
"warmup_steps": 0,
"warmup_proportion": 0.1,
"weight_decay": 0.01,
"use_dynamic_loss_scaling": false,
"init_loss_scaling": 128,
"incr_every_n_steps": 100,
"decr_every_n_nan_or_inf": 2,
"incr_ratio": 2.0,
"decr_ratio": 0.8
},
"num_labels": 2
},
"trainer": {
"type": "CustomDynamicTrainer",
"PADDLE_PLACE_TYPE": "gpu",
"PADDLE_IS_FLEET": 1,
"train_log_step": 10,
"use_amp": true,
"is_eval_dev": 0,
"is_eval_test": 1,
"eval_step": 50,
"save_model_step": 100,
"load_parameters": "",
"load_checkpoint": "",
"pre_train_model": [
{
"name": "ernie_m_1.0_base",
"params_path": "../../models_hub/ernie_m_1.0_base_dir/params"
}
],
"output_path": "./output/cls_ernie_m_1.0_base_one_sent",
"extra_param": {
"meta":{
"job_type": "text_classification"
}
}
}
}
```
### 训练ERNIE-M模型
```json
python run_trainer.py --param_path ./examples/cls_ernie_m_1.0_base_one_sent.json
```
- 训练模型保存于./output/cls_ernie_m_1.0_base_one_sent文件夹下（可在配置文件./examples/cls_ernie_m_1.0_base_one_sent.json中修改输出路径），其中save_inference_model/文件夹会保存用于预测的模型文件，save_checkpoint/文件夹会保存用于热启动的模型文件
- 训练模型的日志文件保存于./log文件夹下
## 开始预测
### 预测的配置文件
- 配置文件 ./examples/cls_ernie_m_1.0_base_one_sent_infer.json
- 在配置文件./examples/cls_ernie_m_1.0_base_one_sent_infer.json中需要更改 inference.inference_model_path 为上面训练过程中所保存的**预测模型的路径**
```json
{
"dataset_reader": {
"predict_reader": {
"name": "predict_reader",
"type": "BasicDataSetReader",
"fields" : [
{
"name": "text_a",
"data_type": "string",
"reader": {"type":"ErnieTextFieldReaderForMultilingual"},
"tokenizer":{
"type":"FullTokenizerErnieM",
"split_char":" ",
"unk_token":"[UNK]",
"params":{
"do_lower_case": "false",
"spm_model_file": "./data/dict/sentencepiece.bpe.model"
}
},
"need_convert": true,
"vocab_path": "../../models_hub/ernie_m_1.0_base_dir/erniem.vocab.txt",
"max_seq_len": 512,
"truncation_type": 0,
"padding_id": 1,
"embedding": {
"type":"ErnieTokenEmbedding",
"use_reader_emb":false,
"emb_dim":768,
"config_path":"../../models_hub/ernie_m_1.0_base_dir/ernie_m_1.0_base_config.json"
}
}
],
"config": {
"data_path": "./data/predict_data_one_sent_multilingual",
"shuffle": false,
"key_tag": false,
"batch_size": 8,
"epoch": 1,
"sampling_rate": 1.0,
"need_data_distribute": false,
"need_generate_examples": true
}
}
},
"inference": {
"output_path": "./output/predict_result.txt",
"inference_model_path": "./output/cls_ernie_m_1.0_base_one_sent/save_inference_model/inference_step_100",
"PADDLE_PLACE_TYPE": "gpu",
"num_labels": 2,
"thread_num": 2,
"extra_param": {
"meta":{
"job_type": "text_classification"
}
}
}
}
```
### ERNIE-M模型预测
```shell
python ./run_infer.py --param_path ./examples/cls_ernie_m_1.0_base_one_sent_infer.json
```
- 预测结果保存于./output/predict_result.txt文件中（可在./examples/cls_ernie_m_1.0_base_one_sent_infer.json中修改输出路径）。
\ No newline at end of file
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或