devbox
繁依Fanyi0
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Python BiLSTM_CRF实现代码，电子病历命名实体识别和关系抽取，序列标注_bilstm-crf模型代码

作者：繁依Fanyi0 | 2024-05-30 20:30:42

赞

踩

bilstm-crf模型代码

参考刘焕勇老师的代码，按照自己数据的训练集进行修改，

1.原始数据样式：

2.清洗后数据样式：

 

3.训练数据

  1. import numpy as np
  2. import matplotlib.pyplot as plt
  3. import os
  4.  
  5. from keras import backend as K
  6. from keras.preprocessing.sequence import pad_sequences
  7. from keras.models import Sequential
  8. from keras.layers import Embedding, Bidirectional, LSTM, Dense, TimeDistributed, Dropout
  9. from keras_contrib.layers.crf import CRF
  10.  
  11. os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
  12. '''
  13. 默认为0，显示所有日志要过滤INFO日志，
  14. 请将其设置为1WARNINGS另外，2并进一步过滤掉ERROR日志，
  15. 将其设置为3可以执行以下操作使警告静音
  16. '''
  17. class LSTMNER:
  18.     def __init__(self):
  19.         cur = '/'.join(os.path.abspath(__file__).split('/')[:-1])
  20.         self.train_path = os.path.join(cur, 'data/train.txt')
  21.         self.vocab_path = os.path.join(cur, 'model/vocab.txt')
  22.         self.embedding_file = os.path.join(cur, 'model/token_vec_300.bin')
  23.         self.model_path = os.path.join(cur, 'model/tokenvec_bilstm2_crf_model_20.h5')
  24.         self.datas, self.word_dict = self.build_data()
  25.         self.class_dict = {
  26.                         'O': 0,
  27.                         'B-pro': 1,
  28.                         'I-pro': 2,
  29.                         'B-sym': 3,
  30.                         'I-sym': 4,
  31.                         'B-dis': 5,
  32.                         'I-dis': 6,
  33.                         'B-equ': 7,
  34.                         'I-equ': 8,
  35.                         'B-dru': 9,
  36.                         'I-dru': 10,
  37.                         'B-ite': 11,
  38.                         'I-ite': 12,
  39.                         'B-bod': 13,
  40.                         'I-bod': 14,
  41.                         'I-dep': 15,
  42.                         'B-dep': 16,
  43.                         'I-mic': 17,
  44.                         'B-mic': 18
  45.                         }
  46.  
  47.         self.EMBEDDING_DIM = 300
  48.         self.EPOCHS = 50
  49.         self.BATCH_SIZE = 64
  50.         self.NUM_CLASSES = len(self.class_dict)
  51.         self.VOCAB_SIZE = len(self.word_dict)
  52.         self.TIME_STAMPS = 150
  53.         self.embedding_matrix = self.build_embedding_matrix()
  54.  
  55.     '''构造数据集'''
  56.     def build_data(self):
  57.         datas = []
  58.         sample_x = []
  59.         sample_y = []
  60.         vocabs = {'UNK'}
  61.         for line in open(self.train_path,encoding = 'utf-8'):
  62.             # if line=='$':
  63.             #     continue
  64.             # else:
  65.             line = line.rstrip().strip('$').split('\t')
  66.             if not line:
  67.                 continue
  68.             char = line[0]
  69.             if not char:
  70.                 continue
  71.             cate = line[-1]
  72.             sample_x.append(char)
  73.             sample_y.append(cate)
  74.             vocabs.add(char)
  75.             if char in ['。','?','!','！','？']:
  76.                 datas.append([sample_x, sample_y])
  77.                 sample_x = []
  78.                 sample_y = []
  79.         word_dict = {wd:index for index, wd in enumerate(list(vocabs))}
  80.         self.write_file(list(vocabs), self.vocab_path)
  81.         return datas, word_dict
  82.  
  83.  
  84.     '''将数据转换成keras所需的格式'''
  85.     def modify_data(self):
  86.         x_train = [[self.word_dict[char] for char in data[0]] for data in self.datas]
  87.         y_train = [[self.class_dict[label] for label in data[1]] for data in self.datas]
  88.         x_train = pad_sequences(x_train, self.TIME_STAMPS)
  89.         y = pad_sequences(y_train, self.TIME_STAMPS)
  90.         y_train = np.expand_dims(y, 2)
  91.         return x_train, y_train
  92.  
  93.     '''保存字典文件'''
  94.     def write_file(self, wordlist, filepath):
  95.         with open(filepath, 'w+',encoding = 'utf-8') as f:
  96.             f.write('\n'.join(wordlist))
  97.  
  98.     '''加载预训练词向量'''
  99.     def load_pretrained_embedding(self):
  100.         embeddings_dict = {}
  101.         with open(self.embedding_file, 'r',encoding = 'utf-8') as f:
  102.             for line in f:
  103.                 values = line.strip().split(' ')
  104.                 if len(values) < 300:
  105.                     continue
  106.                 word = values[0]
  107.                 coefs = np.asarray(values[1:], dtype='float32')
  108.                 embeddings_dict[word] = coefs
  109.         print('Found %s word vectors.' % len(embeddings_dict))
  110.         return embeddings_dict
  111.  
  112.     '''加载词向量矩阵'''
  113.     def build_embedding_matrix(self):
  114.         embedding_dict = self.load_pretrained_embedding()
  115.         embedding_matrix = np.zeros((self.VOCAB_SIZE + 1, self.EMBEDDING_DIM))
  116.         for word, i in self.word_dict.items():
  117.             embedding_vector = embedding_dict.get(word)
  118.             if embedding_vector is not None:
  119.                 embedding_matrix[i] = embedding_vector
  120.         return embedding_matrix
  121.  
  122.     '''使用预训练向量进行模型训练'''
  123.     def tokenvec_bilstm2_crf_model(self):
  124.         model = Sequential()
  125.         embedding_layer = Embedding(self.VOCAB_SIZE + 1,
  126.                                     self.EMBEDDING_DIM,
  127.                                     weights=[self.embedding_matrix],
  128.                                     input_length=self.TIME_STAMPS,
  129.                                     trainable=False,
  130.                                     mask_zero=True)
  131.         model.add(embedding_layer)
  132.         model.add(Bidirectional(LSTM(128, return_sequences=True)))
  133.         model.add(Dropout(0.5))
  134.         model.add(Bidirectional(LSTM(64, return_sequences=True)))
  135.         model.add(Dropout(0.5))
  136.         model.add(TimeDistributed(Dense(self.NUM_CLASSES)))
  137.         crf_layer = CRF(self.NUM_CLASSES, sparse_target=True)
  138.         model.add(crf_layer)
  139.         model.compile('adam', loss=crf_layer.loss_function, metrics=[crf_layer.accuracy])
  140.         model.summary()
  141.         return model
  142.  
  143.     '''训练模型'''
  144.     def train_model(self):
  145.         x_train, y_train = self.modify_data()
  146.         print(x_train.shape, y_train.shape)
  147.         model = self.tokenvec_bilstm2_crf_model()
  148.         history = model.fit(x_train[:],
  149.                             y_train[:],
  150.                             validation_split=0.2,
  151.                             batch_size=self.BATCH_SIZE,
  152.                             epochs=self.EPOCHS)
  153.         # self.draw_train(history)
  154.         model.save(self.model_path)
  155.         return model
  156.  
  157.     '''绘制训练曲线'''
  158.     def draw_train(self, history):
  159.         # Plot training & validation accuracy values
  160.         plt.plot(history.history['acc'])
  161.         plt.title('Model accuracy')
  162.         plt.ylabel('Accuracy')
  163.         plt.xlabel('Epoch')
  164.         plt.legend(['Train'], loc='upper left')
  165.         plt.show()
  166.         # Plot training & validation loss values
  167.         plt.plot(history.history['loss'])
  168.         plt.title('Model loss')
  169.         plt.ylabel('Loss')
  170.         plt.xlabel('Epoch')
  171.         plt.legend(['Train'], loc='upper left')
  172.         plt.show()
  173.         # 7836/7836 [==============================] - 205s 26ms/step - loss: 17.1782 - acc: 0.9624
  174.         '''
  175.         6268/6268 [==============================] - 145s 23ms/step - loss: 18.5272 - acc: 0.7196 - val_loss: 15.7497 - val_acc: 0.8109
  176.         6268/6268 [==============================] - 142s 23ms/step - loss: 17.8446 - acc: 0.9099 - val_loss: 15.5915 - val_acc: 0.8378
  177.         6268/6268 [==============================] - 136s 22ms/step - loss: 17.7280 - acc: 0.9485 - val_loss: 15.5570 - val_acc: 0.8364
  178.         6268/6268 [==============================] - 133s 21ms/step - loss: 17.6918 - acc: 0.9593 - val_loss: 15.5187 - val_acc: 0.8451
  179.         6268/6268 [==============================] - 144s 23ms/step - loss: 17.6723 - acc: 0.9649 - val_loss: 15.4944 - val_acc: 0.8451
  180.         '''
  181.  
  182. if __name__ == '__main__':
  183.     ner = LSTMNER()
  184.     ner.train_model()

4.预测数据：

  1. import numpy as np
  2. from keras import backend as K
  3. from keras.preprocessing.sequence import pad_sequences
  4. from keras.models import Sequential,load_model
  5. from keras.layers import Embedding, Bidirectional, LSTM, Dense, TimeDistributed, Dropout
  6. from keras_contrib.layers.crf import CRF
  7. import matplotlib.pyplot as plt
  8. import os
  9.  
  10. os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
  11.  
  12. class LSTMNER:
  13.     def __init__(self):
  14.         cur = '/'.join(os.path.abspath(__file__).split('/')[:-1])
  15.         self.train_path = os.path.join(cur, 'data/train.txt')
  16.         self.vocab_path = os.path.join(cur, 'model/vocab.txt')
  17.         self.embedding_file = os.path.join(cur, 'model/token_vec_300.bin')
  18.         self.model_path = os.path.join(cur, 'model/tokenvec_bilstm2_crf_model_20.h5')
  19.         self.word_dict = self.load_worddict()
  20.         self.class_dict = {
  21.                         'O': 0,
  22.                         'B-pro': 1,
  23.                         'I-pro': 2,
  24.                         'B-sym': 3,
  25.                         'I-sym': 4,
  26.                         'B-dis': 5,
  27.                         'I-dis': 6,
  28.                         'B-equ': 7,
  29.                         'I-equ': 8,
  30.                         'B-dru': 9,
  31.                         'I-dru': 10,
  32.                         'B-ite': 11,
  33.                         'I-ite': 12,
  34.                         'B-bod': 13,
  35.                         'I-bod': 14,
  36.                         'I-dep': 15,
  37.                         'B-dep': 16,
  38.                         'I-mic': 17,
  39.                         'B-mic': 18
  40.                         }
  41.         self.label_dict = {j:i for i,j in self.class_dict.items()}
  42.         self.EMBEDDING_DIM = 300
  43.         self.EPOCHS = 20
  44.         self.BATCH_SIZE = 64
  45.         self.NUM_CLASSES = len(self.class_dict)
  46.         self.VOCAB_SIZE = len(self.word_dict)
  47.         self.TIME_STAMPS = 150
  48.         self.embedding_matrix = self.build_embedding_matrix()
  49.         self.model = self.tokenvec_bilstm2_crf_model()
  50.         self.model.load_weights(self.model_path)
  51.  
  52.     '加载词表'
  53.     def load_worddict(self):
  54.         vocabs = [line.strip() for line in open(self.vocab_path)]
  55.         word_dict = {wd: index for index, wd in enumerate(vocabs)}
  56.         return word_dict
  57.  
  58.     '''构造输入，转换成所需形式'''
  59.     def build_input(self, text):
  60.         x = []
  61.         for char in text:
  62.             if char not in self.word_dict:
  63.                 char = 'UNK'
  64.             x.append(self.word_dict.get(char))
  65.         x = pad_sequences([x], self.TIME_STAMPS)
  66.         return x
  67.  
  68.     def predict(self, text):
  69.         str = self.build_input(text)
  70.         raw = self.model.predict(str)[0][-self.TIME_STAMPS:]
  71.         result = [np.argmax(row) for row in raw]
  72.         chars = [i for i in text]
  73.         tags = [self.label_dict[i] for i in result][len(result)-len(text):]
  74.         res = list(zip(chars, tags))
  75.         print(res)
  76.         return res
  77.  
  78.     '''加载预训练词向量'''
  79.     def load_pretrained_embedding(self):
  80.         embeddings_dict = {}
  81.         with open(self.embedding_file, 'r') as f:
  82.             for line in f:
  83.                 values = line.strip().split(' ')
  84.                 if len(values) < 300:
  85.                     continue
  86.                 word = values[0]
  87.                 coefs = np.asarray(values[1:], dtype='float32')
  88.                 embeddings_dict[word] = coefs
  89.         print('Found %s word vectors.' % len(embeddings_dict))
  90.         return embeddings_dict
  91.  
  92.     '''加载词向量矩阵'''
  93.     def build_embedding_matrix(self):
  94.         embedding_dict = self.load_pretrained_embedding()
  95.         embedding_matrix = np.zeros((self.VOCAB_SIZE + 1, self.EMBEDDING_DIM))
  96.         for word, i in self.word_dict.items():
  97.             embedding_vector = embedding_dict.get(word)
  98.             if embedding_vector is not None:
  99.                 embedding_matrix[i] = embedding_vector
  100.  
  101.         return embedding_matrix
  102.  
  103.     '''使用预训练向量进行模型训练'''
  104.     def tokenvec_bilstm2_crf_model(self):
  105.         model = Sequential()
  106.         embedding_layer = Embedding(self.VOCAB_SIZE + 1,
  107.                                     self.EMBEDDING_DIM,
  108.                                     weights=[self.embedding_matrix],
  109.                                     input_length=self.TIME_STAMPS,
  110.                                     trainable=False,
  111.                                     mask_zero=True)
  112.         model.add(embedding_layer)
  113.         model.add(Bidirectional(LSTM(128, return_sequences=True)))
  114.         model.add(Dropout(0.5))
  115.         model.add(Bidirectional(LSTM(64, return_sequences=True)))
  116.         model.add(Dropout(0.5))
  117.         model.add(TimeDistributed(Dense(self.NUM_CLASSES)))
  118.         crf_layer = CRF(self.NUM_CLASSES, sparse_target=True)
  119.         model.add(crf_layer)
  120.         model.compile('adam', loss=crf_layer.loss_function, metrics=[crf_layer.accuracy])
  121.         model.summary()
  122.         return model
  123.  
  124. if __name__ == '__main__':
  125.     ner = LSTMNER()
  126.     while 1:
  127.         s = input('enter an sent:').strip()
  128.         ner.predict(s)
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/繁依Fanyi0/article/detail/648496
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号