Customize Multi Output Model

It is very easy to customize your own multi output model. Lets assume you have dataset like this, One input and two output.

Example code at file tests/test_custom_multi_output_classification.py.

  1. x = [
  2.     ['我', '想', '全', '部', '回', '复'], 
  3.     ['我', '想', '上', 'q', 'q', '了'], 
  4.     ['你', '去', '过', '赌', '场', '吗'], 
  5.     ['是', '我', '是', '说', '你', '有', '几', '个', '兄', '弟', '姐', '妹', '不', '是', '你', '自', '己', '说'], 
  6.     ['广', '西', '新', '闻', '网']
  7. ]
  9. output_1 = [
  10.     [0. 0. 1.]
  11.     [1. 0. 0.]
  12.     [1. 0. 0.]
  13.     [0. 0. 1.]
  14.     [1. 0. 0.]]
  16. output_2 = [
  17.     [0. 1. 0.]
  18.     [0. 0. 1.]
  19.     [0. 0. 1.]
  20.     [1. 0. 0.]
  21.     [0. 0. 1.]]

Then you need to create a customized processor inhered from the ClassificationProcessor.

  1. import kashgari
  2. import numpy as np
  3. from typing import Tuple, List, Optional, Dict, Any
  4. from kashgari.processors.classification_processor import ClassificationProcessor
  6. class MultiOutputProcessor(ClassificationProcessor):
  7.     def process_y_dataset(self,
  8.                           data: Tuple[List[List[str]], ...],
  9.                           maxlens: Optional[Tuple[int, ...]] = None,
  10.                           subset: Optional[List[int]] = None) -> Tuple[np.ndarray, ...]:
  11.         # Data already converted to one-hot
  12.         # Only need to get the subset
  13.         result = []
  14.         for index, dataset in enumerate(data):
  15.             if subset is not None:
  16.                 target = kashgari.utils.get_list_subset(dataset, subset)
  17.             else:
  18.                 target = dataset
  19.             result.append(np.array(target))
  21.         if len(result) == 1:
  22.             return result[0]
  23.         else:
  24.             return tuple(result)

Then build your own model inhered from the BaseClassificationModel

  1. import kashgari
  2. import tensorflow as tf
  3. from typing import Tuple, List, Optional, Dict, Any
  4. from kashgari.layers import L
  5. from kashgari.tasks.classification.base_model import BaseClassificationModel
  8. class MultiOutputModel(BaseClassificationModel):
  9.     @classmethod
  10.     def get_default_hyper_parameters(cls) -> Dict[str, Dict[str, Any]]:
  11.         return {
  12.             'layer_bi_lstm': {
  13.                 'units': 256,
  14.                 'return_sequences': False
  15.             }
  16.         }
  18.     # Build your own model
  19.     def build_model_arc(self):
  20.         config = self.hyper_parameters
  21.         embed_model = self.embedding.embed_model
  23.         layer_bi_lstm = L.Bidirectional(L.LSTM(**config['layer_bi_lstm']), name='layer_bi_lstm')
  24.         layer_output_1 = L.Dense(3, activation='sigmoid', name='layer_output_1')
  25.         layer_output_2 = L.Dense(3, activation='sigmoid', name='layer_output_2')
  27.         tensor = layer_bi_lstm(embed_model.output)
  28.         output_tensor_1 = layer_output_1(tensor)
  29.         output_tensor_2 = layer_output_2(tensor)
  31.         self.tf_model = tf.keras.Model(embed_model.inputs, [output_tensor_1, output_tensor_2])
  33.     # Rewrite your predict function
  34.     def predict(self,
  35.                 x_data,
  36.                 batch_size=None,
  37.                 debug_info=False,
  38.                 threshold=0.5):
  39.         tensor = self.embedding.process_x_dataset(x_data)
  40.         pred = self.tf_model.predict(tensor, batch_size=batch_size)
  42.         output_1 = pred[0]
  43.         output_2 = pred[1]
  45.         output_1[output_1 >= threshold] = 1
  46.         output_1[output_1 < threshold] = 0
  47.         output_2[output_2 >= threshold] = 1
  48.         output_2[output_2 < threshold] = 0
  50.         return output_1, output_2

Tada, all done, Now build your own model with customized processor

  1. from kashgari.embeddings import BareEmbedding
  3. # Use your processor to init embedding, You can use any embedding layer provided by kashgari here
  5. processor = MultiOutputProcessor()
  6. embedding = BareEmbedding(processor=processor)
  8. m = MultiOutputModel(embedding=embedding)
  9. m.build_model(train_x, (output_1, output_2))
  10. m.fit(train_x, (output_1, output_2))