文本分类

Kashgari 提供了一系列的文本分类模型。所有的文本分类模型都继承自 BaseClassificationModel 类，提供了同样的 API。所以切换模型做实验非常的方便。

接口文档请看： 分类模型 API 文档

内置模型列表

模型名称 模型描述
BiLSTM_Model
BiGRU_Model
CNN_Model
CNN_LSTM_Model
CNN_GRU_Model
AVCNN_Model
KMax_CNN_Model
R_CNN_Model
AVRNN_Model
Dropout_BiGRU_Model
Dropout_AVRNN_Model
DPCNN_Model

训练分类模型

Kashgari 内置了一个意图分类数据集用于测试。您也可以使用自己的数据，只需要把数据集格式化为同样的格式即可。

  1. from kashgari.corpus import SMP2018ECDTCorpus
  3. # 加载内置数据集
  4. train_x, train_y = SMP2018ECDTCorpus.load_data('train')
  5. valid_x, valid_y = SMP2018ECDTCorpus.load_data('valid')
  6. test_x, test_y = SMP2018ECDTCorpus.load_data('test')
  8. # 也可以使用自己的数据集
  9. train_x = [['Hello', 'world'], ['Hello', 'Kashgari']]
  10. train_y = ['a', 'b']
  12. valid_x, valid_y = train_x, train_y
  13. test_x, test_x = train_x, train_y

使用数据集训练模型。所有的模型都提供同样的接口，所以你可以 BiLSTM_Model 模型替换为任何一个内置的分类模型。

  1. import kashgari
  2. from kashgari.tasks.classification import BiLSTM_Model
  4. import logging
  5. logging.basicConfig(level='DEBUG')
  7. model = BiLSTM_Model()
  8. model.fit(train_x, train_y, valid_x, valid_y)
  10. # 验证模型，此方法将打印出详细的验证报告
  11. model.evaluate(test_x, test_y)
  13. # 保存模型到 `saved_ner_model` 目录下
  14. model.save('saved_classification_model')
  16. # 加载保存模型
  17. loaded_model = kashgari.utils.load_model('saved_classification_model')
  19. # 使用模型进行预测
  20. loaded_model.predict(test_x[:10])

使用预训练语言模型进行迁移学习

Kashgari 内置了几种预训练语言模型处理模块，简化迁移学习流程。下面是一个使用 BERT 的例子。

  1. import kashgari
  2. from kashgari.tasks.classification import BiGRU_Model
  3. from kashgari.embeddings import BERTEmbedding
  5. import logging
  6. logging.basicConfig(level='DEBUG')
  8. bert_embed = BERTEmbedding('<PRE_TRAINED_BERT_MODEL_FOLDER>',
  9.                            task=kashgari.LABELING,
  10.                            sequence_length=100)
  11. model = BiGRU_Model(bert_embed)
  12. model.fit(train_x, train_y, valid_x, valid_y)

你还可以把 BERT 替换成 WordEmbedding 或者 GPT2Embedding 等，更多请查阅 Embedding 文档

调整模型超参数

通过模型的 get_default_hyper_parameters() 方法可以获取默认超参，将会返回一个字典。通过修改字典来修改超参列表。再使用新的超参字典初始化模型。

假设我们想把 layer_bi_lstm 层的神经元数量调整为 32：

  1. from kashgari.tasks.classification import BiLSTM_Model
  3. hyper = BiLSTM_Model.get_default_hyper_parameters()
  4. print(hyper)
  5. # {'layer_bi_lstm': {'units': 128, 'return_sequences': False}, 'layer_dense': {'activation': 'softmax'}}
  7. hyper['layer_bi_lstm']['units'] = 32
  9. model = BiLSTM_Model(hyper_parameters=hyper)

使用训练回调

Kashgari 是基于 tf.keras, 所以你可以直接使用全部的 tf.keras 回调类，例如我们使用 TensorBoard 可视化训练过程。

  1. from tensorflow.python import keras
  2. from kashgari.tasks.classification import BiGRU_Model
  3. from kashgari.callbacks import EvalCallBack
  5. import logging
  6. logging.basicConfig(level='DEBUG')
  8. model = BiGRU_Model()
  10. tf_board_callback = keras.callbacks.TensorBoard(log_dir='./logs', update_freq=1000)
  12. # 这是 Kashgari 内置回调函数，会在训练过程计算精确度，召回率和 F1
  13. eval_callback = EvalCallBack(kash_model=model,
  14.                              valid_x=valid_x,
  15.                              valid_y=valid_y,
  16.                              step=5)
  18. model.fit(train_x,
  19.           train_y,
  20.           valid_x,
  21.           valid_y,
  22.           batch_size=100,
  23.           callbacks=[eval_callback, tf_board_callback])

多标签分类

Kashgari 支持多分类多标签分类。

假设我们的数据集是这样的：

  1. x = [
  2.    ['This','news',are',very','well','organized'],
  3.    ['What','extremely','usefull','tv','show'],
  4.    ['The','tv','presenter','were','very','well','dress'],
  5.    ['Multi-class', 'classification', 'means', 'a', 'classification', 'task', 'with', 'more', 'than', 'two', 'classes']
  6. ]
  8. y = [
  9.    ['A', 'B'],
  10.    ['A',],
  11.    ['B', 'C'],
  12.    []
  13. ]

现在我们需要初始化一个 Processor 和 Embedding 对象，然后再初始化我们的模型。

  1. from kashgari.tasks.classification import BiLSTM_Model
  2. from kashgari.processors import ClassificationProcessor
  3. from kashgari.embeddings import BareEmbedding
  5. import logging
  6. logging.basicConfig(level='DEBUG')
  8. # 需要指定我们使用分类数据处理器，且支持多分类
  9. processor = ClassificationProcessor(multi_label=True)
  10. embed = BareEmbedding(processor=processor)
  12. model = BiLSTM_Model(embed)
  13. model.fit(x, y)

自定义模型结构

除了内置模型以外，还可以很方便的自定义自己的模型结构。只需要继承 BaseClassificationModel 对象，然后实现get_default_hyper_parameters() 方法 和 build_model_arc() 方法。

  1. from typing import Dict, Any
  2. from tensorflow import keras
  4. from kashgari.tasks.classification.base_model import BaseClassificationModel
  5. from kashgari.layers import L
  7. import logging
  8. logging.basicConfig(level='DEBUG')
  11. class DoubleBLSTMModel(BaseClassificationModel):
  13.     @classmethod
  14.     def get_default_hyper_parameters(cls) -> Dict[str, Dict[str, Any]]:
  15.         """
  16.         Get hyper parameters of model
  17.         Returns:
  18.             hyper parameters dict
  19.         """
  20.         return {
  21.             'layer_blstm1': {
  22.                 'units': 128,
  23.                 'return_sequences': True
  24.             },
  25.             'layer_blstm2': {
  26.                 'units': 128,
  27.                 'return_sequences': False
  28.             },
  29.             'layer_dropout': {
  30.                 'rate': 0.4
  31.             },
  32.             'layer_time_distributed': {},
  33.             'layer_activation': {
  34.                 'activation': 'softmax'
  35.             }
  36.         }
  38.     def build_model_arc(self):
  39.         """
  40.         build model architectural
  41.         """
  42.         # 此处作用是从上层拿到输出张量形状和 Embedding 层的输出
  43.         output_dim = len(self.pre_processor.label2idx)
  44.         config = self.hyper_parameters
  45.         embed_model = self.embedding.embed_model
  47.         # 定义你自己的层
  48.         layer_blstm1 = L.Bidirectional(L.LSTM(**config['layer_blstm1']),
  49.                                        name='layer_blstm1')
  50.         layer_blstm2 = L.Bidirectional(L.LSTM(**config['layer_blstm2']),
  51.                                        name='layer_blstm2')
  53.         layer_dropout = L.Dropout(**config['layer_dropout'],
  54.                                   name='layer_dropout')
  56.         layer_time_distributed = L.TimeDistributed(L.Dense(output_dim,
  57.                                                            **config['layer_time_distributed']),
  58.                                                    name='layer_time_distributed')
  59.         layer_activation = L.Activation(**config['layer_activation'])
  61.         # 定义数据流
  62.         tensor = layer_blstm1(embed_model.output)
  63.         tensor = layer_blstm2(tensor)
  64.         tensor = layer_dropout(tensor)
  65.         tensor = layer_time_distributed(tensor)
  66.         output_tensor = layer_activation(tensor)
  68.         # 初始化模型
  69.         self.tf_model = keras.Model(embed_model.inputs, output_tensor)
  71. # 此模型可以和任何一个 Embedding 组合使用
  72. model = DoubleBLSTMModel()
  73. model.fit(train_x, train_y, valid_x, valid_y)

使用 CuDNN 加速 GPU 训练

Kashgari 可以使用 CuDNN 层来加速训练。CuDNNLSTM 和 CuDNNGRU 训练速度比 LSTM 和 GRU 快很多，但是只能在 GPU 上使用。如果需要 GPU 训练，CPU 推断，那么不能使用 CuDNN 来加速训练。设置 CuDNN 方法如下：

  1. kashgari.config.use_cudnn_cell = True