快速安装 simpletransformers

simpletransformers 项目地址：https://hub.fastgit.org/ThilinaRajapakse/simpletransformers
simpletransformers 文档地址：
https://simpletransformers.ai/

快速安装方式：

  • 使用Conda安装

1）新建虚拟环境

  1. conda create -n st python pandas tqdm
  2. conda activate st

2）安装cuda环境

  1. conda install pytorch>=1.6 cudatoolkit=11.0 -c pytorch

3）安装 simpletransformers

  1. pip install simpletransformers

4) 安装 wandb
wandb 用于在web浏览器中追踪和可视化Weights和Biases(wandb)

  1. pip install wandb

目前支持的任务：

任务 模型
二元和多类文本分类 ClassificationModel
对话式人工智能（聊天机器人训练） ConvAIModel
语言生成 LanguageGenerationModel
语言模型训练/微调 LanguageModelingModel
多标签文本分类 MultiLabelClassificationModel
多模态分类（文本和图像数据结合） MultiModalClassificationModel
命名实体识别 NERModel
问答 QuestionAnsweringModel
回归 ClassificationModel
句子对分类 ClassificationModel
文本表示生成 RepresentationModel

预训练模型去哪里下载？

有关预训练模型，请参阅Hugging Face 文档。
根据文档中给出的model_type，只要在args中正确设置model_name的字典值就是可以加载预训练模型

【实践01】文本分类

数据集

笔者选用CLUE的作为benchmark数据集
选取数据集：
（1）TNEWS’ 今日头条中文新闻（短文）分类
（2）IFLYTEK’ 长文本分类

中文语言理解测评基准(CLUE)

https://www.cluebenchmarks.com/dataSet_search.html
为更好的服务中文语言理解、任务和产业界，做为通用语言模型测评的补充，通过搜集整理发布中文任务及标准化测评等方式完善基础设施，最终促进中文NLP的发展。
Update: CLUE论文被计算语言学国际会议 COLING2020高分录用

  • IFLYTEK’ 长文本分类

下载地址：https://github.com/CLUEbenchmark/CLUE
该数据集共有1.7万多条关于app应用描述的长文本标注数据，包含和日常生活相关的各类应用主题，共119个类别：”打车”:0,”地图导航”:1,”免费WIFI”:2,”租车”:3,….,”女性”:115,”经营”:116,”收款”:117,”其他”:118(分别用0-118表示)。每一条数据有三个属性，从前往后分别是 类别ID，类别名称，文本内容。
数据量：训练集(12,133)，验证集(2,599)，测试集(2,600)

  1. {"label": "110",
  2.  "label_des": "社区超市",
  3.  "sentence": "朴朴快送超市创立于2016年，专注于打造移动端30分钟即时配送一站式购物平台，商品品类包含水果、蔬菜、肉禽蛋奶、海鲜水产、粮油调味、酒水饮料、休闲食品、日用品、外卖等。朴朴公司希望能以全新的商业模式，更高效快捷的仓储配送模式，致力于成为更快、更好、更多、更省的在线零售平台，带给消费者更好的消费体验，同时推动中国食品安全进程，成为一家让社会尊敬的互联网公司。,朴朴一下，又好又快,1.配送时间提示更加清晰友好2.保障用户隐私的一些优化3.其他提高使用体验的调整4.修复了一些已知bug"}

数据处理

Simple Transformers要求数据必须包含在至少两列的Pandas DataFrames中。 只需为列的文本和标签命名，SimpleTransformers就会处理数据。
第一列包含文本，类型为str。
第二列包含标签，类型为int。
对于多类分类，标签应该是从0开始的整数。

  1. import json
  2. import pandas as pd
  4. def load_clue_iflytek(path,mode=None):
  5.     """适应simpletransformer的加载方式"""
  6.     data = []
  7.     with open(path, "r", encoding="utf-8") as fp:
  8.         if mode == 'train' or mode =='dev':
  9.             for idx, line in enumerate(fp):
  10.                 line = json.loads(line.strip())
  11.                 label = int(line["label"])
  12.                 text = line['sentence']
  13.                 data.append([text, label])
  14.             data_df = pd.DataFrame(data, columns=["text", "labels"])
  15.             return data_df
  16.         elif mode == 'test':
  17.             for idx, line in enumerate(fp):
  18.                 line = json.loads(line.strip())
  19.                 text = line['sentence']
  20.                 data.append([text])
  21.             data_df = pd.DataFrame(data, columns=["text"])
  22.             return data_df

模型搭建和训练

先进行参数配置，Simple Transformers具有dict args， 有关每个args的详细说明，可有参考：https://simpletransformers.ai/docs/tips-and-tricks/
1）参数配置

  1. # 配置config
  2. import argparse
  4. def data_config(parser):
  5.     parser.add_argument("--trainset_path", type=str, default="data/Chinese_Spam_Message/train.json",
  6.                         help="训练集路径")
  7.     parser.add_argument("--testset_path", type=str, default="data/Chinese_Spam_Message/test.txt",
  8.                         help="测试集路径")
  9.     parser.add_argument("--reprocess_input_data", type=bool, default=True,
  10.                         help="如果为True，则即使cache_dir中存在输入数据的缓存文件，也将重新处理输入数据")
  11.     parser.add_argument("--overwrite_output_dir", type=bool, default=True,
  12.                         help="如果为True，则训练后的模型将保存到ouput_dir，并将覆盖同一目录中的现有已保存模型")
  13.     parser.add_argument("--use_cached_eval_features", type=bool, default=True,
  14.                         help="训练期间的评估使用缓存特征，将此设置为False将导致在每个评估步骤中重新计算特征")
  15.     parser.add_argument("--output_dir", type=str, default="outputs/",
  16.                         help="存储所有输出，包括模型checkpoints和评估结果")
  17.     parser.add_argument("--best_model_dir", type=str, default="outputs/best_model/",
  18.                         help="保存评估过程中的最好模型")
  19.     return parser
  22. def model_config(parser):
  23.     parser.add_argument("--max_seq_length", type=int, default=64,
  24.                         help="模型支持的最大序列长度")
  25.     parser.add_argument("--model_type", type=str, default="bert",
  26.                         help="模型类型bert/roberta")
  27.     # 要加载以前保存的模型而不是默认模型的模型，可以将model_name更改为包含已保存模型的目录的路径。
  28.     parser.add_argument("--model_name", type=str, default="./outputs/bert",
  29.                         help="选择使用哪个预训练模型")
  30.     parser.add_argument("--manual_seed", type=int, default=0,
  31.                         help="为了产生可重现的结果，需要设置随机种子")
  32.     parser.add_argument("--learning_rate", type=int, default=4e-5,
  33.                         help="学习率")
  34.     return parser
  37. def train_config(parser):
  38.     parser.add_argument("--num_train_epochs", type=int, default=3,
  39.                         help="模型训练迭代数")
  40.     parser.add_argument("--wandb_kwargs", type=dict, default={"name": "bert"},
  41.                         help="")
  42.     parser.add_argument("--n_gpu", type=int, default=1,
  43.                         help="训练时使用的GPU个数")
  44.     parser.add_argument("--train_batch_size", type=int, default=64)
  45.     parser.add_argument("--eval_batch_size", type=int, default=32)
  46.     return parser
  49. def set_args():
  50.     parser = argparse.ArgumentParser()
  51.     parser = data_config(parser)
  52.     parser = model_config(parser)
  53.     parser = train_config(parser)
  55.     args,_ = parser.parse_known_args()
  56.     return args

2）模型搭建和训练

  1. from simpletransformers.classification import ClassificationModel
  2. from sklearn.metrics import f1_score, accuracy_score
  3. import logging
  5. def f1_multiclass(labels, preds):
  6.       return f1_score(labels, preds, average='micro')
  8. # 创建分类模型
  9. model = ClassificationModel(args.model_type, args.model_name, num_labels=num_labels, args=vars(args))
  11. # 训练模型，并在训练时评估
  12. model.train_model(train,eval_df=dev)
  14. # 模型预测
  15. result, model_outputs, wrong_predictions = model.eval_model(dev, f1=f1_multiclass)
  18. # 模型预测
  19. predictions, raw_outputs = model.predict(test["text"][0])
  20. print(predictions)
  21. print(raw_outputs)

预测结果

为了保证能跑动，maxlen只用了64，也只训练了3轮，F1值的效果并不是很好

  1. {"eval_loss" = 1.8086365330510024,"f1" = 0.5917660638707195,"mcc" = 0.5727319886339782}

完整代码

  1. import json
  2. import pandas as pd
  3. from simpletransformers.classification import ClassificationModel
  4. from sklearn.metrics import f1_score, accuracy_score
  5. import logging
  7. def load_clue_iflytek(path,mode=None):
  8.     """适应simpletransformer的加载方式"""
  9.     data = []
  10.     with open(path, "r", encoding="utf-8") as fp:
  11.         if mode == 'train' or mode =='dev':
  12.             for idx, line in enumerate(fp):
  13.                 line = json.loads(line.strip())
  14.                 label = int(line["label"])
  15.                 text = line['sentence']
  16.                 data.append([text, label])
  17.             data_df = pd.DataFrame(data, columns=["text", "labels"])
  18.             return data_df
  19.         elif mode == 'test':
  20.             for idx, line in enumerate(fp):
  21.                 line = json.loads(line.strip())
  22.                 text = line['sentence']
  23.                 data.append([text])
  24.             data_df = pd.DataFrame(data, columns=["text"])
  25.             return data_df
  27. # 配置config
  28. import argparse
  30. def data_config(parser):
  31.     parser.add_argument("--trainset_path", type=str, default="data/Chinese_Spam_Message/train.json",
  32.                         help="训练集路径")
  33.     parser.add_argument("--testset_path", type=str, default="data/Chinese_Spam_Message/test.txt",
  34.                         help="测试集路径")
  35.     parser.add_argument("--reprocess_input_data", type=bool, default=True,
  36.                         help="如果为True，则即使cache_dir中存在输入数据的缓存文件，也将重新处理输入数据")
  37.     parser.add_argument("--overwrite_output_dir", type=bool, default=True,
  38.                         help="如果为True，则训练后的模型将保存到ouput_dir，并将覆盖同一目录中的现有已保存模型")
  39.     parser.add_argument("--use_cached_eval_features", type=bool, default=True,
  40.                         help="训练期间的评估使用缓存特征，将此设置为False将导致在每个评估步骤中重新计算特征")
  41.     parser.add_argument("--output_dir", type=str, default="outputs/",
  42.                         help="存储所有输出，包括模型checkpoints和评估结果")
  43.     parser.add_argument("--best_model_dir", type=str, default="outputs/best_model/",
  44.                         help="保存评估过程中的最好模型")
  45.     return parser
  48. def model_config(parser):
  49.     parser.add_argument("--max_seq_length", type=int, default=64,
  50.                         help="模型支持的最大序列长度")
  51.     parser.add_argument("--model_type", type=str, default="bert",
  52.                         help="模型类型bert/roberta")
  53.     # 要加载以前保存的模型而不是默认模型的模型，可以将model_name更改为包含已保存模型的目录的路径。
  54.     parser.add_argument("--model_name", type=str, default="./outputs/bert",
  55.                         help="选择使用哪个预训练模型")
  56.     parser.add_argument("--manual_seed", type=int, default=0,
  57.                         help="为了产生可重现的结果，需要设置随机种子")
  58.     parser.add_argument("--learning_rate", type=int, default=4e-5,
  59.                         help="学习率")
  60.     return parser
  63. def train_config(parser):
  64.     parser.add_argument("--num_train_epochs", type=int, default=3,
  65.                         help="模型训练迭代数")
  66.     parser.add_argument("--wandb_kwargs", type=dict, default={"name": "bert"},
  67.                         help="")
  68.     parser.add_argument("--n_gpu", type=int, default=1,
  69.                         help="训练时使用的GPU个数")
  70.     parser.add_argument("--train_batch_size", type=int, default=64)
  71.     parser.add_argument("--eval_batch_size", type=int, default=32)
  72.     return parser
  75. def set_args():
  76.     parser = argparse.ArgumentParser()
  77.     parser = data_config(parser)
  78.     parser = model_config(parser)
  79.     parser = train_config(parser)
  81.     args,_ = parser.parse_known_args()
  82.     return args
  86. def f1_multiclass(labels, preds):
  87.       return f1_score(labels, preds, average='micro')
  90. if __name__ == "__main__":
  91.     args = set_args()
  93.     logging.basicConfig(level=logging.INFO)
  94.     transformers_logger = logging.getLogger("transformers")
  95.     transformers_logger.setLevel(logging.WARNING)
  97.     # 模型训练
  98.     train = load_clue_iflytek("./data/iflytek/train.json", mode='train')
  99.     dev = load_clue_iflytek("./data/iflytek/dev.json", mode='dev')
  100.     test = load_clue_iflytek("./data/iflytek/test.json", mode='test')
  101.     num_labels = len(train["labels"].unique())
  102.     print(train.shape)
  103.     print(dev.shape)
  105.     # 创建分类模型
  106.     model = ClassificationModel(args.model_type, args.model_name, num_labels=num_labels, args=vars(args))
  108.     # 训练模型，并在训练时评估
  109.     model.train_model(train,eval_df=dev)
  111.     # 模型预测
  112.     result, model_outputs, wrong_predictions = model.eval_model(dev, f1=f1_multiclass)

Simpletransformers上手快，但只偏向于快速应用或者写baseline，需要更改模型结构灵活组合方法还是需要掌握transformer等自由度高的python库
NLP萌新，才疏学浅，有错误或者不完善的地方，请批评指正！！

【实践02】命名实体识别

数据集

笔者选用CLUE的作为benchmark数据集
选取数据集：
（1）CLUE Fine-Grain NER

中文语言理解测评基准(CLUE)

https://www.cluebenchmarks.com/dataSet_search.html
本数据是在清华大学开源的文本分类数据集THUCTC基础上，选出部分数据进行细粒度命名实体标注，原数据来源于Sina News RSS.
训练集：10748， 验证集：1343，标签类别：10个
标签分别为:

  • 地址（address）
  • 书名（book）
  • 公司（company）
  • 游戏（game）
  • 政府（goverment）
  • 电影（movie）
  • 姓名（name）
  • 组织机构（organization）
  • 职位（position）
  • 景点（scene）

cluener下载链接：数据下载
任务详情：CLUENER2020

  1. {"text": "浙商银行企业信贷部叶老桂博士则从另一个角度对五道门槛进行了解读。叶老桂认为，对目前国内商业银行而言，", 
  2.  "label": {
  3.    "name": {"叶老桂": [[9, 11]]}, 
  4.    "company": {"浙商银行": [[0, 3]]}}
  5. }
  7. {"text": "生生不息CSOL生化狂潮让你填弹狂扫", 
  8.  "label": {
  9.    "game": {"CSOL": [[4, 7]]}
  10.  }
  11. }

标签定义与规则：
地址（address）: 省市区街号，路，街道，村等（如单独出现也标记），注意：地址需要标记完全, 标记到最细。
书名（book）: 小说，杂志，习题集，教科书，教辅，地图册，食谱，书店里能买到的一类书籍，包含电子书。
公司（company）: 公司，集团，**银行（央行，中国人民银行除外，二者属于政府机构）, 如：新东方，包含新华网/中国军网等。
游戏（game）: 常见的游戏，注意有一些从小说，电视剧改编的游戏，要分析具体场景到底是不是游戏。
政府（goverment）: 包括中央行政机关和地方行政机关两级。 中央行政机关有国务院、国务院组成部门（包括各部、委员会、中国人民银行和审计署）、国务院直属机构（如海关、税务、工商、环保总局等），军队等。
电影（movie）: 电影，也包括拍的一些在电影院上映的纪录片，如果是根据书名改编成电影，要根据场景上下文着重区分下是电影名字还是书名。
姓名（name）: 一般指人名，也包括小说里面的人物，宋江，武松，郭靖，小说里面的人物绰号：及时雨，花和尚，著名人物的别称，通过这个别称能对应到某个具体人物。
组织机构（organization）: 篮球队，足球队，乐团，社团等，另外包含小说里面的帮派如：少林寺，丐帮，铁掌帮，武当，峨眉等。
职位（position）: 古时候的职称：巡抚，知州，国师等。现代的总经理，记者，总裁，艺术家，收藏家等。
景点（scene）: 常见旅游景点如：长沙公园，深圳动物园，海洋馆，植物园，黄河，长江等。

数据处理

Simple Transformers要求数据必须包含在至少三列的Pandas DataFrames中。
需为列的句子id、文本和标签命名，SimpleTransformers就会处理数据。
第一列包含句子id，类型为int。
第二列包含单词，类型为str。
第二列包含标签，类型为int。

  1. import json
  2. import pandas as pd
  4. def load_cluener2020_data(path):
  5.     """适应simpletransformer的加载方式"""
  6.     data = []
  7.     labels_list = []
  8.     with open(path, "r", encoding="utf-8") as f:
  9.         for idx, line in enumerate(f):
  10.             line = json.loads(line.strip())
  11.             text = line["text"]
  12.             label_entities = line.get("label", None)
  13.             words = list(text)
  14.             labels = ['O'] * len(words)
  15.             if label_entities:
  16.                 for key, value in label_entities.items():
  17.                     for sub_name, sub_index in value.items():
  18.                         for start_index, end_index in sub_index:
  19.                             assert "".join(words[start_index:end_index+1]) == sub_name
  20.                             if start_index == end_index:
  21.                                 labels[start_index] = "S-" + key
  22.                             else:
  23.                                 labels[start_index] = "B-" + key
  24.                                 labels[start_index+1:end_index+1] = ["I-"+key] * (len(sub_name) - 1)
  25.             for word, label in zip(words, labels):
  26.                 data.append([idx, word, label])
  27.                 if label not in labels_list:
  28.                     labels_list.append(label)
  29.     data_df = pd.DataFrame(data, columns=["sentence_id", "words", "labels"])
  30.     return data_df, labels_list

处理完后的形式如下：
image.png

模型搭建和训练

先进行参数配置，Simple Transformers具有dict args， 有关每个args的详细说明，可有参考：https://simpletransformers.ai/docs/tips-and-tricks/
1）参数配置

  1. # 配置config
  2. import argparse
  3. def data_config(parser):
  4.     parser.add_argument("--trainset_path", type=str, default="data/CLUENER2020/train.json",
  5.                         help="训练集路径")
  6.     parser.add_argument("--devset_path", type=str, default="data/CLUENER2020/dev.json",
  7.                         help="验证集路径")
  8.     parser.add_argument("--testset_path", type=str, default="data/CLUENER2020/test.json",
  9.                         help="测试集路径")
  10.     parser.add_argument("--reprocess_input_data", type=bool, default=True,
  11.                         help="如果为True，则即使cache_dir中存在输入数据的缓存文件，也将重新处理输入数据")
  12.     parser.add_argument("--overwrite_output_dir", type=bool, default=True,
  13.                         help="如果为True，则训练后的模型将保存到ouput_dir，并将覆盖同一目录中的现有已保存模型")
  14.     parser.add_argument("--use_cached_eval_features", type=bool, default=True,
  15.                         help="训练期间的评估使用缓存特征，将此设置为False将导致在每个评估步骤中重新计算特征")
  16.     parser.add_argument("--output_dir", type=str, default="outputs/",
  17.                         help="存储所有输出，包括模型checkpoints和评估结果")
  18.     parser.add_argument("--best_model_dir", type=str, default="outputs/best_model/",
  19.                         help="保存评估过程中的最好模型")
  20.     return parser
  22. def model_config(parser):
  23.     parser.add_argument("--max_seq_length", type=int, default=200,
  24.                         help="模型支持的最大序列长度")
  25.     parser.add_argument("--model_type", type=str, default="bert",
  26.                         help="模型类型bert/roberta")
  27.     parser.add_argument("--model_name", type=str, default="../pretrainmodel/bert",
  28.                         help="选择使用哪个预训练模型")
  29.     parser.add_argument("--manual_seed", type=int, default=2021,
  30.                         help="为了产生可重现的结果，需要设置随机种子")
  31.     return parser
  33. def train_config(parser):
  34.     parser.add_argument("--evaluate_during_training", type=bool, default=True,
  35.                         help="设置为True以在训练模型时执行评估，确保评估数据已传递到训练方法")
  36.     parser.add_argument("--num_train_epochs", type=int, default=3,
  37.                         help="模型训练迭代数")
  38.     parser.add_argument("--evaluate_during_training_steps", type=int, default=100,
  39.                         help="在每个指定的step上执行评估，checkpoint和评估结果将被保存")
  40.     parser.add_argument("--save_eval_checkpoints", type=bool, default=True)
  41.     parser.add_argument("--save_model_every_epoch", type=bool, default=True,
  42.                         help="每次epoch保存模型")
  43.     parser.add_argument("--n_gpu", type=int, default=1,
  44.                         help="训练时使用的GPU个数")
  45.     parser.add_argument("--train_batch_size", type=int, default=16)
  46.     parser.add_argument("--eval_batch_size", type=int, default=8)
  47.     return parser
  49. def set_args():
  50.     parser = argparse.ArgumentParser()
  51.     parser = data_config(parser)
  52.     parser = model_config(parser)
  53.     parser = train_config(parser)
  55.     args,unknown = parser.parse_known_args()
  56.     return args

2）模型搭建和训练

  1. import logging
  2. from simpletransformers.ner import NERModel
  4. # 可从训练集获取
  5. labels_list = ["B-company", "I-company", 'O', "B-name", "I-name", 
  6.                "B-game", "I-game", "B-organization", "I-organization",
  7.                "B-movie", "I-movie", "B-position", "I-position",
  8.                "B-address", "I-address", "B-government", "I-government",
  9.                "B-scene", "I-scene", "B-book", "I-book",
  10.                "S-company", "S-address", "S-name", "S-position"]
  11. # 训练
  12. args = set_args()
  13. logging.basicConfig(level=logging.INFO)
  14. transformers_logger = logging.getLogger("transformers")
  15. transformers_logger.setLevel(logging.WARNING)
  16. # 读取数据
  17. train_df, labels_list = load_cluener2020_data(args.trainset_path)
  18. dev_df, _ = load_cluener2020_data(args.devset_path)
  20. # 创建命名实体识别模型
  21. model = NERModel(args.model_type, args.model_name, labels=labels_list, args=vars(args))
  22. model.save_model(model=model.model)  # 可以将预训练模型下载到output_dir
  24. # 训练模型，并在训练时评估
  25. model.train_model(train_df, eval_data=dev_df)

预测结果

训练3轮，最佳F1值0.772964
image.png

完整代码

  1. import json
  2. import argparse
  3. import numpy as np
  4. import pandas as pd
  5. import logging
  6. from simpletransformers.ner import NERModel
  8. def data_config(parser):
  9.     parser.add_argument("--trainset_path", type=str, default="data/CLUENER2020/train.json",
  10.                         help="训练集路径")
  11.     parser.add_argument("--devset_path", type=str, default="data/CLUENER2020/dev.json",
  12.                         help="验证集路径")
  13.     parser.add_argument("--testset_path", type=str, default="data/CLUENER2020/test.json",
  14.                         help="测试集路径")
  15.     parser.add_argument("--reprocess_input_data", type=bool, default=True,
  16.                         help="如果为True，则即使cache_dir中存在输入数据的缓存文件，也将重新处理输入数据")
  17.     parser.add_argument("--overwrite_output_dir", type=bool, default=True,
  18.                         help="如果为True，则训练后的模型将保存到ouput_dir，并将覆盖同一目录中的现有已保存模型")
  19.     parser.add_argument("--use_cached_eval_features", type=bool, default=True,
  20.                         help="训练期间的评估使用缓存特征，将此设置为False将导致在每个评估步骤中重新计算特征")
  21.     parser.add_argument("--output_dir", type=str, default="outputs/",
  22.                         help="存储所有输出，包括模型checkpoints和评估结果")
  23.     parser.add_argument("--best_model_dir", type=str, default="outputs/best_model/",
  24.                         help="保存评估过程中的最好模型")
  25.     return parser
  27. def model_config(parser):
  28.     parser.add_argument("--max_seq_length", type=int, default=200,
  29.                         help="模型支持的最大序列长度")
  30.     parser.add_argument("--model_type", type=str, default="bert",
  31.                         help="模型类型bert/roberta")
  32.     parser.add_argument("--model_name", type=str, default="../pretrainmodel/bert",
  33.                         help="选择使用哪个预训练模型")
  34.     parser.add_argument("--manual_seed", type=int, default=2021,
  35.                         help="为了产生可重现的结果，需要设置随机种子")
  36.     return parser
  38. def train_config(parser):
  39.     parser.add_argument("--evaluate_during_training", type=bool, default=True,
  40.                         help="设置为True以在训练模型时执行评估，确保评估数据已传递到训练方法")
  41.     parser.add_argument("--num_train_epochs", type=int, default=3,
  42.                         help="模型训练迭代数")
  43.     parser.add_argument("--evaluate_during_training_steps", type=int, default=100,
  44.                         help="在每个指定的step上执行评估，checkpoint和评估结果将被保存")
  45.     parser.add_argument("--save_eval_checkpoints", type=bool, default=True)
  46.     parser.add_argument("--save_model_every_epoch", type=bool, default=True,
  47.                         help="每次epoch保存模型")
  48.     parser.add_argument("--n_gpu", type=int, default=1,
  49.                         help="训练时使用的GPU个数")
  50.     parser.add_argument("--train_batch_size", type=int, default=16)
  51.     parser.add_argument("--eval_batch_size", type=int, default=8)
  52.     return parser
  54. def set_args():
  55.     parser = argparse.ArgumentParser()
  56.     parser = data_config(parser)
  57.     parser = model_config(parser)
  58.     parser = train_config(parser)
  60.     args,unknown = parser.parse_known_args()
  61.     return args
  63. def load_cluener2020_data(path):
  64.     """适应simpletransformer的加载方式"""
  65.     data = []
  66.     labels_list = []
  67.     with open(path, "r", encoding="utf-8") as f:
  68.         for idx, line in enumerate(f):
  69.             line = json.loads(line.strip())
  70.             text = line["text"]
  71.             label_entities = line.get("label", None)
  72.             words = list(text)
  73.             labels = ['O'] * len(words)
  74.             if label_entities:
  75.                 for key, value in label_entities.items():
  76.                     for sub_name, sub_index in value.items():
  77.                         for start_index, end_index in sub_index:
  78.                             assert "".join(words[start_index:end_index+1]) == sub_name
  79.                             if start_index == end_index:
  80.                                 labels[start_index] = "S-" + key
  81.                             else:
  82.                                 labels[start_index] = "B-" + key
  83.                                 labels[start_index+1:end_index+1] = ["I-"+key] * (len(sub_name) - 1)
  84.             for word, label in zip(words, labels):
  85.                 data.append([idx, word, label])
  86.                 if label not in labels_list:
  87.                     labels_list.append(label)
  88.     data_df = pd.DataFrame(data, columns=["sentence_id", "words", "labels"])
  89.     return data_df, labels_list
  91. def train_model():
  92.     # 可从训练集获取
  93.     labels_list = ["B-company", "I-company", 'O', "B-name", "I-name", 
  94.                    "B-game", "I-game", "B-organization", "I-organization",
  95.                    "B-movie", "I-movie", "B-position", "I-position",
  96.                    "B-address", "I-address", "B-government", "I-government",
  97.                    "B-scene", "I-scene", "B-book", "I-book",
  98.                    "S-company", "S-address", "S-name", "S-position"]
  99.     # 训练
  100.     args = set_args()
  101.     logging.basicConfig(level=logging.INFO)
  102.     transformers_logger = logging.getLogger("transformers")
  103.     transformers_logger.setLevel(logging.WARNING)
  104.     # 读取数据
  105.     train_df, labels_list = load_cluener2020_data(args.trainset_path)
  106.     dev_df, _ = load_cluener2020_data(args.devset_path)
  107.     print(train_df.head(10))
  108.     print(dev_df.head(10))
  110.     # 创建命名实体识别模型
  111.     model = NERModel(args.model_type, args.model_name, labels=labels_list, args=vars(args))
  112.     model.save_model(model=model.model)  # 可以将预训练模型下载到output_dir
  114.     # 训练模型，并在训练时评估
  115.     model.train_model(train_df, eval_data=dev_df)
  117. if __name__ == '__main__':
  118.     train_model()

Simpletransformers上手快，但只偏向于快速应用或者写baseline，需要更改模型结构灵活组合方法还是需要掌握transformer等自由度高的python库
NLP萌新，才疏学浅，有错误或者不完善的地方，请批评指正！！